前言：

  本次博客包含的内容有pta题目集4（四边形）、5（五边形）以及期中考试三次题目集。其中第四次和第五次题目集难度较大，比较复杂，涉及的知识点也比较多。而期中考试由于是在课堂上完成，难度较小，代码长度也比较少。

  这次的作业由于有了一定的基础，写起题目来也更加规范，也在老师的讲解后学会了继承与多态以及对象数组、动态链表的使用方法。

设计与分析：

  题目4-7-2：点线形系列4-凸四边形的计算

用户输入一组选项和数据，进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入四个点坐标，判断是否是四边形、平行四边形，判断结果输出true/false，结果之间以一个英文空格符分隔。
2：输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
3：输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
4：输入六个点坐标，前两个点构成一条直线，后四个点构成一个四边形或三角形，输出直线与四边形（也可能是三角形）相交的交点数量。如果交点有两个，再按面积从小到大输出四边形(或三角形)被直线分割成两部分的面积（不换行）。若直线与四边形或三角形的一条边线重合，输出"The line is coincide with one of the lines"。若后四个点不符合四边形或三角形的输入，输出"not a quadrilateral or triangle"。
后四个点构成三角形的情况：假设三角形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z 不与xy都相邻，如z x y s、x z s y、x s z y
5：输入五个点坐标，输出第一个是否在后四个点所构成的四边形（限定为凸四边形，不考虑凹四边形）或三角形（判定方法见选项4）的内部（若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the triangle/outof the triangle）。如果点在多边形的某条边上，输出"on the triangle或者on the quadrilateral"。若后四个点不符合四边形或三角形，输出"not a quadrilateral or triangle"。

输入格式:

基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。

输出格式:

基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
注意：输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0

选项1、2、3中，若四边形四个点中有重合点，输出"points coincide"。
选项4中，若前两个输入线的点重合，输出"points coincide"。

输入样例9:

选项3，。例如：

  1. 3:0,0 -10,100 0,99 10,100

输出样例:

在这里给出相应的输出。例如：

  1. false 221.097 990.0

题目分析：

  这个题目需要我们设计一个四边形的类，我的思路是要用到四个point点类以及六个line边类来存储四边形的四个点和四条边和两条对角线，此外我们还用了两个大小为四的对象数组来存四个点和四条边

  1.     point a;
  2.     point b;
  3.     point c;
  4.     point d;
  5.     line ab;
  6.     line bc;
  7.     line cd;
  8.     line ad;
  9.     line ac;
  10.     line bd;
  11.     point[] dian=new point[4];
  12.     line[] bian =new line[4];

  判断是否是四边形我的思路是判断对角线交点是否在任一对角线内，这样就可以排除所有的不是四边形的情况。而平行四边形则是在四边形的基础上判断是否有一组对边平行且相等。

  1. /*判断是否四边形
  2.     是则true否则false
  3.      */
  4.     boolean isQuadrangle() {
  5.         if (isPointEql()) {
  6.             return false;
  7.         } else if (ab.shifoupingxin(bc) || ab.shifoupingxin(ad) || bc.shifoupingxin(cd) || cd.shifoupingxin(ad)) {
  8.             return false;
  9.         }
  10.         point m = new point();
  11.         m = ac.qiujiaodain(bd);
  12.         return (ac.xianduannei(m) || bd.xianduannei(m));
  13.     }
  15.  /*判断平行四边形
  16.     是则true否则false
  17.      */
  18.     boolean isRhomboid() {
  19.         if (isQuadrangle()) {
  20.             return ab.shifoupingxin(cd) && bc.shifoupingxin(ad);
  21.         } else
  22.             return false;
  23.     }

判断菱形的方法是平行四边形的情况下判断对角线是否垂直；矩形的方法是平行四边形的情况下判断是否有一个角为直角；正方形的方法是判断是否同时为菱形和矩形。

  1.     /*判断菱形
  2.     是则true否则false
  3.      */
  4.     boolean isRhombus() {
  5.         if (isRhomboid()) {
  6.             return ac.shifoucuizhi(bd);
  7.         }
  8.         return false;
  9.     }
  11.     /*判断矩形
  12.     是则true否则false
  13.      */
  14.     boolean isRectangle() {
  15.         if (isRhomboid()) {
  16.             return ab.shifoucuizhi(bc);
  17.         }
  18.         return false;
  19.     }
  21.     /*判断正方形
  22.    是则true否则false
  23.     */
  24.     boolean isSquare() {
  25.         if (isRhomboid()) {
  26.             return isRhombus() && isRectangle();
  27.         }
  28.         return false;
  29.     }

判断凹凸四边形是判断对角线是否相交，相交则为凸四边形，否则为凹四边形。面积用的是求对角线分割的两个三角形的面积之和，凹四边形则求两个对角线分别分隔的两三角形面积之和中更小的一个。周长则是四条边的长度之和

  1.      /*判断凹凸四边形
  2.     凹四边形false，凸四边形true
  3.      */
  4.     boolean isTuQuadrangle() {
  5.         point o = new point();
  6.         o = ac.qiujiaodain(bd);
  7.         return ac.xianduannei(o) && bd.xianduannei(o);
  8.     }
  9.     /*求周长
  10.     返回周长的double值
  11.      */
  12.     double perimeter() {
  13.         return ab.length + bc.length + cd.length + ad.length;
  14.     }
  16.     /*求面积
  17.     返回四边形面积
  18.      */
  19.     double area() {
  20.         triangle t1 = new triangle();
  21.         triangle t2 = new triangle();
  22.         triangle t3 = new triangle();
  23.         triangle t4 = new triangle();
  24.         t1.createTriangle(a, b, c);
  25.         t2.createTriangle(a, c, d);
  26.         t3.createTriangle(a, b, d);
  27.         t4.createTriangle(b, c, d);
  28.         if (isTuQuadrangle()) {
  30.             return t1.mianji() + t2.mianji();
  31.         } else {
  32.             return Math.min(t1.mianji() + t2.mianji(), t4.mianji() + t3.mianji());
  33.         }
  34.     }

判断四个点是否为三角形，以及去除冗余点的方法如下

  1.    /*判断是否是一个三角形
  2.     是则true否则false
  3.      */
  4.     boolean isTriangle() {
  5.         if (a.iseql(b) || a.iseql(c) || a.iseql(d) || b.iseql(c) || b.iseql(d) || c.iseql(d)) {
  6.             return true;
  7.         } else
  8.             return ac.xianduannei(b) || ac.xianduannei(d) || bd.xianduannei(a) || bd.xianduannei(c);
  9.     }
  11.     /*如果是个三角形，去除冗余点
  12.     返回三角形
  13.      */
  14.     triangle threePoint() {
  15.         triangle t = new triangle();
  16.         if (a.iseql(b) || a.iseql(c) || a.iseql(d)) {
  17.             t.createTriangle(b, c, d);
  18.         } else if (b.iseql(c) || b.iseql(d)) {
  19.             t.createTriangle(a, c, d);
  20.         } else if (c.iseql(d)) {
  21.             t.createTriangle(a, b, c);
  22.         } else if (ac.xianduannei(b)) {
  23.             t.createTriangle(a, c, d);
  24.         } else if (ac.xianduannei(d)) {
  25.             t.createTriangle(a, b, c);
  26.         } else if (bd.xianduannei(a)) {
  27.             t.createTriangle(b, c, d);
  28.         } else if (bd.xianduannei(c)) {
  29.             t.createTriangle(a, b, d);
  30.         }
  31.         return t;
  32.     }

求直线与四边形交点的个数方法，以及求被分割的较大部分面积的方法如下。


  2.     /*求交点个数
  3.     输入一条直线
  4.     输出直线与四边形的交点
  5.      */
  6.     int numOfPoint(line l) {
  7.         int sum = 0;
  8.         triangle t1 = new triangle();//分成两个三角形求线段l与两三角形的交点个数
  9.         t1.createTriangle(a, b, c);
  10.         triangle t2 = new triangle();
  11.         t2.createTriangle(a, d, c);
  12.         if (l.shifoupingxin(ac) && l.iszhixianshang(a) && l.iszhixianshang(c)) {//线段ac与l重合
  13.             if (l.onTheLine(a))
  14.                 sum++;
  15.             if (l.onTheLine(c))
  16.                 sum++;
  17.             return sum;
  18.         } else if (l.shifoupingxin(ac) && !l.iszhixianshang(a)) {//l和ac平行
  19.             sum = t1.jiaodiangeshu(l) + t2.jiaodiangeshu(l);
  20.             return sum;
  21.         } else if (l.onTheLine(a) || l.onTheLine(c)) {//顶点a或c在直线l上
  22.             sum = t1.jiaodiangeshu(l) + t2.jiaodiangeshu(l) - 1;
  23.             return sum;
  24.         } else if (ac.onTheLine(l.qiujiaodain(ac)) && l.onTheLine(l.qiujiaodain(ac))) {//l与ac交点在线段ac内
  25.             sum = t2.jiaodiangeshu(l) + t1.jiaodiangeshu(l) - 2;
  26.             return sum;
  27.         } else//l与ac交点不在线段ac内
  28.             sum = t1.jiaodiangeshu(l) + t2.jiaodiangeshu(l);
  29.         return sum;
  30.     }
  32.     /*求四边形被直线l分割的两部分面积较大的那部分面积
  33.     输入线段l
  34.     输出较大部分面积
  35.      */
  36.     double biggerArea(line l) {
  37.         point[] P = new point[4];
  38.         line[] L = new line[4];
  39.         P[0] = a;
  40.         P[1] = b;
  41.         P[2] = c;
  42.         P[3] = d;
  43.         L[0] = ab;
  44.         L[1] = bc;
  45.         L[2] = cd;
  46.         L[3] = ad;
  47.         if (isTuQuadrangle()) {//凸四边形的情况
  48.             for (int i = 0; i < 2; i++) {//l过对角线，分隔为两个三角形
  49.                 if (l.iszhixianshang(P[i]) && l.iszhixianshang(P[i + 2])) {
  50.                     triangle t1 = new triangle();
  51.                     t1.createTriangle(P[i], P[i + 1], P[i + 2]);
  52.                     return Math.max(t1.mianji(), area() - t1.mianji());
  53.                 }
  54.             }
  55.             for (int i = 0; i < 4; i++) {//l过一个顶点，分割为一个三角形和一个四边形
  56.                 if (l.iszhixianshang(P[i]) && L[(i + 1) % 4].xianduannei(l.qiujiaodain(L[(i + 1) % 4]))) {
  57.                     triangle t1 = new triangle();
  58.                     t1.createTriangle(P[i], P[(i + 1) % 4], l.qiujiaodain(L[(i + 1) % 4]));
  59.                     return Math.max(t1.mianji(), area() - t1.mianji());
  60.                 }
  61.                 if (l.iszhixianshang(P[i]) && L[(i + 2) % 4].xianduannei(l.qiujiaodain(L[(i + 2) % 4]))) {
  62.                     triangle t1 = new triangle();
  63.                     t1.createTriangle(P[i], P[(i + 3) % 4], l.qiujiaodain(L[(i + 2) % 4]));
  64.                     return Math.max(t1.mianji(), area() - t1.mianji());
  65.                 }
  66.             }
  67.             for (int i = 0; i < 2; i++) {//l分隔为两个四边形mncb和mndc
  68.                 if (L[i].xianduannei(l.qiujiaodain(L[i])) && L[i + 2].xianduannei(l.qiujiaodain(L[i + 2]))) {
  69.                     quadrangle q1 = new quadrangle();
  70.                     point m = l.qiujiaodain(L[i]);
  71.                     point n = l.qiujiaodain(L[i + 2]);
  72.                     q1.setQuadrangle(m, n, P[i + 2], P[i + 1]);
  73.                     return Math.max(q1.area(), area() - q1.area());
  74.                 }
  75.             }
  76.             for (int i = 0; i < 4; i++) {//l分隔为一个三角形和一个五边形
  77.                 if (L[i].xianduannei(l.qiujiaodain(L[i])) && L[(i + 1) % 4].xianduannei(l.qiujiaodain(L[(i + 1) % 4]))) {
  78.                     triangle t1 = new triangle();
  79.                     point m = l.qiujiaodain(L[i]);
  80.                     point n = l.qiujiaodain(L[(i + 1) % 4]);
  81.                     t1.createTriangle(P[(i + 1) % 4], m, n);
  82.                     return Math.max(t1.mianji(), area() - t1.mianji());
  83.                 }
  84.             }
  86.         } else {
  87.             for (int i = 0; i < 4; i++) {//l分隔为一个三角形和一个五边形
  88.                 if (L[i].xianduannei(l.qiujiaodain(L[i])) && L[(i + 1) % 4].xianduannei(l.qiujiaodain(L[(i + 1) % 4]))) {
  89.                     triangle t1 = new triangle();
  90.                     point m = l.qiujiaodain(L[i]);
  91.                     point n = l.qiujiaodain(L[(i + 1) % 4]);
  92.                     t1.createTriangle(P[(i + 1) % 4], m, n);
  93.                     return Math.max(t1.mianji(), area() - t1.mianji());
  94.                 }
  95.             }
  97.         }
  99.         return 0;
  100.     }

判断点是否在四边形内的方法如下。


  2.     /*判断点是否在图形内
  3.     输入一个点
  4.     若点在四边形内返回0在四边形上返回1四边形外返回2
  5.      */
  6.     int isInQar(point m) {
  7.         point n = new point();
  8.         n.setpoint(999, -99);
  9.         line l = new line();
  10.         l.setl(m, n);
  11.         if (ab.xianduannei(m) || bc.xianduannei(m) || cd.xianduannei(m) || ad.xianduannei(m) || a.iseql(m) || b.iseql(m) || c.iseql(m) || d.iseql(m))
  12.             return 1;
  13.         else if (numOfPoint(l) == 1)
  14.             return 0;
  15.         else if (numOfPoint(l) != 1) {
  16.             return 2;
  17.         }
  18.         return 2;
  20.     }

这是各类之间的联系图

这是SourceMonitor生成的报表内容

踩坑心得：

  刚开始写这道题的时候没有用对象数组存四个点和四条边，导致后面计算直线与四边形交点个数和求分隔的面积时有太多重复的相似代码，完全可以使用对象数组存储四个点和边，这样只要考虑一种情况就能应用到四条边上。一开始也没注意是求直线与四边形交点个数，写的时候是按照线段与四边形交点各数求的，属实是没仔细看题犯糊涂了。

题目5-7：点线形系列5-凸五边形的计算

用户输入一组选项和数据，进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入五个点坐标，判断是否是五边形，判断结果输出true/false。
2：输入五个点坐标，判断是凹五边形（false）还是凸五边形(true)，如果是凸五边形，则再输出五边形周长、面积，结果之间以一个英文空格符分隔。 若五个点坐标无法构成五边形，输出"not a pentagon"
3：输入七个点坐标，前两个点构成一条直线，后五个点构成一个凸五边形、凸四边形或凸三角形，输出直线与五边形、四边形或三角形相交的交点数量。如果交点有两个，再按面积从小到大输出被直线分割成两部分的面积（不换行）。若直线与多边形形的一条边线重合，输出"The line is coincide with one of the lines"。若后五个点不符合五边形输入，若前两点重合，输出"points coincide"。

以上3选项中，若输入的点无法构成多边形，则输出"not a polygon"。输入的五个点坐标可能存在冗余，假设多边形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如：x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z不与xy都相邻，如：z x y s、x z s y、x s z y

4：输入十个点坐标，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），判断它们两个之间是否存在包含关系（一个多边形有一条或多条边与另一个多边形重合，其他部分都包含在另一个多边形内部，也算包含）。
两者存在六种关系：1、分离（完全无重合点） 2、连接（只有一个点或一条边重合） 3、完全重合 4、被包含（前一个多边形在后一个多边形的内部）5、交错 6、包含（后一个多边形在前一个多边形的内部）。
各种关系的输出格式如下：
1、no overlapping area between the previous triangle/quadrilateral/ pentagon and the following triangle/quadrilateral/ pentagon
2、the previous triangle/quadrilateral/ pentagon is connected to the following triangle/quadrilateral/ pentagon
3、the previous triangle/quadrilateral/ pentagon coincides with the following triangle/quadrilateral/ pentagon
4、the previous triangle/quadrilateral/ pentagon is inside the following triangle/quadrilateral/ pentagon
5、the previous triangle/quadrilateral/ pentagon is interlaced with the following triangle/quadrilateral/ pentagon
6、the previous triangle/quadrilateral/ pentagon contains the following triangle/quadrilateral/ pentagon

5：输入十个点坐标，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），输出两个多边形公共区域的面积。注：只考虑每个多边形被另一个多边形分割成最多两个部分的情况，不考虑一个多边形将另一个分割成超过两个区域的情况。
6：输入六个点坐标，输出第一个是否在后五个点所构成的多边形（限定为凸多边形，不考虑凹多边形），的内部（若是五边形输出in the pentagon/outof the pentagon，若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the triangle/outof the triangle）。输入入错存在冗余点要排除，冗余点的判定方法见选项5。如果点在多边形的某条边上，输出"on the triangle/on the quadrilateral/on the pentagon"。
以上4、5、6选项输入的五个点坐标可能存在冗余，假设多边形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如：x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z不与xy都相邻，如：z x y s、x z s y、x s z y

输入格式:

基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。

输出格式:

基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
注意：输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0

输入样例1:

选项1，点重合。例如：

  1. 1:-1,-1 1,2 -1,1 1,0

输出样例:

在这里给出相应的输出。例如：

  1. wrong number of points

输入样例:

在这里给出一组输入。例如：

  1. 4:0,0 6,0 7,1 8,3 6,6 0,0 6,0 7,1 8,3 6,6

输出样例:

在这里给出相应的输出。例如：

  1. the previous pentagon coincides with the following

题目分析：

本题我们需要设计一个五边形的类，我的设计思路是用五个point点类存放五边形的五个点，十个line线类来存放五条边和五条对角线，还用到对象数组来存放这些点和边。

  1.     point a=new point();
  2.     point b=new point();
  3.     point c=new point();
  4.     point d=new point();
  5.     point e=new point();
  6.     line ab,bc,cd,de,ea;
  7.     line ac,ce,eb,bd,da;
  8.     point[] dian=new point[5];
  9.     line[] bian =new line[5];
  10.     line[] djx =new line[5];

判断是否为五边形和凸五边形的方法如下：


  2.     /*判断是否为五边形
  3.     是则返回true否则false
  4.      */
  5.     boolean isFiveAngle(){
  6.         for (int i = 0; i < 5; i++) {
  7.             if (bian[i].shifoupingxin(bian[(i+1)%5])){
  8.                 return false;
  9.             } else if (bian[i].xiangjiao(bian[(i+2)%5])||bian[i].xiangjiao(bian[(i+3)%5])) {
  10.                 return false;
  11.             }
  12.         }
  13.         return true;
  14.     }
  15.     /*判断是否为凸五边形
  16.     是则返回true否则false
  17.      */
  18.     boolean isTuFiveAngle (){
  19.         if(isFiveAngle()){
  20.             for (int i = 0; i < 5; i++) {
  21.                 if (!djx[i].xiangjiao(djx[(i+2)%5])||!djx[i].xiangjiao(djx[(i+3)%5]))
  22.                     return false;
  23.             }
  24.             return true;
  25.         }return false;
  26.     }

求五边形周长，面积的方法如下：

  1.     /*求五边形周长
  2.     返回五边形的周长
  3.      */
  4.     double perimeter(){
  5.         double sum=0;
  6.         for (int i = 0; i < 5; i++) {
  7.             sum+=bian[i].length;
  8.         }
  9.         return sum;
  10.     }
  11.     /*求五边形面积
  12.     返回五边形的面积
  13.      */
  14.     double area(){
  16.         if (isTuFiveAngle()){
  17.             triangle t=new triangle(a,b,c);
  18.             quadrangle q=new quadrangle(a,c,d,e);
  19.             return t.mianji()+q.area();
  20.         }
  21.         else {
  22.             return 0;
  23.         }
  24.     }

判断是否为四边形并去除冗余点的方法如下：

  1. /*判断是否是四边形
  2. 是返回true否则false
  3.  */
  4. boolean isQuadrangle(){
  5.     for (int i = 0; i < 5; i++) {
  6.         for (int j = i; j < 4; j++) {
  7.             if (dian[i].iseql(dian[(j+1)%5])){
  8.                 return true;
  9.             }
  10.         }
  12.         line l=new line(dian[(i+1)%5],dian[(i+4)%5]);
  13.         if (l.onTheLine(dian[i])){
  14.             return true;
  15.         }
  16.     }
  17.     return false;
  18. }
  19. /*若是四边形返回四边形，去除冗余点
  20. 返回四边形
  21.  */
  22. quadrangle fourPoint(){
  23.     quadrangle q=new quadrangle();
  24.     for (int i = 0; i < 5; i++) {
  25.         for (int j = i; j < 4; j++) {
  26.             if (dian[i].iseql(dian[(j+1)%5])){
  27.                 q.setQuadrangle(dian[(i+1)%5],dian[(i+2)%5],dian[(i+3)%5],dian[(i+4)%5]);
  28.             }
  29.         }
  31.         line l=new line(dian[(i+1)%5],dian[(i+4)%5]);
  32.         if (l.onTheLine(dian[i])){
  33.             q.setQuadrangle(dian[(i+1)%5],dian[(i+2)%5],dian[(i+3)%5],dian[(i+4)%5]);
  34.         }
  35.     }return q;
  36. }

求直线与五边形交点个数的方法如下：

  1. /*求线和五边形交点个数
  2. 输入一条线段
  3. 输出交点个数
  4.  */
  5. int numOfPoint(line l){
  6.     int sum=0;
  7.     triangle t=new triangle(a,b,c);
  8.     quadrangle q=new quadrangle(a,c,d,e);
  9.     if (ac.chonghe(l)){
  10.         if (l.onTheLine(a))
  11.             sum++;
  12.         if (l.onTheLine(c))
  13.             sum++;
  14.     }
  15.     else if (l.shifoupingxin(ac)&&!l.onTheLine(a))
  16.     {
  17.         sum=t.jiaodiangeshu(l)+q.numOfPoint(l);
  19.     } else if (l.onTheLine(a)||l.onTheLine(c)) {
  20.         sum=t.jiaodiangeshu(l)+q.numOfPoint(l)-1;
  21.     } else if (l.xiangjiao(ac)) {
  22.         sum=t.jiaodiangeshu(l)+q.numOfPoint(l)-2;
  23.     } else if (!l.xiangjiao(ac)) {
  24.         sum=t.jiaodiangeshu(l)+q.numOfPoint(l);
  25.     }
  26.     return sum;
  27. }

求被直线分隔的较大部分面积如下：

  1. /*若交点个数为2，求被分割的两部分面积中较大的那部分
  2. 输入一条线段
  3. 返回较大部分的面积
  4.  */
  5. double biggerArea(line l){
  6.     double s=0;
  7.     for (int i = 0; i < 5; i++) {
  8.         if (l.onTheLine(dian[i])){//点在线上
  9.             if (l.onTheLine(dian[(i+2)%5])){//两点在线上
  10.                 triangle t=new triangle(dian[i],dian[(i+1)%5],dian[(i+2)%5]);
  11.                 s=Math.max(t.mianji(),area()-t.mianji());
  12.                 return s;
  13.             }
  14.             if (l.onTheLine(dian[(i+3)%5])){
  15.                 triangle t=new triangle(dian[i],dian[(i+3)%5],dian[(i+4)%5]);
  16.                 s=Math.max(t.mianji(),area()-t.mianji());
  17.                 return s;
  18.             }
  19.             if (l.xiangjiao(bian[(i+1)%5])){//一个为三角形，一个为六边形
  20.                 triangle t=new triangle(dian[i],dian[(i+1)%5],l.qiujiaodain(bian[(i+1)%5]));
  21.                 s=Math.max(area()-t.mianji(),t.mianji());
  22.             }
  23.             if (l.xiangjiao(bian[(i+2)%5])){//一个为四边形，一个为五边形
  24.                 quadrangle q=new quadrangle(dian[i],dian[(i+1)%5],dian[(i+2)%5],l.qiujiaodain(bian[(i+2)%5]));
  25.                 s=Math.max(area()-q.area(),q.area());
  26.             }
  27.             if (l.xiangjiao(bian[(i+3)%5])){//一个为三角形，一个为六边形
  28.                 triangle t=new triangle(dian[i],dian[(i+4)%5],l.qiujiaodain(bian[(i+3)%5]));
  29.                 s=Math.max(area()-t.mianji(),t.mianji());
  30.             }
  31.         }
  32.         if (l.xiangjiao(bian[i])&&l.xiangjiao(bian[(i+1)%5])){//若与两条邻边相交,一个三角形一个六边形
  33.             triangle t=new triangle(dian[(i+1)%5],l.qiujiaodain(bian[i]),l.qiujiaodain(bian[(i+1)%5]));
  34.             s= Math.max(area()-t.mianji(),t.mianji());
  35.             break;
  36.             }
  37.         if (l.xiangjiao(bian[i])&&l.xiangjiao(bian[(i+2)%5])){//若不与邻边相交，一个四边形，一个五边形
  38.             quadrangle q=new quadrangle(dian[(i+1)%5],dian[(i+2)%5],l.qiujiaodain(bian[i]),l.qiujiaodain(bian[(i+2)%5]));
  39.             s= Math.max(area()-q.area(),q.area());
  40.             break;
  41.         }
  43.     }
  44.     return s;
  45. }

判断点是否在五边形内部的方法如下：


  2. /*判断点是否在五边形内部
  3. 输入一个点
  4. 若在五边形内部输出true 否则false
  5.  */
  6. boolean isPointIn(point m){
  7.     point x=new point(99,-999);
  8.     line l=new line(x,m);
  9.     return numOfPoint(l)==1;
  10. }
  11. /*判断点是否在五边形的边上
  12. 输入一个点
  13. 若在边上输出true 否则输出false
  14.  */
  15. boolean isPointOn(point m){
  16.     for (int i = 0; i < 5; i++) {
  17.         if (bian[i].onTheLine(m))
  18.             return true;
  19.     }
  20.     return false;
  21. }

这是本题各类之间的联系图

这是SourceMonitor生成的报表内容

踩坑心得：

  本次题目的难度比较大，我有好多点没有做出来，所以这次的代码量比较少，实现了基本的内容。其他的内容没有来的及去完成。本题也用了对象数组来帮助我们完成计算交点个数等方法，这里的一些方法的主要思想基本和前两次的内容差不多，所以我就没有进行过多的赘述，大家也应该能够看得懂。

改进建议：

  本次题目剩余的功能可以用求五条边的交点个数和点是否在图形内的方法结合起来进行计算求解，若五个点都在另一个五边形的外面就是分离，若五个点都在五边形内部就是包含或被包含，若两各五边形有交点就是交错，若只有一个交点或一条边重合就是连接，五个点完全相同就是重合。大致思路就是这样的，具体的实现我没有来的及去完成。

期中考试：

  期中考试一共有三题，都是关于点线面的重构，由于是在课堂上完成的，题目难度并不大，主要是考查多态与继承和动态数组的掌握程度，大家在完成了前面几次题目集后想必这种难度的题目应当是都不会有什么太大的问题。

  7-1 点与线（类设计）

  • 设计一个类表示平面直角坐标系上的点Point，私有属性分别为横坐标x与纵坐标y，数据类型均为实型数，除构造方法以及属性的getter与setter方法外，定义一个用于显示信息的方法display(),用来输出该坐标点的坐标信息，格式如下：(x,y)，数值保留两位小数。为简化题目，其中，坐标点的取值范围设定为(0,200]。若输入有误，系统则直接输出Wrong Format

  • 设计一个类表示平面直角坐标系上的线Line，私有属性除了标识线段两端的点point1、point2外，还有一个字符串类型的color，用于表示该线段的颜色，同样，除构造方法以及属性的getter与setter方法外，定义一个用于计算该线段长度的方法getDistance(),还有一个用于显示信息的方法display(),用来输出线段的相关信息，输出格式如下：

    1.   ```
    2.       The line's color is:颜色值
    3.       The line's begin point's Coordinate is:
    4.       (x1,y1)
    5.       The line's end point's Coordinate is:
    6.       (x2,y2)
    7.       The line's length is:长度值
    8.   ```

    其中，所有数值均保留两位小数，建议可用String.format("%.2f", data)方法。

    1.   设计类图如下图所示。
     

** 题目要求：在主方法中定义一条线段对象，从键盘输入该线段的起点坐标与终点坐标以及颜色，然后调用该线段的display()方法进行输出。**

  • 以下情况为无效作业

    • 无法运行
    • 设计不符合所给类图要求
    • 未通过任何测试点测试
    • 判定为抄袭

输入格式:

分别输入线段的起点横坐标、纵坐标、终点的横坐标、纵坐标以及颜色，中间可用一个或多个空格、tab或者回车分隔。

输出格式:

  1. The line's color is:颜色值
  2. The line's begin point's Coordinate is:
  3. (x1,y1)
  4. The line's end point's Coordinate is:
  5. (x2,y2)
  6. The line's length is:长度值
输入样例1:

在这里给出一组输入。例如：

  1. 5
  2. 9.4
  3. 12.3
  4. 84
  5. Red
 
输出样例1:

在这里给出相应的输出。例如：

  1. The line's color is:Red
  2. The line's begin point's Coordinate is:
  3. (5.00,9.40)
  4. The line's end point's Coordinate is:
  5. (12.30,84.00)
  6. The line's length is:74.96
 
7-2 点线面问题重构（继承与多态）

在“点与线（类设计）”题目基础上，对题目的类设计进行重构，以实现继承与多态的技术性需求。

  • 对题目中的点Point类和线Line类进行进一步抽象，定义一个两个类的共同父类Element（抽象类），将display()方法在该方法中进行声明（抽象方法），将Point类和Line类作为该类的子类。
  • 再定义一个Element类的子类面Plane，该类只有一个私有属性颜色color，除了构造方法和属性的getter、setter方法外，display()方法用于输出面的颜色，输出格式如下：The Plane's color is:颜色
  • 在主方法内，定义两个Point（线段的起点和终点）对象、一个Line对象和一个Plane对象，依次从键盘输入两个Point对象的起点、终点坐标和颜色值（Line对象和Plane对象颜色相同），然后定义一个Element类的引用，分别使用该引用调用以上四个对象的display()方法，从而实现多态特性。示例代码如下： 
    1.       element = p1;//起点Point
    2.       element.display();
    4.       element = p2;//终点Point
    5.       element.display();
    7.       element = line;//线段
    8.       element.display();
    10.       element = plane;//面
    11.       element.display();
     
     

    类结构如下图所示。

其中，所有数值均保留两位小数，建议可用String.format("%.2f", data)方法。

  • 以下情况为无效作业

    • 无法运行
    • 设计不符合所给类图要求
    • 未通过任何测试点测试
    • 判定为抄袭

输入格式:

分别输入线段的起点横坐标、纵坐标、终点的横坐标、纵坐标以及颜色，中间可用一个或多个空格、tab或者回车分隔。

输出格式:

  1. (x1,y1)
  2. (x2,y2)
  3. The line's color is:颜色值
  4. The line's begin point's Coordinate is:
  5. (x1,y1)
  6. The line's end point's Coordinate is:
  7. (x2,y2)
  8. The line's length is:长度值
  9. The Plane's color is:颜色值
7-3 点线面问题再重构（容器类）

 

在“点与线（继承与多态）”题目基础上，对题目的类设计进行重构，增加容器类保存点、线、面对象，并对该容器进行相应增、删、遍历操作。

  • 在原有类设计的基础上，增加一个GeometryObject容器类，其属性为ArrayList<Element>类型的对象（若不了解泛型，可以不使用<Element>）
  • 增加该类的add()方法及remove(int index)方法，其功能分别为向容器中增加对象及删除第index - 1（ArrayList中index>=0）个对象
  • 在主方法中，用户循环输入要进行的操作（choice∈[0,4]），其含义如下：
    • 1：向容器中增加Point对象
    • 2：向容器中增加Line对象
    • 3：向容器中增加Plane对象
    • 4：删除容器中第index - 1个数据，若index数据非法，则无视此操作
    • 0：输入结束

    示例代码如下：

    1.    choice = input.nextInt();
    2.     while(choice != 0) {
    3.         switch(choice) {
    4.         case 1://insert Point object into list
    5.           ...
    6.             break;
    7.         case 2://insert Line object into list
    8.             ...
    9.             break;
    10.         case 3://insert Plane object into list
    11.             ...
    12.             break;
    13.         case 4://delete index - 1 object from list
    14.             int index = input.nextInt();
    15.             ...
    16.         }
    17.         choice = input.nextInt();
    18.     }
     
     

    输入结束后，按容器中的对象顺序分别调用每个对象的display()方法进行输出。
    类图如下所示：

  • 以下情况为无效作业

    • 无法运行
    • 设计不符合所给类图要求
    • 未通过任何测试点测试
    • 判定为抄袭

输入格式:

  1. switch(choice) {
  2.             case 1://insert Point object into list
  3.               输入“点”对象的x，y值
  4.                 break;
  5.             case 2://insert Line object into list
  6.                 输入“线”对象两个端点的x，y值
  7.                 break;
  8.             case 3://insert Plane object into list
  9.                 输入“面”对象的颜色值
  10.                 break;
  11.             case 4://delete index - 1 object from list
  12.                 输入要删除的对象位置（从1开始）
  13.                 ...
  14.             }
 
 

输出格式:

  • Point、Line、Plane的输出参考题目2
  • 删除对象时，若输入的index超出合法范围，程序自动忽略该操作

输入样例:

在这里给出一组输入。例如：

  1. 1
  2. 3.4
  3. 5.6
  4. 2
  5. 4.4
  6. 8.0
  7. 0.98
  8. 23.888
  9. Red
  10. 3
  11. Black
  12. 1
  13. 9.8
  14. 7.5
  15. 3
  16. Green
  17. 4
  18. 3
  19. 0

题目分析：

  由于这三题的关联性较强，我就一起进行分析了：分析题目后我们得知，父类只需要有一个display的方法就可以了，而电线面类都继承父类element，这里的父类主要是一种身份识别的功能，点线面类都是element这种类型的类，我们在第三题写动态数组时就要用到这种特性。具体的实现没有什么难点，大家直接按照题目给的类图完成基本没有什么问题，我就直接放代码了。

这里是用到的点线面类和他们的父类以及最后的容器类：


  2. abstract class Element{
  3.     abstract void display();
  4. }
  5. class Point extends Element{
  6.     private double x,y;
  7.     public Point(){}
  8.     public Point(double x,double y){
  9.         this.x=x;
  10.         this.y=y;
  11.     }
  12.     boolean isIn0to200(){
  13.         return (x>0&&x<=200&&y>0&&y<=200);
  14.     }
  16.     public double getX() {
  17.         return x;
  18.     }
  20.     public double getY() {
  21.         return y;
  22.     }
  24.     public void setX(double x) {
  25.         this.x = x;
  26.     }
  28.     public void setY(double y) {
  29.         this.y = y;
  30.     }
  31.     void display(){
  32.         System.out.println("("+String.format("%.2f",x)+","+String.format("%.2f",y)+")");
  33.     }
  34. }
  36. class Line extends Element{
  37.     private Point point1=new Point();
  38.     private Point point2=new Point();
  39.     private String color;
  40.     public Line(){}
  41.     public Line(Point x,Point y,String color){
  42.         this.point1=x;
  43.         this.point2=y;
  44.         this.color=color;
  45.     }
  47.     public Point getPoint1() {
  48.         return point1;
  49.     }
  51.     public Point getPoint2() {
  52.         return point2;
  53.     }
  55.     public String getColor() {
  56.         return color;
  57.     }
  59.     public void setColor(String color) {
  60.         this.color = color;
  61.     }
  63.     public void setPoint2(Point point2) {
  64.         this.point2 = point2;
  65.     }
  67.     public void setPoint1(Point point1) {
  68.         this.point1 = point1;
  69.     }
  70.     double getDistance(){
  71.         double d=0;
  72.         d= Math.pow((point1.getX()- point2.getX()),2)+Math.pow((point1.getY()- point2.getY()),2);
  73.         return Math.sqrt(d);
  74.     }
  75.     void display(){
  76.         System.out.println("The line's color is:"+color);
  77.         System.out.println("The line's begin point's Coordinate is:");
  78.         point1.display();
  79.         System.out.println("The line's end point's Coordinate is:");
  80.         point2.display();
  81.         System.out.println("The line's length is:"+String.format("%.2f",getDistance()));
  83.     }
  84. }
  86. class Plane extends Element{
  87.     String color;
  88.     public Plane(){}
  89.     public Plane(String color){
  90.         this.color=color;
  91.     }
  93.     public String getColor() {
  94.         return color;
  95.     }
  97.     public void setColor(String color) {
  98.         this.color = color;
  99.     }
  101.     void display(){
  102.         System.out.println("The Plane's color is:"+color);
  103.     }
  104. }
  106. class GeometryObject{
  107.     ArrayList<Element> elements=new ArrayList<>();
  108.     void add(Element element){
  109.         elements.add(element);
  110.     }
  111.     void remove(int index){
  112.         elements.remove(index-1);
  113.     }
  114.     int size(){
  115.         return elements.size();
  116.     }
  118.     public ArrayList<Element> getList() {
  119.         return elements;
  120.     }
  121. }

这是第一题的主函数：

  1. public class Main1 {
  2.     public static void main(String[] args) {
  3.         Scanner in=new Scanner(System.in);
  4.         Point p1=new Point(in.nextDouble(),in.nextDouble());
  5.         Point p2=new Point(in.nextDouble(),in.nextDouble());
  6.         if (p1.isIn0to200()&&p2.isIn0to200()){
  7.             Line line=new Line(p1,p2,in.next());
  8.             line.display();
  9.         }
  10.         else System.out.println("Wrong Format");
  12.     }
  13. }

这是第二题的主函数：


  2. public class Main2 {
  3.     public static void main(String[] args) {
  4.         Scanner in=new Scanner(System.in);
  5.         Point p1=new Point(in.nextDouble(), in.nextDouble());
  6.         Point p2=new Point(in.nextDouble(),in.nextDouble());
  7.         String color=in.next();
  8.         if (p1.isIn0to200()&&p2.isIn0to200()){
  9.             Line line=new Line(p1,p2,color);
  10.             Plane plane=new Plane(color);
  11.             Element element;
  12.             element = p1;//起点Point
  13.             element.display();
  15.             element = p2;//终点Point
  16.             element.display();
  18.             element = line;//线段
  19.             element.display();
  21.             element = plane;//面
  22.             element.display();
  23.         }else System.out.println("Wrong Format");
  25.     }
  26. }

这是第三题的主函数：

  1. public class Main3 {
  2.     public static void main(String[] args) {
  3.         Scanner in = new Scanner(System.in);
  4.         int choice = in.nextInt();
  5.         GeometryObject geometryObject = new GeometryObject();
  6.         while (choice != 0) {
  7.             switch (choice) {
  8.                 case 1:
  9.                     Point point = new Point(in.nextDouble(), in.nextDouble());
  10.                     if (point.isIn0to200()) {
  11.                         geometryObject.add(point);
  12.                     }
  13.                     break;
  15.                 case 2:
  16.                     Point p1 = new Point(in.nextDouble(), in.nextDouble());
  17.                     Point p2 = new Point(in.nextDouble(), in.nextDouble());
  18.                     if (p1.isIn0to200() && p2.isIn0to200()) {
  19.                         Line line = new Line(p1, p2, in.next());
  20.                         geometryObject.add(line);
  22.                         break;
  23.                     }
  24.                 case 3:
  25.                     String color = in.next();
  26.                     Plane plane = new Plane(color);
  27.                     geometryObject.add(plane);
  28.                     break;
  30.                 case 4:
  31.                     int index = in.nextInt();
  32.                     if (index>0&&index<=geometryObject.size()){
  33.                         geometryObject.remove(index);
  34.                     }
  36.                     break;
  37.                 default:break;
  39.             }
  40.             choice = in.nextInt();
  41.         }
  43.         for (int i = 0; i < geometryObject.size(); i++) {
  44.             geometryObject.elements.get(i).display();
  45.         }
  46.     }
  47. }

这里是各类之间的联系图：

这是SourceMonitor生成的报表内容：

踩坑心得：

  这里要注意判断给的范围是否合适，以及输出的格式是保留两位小数，可以用老师题目给的方法完成。还有while循环内要记得更新choice，第三题判断如果不合法直接略过这个点就可以了，不需要额外的输出。注意删除的是第i-1位的数组，不在数组范围内的不用删除。

总结：

  本次的三个题目中除了期中考试的题目由于课上完成难度较为简单，其他两个难度总体上来说是比较难的，涉及的知识点也多，不太容易能够融汇贯通的串联起来，还要求以前写的方法考虑的足够全面，有些时候少考虑的情况在后面也许就会用的到。这几次的作业帮助我们学习了解了继承与多态的方法，虽然我这次四边形五边形没有用到这个，但是用继承和多态会使后面的复杂度降低不少。经过这几次的作业以后，确实使我对java有了更深的理解，也让我能够更加熟练的使用java来编写程序了。感谢您的阅读！

nchu第二次面向对象编程博客作业的更多相关文章

  1. OO第二次博客作业—17373247

    OO第二次博客作业 零.写在前面 OO第二单元宣告结束,在这个单元里自己算是真正对面向对象编程产生了比较深刻的理解,也认识到了一个合理的架构为编程带来的极大的便利. (挂三次评测分数 看出得分接近等差 ...

  2. OO第二次博客作业——电梯调度

    OO第二次博客作业——电梯调度 前言 最近三周,OO课程进入多线程学习阶段,主要通过三次电梯调度作业来学习.从单部电梯的傻瓜式调度到有性能要求的调度到多部电梯的调度,难度逐渐提升,对同学们的要求逐渐变 ...

  3. OO第二次博客作业（第二单元总结）

    在我开始写这次博客作业的时候,窗外响起了希望之花,由此联想到乘坐自己写的电梯FROM-3-TO--1下楼洗澡,然后······ 开个玩笑,这么辣鸡的电梯肯定不会投入实际使用的,何况只是一次作业.还是从 ...

  4. 第二周博客作业 <西北师范大学| 周安伟>

    一,本周助教小结 逐步开始适应助教工作,对学生发布的博客进行点评,查看学生对软件工程前期的准备情况. 二,助教本人博客 https://home.cnblogs.com/u/zaw-315/ 三,学生 ...

  5. Java第二次博客作业

    Java第二次博客作业 时间过的很快啊,在不知不觉中这门课程的学习也就快要过去一半了,现在就来总结一下在这个第二个月的学习当中存在的问题以及得到的心得. 1.前言 第四次题目集和第五次题目集给我的感觉 ...

  6. oo 第一次博客作业

    oo 第一次博客作业 早在大一就听说了oo的各种传奇故事,大二下学期终于也开始了我的oo之旅. 基于度量来分析自己的程序结构 第一次作业 类图分析 耦合度分析 可以看出在第一次作业中,我的耦合度非常高 ...

  7. [BUAA OO]第三次博客作业

    OO第三次博客作业 1. 规格化设计的发展 我认为,规格化设计主要源自于软件设计的两次危机.第一次是由于大量存在的goto语句,让当时被广泛应用的面向过程式的编程语言臃肿不堪,在逻辑性上与工程规模上鱼 ...

  8. OO第三次博客作业——规格

    OO第三次博客作业——规格 一.调研结果: 规格的历史: 引自博文链接:http://blog.sina.com.cn/s/blog_473d5bba010001x9.html 传统科学的特点是发现世 ...

  9. BUAA_OO_博客作业四

    BUAA_OO_博客作业四 1 第四单元两次作业的架构设计 1.1 第13次作业 类图 ​ 作业要求:通过实现UmlInteraction这个官方提供的接口,来实现自己的UmlInteraction解 ...

  10. OO第4次博客作业

    OO第4次博客作业 一.第4单元设计 第四单元主要围绕UML图的结构进行JAVA代码编写,对JAVA的层次结构进行更多的认识.个人认为编程操作在实质上与上一章的PathContainer有许多的相同之 ...

随机推荐

  1. 一套.NET Core +WebAPI+Vue前后端分离权限框架

    今天给大家推荐一个基于.Net Core开发的企业级的前后端分离权限框架. 项目简介 这是基于.NetCore开发的.构建的简单.跨平台.前后端分离的框架.此项目代码清晰.层级分明.有着完善的权限功能 ...

  2. dockerfile 打包镜像

    打包镜像指令 docke人 build -t xxx -f dockerfile2 . xxx 镜像名称 -f 指定dockerfile2 文件 (多个文件的话) . 当前的上下文空间 dockerf ...

  3. 前端之Vue day08 Vue3项目搭建、setup、toRefs

    一.Vue3 介绍 # 新项目使用vue3,有部分老项目使用vue2 # vue3 的变化 1.性能的提升 -打包大小减少41% -初次渲染快55%, 更新渲染快133% -内存减少54% 2.源码的 ...

  4. 重新安装office原版本没卸载干净

    先在设置--卸载界面确保已经卸载 在键盘上按"win+R",在运行窗口里面输入"regedit",回车 ,进入注册表编辑器 找到products 删除与offi ...

  5. python_test_0001_base_string

    #!/usr/bin/python # -*- coding: UTF-8 -*- from lib_001_decorator_log_funcname import decorator_log_f ...

  6. Linux 扩容 / 根分区(LVM+非LVM)

    目录: 1,概述 2,CentOS7,LVM根分区扩容步骤 3,CentOS7,非LVM根分区扩容步骤: 一.背景,概述 MBR(Master Boot Record)(主引导记录)和GPT(GUID ...

  7. 【git】3.2git分支-分支的新建与合并

    资料来源 (1) https://git-scm.com/book/zh/v2/Git-%E5%88%86%E6%94%AF-%E5%88%86%E6%94%AF%E7%9A%84%E6%96%B0% ...

  8. Linux&Android相关常用命令汇总记录

    Linux&Android相关常用命令汇总记录 0@Linux&Android系统命令行下如何查看命令的帮助信息: command --help 1@在Linux系统中,设备分为三类, ...

  9. sublime4 支持中文

    sublime_text_build_4143_x64_setup 安装完毕后,工具,命令面板,install package,ChineseLocalizations

  10. 用dig或nslookup命令查询txt解析记录

    这几天想把HTTPS装上,阿里云的免费证书需要在域名解析的地方添加TXT记录.文档里用的是dig命令,我本地装了nslookup.试验下如何用咯. dig命令 dig用法很多,这里只使用dig txt ...