java题目集四，实验二，期中考试题目总结

前言

  在pta题目集4中，共有三题，第一题和第三题都相对容易，难度较低，考察的是使用正则表达式和设计一个类，根据题目含义以及使用split语句和一些java基本语法语句，能够完成这两个题目。第二题主要考察算法，当然也需要使用正则表达式否则语句复杂度会很大，第二题的算法对我而言还是具有挑战性，虽然前面题目集三有过类似算法，但其中还是有所不同，使用多个算法不断尝试使用，但仍然有bug，而测试点是层层递进的，导致数个测试点无法通过。

  在实验二中，主要涉及的是类和类方法的构造，以及数据隐藏后的处理，难度低。需要根据所给代码来补充完善农夫过河的代码，实现其功能，然后再对farmer,wolf,sheep,cabbage进行数据封装的改进，将属性隐藏。增加Boat（船）类，设计船类的相应方法，并修改main方法中相关的代码，改进农夫带东西过河的功能，解决之前代码中存在的农夫带东西过河的判断问题。为wolf,sheep 两个类添加带Stirng name参数的构造函数得出相应输出结果。题目理解起来不难，根据题目要求可一步一步实现，完成相应输出。

  在期中考试题目中，一共有三道题目，三题层层递进的关系，每题在前一题的基础上有所增加或修改，但整体难度不难，根据题目所给类图和题意分析即可完成。第一题考察的是类设计方面的知识，难度低，只需要根据题目给出的类图以及题意，按部就班的，使用Java类设计的方法和语法语句，一步步写下去就能够完成。第二题考察的是继承与多态方面的知识，难度较低，只需建立父类抽象类，加入抽象方法，形成继承关系，要注意抽象方法不能赋空。第三题考察的是容器类方面的知识，创建一个容器存入Element类对象，根据类图和题意，创建相应方法能够完成该题目，要注意remove方法删除的位置是下标位置。

设计与分析

  题目集四：

 7-2 点线形系列4-凸四边形的计算（70分）

用户输入一组选项和数据，进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
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"。

 

 

 度量分析：

 

 

   这题考察算法，题目含义清楚，创建了点、线两个类，刚开始使用正则表达式判断输入格式是否正确，再通过switch语句选择对应选项，然后构造相应的方法完成题目所给测试点，但是计算的算法思路不清晰，四边形判断方法的算法有误，无法正确判断所有是否能构成四边形的情况，于是数个与四边形判断有关的测试点无法通过，其他测试点均能够通过。

主要代码分析：

boolean b=a.matches("^[1-5]{1}\\:(((\\-|\\+)?([1-9]\\d*|0)(\\.\\d+)?)\\,((\\-|\\+)?([1-9]\\d*|0)(\\.\\d+)?)){1}((\\s(((\\-|\\+)?([1-9]\\d*|0)(\\.\\d+)?)\\,((\\-|\\+)?([1-9]\\d*|0)(\\.\\d+)?)))*(\\s)?)");

代码思路：为了避免代码的复杂性，因此学习了正则表达式用来方便的判断输入格式的正确性，如果正确则输出true否则false，刚开始没对输入点的个数判断正确，导致一个测试点无法通过，经过改良，该正则表达式能够很好正确的判断出输入格式是否正确。

public void test5(Point a,Point b,Point c,Point d,Point e) {
        if(!sibianxing(b,c,d,e)&&!sanjiaoxing(b,c,d,e)) {
            System.out.println("not a quadrilateral or triangle");
        }
        else {
            if(sibianxing(b,c,d,e)) {
                if((panduan(a,b,c)&&pan(b,a,c))||(panduan(a,c,d)&&pan(c,a,d))||(panduan(a,d,e)&&pan(d,a,e))||(panduan(a,e,b)&&pan(e,a,b))) {
                    System.out.println("on the quadrilateral");
                }
                else {
                    if(tusibian(a,b,c,d,e)) {
                        System.out.println("in the quadrilateral");
                    }
                    else
                        System.out.println("outof the quadrilateral");
                }
            }
            if(sanjiaoxing(b,c,d,e)) {
                if((panduan(a,b,c)&&pan(b,a,c))||(panduan(a,c,d)&&pan(c,a,d))||(panduan(a,d,e)&&pan(d,a,e))||(panduan(a,e,b)&&pan(e,a,b))) {
                    System.out.println("on the triangle");
                }
                else {
                    if(find(b,c)||panduan(b,c,d)) {
                        double s1,s2,s3,S;
                        double x1=jisuan(b,d);
                        s1=dd(a,b,d)*x1/2;
                        double x2=jisuan(b,e);
                        s2=dd(a,b,e)*x2/2;
                        double x3=jisuan(d,e);
                        s3=dd(a,d,e)*x3/2;
                        double xx=jisuan(d,e);
                        S=dd(b,d,e)*xx/2;
                        if(Math.abs(s1+s2+s3-S)<0.00001) {
                            System.out.println("in the triangle");
                        }
                        else {
                            System.out.println("outof the triangle");
                        }
                    }
                    if(find(b,d)||find(c,d)||panduan(c,d,e)) {
                        double s1,s2,s3,S;
                        double x1=jisuan(b,c);
                        s1=dd(a,b,c)*x1/2;
                        double x2=jisuan(b,e);
                        s2=dd(a,b,e)*x2/2;
                        double x3=jisuan(c,e);
                        s3=dd(a,c,e)*x3/2;
                        double xx=jisuan(c,e);
                        S=dd(b,c,e)*xx/2;
                        if(Math.abs(s1+s2+s3-S)<0.00001) {
                            System.out.println("in the triangle");
                        }
                        else {
                            System.out.println("outof the triangle");
                        }
                    }
                    if(find(b,e)||find(c,e)||find(d,e)||panduan(d,e,b)) {
                        double s1,s2,s3,S;
                        double x1=jisuan(b,c);
                        s1=dd(a,b,c)*x1/2;
                        double x2=jisuan(b,d);
                        s2=dd(a,b,d)*x2/2;
                        double x3=jisuan(c,d);
                        s3=dd(a,c,d)*x3/2;
                        double xx=jisuan(c,d);
                        S=dd(b,c,d)*xx/2;
                        if(Math.abs(s1+s2+s3-S)<0.00001) {
                            System.out.println("in the triangle");
                        }
                        else {
                            System.out.println("outof the triangle");
                        }
                    }
                    if(panduan(e,b,c)) {
                        double s1,s2,s3,S;
                        double x1=jisuan(c,d);
                        s1=dd(a,c,d)*x1/2;
                        double x2=jisuan(c,e);
                        s2=dd(a,c,e)*x2/2;
                        double x3=jisuan(d,e);
                        s3=dd(a,d,e)*x3/2;
                        double xx=jisuan(d,e);
                        S=dd(c,d,e)*xx/2;
                        if(Math.abs(s1+s2+s3-S)<0.00001) {
                            System.out.println("in the triangle");
                        }
                        else {
                            System.out.println("outof the triangle");
                        }
                    }
                }
            }
        }
    }

代码思路：该选项五使用了许多if-else语句用于判断，先判断是否能形成四边形或三角形，再根据输入点的位置和形式，分多种情况讨论，判断点在三角形或四边形的内部或外部。因为四边形的判断算法有误，所以部分四边形相关的测试点无法通过，其他对应测试点输出。

优缺点：

  优点：

1.使用了正则表达式来判断输入格式的正确性，吸取了前几个题目集的教训，能够使得代码变得更加清晰，降低了代码的复杂度。

2.对题目给的选项五要求考虑周全，涉及多种情况，防止遗漏可能的测试点，让输出结果精准正确。

  缺点：

1.对正则表达式的使用不是非常熟练，还需要多加练习与理解，格式判断时使用需要注意格式不得遗漏或增加。

2.使用了许多if-else语句，虽然考虑周全能够概括所有测试点，但是会使代码的可读性降低。

实验二题目：

  实验二（1）：

  农夫过河问题：一个农夫带着一匹狼、一只羊、一颗白菜要过河，河上只有一条船能够渡河，而且农夫每次最多只能带一个动物或物品过河。当农夫不在的时候狼会吃羊，羊会吃白菜。

  请以代码为基础，将程序代码补充完整，实现农夫过河游戏功能：由用户选择角色过河，系统自动判断游戏的胜负：当出现有生物被吃掉的时候，游戏失败，所有角色都到了河的另一边，游戏成功。

  游戏输出示例：

  ==================Please choose operation============

    ==========1:Cross the river alone===========

    ==========2:Cross the river with wolf=========

    ==========3:Cross the river with sheep============

    ==========4:Cross the river with cabbage==========

    ==========0:Quit===============

  ===================================================

  Input the number(0~4):

  2

  Farmer has Cross  :true

  Wolf is alive  :true   Wolf has Cross  :true

  Sheep is alive :true   Sheep has Cross :false

  Cabbage is alive:false   Cabbage has Cross:false

  game over: you lose !

 

 

 度量分析：

 

 

 实验二（2）：

 农夫过河问题:将之前的代码进行如下改进：

（1）对farmer,wolf,sheep,cabbage进行数据封装的改进，将属性隐藏。

（2）增加Boat（船）类，设计船类的相应方法，并修改main方法中相关的代码，改进农夫带东西过河的功能，解决之前代码中存在的农夫带东西过河的判断问题。

（3）为wolf,sheep 两个类添加带Stirng name参数的构造函数，当创建wolf,sheep对象时，假设输入了name参数，程序分别输出：

        啊呜~~~我 *name* 狼又回来了

        咩咩，我是可爱的小羊*name*

       当wolf,sheep对象使用showStatus()方法输出状态时，输出内容要带上name的信息，如：

    Sheep *name* is alive :true   Sheep *name* has Cross : false

 

 

 度量分析：

 

 

 主要代码分析：

class Wolf{
    private String name;
    private boolean hasCross=false;
    private boolean isAlive=true;
    Wolf(String name){
        this.name = name;
        System.out.println("啊呜~~~我 *"+name+"* 狼又回来了");
    }
    Wolf() {
        
    }
    public void crossRiver() {
        if(isHasCross()==false) {
            this.setHasCross(true);
        }
        else {
            this.setHasCross(false);
        }
    }
    public void showStatus() {
        System.out.println("Wolf is alive :"+isAlive+"   Wolf has Cross :"+isHasCross());
    }
    public void showStatus(String name) {
        System.out.println("Wolf *"+name+"* is alive :"+isAlive+"   Wolf *"+name+"* has Cross :"+isHasCross());
    }
    public void eatSheep(Sheep sheep,Farmer farmer) {
        if(sheep.isHasCross()==isHasCross()&&isHasCross()!=farmer.isHasCross()) {
            sheep.setAlive(false);
        }
    }
    public boolean isHasCross() {
        return hasCross;
    }
    public void setHasCross(boolean hasCross) {
        this.hasCross = hasCross;
    }
}

代码思路：实验二（1），根据题目给出的代码和游戏规则，对应的完善相关区域。实验二（2），根据实验要求，对farmer,wolf,sheep,cabbage进行数据封装的改进，将属性隐藏。使用private对数据隐藏。隐藏完后，数据不能够直接在其他类中调用了，需要添加返回该变量值的方法用来获得该变量的值。创建一个船类，在类中创建一个判断农夫与携带的物品是否在同一边的方法，并将农夫与该物品过河的方法也放入其中。为wolf,sheep 两个类添加带Stirng name参数的构造函数，同时对创建对象的函数放入名字，对展示状态的showstatus方法也添加带String name参数的函数。从而完成题目要求。

优缺点：

优点：1.在对变量隐藏后，能够很好的设计set、get方法来获取变量，并且能够根据题目完成对应的输出要求。

2.设计的类简洁明了，结构清晰，代码复杂度低，代码可读性强。

3.对数据封装的改进，将属性隐藏，提高代码安全性，修复了判定携带物品时是否在同一边。

缺点：1.该题使用了大量重复类型的方法，是否可用继承与多态的形式，提高代码复用性。

期中考试题目集：

  7-1 点与线（类设计）（20分）

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

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

    ```
        The line's color is:颜色值
        The line's begin point's Coordinate is:
        (x1,y1)
        The line's end point's Coordinate is:
        (x2,y2)
        The line's length is:长度值
    ```
  

   

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

    设计类图如下图所示。
  

   

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

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

输入格式:

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

输出格式:

The line's color is:颜色值
The line's begin point's Coordinate is:
(x1,y1)
The line's end point's Coordinate is:
(x2,y2)
The line's length is:长度值

 

 

 

 

 

软件画的图与所给图有偏差，说明代码与题目要求的有所偏差，还需改进。

度量分析：

 

 该题目是根据题意和所给类图，设计相应的类和类方法，整体难度低，只需按部就班写下去，设计point类和Line类，Main类调用Point类和Line类，Line类调用Point类，再根据输入、输出样例，使用Point类和Line类的display方法得出对应输出，解答该题目。

主要代码分析：

class Line {
    private Point point1;
    private Point point2;
    private String color;
    Line() {
        
    }
    Line(Point p1,Point p2,String color) {
        setPoint1(p1);
        setPoint2(p2);
        setColor(color);
    }
    public Point getPoint1() {
        return point1;
    }
    public void setPoint1(Point point1) {
        this.point1=point1;
    }
    public Point getPoint2() {
        return point2;
    }
    public void setPoint2(Point point2) {
        this.point2=point2;
    }
    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));
    }
    public void display() {
        System.out.println("The line's color is:"+getColor());
        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()));
    }
}

代码思路：Line类能够调用Point类，将两个Point类和color放于Line类构造方法中，getDistance方法计算出两个点的距离，display方法调用getcolor方法、getDistance方法以及Point1、Point2的display方法，最后Main类调用Line类的display方法，得出输出样例对应的输出结果。

优缺点：

优点：1.很好的根据题目题意，使用String.format方法，构造出相应正确的类方法，并且能够完成输出样例所给要求。

2.设计的类简洁明了，结构清晰，代码复杂度低，代码可读性强。

缺点：1.所画类图与题目所给类图有所偏差，代码还需改进。

7-2 点线面问题重构（继承与多态）（40分）

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

• 对题目中的点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()方法，从而实现多态特性。示例代码如下：

        element = p1;//起点Point
        element.display();
        
        element = p2;//终点Point
        element.display();
        
        element = line;//线段
        element.display();
        
        element = plane;//面
        element.display();
  

   
  类结构如下图所示。

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

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

输入格式:

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

输出格式:

(x1,y1)

(x2,y2)

The line's color is:颜色值

The line's begin point's Coordinate is:

(x1,y1)

The line's end point's Coordinate is:

(x2,y2)

The line's length is:长度值

The Plane's color is:颜色值

 

 

度量分析：

 

 该题在前一题的基础上添加Plane类，然后添加Element父类（抽象类），将这三个Point类、Line类、Plane类作为Element类的子类，构造Plane类的对应类图的变量和方法，再通过Main类创建两个point类对象、一个Line类对象、一个Plane类对象，定义一个Element类的引用，分别使用该引用调用以上四个对象的display()方法，输出对应结果。

主要代码分析：

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        double x1=in.nextDouble();
        double y1=in.nextDouble();
        double x2=in.nextDouble();
        double y2=in.nextDouble();
        String color=in.next();
        if(x1>200||x1<=0||y1>200||y1<=0||x2>200||x2<=0||y2>200||y2<=0){
            System.out.println("Wrong Format");
        }
        else{
            Point p1=new Point(x1,y1);
            Point p2=new Point(x2,y2);
            Line line=new Line(p1,p2,color);
            Plane plane=new Plane(color);
            Element element;
            element = p1;//起点Point
            element.display();
            
            element = p2;//终点Point
            element.display();
            
            element = line;//线段
            element.display();
            
            element = plane;//面
            element.display();

            in.close();
        }
    }
}
abstract class Element {
    public abstract void display();
}

代码思路：通过获取键盘输入，构造相应的Point类对象、Plane类对象、Line类对象，将这些对象赋于element类对象，通过element类对象调用各个对象的display方法。且注意抽象类的定义和抽象方法的定义时需要使用abstract，而且抽象方法display（）不能赋空，需要写成public abstract void display();

优缺点：

优点：

1.能够明显简洁直观的调用每一个类对象，父类能够使用调用子类对象。

2.通过子类继承父类，增加了代码的复用性。

3.降低了某些方法的复杂性，避免代码重复,提高可重用性。

缺点：

1.破坏封装，子类与父类之间紧密耦合，子类依赖于父类的实现，子类缺乏独立性。
2.支持扩展，但是往往以增强系统结构的复杂度为代价。
3.不支持动态继承。在运行时，子类无法选择不同的父类。

7-3 点线面问题再重构（容器类）分数40

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

• 在原有类设计的基础上，增加一个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：输入结束
  示例代码如下：

     choice = input.nextInt();
      while(choice != 0) {
          switch(choice) {
          case 1://insert Point object into list 
            ...
              break;
          case 2://insert Line object into list
              ...
              break;
          case 3://insert Plane object into list
              ...
              break;
          case 4://delete index - 1 object from list
              int index = input.nextInt();
              ...
          }
          choice = input.nextInt();
      }
  

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

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

输入格式:

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

 

输出格式:

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

 

 

 度量分析：

 

 这题根据前两题“点与线（类设计）”和“点与线（继承与多态）”题目基础上，并且提供了类图，整体难度不大。对题目的类设计进行重构，增加一个GeometryObject容器类保存点、线、面对象，并对该容器进行相应增add方法、删remove方法、遍历（我使用的是for循环遍历输出）操作，然后通过Main类在while语句中循环使用switch语句，选择对应选项，创建对应对象使用对应方法，输入0结束循环，最后通过遍历操作，调用GeometryObject类中装入的每一个对象的display()方法。

 主要代码分析：

public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int choice;
        choice = input.nextInt();
        while(choice != 0) {
            switch(choice) {
            case 1://insert Point object into list 
                double x1=input.nextDouble();
                double y1=input.nextDouble();
                GeometryObject.add(new Point(x1,y1));
                break;
            case 2://insert Line object into list
                double x=input.nextDouble();
                double y=input.nextDouble();
                double x2=input.nextDouble();
                double y2=input.nextDouble();
                String color=input.next();
                GeometryObject.add(new Line(new Point(x,y),new Point(x2,y2),color));
                break;
            case 3://insert Plane object into list
                String color1=input.next();
                GeometryObject.add(new Plane(color1));
                break;
            case 4://delete index - 1 object from list
                int index = input.nextInt();
                GeometryObject.remove(index);
                break;
            }
            choice = input.nextInt();
        }
        for(int i=0;i<GeometryObject.list.size();i++) {
            GeometryObject.list.get(i).display();
        }
        input.close();
    }
}
class GeometryObject {
    static ArrayList<Element> list=new ArrayList<>();
    public GeometryObject(){
        
    }
    public static void add(Element element) {
        list.add(element);
    }
    public static void remove(int index) {
        if(list.size()>index-1) {
            list.remove(index-1);
        }
        return;
    }
    public ArrayList<Element> getList(){
         return list;
    }
}

代码思路：

根据题目所给题意和所给类图，使用for语句，循环使用switch语句选择，使用GeometryObject类的静态方法完成对应操作，以0结束循环。创建GeometryObject容器类中的增add方法、删除remove方法、返回链表getList方法，刚开始考试时创建list变量，无法根据类图形成私有变量，加上private后，无法调用静态变量，主类中通过GeometryObject类调用静态方法会报错，其他能够与类图一致。考试结束后，发现Main方法中应该使用getList方法获取List变量，GeometryObject容器类所有的变量和方法除了构造方法外都应该使用静态。然后根据输入格式输入，输出相应结果。

优缺点：

  优点：1.使用switch语句，代码可读性强、易于维护。

2.可以自动地调整自己的尺寸大小。在实际的编程中可以往容器中放置任何数量的对象，而不用担心容器应该设置成多大。

3.使用容器类，安全性、灵活性高。

  缺点：1.switch语句的比较是从上往下，所以需要把匹配概率大的选择因子放在前面，否则会降低效率。

2.用于匹配的选择因子必须是整形或字符型常量。

3.容易忘记使用break来防止后面的语句使用。

采坑心得

 PTA题目集四 7-2：

 

 

 1.此方法用于判断是否为四边形，但是算法效率不高，有许多情况遗漏，尝试了多种方法，只有这种相对测试点通过的更多。刚开始本想使用对边的交线的交点在内部还是外部来判断，但是存在bug测试点通过的更少了。判断是否为四边形的算法还有待提高有待精炼。

 

 

 2.该函数为改变数据位数（即对数据四舍五入，保留至三位小数），通过计算数据小数点后面有几位数，如果小于3则正常输出，否则保留三位小数四舍五入输出，该方法要注意数据输出位数以及是否四舍五入，刚开始我是直接用%.3f输出，发现有bug会出现0.100等情况。所以对算法需要更加仔细考虑、测试。

实验二：

 

 该题目比较简单，对数据进行封装，隐藏时，要想获取相关数据，需要设计类似set、get的方法来设置和获取数据变量，否则后续操作中无法获取而显示空。

期中考试第一题：

  

 

 

 该题目比较简单，只需要注意getDistance()方法中因为私有变量所以要getX、getY方法获取x、y，display()方法中需要使用getcolor方法获取color，否则到时候调用display()方法时，无法获取那些变量，导致输出有误，无法得到正常的输出结果，我之前没注意，测试时就出现问题（要切记）。

期中考试第二题：

  

 

 

 1.该题目创建抽象类和创建抽象方法时，要记住抽象方法必须在抽象类中，而抽象类可以不止放抽象方法。同时，抽象方法display不能给空，需要写成如上图public abstract void display();的形式。

 

 

 

 

 

 2.要记得写上extends，否则构成不了继承关系，对后面的使用造成影响。

 

 

 3.此方法通过将点对象、线对象、面对象赋于Element类对象，通过父类Element调用对应子类的display()方法，不能直接用相应对象调用相应方法，否则无法完成题目所给要求。

期中考试第三题：

  

 

 此题目整体难度不大，只需要理解容器类的概念，remove(int index)方法刚开始我构造时，是想要判断输入非法时返回空，其他情况执行移除操作，但是发现实现相对困难需要找出多种情况，后来换成先找出正确的情况（list的大小大于index-1）执行删除操作，其他情况返回空，这样花费的时间少，且更容易。

改进建议

题目集四7-2：

1.由SourceMonitor以及PowerDesigner软件测评结果可以得知，代码复杂度低，因为吸取了前面题目集的教训，使用正则表达式，减少了许多if-else语句的使用。但是使用正则表达式需要注意格式的问题，需要做到准确无误，此题一开始使用正则表达式时我对点的输出有所遗漏，导致测试点无法通过，故需要多训练使用正则表达式，熟悉它。

2.该题目还是考察的多边形算法问题，数个关于判断四边形的测试点没有通过，判断四边形的方法算法还有待改进，需要多加测试，将四边形算法精练，改善算法。

实验二：

由SourceMonitor的评测图以及PowerDesigner软件测评结果可知，代码复杂度低，因为主要是类的设计与构造，没有什么复杂难度，但要注意实验的要求，要能够完整的完成题目所给的要求，该题几个类的方法都有很多类似之处，因此可考虑运用继承与多态的方法来完善和改进，提高代码的复用性。

期中考试7-1、7-2、7-3：

由SourceMonitor的评测图以及PowerDesigner软件测评结果可知，代码复杂度不高，应该也是代码较简单，没有使用过多的代码。类设计方面要注意简洁明了，直观，当然也要保证类功能的齐全，在使用私有变量时get、set等方法的使用也必不可少。继承与多态方面，要注意写extends形成继承关系，同时要注意使用多态，不要还是单纯调用相应对象来调用相应的方法，使用多态来提高代码的复用性，抽象类的知识以及抽象方法使用也要多熟悉。容器类方面，要记住容器类的许多方法，有些返回值是长度有些是下标位置，要格外注意，对容器与装入容器对象的关系以及调用容器内对象的方法要理解透彻。

总结

 在java这几周的学习中，老师讲了继承与多态还有抽象类、容器类方面的知识，学习了一些java的进阶知识，同时复习了前几周学习的类与对象，类设计等的知识。在前几周学习相对清楚的情况下，学习这些进阶知识就不会那么累，相对易于理解，只需要上课认真听课，课后温习写代码多加练习即可。在java面向对象的学习中，应该多加练习代码，多提高自己的算法能力，其实也是在打牢基础，为以后更难的java知识做铺垫，避免学习后面的知识时，困难重重。

这次的题目集四、实验二和期中考试，让我明白了许多还需要提高的地方：

1.对于算法方面还需要下许多功夫，要多加练习，勤能补拙，多学习网上的算法来提高自己，掌握多种算法防止一种算法算不全。

2.正则表达式虽然学习了许多，但掌握的不牢固，使用正则表达式时要考虑周全，多注意格式，避免出现一些小错误而导致输出结果有误。

3.对于题目给出的类图要理解透彻，+表示public，-表示private，#表示protected，要注意类图的多种类型箭头的含义，能够更好地通过给出的类图完成相应的代码。

4.继承与多态的一些知识还不够理解，对父类与子类的关系理解不够清晰，抽象类方法不得给空，直接加；号结束即可。容器类的许多方法还需多背，对容器类对象的调用需要多加理解、练习。

5.课后多查阅java知识资料，可以在CSDN、MOOC等地方查阅相关Java的方法、知识，可以听听java网课，巩固自己对java的理解，并且多记住一些Java的基本函数和语法，对Java的类图和基本语法要能够看懂看明白，然后多写Java代码练习java，提高自己。