题目集4~5以及期中考试的总结性Blog
作者：互联网
一：前言：
第四次作业
知识点：第一题考察对输入字符串进行数字提取并进行计算等知识；第二题考察的知识点较多，主要是与之前三角形类相接轨，在原先的基础上，又涉及继承与多态等新知识点；第三题则是考察属性与方法的类型，比如：public private等。
题量：较少。
难度：第一题和第三题难度较小，第二题的难度较大。
期中考试
知识点：第一题考察类的设计；第二题考察继承与多态；第三题主要考察容器类的知识。
题量：较少。
难度：相对于这几次大作业来说，这次期中考试的难度较小。
第五次作业
知识点：这两题考察了字符串格式判断，转换；以及利用继承与多态来将不同多边形的判断，计算统一等，还有对数据的处理等知识。
题量：较少。
难度：这次大作业是前几次大作业的“进阶”，不仅考察了对前几次点类，线类，三角形类，四边形类的重复利用；还增加了五边形类的设计，因为我之前类的设计并不是很合理，导致我需要对之前的类进行了一些修改，这增加了不少难度，同时需要在这里使用了继承与多态来简化代码，这对我来说也是一个不小的挑战。
二．设计与分析
（1）第四次作业的7-2
第一步：对字符串进行格式判断，并输出错误类型。
我的选择是单独设计一个字符判断类，如下：
class Judge{
static String standard = "^(-?\\+?(0|[1-9][0-9]*))(\\.\\d+)?[,](-?\\+?(0|[1-9][0-9]*))(\\.\\d+)?$";
// 输入：点坐标字符串，点数量
// 输出：0无错误；1格式错误；2数量错误
public static int judge(String s,int n) {
int p = 0;
String[] str =s.split(" ");
if(judge1(str)!=0) {
p=1;
}
else if(judge2(str,n)!=0) {
p=2;
}
return p;
}
private static int judge1(String[] str) {
int p = 0;
for(int i=0; i<str.length; i++) {
if(!str[i].matches(standard)) {
p=1;
break;
}
}
return p;
}
private static int judge2(String[] str,int n) {
int p = 0;
if(str.length != n)
p=2;
return p;
}
}
然后根据判断结果进行接下来的操作：
int err=Judge.judge(s.substring(2),6);
if(err==1)
System.out.println("Wrong Format");
else if(err==2)
System.out.println("wrong number of points");
else {
}
第二步：在字符串符合格式的情况下，进行字符串的转换，将字符串转换为点的链表集合。
同样的，我也是选择将其做成一个类。
class Trans{
private static ArrayList<Point> gather = new ArrayList<>();
private static Point a;
//输入：字符串
//输出：点链表
public static ArrayList<Point> trans(String s) {
String[] str =s.split(" ");
for(int i=0; i<str.length; i++) {
tran(str[i]);
gather.add(a);
}
return gather;
}
private static void tran(String s) {
String[] str =s.split(",");
a = new Point(transdouble(str[0]),transdouble(str[1]));
}
private static double transdouble(String s) {
return Double.parseDouble(s);
}
}
第三步：根据选项进行各种计算
public class Main {
static ArrayList<Point> points;
static String s = new String();
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
s = in.nextLine();
if(s.charAt(0)-'0'>5||s.charAt(0)-'0'<1||s.charAt(1)!=':')
System.out.print("Wrong Format");
else
switch (s.charAt(0)) {
case '1':{xx1();break;}
case '2':{xx2();break;}
case '3':{xx3();break;}
case '4':{xx4();break;}
case '5':{xx5();break;}
}
in.close();
}
// 格式化
static Double output(double b) {
DecimalFormat df = new DecimalFormat("#.000");
Double output = Double.valueOf(df.format(b));
return output;
}
// 选项一：判断是否是四边形、平行四边形
static void xx1() {
int err=Judge.judge(s.substring(2),4);
if(err==1)
System.out.println("Wrong Format");
else if(err==2)
System.out.println("wrong number of points");
else {
points=Trans.trans(s.substring(2));
Quadrangle q = new Quadrangle(points.get(0),points.get(1),points.get(2),points.get(3));
if(q.chonghe())
System.out.println("points coincide");
else
System.out.println(q.bequadrangle()+" "+q.pxsbx());
}
}
// 选项二：判断是否是菱形、矩形、正方形
static void xx2() {
int err=Judge.judge(s.substring(2),4);
if(err==1)
System.out.println("Wrong Format");
else if(err==2)
System.out.println("wrong number of points");
else {
points=Trans.trans(s.substring(2));
Quadrangle q = new Quadrangle(points.get(0),points.get(1),points.get(2),points.get(3));
if(!q.bequadrangle())
System.out.println("not a quadrilateral");
else if(q.chonghe())
System.out.println("points coincide");
else
System.out.println(q.lx()+" "+q.jx()+" "+q.zfx());
}
}
// 选项三：判断是凹四边形（false）还是凸四边形(true)
static void xx3() {
int err=Judge.judge(s.substring(2),4);
if(err==1)
System.out.println("Wrong Format");
else if(err==2)
System.out.println("wrong number of points");
else {
points=Trans.trans(s.substring(2));
Quadrangle q = new Quadrangle(points.get(0),points.get(1),points.get(2),points.get(3));
if(!q.bequadrangle())
System.out.println("not a quadrilateral");
else if(q.chonghe())
System.out.println("points coincide");
else {
System.out.println(q.at()+" "+output(q.zhouchang())+" "+output(q.mianji()));
}
}
}
// 选项四：输出直线与四边形（也可能是三角形）相交的交点数量，交点为2则输出面积
static void xx4() {
int err=Judge.judge(s.substring(2),6);
if(err==1)
System.out.println("Wrong Format");
else if(err==2)
System.out.println("wrong number of points");
else {
points=Trans.trans(s.substring(2));
Line n = new Line(points.get(0),points.get(1));
Quadrangle q = new Quadrangle(points.get(2),points.get(3),points.get(4),points.get(5));
if(!n.beLine())
System.out.println("points coincide");
else {
if(q.bequadrangle()) {
if(q.xchonghe(n))
System.out.println("The line is coincide with one of the lines");
else{
ArrayList<Point> jd = q.jiaodians(n);
System.out.print(jd.size());
if(jd.size()==2) {
double mj = q.fgmianji(jd);
if(mj<(q.mianji()-mj))
System.out.println(" "+output(mj)+" "+output((q.mianji()-mj)));
else
System.out.println(" "+output((q.mianji()-mj))+" "+output(mj));
}
}
}
else if(q.betriangle1()!=null) {
Triangle tri = q.betriangle1();
if(tri.bianchonghe(n))
System.out.println("The line is coincide with one of the lines");
else{
ArrayList<Point> jd = tri.jiaodians(n);
System.out.print(jd.size());
if(jd.size()==2) {
double mj = tri.fgmianji(new Line(jd.get(0),jd.get(1)));
if(mj<(tri.mianji()-mj))
System.out.println(" "+output(mj)+" "+output((tri.mianji()-mj)));
else
System.out.println(" "+output((tri.mianji()-mj))+" "+output(mj));
}
}
}
else if(q.betriangle2()!=null) {
Triangle tri = q.betriangle2();
if(tri.bianchonghe(n))
System.out.println("The line is coincide with one of the lines");
else{
ArrayList<Point> jd = tri.jiaodians(n);
System.out.print(jd.size());
if(jd.size()==2) {
double mj = tri.fgmianji(new Line(jd.get(0),jd.get(1)));
System.out.println(" "+output(mj)+" "+output((tri.mianji()-mj)));
}
}
}
else
System.out.println("not a quadrilateral or triangle");
}
}
}
// 选项五：输出第一个点是否在四边形或三角形的内部
static void xx5() {
int err=Judge.judge(s.substring(2),5);
if(err==1)
System.out.println("Wrong Format");
else if(err==2)
System.out.println("wrong number of points");
else {
points=Trans.trans(s.substring(2));
Point n = points.get(0);
Quadrangle q = new Quadrangle(points.get(1),points.get(2),points.get(3),points.get(4));
if(q.bequadrangle()) {
if(q.xianshang(n))
System.out.println("on the quadrilateral");
else if(q.nei(n))
System.out.println("in the quadrilateral");
else
System.out.println("outof the quadrilateral");
}
else if(q.betriangle1()!=null) {
Triangle tri = q.betriangle1();
if(tri.xianshang(n))
System.out.println("on the triangle");
else if(tri.neibu(n))
System.out.println("in the triangle");
else
System.out.println("outof the triangle");
}
else if(q.betriangle2()!=null) {
Triangle tri = q.betriangle2();
if(tri.xianshang(n))
System.out.println("on the triangle");
else if(tri.neibu(n))
System.out.println("in the triangle");
else
System.out.println("outof the triangle");
}
else {
System.out.println("not a quadrilateral or triangle");
}
}
}
}
心得：
这次代码的设计还有很多的不合理，首先，没有使用继承于多态，导致代码量过大，其次对于重复、反复的代码没有做成函数来简化，最后，有一些类方法的设计不合理，进行了反复，不必要的运算。我认识到在写代码时要有“长远的目光”，不能只关注于眼前的问题，要注重于解决一类问题，而非一个问题，这样设计出来的类在重复利用，被其他同种问题的类继承与改写将会有很大的简便。
（2）期中考试的7-3
第一步：建立容器类
class GeometryObject{
ArrayList<Element> r = new ArrayList<Element>();
GeometryObject(){
}
public void add(Element element) {
r.add(element);
}
public void remove(int index) {
r.remove(index-1);
}
public ArrayList<Element> getList() {
return r;
}
}
abstract class Element{
public abstract void display();
}
第二步：继承容器类
class Plane extends Element{
String color;
Plane(){
}
Plane(String color){
this.color=color;
}
public String getcolor() {
return color;
}
public void setcolor(String color) {
this.color=color;
}
@Override
public void display() {
System.out.println("The Plane's color is:"+color);
}
}
class Point extends Element{
private double x;
private double y;
Point(){
}
Point(double x,double y){
this.x=x;
this.y=y;
}
public double getx() {
return x;
}
public double gety() {
return y;
}
public void setx(double x) {
this.x=x;
}
public void sety(double y) {
this.y=y;
}
@Override
public void display() {
System.out.println("("+String.format("%.2f",x)+","+String.format("%.2f",y)+")");
}
}
class Line extends Element{
Point point1;
Point point2;
String color;
Line(){
}
Line(Point p1,Point p2,String color){
this.point1=p1;
this.point2=p2;
this.color=color;
}
public Point getpoint1() {
return point1;
}
public Point getpoint2() {
return point2;
}
public void setpoint1(Point p1) {
this.point1=p1;
}
public void setpoint2(Point p2) {
this.point2=p2;
}
public String getcolor() {
return color;
}
public void setcolor(String color) {
this.color=color;
}
public double getDistance() {
return Math.sqrt(Math.pow(point1.getx()-point2.getx(),2)+Math.pow(point1.gety()-point2.gety(),2));
}
@Override
public void display() {
System.out.println("The line's color is:"+color);
System.out.println("The line's begin point's Coordinate is:");
point1.display();
System.out.println("The line's end point's Coordinate is:");
point2.display();
System.out.println("The line's length is:"+String.format("%.2f",getDistance()));
}
}
第三步：完成题目要求，建立主类
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
GeometryObject list = new GeometryObject();
int index;
double x1;double y1;
double x2;double y2;
String color = new String();
int choice = in.nextInt();
while(choice != 0) {
switch(choice) {
case 1:
Point p = new Point();
x1=in.nextDouble();
y1=in.nextDouble();
if(x1==judge(x1)&&y1==judge(y1)) {
p.setx(x1);p.sety(y1);
list.add(p);
}
else {
System.out.println("Wrong Format");
return;
}
break;
case 2:
Line l = new Line();
x1=in.nextDouble();
y1=in.nextDouble();
x2=in.nextDouble();
y2=in.nextDouble();
color=in.next();
if(x1==judge(x1)&&y1==judge(y1)&&x2==judge(x2)&&y2==judge(y2)) {
l.setpoint1(new Point(x1,y1));
l.setpoint2(new Point(x2,y2));
l.setcolor(color);
list.add(l);
}
else {
System.out.println("Wrong Format");
return;
}
break;
case 3:
Plane plane = new Plane();
color=in.next();
plane.setcolor(color);
list.add(plane);
break;
case 4:
index = in.nextInt();
if(index<=list.getList().size())
list.remove(index);
}
choice = in.nextInt();
}
ArrayList<Element> r = new ArrayList<Element>();
r=list.getList();
Element element;
for(int i=0; i<r.size(); i++) {
element=r.get(i);
element.display();
}
in.close();
}
static double judge(double x) {
if(x<=200&&x>0)
return x;
else
return x-1;
}
}
心得：本题相对来说较为简单，但是这道题引导我们将一步步的了解继承与多态，由浅入深，并且让我们不断对问题进行重构，加深对知识点的理解。
（3）第四次作业的7-1、7-2
第一步：添加处理数据的类；即删除重复点及共线点。
class Delete{
// 输入：点集合
// 输出：不含重合点和三点一线情况的点集合
public static void delete(ArrayList<Point> p){
chonghe(p);
tongxian(p);
}
public static void chonghe(ArrayList<Point> p){
for(int i=0; i<p.size()-1; i++) {
for(int j=i+1; j<p.size(); j++) {
if(p.get(i).juli(p.get(j))==0) {
p.remove(j);j--;
}
}
}
}
private static void tongxian(ArrayList<Point> p){
for(int i=1; i<p.size()-1; i++) {
if(new Line(p.get(i-1),p.get(i+1)).juli(p.get(i))<0.0000001) {
p.remove(i);i--;
}
}
if(new Line(p.get(p.size()-2),p.get(p.size()-1)).juli(p.get(0))<0.0000001)
p.remove(p.size()-1);
}
}
第二步：将原来的三角形类和四边形类进行重构，使用继承与多态，让代码更简便，有利于后续五边形类的设计。
class Triangle{
Point a;
Point b;
Point c;
Triangle(Point a,Point b,Point c) {
this.a=a;
this.b=b;
this.c=c;
}
public String toString(){
return "triangle";
}
// 输入：
// 输出：三点是否构成三角形
public boolean be() {
if(new Line(a,b).juli(c)<0.0000001)
return false;
return true;
}
// 输入：
// 输出：三角形是否等腰
public boolean dengyao() {
if((a.juli(b)==a.juli(c))||(a.juli(b)==b.juli(c))||(a.juli(c)==b.juli(c)))
return true;
else
return false;
}
// 输入：
// 输出：三角形是否等边
public boolean dengbian() {
if(a.juli(b)==a.juli(c)&&a.juli(b)==b.juli(c))
return true;
else
return false;
}
// 输入：
// 输出：三角形是否为钝角三角形
public boolean dunjiao() {
if(a.juli(b)*a.juli(b)+b.juli(c)*b.juli(c)<a.juli(c)*a.juli(c))
return true;
else if(a.juli(c)*a.juli(c)+b.juli(c)*b.juli(c)<a.juli(b)*a.juli(b))
return true;
else if(a.juli(b)*a.juli(b)+a.juli(c)*a.juli(c)<b.juli(c)*b.juli(c))
return true;
return false;
}
// 输入：
// 输出：三角形是否为直角三角形
public boolean zhijao() {
if(Math.abs(a.juli(b)*a.juli(b)+b.juli(c)*b.juli(c)-a.juli(c)*a.juli(c))<0.000001)
return true;
else if(Math.abs(a.juli(c)*a.juli(c)+b.juli(c)*b.juli(c))-a.juli(b)*a.juli(b)<0.000001)
return true;
else if(Math.abs(a.juli(b)*a.juli(b)+a.juli(c)*a.juli(c)-b.juli(c)*b.juli(c))<0.000001)
return true;
return false;
}
// 输入：
// 输出：三角形是否为锐角三角形
public boolean ruijiao() {
if(a.juli(b)*a.juli(b)+b.juli(c)*b.juli(c)>a.juli(c)*a.juli(c))
return true;
else if(a.juli(c)*a.juli(c)+b.juli(c)*b.juli(c)>a.juli(b)*a.juli(b))
return true;
else if(a.juli(b)*a.juli(b)+a.juli(c)*a.juli(c)>b.juli(c)*b.juli(c))
return true;
return false;
}
// 输入：
// 输出：三角形周长
public double zhouchang() {
return (a.juli(b)+a.juli(c)+b.juli(c));
}
// 输入：
// 输出：三角形面积
public double mianji() {
return 0.5*a.juli(b)*new Line(a,b).juli(c);
}
// 输入：
// 输出：三角形重心
public Point zhongxin() {
return new Point((a.x+b.x+c.x)/3.0,(a.y+b.y+c.y)/3.0);
}
// 输入：一条线
// 输出：是否与某条边重合
public boolean xchonghe(Line n) {
if(n.juli(a)==0&&n.juli(b)==0)
return true;
if(n.juli(a)==0&&n.juli(c)==0)
return true;
if(n.juli(b)==0&&n.juli(c)==0)
return true;
return false;
}
// 输入：一条分割线
// 输出：与三角形的交点的链表
public ArrayList<Point> jiaodians(Line n) {
ArrayList<Point> jd = new ArrayList<>();
Point jdian;
Line A = new Line(a, b);
if(!A.pingxing(n)) {
jdian = A.jiaodian(n);
if(A.nei(jdian))
jd.add(jdian);
}
Line B = new Line(a, c);
if(!B.pingxing(n)) {
jdian = B.jiaodian(n);
if(B.nei(jdian))
jd.add(jdian);
}
Line C = new Line(b, c);
if(!C.pingxing(n)) {
jdian = C.jiaodian(n);
if(C.nei(jdian))
jd.add(jdian);
}
if(n.juli(a)==0)
jd.add(a);
else if(n.juli(b)==0)
jd.add(b);
else if(n.juli(c)==0)
jd.add(c);
return jd;
}
// 输入：一条由与三角形交点组成的分割三角形的线
// 输出：三角形被分割后所得三角形的面积（未分大小）
public double fgmianji(ArrayList<Point> jd,ArrayList<Point> points) {
ArrayList<Point> tc = new ArrayList<Point>();
Line n = new Line(jd.get(0),jd.get(1));
tche(tc,n);
return fgmianji1(tc,n);
}
public void tche(ArrayList<Point> tc,Line n){
if(n.dairu(a))
tc.add(a);
if(n.dairu(b))
tc.add(b);
if(n.dairu(c))
tc.add(c);
}
public double fgmianji1(ArrayList<Point> tc,Line n){
if(tc.size()==1)
return new Triangle(n.a,n.b,tc.get(0)).mianji();
if(tc.size()==2) {
Quadrangle u = new Quadrangle(n.a,n.b,tc.get(0),tc.get(1));
if(u.be())
return u.mianji();
return new Quadrangle(n.b,n.a,tc.get(0),tc.get(1)).mianji();
}
return 0;
}
// 输入：一个点
// 输出：是否在三角形内
public boolean nei(Point n) {
double sum = 0;
sum+=new Triangle(n,a,b).mianji()+new Triangle(n,b,c).mianji()+new Triangle(n,a,c).mianji();
if(Math.abs(mianji()-sum)<0.0000001)
return true;
return false;
}
// 输入：一个点
// 输出：是否在三角形线上
public boolean xianshang(Point g) {
Line A = new Line(a, b);
Line B = new Line(b, c);
Line C = new Line(a, c);
if(A.nei(g)||B.nei(g)||C.nei(g))
return true;
if(ddshang(g))
return true;
return false;
}
// 输入：一个点
// 输出：是否在三角形顶点上
public boolean ddshang(Point g) {
if(g.juli(a)<0.0000001||g.juli(b)<0.0000001||g.juli(c)<0.0000001)
return true;
return false;
}
}
class Quadrangle extends Triangle{
Point d;
Quadrangle(Point a,Point b,Point c,Point d){
super(a,b,c);
this.d=d;
}
public String toString(){
return "quadrilateral";
}
// 输入：
// 输出：是否构成四边形
public boolean be() {
Line dui1 = new Line(a,c);
Line dui2 = new Line(b,d);
Point dian = dui1.jiaodian(dui2);
if(dui1.juli(b)<0.0000001||dui1.juli(d)<0.0000001)
return false;
if(dui2.juli(a)<0.0000001||dui2.juli(c)<0.0000001)
return false;
if((dui1.nei(dian))||(dui2.nei(dian)))
return true;
return false;
}
// 输入：
// 输出：是否为平行四边形
public boolean pxsbx() {
if(be()&&new Line(a,b).pingxing(new Line(c,d))&&new Line(a,d).pingxing(new Line(b,c)))
return true;
return false;
}
// 输入：
// 输出：是否为菱形
public boolean lx() {
if(pxsbx()&&(a.juli(b)==a.juli(d)))
return true;
return false;
}
// 输入：
// 输出：是否为矩形
public boolean jx() {
if(pxsbx()&&new Line(a,b).chuizhi(new Line(b,c)))
return true;
return false;
}
// 输入：
// 输出：是否为正方形
public boolean zfx() {
if(jx()&&Math.abs(a.juli(b)-b.juli(c))<0.0000001)
return true;
return false;
}
// 输入：
// 输出：true凸四边形，false凹四边形
public boolean at() {
Line dui1 = new Line(a,c);
Line dui2 = new Line(b,d);
Point dian = dui1.jiaodian(dui2);
if((dui1.nei(dian))&&(dui2.nei(dian)))
return true;
return false;
}
// 输入：
// 输出：周长
public double zhouchang() {
return a.juli(b)+b.juli(c)+c.juli(d)+d.juli(a);
}
// 输入：
// 输出：面积
public double mianji() {
Line dui1 = new Line(a,c);
Line dui2 = new Line(b,d);
Point dian = dui1.jiaodian(dui2);
if(dui1.nei(dian))
return Math.abs(new Triangle(b,d,a).mianji()+new Triangle(b,d,c).mianji());
else
return Math.abs(new Triangle(a,c,b).mianji()+new Triangle(a,c,d).mianji());
}
// 输入：一条直线
// 输出：直线是否与某条边重合
public boolean xchonghe(Line n) {
if(super.xchonghe(n)&&(n.juli(a)!=0||n.juli(c)!=0))
return true;
if(n.juli(d)<0.0000001&&n.juli(a)<0.0000001)
return true;
if(n.juli(d)<0.0000001&&n.juli(c)<0.0000001)
return true;
return false;
}
// 输入：一条直线
// 输出：与四边形的交点集
public ArrayList<Point> jiaodians(Line n) {
ArrayList<Point> jd = new ArrayList<>();
Point jdian;
jd.addAll(super.jiaodians(n));
jd.addAll(new Triangle(a,c,d).jiaodians(n));
Delete.delete(jd);
Line D = new Line(a,c);
jdian = D.jiaodian(n);
if(D.nei(jdian))
for(int i=0; i<jd.size(); i++)
if(jdian.juli(jd.get(i))<0.0000001) {
jd.remove(i);i--;
}
return jd;
}
// 输入：一条分割线
// 输出：分割后所得其中一个三角形或四边形的面积（未分大小）
public double fgmianji(ArrayList<Point> jd,ArrayList<Point> points) {
ArrayList<Point> tc = new ArrayList<Point>();
Line n = new Line(jd.get(0),jd.get(1));
tche(tc,n);
if(fgmianji1(tc,n)!=0) {
return fgmianji1(tc,n);
}
ArrayList<Point> lyc = new ArrayList<Point>();
for(int i=0; i<4; i++)
if(!tc.contains(points.get(i)))
lyc.add(points.get(i));
return fgmianji1(lyc,n);
}
public void tche(ArrayList<Point> tc,Line n){
super.tche(tc, n);
if(n.dairu(d))
tc.add(d);
}
public double fgmianji1(ArrayList<Point> tc,Line n){
if(tc.size()==1)
return new Triangle(n.a,n.b,tc.get(0)).mianji();
if(tc.size()==2) {
Quadrangle u = new Quadrangle(n.a,n.b,tc.get(0),tc.get(1));
if(u.be())
return u.mianji();
return new Quadrangle(n.b,n.a,tc.get(0),tc.get(1)).mianji();
}
return 0;
}
// 输入：一个点
// 输出：点是否在四边形上
public boolean xianshang(Point n) {
Line C = new Line(c, d);
Line D = new Line(d, a);
if((super.xianshang(n)&&!new Line(a,c).nei(n))||C.nei(n)||D.nei(n))
return true;
if(d.juli(n)<0.0000001)
return true;
return false;
}
// 输入：一个点
// 输出：是否在四边形顶点上
public boolean ddshang(Point g) {
if(super.ddshang(g)||g.juli(d)<0.0000001)
return true;
return false;
}
// 输入：一个点
// 输出：点是否在四边形内
public boolean nei(Point n) {
double sum = 0;
sum+=new Triangle(n,a,b).mianji()+new Triangle(n,b,c).mianji()+new Triangle(n,c,d).mianji()+new Triangle(n,d,a).mianji();
if(Math.abs(sum-mianji())<0.0000001)
return true;
return false;
}
}
第三步：进行五边形类的设计，并使其继承四边形类。
class Pentagon extends Quadrangle{
Point e;
Pentagon(Point a,Point b,Point c,Point d,Point e){
super(a,b,c,d);
this.e=e;
}
public String toString(){
return "pentagon";
}
// 输入：
// 输出：是否构成五边形
public boolean be() {
Line A=new Line(a,b);Line B=new Line(b,c);Line C=new Line(c,d);Line D=new Line(d,e);Line E=new Line(e,a);
if(!bepentagon1(A,C)||!bepentagon1(A,D)||!bepentagon1(A,E)||!bepentagon1(B,D)||!bepentagon1(B,E)||!bepentagon1(C,E))
return false;
return true;
}
private boolean bepentagon1(Line A,Line B) {
Point o = A.jiaodian(B);
if(A.nei(o)&&B.nei(o))
return false;
return true;
}
// 输入：一条直线
// 输出：直线是否与某条边重合
public boolean xchonghe(Line n) {
if(super.xchonghe(n)&&(n.juli(d)!=0||n.juli(a)!=0))
return true;
if(n.juli(a)<0.0000001&&n.juli(e)<0.0000001)
return true;
if(n.juli(d)<0.0000001&&n.juli(e)<0.0000001)
return true;
return false;
}
// 输入：
// 输出：是否构成凸五边形
public boolean at() {
if(super.at()&&!super.nei(e))
return true;
return false;
}
// 输入：
// 输出：五边形的周长
public double zhouchang() {
return a.juli(b)+b.juli(c)+c.juli(d)+d.juli(e)+a.juli(e);
}
// 输入：
// 输出：凸五边形的面积
public double mianji() {
return new Quadrangle(a,b,c,d).mianji()+new Triangle(a,d,e).mianji();
}
// 输入：
// 输出：直线与凸五边形的交点
public ArrayList<Point> jiaodians(Line n){
ArrayList<Point> jd = new ArrayList<>();
Point jdian;
jd.addAll(super.jiaodians(n));
jd.addAll(new Triangle(d,e,a).jiaodians(n));
Delete.delete(jd);
Line D = new Line(d, a);
jdian = D.jiaodian(n);
if(D.nei(jdian))
for(int i=0; i<jd.size(); i++)
if(jdian.juli(jd.get(i))<0.0000001) {
jd.remove(i);i--;
}
return jd;
}
// 输入：一条分割线
// 输出：分割后所得其中一个三角形或四边形的面积（未分大小）
public double fgmianji(ArrayList<Point> jd,ArrayList<Point> points) {
ArrayList<Point> tc = new ArrayList<Point>();
Line n = new Line(jd.get(0),jd.get(1));
tche(tc,n);
if(fgmianji1(tc,n)!=0) {
return fgmianji1(tc,n);
}
ArrayList<Point> lyc = new ArrayList<Point>();
for(int i=0; i<5; i++)
if(!tc.contains(points.get(i)))
lyc.add(points.get(i));
return fgmianji1(lyc,n);
}
public void tche(ArrayList<Point> tc,Line n){
super.tche(tc, n);
if(n.dairu(e))
tc.add(e);
}
// 输入：一个点
// 输出：点是否在五边形内
public boolean nei(Point n) {
double sum = 0;
sum+=new Triangle(n,a,b).mianji()+new Triangle(n,b,c).mianji()+new Triangle(n,c,d).mianji()+new Triangle(n,d,e).mianji()+new Triangle(n,e,a).mianji();
if(Math.abs(sum-mianji())<0.0000001)
return true;
return false;
}
// 输入：一个点
// 输出：点是否在五边形上
public boolean xianshang(Point n) {
Line D = new Line(d, e);
Line E = new Line(e, a);
if((super.xianshang(n)&&!new Line(a,c).nei(n))||E.nei(n)||D.nei(n))
return true;
if(e.juli(n)<0.0000001)
return true;
return false;
}
// 输入：一个点
// 输出：是否在四边形顶点上
public boolean ddshang(Point g) {
if(super.ddshang(g)||g.juli(e)<0.0000001)
return true;
return false;
}
}
心得：继承与多态对于代码的简化作用是很大的，例如：
public void tche(ArrayList<Point> tc,Line n){
super.tche(tc, n);
if(n.dairu(e))
tc.add(e);
}
// 输入：一个点
// 输出：是否在四边形顶点上
public boolean ddshang(Point g) {
if(super.ddshang(g)||g.juli(e)<0.0000001)
return true;
return false;
}
// 选项三：计算交点数及分割面积
static void xx3() {
if(!haveerr(Judge.judge(s.substring(2),7))){
points=Trans.trans(s.substring(2));
Line n = new Line(points.get(0),points.get(1));
points.remove(0);points.remove(0);
Delete.delete(points);
if(!n.beLine()) System.out.println("points coincide");
else{
Triangle tri = zuhe(points);
if(tri==null) {
System.out.println("not a polygon");return;}
if(tri.xchonghe(n))
System.out.println("The line is coincide with one of the lines");
else{
ArrayList<Point> jd = tri.jiaodians(n);
System.out.print(jd.size());
if(jd.size()==2) {
double mj = tri.fgmianji(jd,points);
if(mj<(tri.mianji()-mj))
System.out.println(" "+output(mj)+" "+output((tri.mianji()-mj)));
else
System.out.println(" "+output((tri.mianji()-mj))+" "+output(mj));
}
}
}
}
}
不仅仅是对新的类的设计，对于主类的代码也有了很大的简化。所以我们之后在处理问题时要有长远的目光，有时候使用继承与多态将会给我们带来极大的便利。
三．踩坑心得
1、在编写代码前要思考清楚，在这几次代码中我每一次都要对前一次代码进行修改，或解决一些bug，或简化一些步骤，尤其是最后一次，在原代码的基础上将其转换为继承与多态的形式，花费了较多的时间和精力。
2、在使用类时，比如String类，ArrayList类以及自己设计的类要注意是管理者而非拥有者，正如C语言中的指针，在涉及数据的更改时更需要注意，否则会产生很大的困扰。我在设计选项5和选项6时因为没有意识到这一点导致我将两个多边形的顶点分离时有一些我意料不到的错误，花费了较多的时间来解决它。下面附上解决后的部分代码：
static void xx4() {
if(!haveerr(Judge.judge(s.substring(2),10))){
Triangle tri;Triangle tri1;
points=Trans.trans(s.substring(2));
points1 = new ArrayList<Point>();
for(int i=5; i<points.size(); i++)
points1.add(points.get(i));
points.removeAll(points1);
Delete.delete(points);
Delete.delete(points1);
tri=zuhe(points);tri1=zuhe(points1);
if(tri==null||tri1==null) {
System.out.println("not a polygon");return;}
int n1=neibu(tri,points1);int n2=neibu(tri1,points);int b1=bian(tri,points1);int b2=bian(tri1,points);int x1=xs(tri,points1);int x2=xs(tri1,points);
if(n1==0&&n2==0)
System.out.println("no overlapping area between the previous "+tri+" and the following "+tri1);
else if(b1==points1.size()&&b2==points.size())
System.out.println("the previous "+tri+" coincides with the following "+tri1);
else if(n2==points.size())
System.out.println("the previous "+tri+" is inside the following "+tri1);
else if(n1==points1.size())
System.out.println("the previous "+tri+" contains the following "+tri1);
else if((b1==1&&n1==1&&n2==1)||(bianch(tri)&&(n2==2||n1==2)))
System.out.println("the previous "+tri+" is connected to the following "+tri1);
else
System.out.println("the previous "+tri+" is interlaced with the following "+tri1);
}
}
四．改进建议
1、以后在编写代码之前我应当要思考清楚该怎么写，让真正编写代码时思路清晰，目标明确，同时也能够减少后续代码的修改。这一点是我当前急需改进的，我认为有明确的思路是编写一个好代码最基础的。附上我两次对于四边形分割面积方法的设计：（后者为改后）
// 输入：一条分割线
// 输出：分割后所得其中一个三角形或四边形的面积（未分大小）
public double fgmianji(ArrayList<Point> points) {
Line ac=new Line(a,c);
Line bd=new Line(b,d);
Line n=new Line(points.get(0),points.get(1));
// 分割成两个四边形
if(fgcsbx(points.get(0),points.get(1),new Line(a,b),new Line(c,d)))
return new Quadrangle(points.get(1),points.get(0),b,c).mianji();
if(fgcsbx(points.get(1),points.get(0),new Line(a,b),new Line(c,d)))
return new Quadrangle(points.get(0),points.get(1),b,c).mianji();
if(fgcsbx(points.get(0),points.get(1),new Line(a,d),new Line(b,c)))
return new Quadrangle(points.get(0),points.get(1),c,d).mianji();
if(fgcsbx(points.get(1),points.get(0),new Line(a,d),new Line(b,c)))
return new Quadrangle(points.get(1),points.get(0),c,d).mianji();
// 分割成两个三角形
if(ac.juli(points.get(0))-0<0.0000001&&ac.juli(points.get(1))-0<0.0000001)
return new Triangle(a,b,c).mianji();
if(bd.juli(points.get(0))-0<0.0000001&&bd.juli(points.get(1))-0<0.0000001)
return new Triangle(b,c,d).mianji();
// 分割成三角形和多边形
if(fgcsj(n,new Triangle(a,c,d),ac))
return new Triangle(n.a,n.b,d).mianji();
if(fgcsj(n,new Triangle(a,c,b),ac))
return new Triangle(n.a,n.b,b).mianji();
if(fgcsj(n,new Triangle(b,d,a),bd))
return new Triangle(n.a,n.b,a).mianji();
if(fgcsj(n,new Triangle(b,d,c),bd))
return new Triangle(n.a,n.b,c).mianji();
return 0;
}
// 输入：一条分割线
// 输出：分割后所得其中一个三角形或四边形的面积（未分大小）
public double fgmianji(ArrayList<Point> jd,ArrayList<Point> points) {
ArrayList<Point> tc = new ArrayList<Point>();
Line n = new Line(jd.get(0),jd.get(1));
tche(tc,n);
if(fgmianji1(tc,n)!=0) {
return fgmianji1(tc,n);
}
ArrayList<Point> lyc = new ArrayList<Point>();
for(int i=0; i<4; i++)
if(!tc.contains(points.get(i)))
lyc.add(points.get(i));
return fgmianji1(lyc,n);
}
public void tche(ArrayList<Point> tc,Line n){
super.tche(tc, n);
if(n.dairu(d))
tc.add(d);
}
public double fgmianji1(ArrayList<Point> tc,Line n){
if(tc.size()==1)
return new Triangle(n.a,n.b,tc.get(0)).mianji();
if(tc.size()==2) {
Quadrangle u = new Quadrangle(n.a,n.b,tc.get(0),tc.get(1));
if(u.be())
return u.mianji();
return new Quadrangle(n.b,n.a,tc.get(0),tc.get(1)).mianji();
}
return 0;
}
2、在这几次代码编写时没有将太多的注意力放在代码封装等上，只是简单的完成目标而已，在以后编写代码时应当注意，一个好的代码不但是高效的、能解决问题的，同时安全性也是其中非常重要的一部分。
五．总结
1、这几次代码的设计让我认识到面向对象与面向过程的区别，对于面向对象来说，类的设计至关重要，能否把类的基础设计好是对后续代码编写难易、好坏有极大的影响。
2、我开始意识到继承与多态在处理一些问题时的优点。正如这几次多边形题目来说，在使用了继承与多态之后，我的代码有了很大的简化，编写五边形类的思路也清晰了很多，编写时也比编写四边形类时要反复更改的代码较少。
3、在算法上，即处理问题上，我也需要加强练习，逐渐培养自己的模式，完善自己解决问题的方法，提升自己这方面的能力。
4、课外我要多多了解其他的知识，我意识到光靠老师上课时讲的东西时远远不够的，自己在课外也要不断学习，比如继承与多态的知识、图像等方面的知识、以及更底层的一些知识等等，不断增强自我学习能力，利用百度、csdn等网络资源帮助我们解决问题，提升自我。
标签：总结性,return,get,期中考试,public,Blog,new,Line,tc 来源： https://www.cnblogs.com/xieweimeng/p/16272499.html