面对对象程序设计题目分析与心得2

一、前言

1.第四次题目集

　　此次题目集所遇到的知识点有正则表达式，字符串比较方法equals，对字符串用split方法分割提取字符串中数字（Ascll码）并用parseInt方法转化为可相加的数字，for-each循环遍历数组或者Arraylist容器；还有考查继承，用DecimalFormat类格式化输出，四边形判定方法，运用面积大小关系判断一个点与多边形的位置关系，对于四个点是否有冗余点，构成四边形或三角形；考查对题目的仔细分析。

2.期中考试

　　主要考查继承与多态，根据题目所给类图编写程序，对输入进行限制，运用Math类进行数学运算，使用String.format方法格式化输出，抽象类作为父类语法考查；运用ArrayList类中add和remove方法进行增加和删除。

3.第五次题目集

　　此次较第四次增加一个五边形的类，五边形的判定方法，对五个点是否有冗余的判断，判断两个多边形的位置关系，求两个多边形的公共区域，同样考查继承，大体上与第四次考查的内容差不多。

4.超星

　　超星的题目主要来源于老师课堂布置的设计类图

　　四个的题量都不多，第五次甚至只有一个题，较为简单的是期中考试，基本上仅仅考查继承并且给出了类图，其次是第四次，最后是第五次。

二、设计与分析

1.第四次题目集

　　（1)类图

　　

　　（2）圈复杂度

 

 　　（3）解释

　　此题类与类之间没有太大的联系，都是根据题目相应选项调用相应方法。

　　Judge复杂度过高是因为if-else语句太多，然后根据返回值来确定哪些点构成三角形

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

/*      * 输入：用户输入点集      * 返回：1:2 3 4构成三角形，2:1 3 4构成三角形，3:1 2 4构成三角形，4:1 2 3构成三角形，0：四个点不构成三角形      */     public static int f(ArrayList<Point> ps){ //      判断四个点是否构成三角形         if(ps.size()==5) {             Line L1 = new Line(ps.get(2), ps.get(4));//第二个点与第四个点构成的直线             Line L2 = new Line(ps.get(1), ps.get(3));//第一个点与第三个点构成的直线                   if(L1.isBetween(ps.get(1))&& !L1.isBetween(ps.get(3))|| ps.get(1).isCoincide(ps.get(2))|| ps.get(1).isCoincide(ps.get(4))) {                 return 1;             }             else if(L2.isBetween(ps.get(2))&& !L2.isBetween(ps.get(4))|| ps.get(2).isCoincide(ps.get(1))|| ps.get(2).isCoincide(ps.get(3))) {                 return 2;             }             else if(L1.isBetween(ps.get(3))&& !L1.isBetween(ps.get(1))|| ps.get(3).isCoincide(ps.get(2))|| ps.get(3).isCoincide(ps.get(4))) {                 return 3;             }             else if(L2.isBetween(ps.get(4))&& !L2.isBetween(ps.get(2))|| ps.get(4).isCoincide(ps.get(1))|| ps.get(4).isCoincide(ps.get(3))) {                 return 4;             }             else                 return 0;         }         else {             Line L1 = new Line(ps.get(2), ps.get(4));//第二个点与第四个点构成的直线             Line L2 = new Line(ps.get(3), ps.get(5));//第一个点与第三个点构成的直线                   if(L2.isBetween(ps.get(2))&& !L2.isBetween(ps.get(4))|| ps.get(2).isCoincide(ps.get(3))|| ps.get(2).isCoincide(ps.get(5))) {                 return 1;             }             else if(L1.isBetween(ps.get(3))&& !L1.isBetween(ps.get(5))|| ps.get(3).isCoincide(ps.get(2))|| ps.get(3).isCoincide(ps.get(4))) {                 return 2;             }             else if(L2.isBetween(ps.get(4))&& !L2.isBetween(ps.get(2))|| ps.get(4).isCoincide(ps.get(3))|| ps.get(4).isCoincide(ps.get(5))) {                 return 3;             }             else if(L1.isBetween(ps.get(5))&& !L1.isBetween(ps.get(3))|| ps.get(5).isCoincide(ps.get(2))|| ps.get(5).isCoincide(ps.get(4))) {                 return 4;             }             else                 return 0;         }     }

　　

　　这里将线作为四边形的属性是为了方便，在网上一顿搜索后找到四边形的面积计算方法

 

?

1 2 3 4 5 6 7 8

public double getArea() { //  获取四边形面积     Point x = new Point(l1.getMiddlePoint().x, l1.getMiddlePoint().y);     Point y = new Point(l3.getMiddlePoint().x, l3.getMiddlePoint().y);     Point z = new Point(l2.getMiddlePoint().x, l2.getMiddlePoint().y);     Line l = new Line(x, y);     return (double)2 * l.getDistance(z) * x.getDistance(y); }

　　（4）心得

　　四边形中将线作为属性不好，这样可能会造成四边形的点和线不对应的情况，后续在类中添加方法getsideline；知道怎么样的点才算冗余点，但是根据返回值来判断哪些点的方法不好，后续改为返回点集；知道四边形面积求法；由于没用继承，所以出现了很多代码重复。

　　（5）整题源码

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {    

        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        InputData d = new InputData();
        ParseInput.paseInput(s, d);
        int choice = d.getChoice();
        ArrayList<Point> ps = d.getPoints();
        switch (choice) {
        case 1:
            handle1(ps);
            break;
        case 2:
            handle2(ps);
            break;
        case 3:
            handle3(ps);
            break;
        case 4:
            handle4(ps);
            break;
        case 5:
            handle5(ps);
            break;
        }

    }

//    输入四个点坐标，判断是否是四边形、平行四边形，判断结果输出true/false，结果之间以一个英文空格符分隔。
    public static void handle1(ArrayList<Point> ps) {
        PointInputError.wrongNumberOfPoints(ps, 4);
        Quadrilateral q = new Quadrilateral(ps.get(0), ps.get(1), ps.get(2), ps.get(3));
        System.out.println(q.isQuadrilateral()+" "+q.isParallelogram());
    }

//    输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
    public static void handle2(ArrayList<Point> ps) {
        PointInputError.wrongNumberOfPoints(ps, 4);
        Quadrilateral q = new Quadrilateral(ps.get(0), ps.get(1), ps.get(2), ps.get(3));
        if(!q.isQuadrilateral()) {
            System.out.println("not a quadrilateral");
            System.exit(0);
        }
        System.out.println(q.isDiamond()+" "+q.isDectangle()+" "+q.isSquare());
    }

//    输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
    public static void handle3(ArrayList<Point> ps) {
        PointInputError.wrongNumberOfPoints(ps, 4);
        Quadrilateral q = new Quadrilateral(ps.get(0), ps.get(1), ps.get(2), ps.get(3));
        if(!q.isQuadrilateral()) {
            System.out.println("not a quadrilateral");
            System.exit(0);
        }
        System.out.println(q.isConcave()+" "+OutFormat.doubleFormat(q.getPerimeter())+" "+OutFormat.doubleFormat(q.getArea()));
    }

    public static void handle4(ArrayList<Point> ps) {
        PointInputError.wrongNumberOfPoints(ps, 6);
        int n = Judge.f(ps);
        Triangle a = new Triangle();
        Line l = new Line(ps.get(0), ps.get(1));
        switch(n) {
            case 1:a.setX(ps.get(3));a.setY(ps.get(4));a.setZ(ps.get(5));break;
            case 2:a.setX(ps.get(2));a.setY(ps.get(4));a.setZ(ps.get(5));break;
            case 3:a.setX(ps.get(2));a.setY(ps.get(3));a.setZ(ps.get(5));break;
            case 4:a.setX(ps.get(2));a.setY(ps.get(3));a.setZ(ps.get(4));break;
            case 0:{Quadrilateral q = new Quadrilateral(ps.get(2), ps.get(3), ps.get(4), ps.get(5));
                if(!q.isQuadrilateral()) {
                    System.out.println("not a quadrilateral or triangle");
                    System.exit(0);
                }
                if(q.judgeLineCoincide(l)) {
                    System.out.println("The line is coincide with one of the lines");
                    System.exit(0);
                }
                System.out.print(q.getIntersections(l).size());
                if(q.getIntersections(l).size()==2) {
                    double[] area = q.calArea(q.getIntersections(l).get(0), q.getIntersections(l).get(1));
                    System.out.println(" "+OutFormat.doubleFormat(area[0])+" "+OutFormat.doubleFormat(area[1]));
                }
            }break;
        }
        
        if(n!=0) {
            if(!a.isTriangle()) {
                System.out.println("not a quadrilateral or triangle");
                System.exit(0);
            }
            if(a.judgeLineCoincide(l)) {
                System.out.println("The line is coincide with one of the lines");
                System.exit(0);
            }
            System.out.print(a.getIntersections(l).size());
            if(a.getIntersections(l).size()==2) {
                double[] area =a.calArea(a.getIntersections(l).get(0), a.getIntersections(l).get(1));
                System.out.println(" "+OutFormat.doubleFormat(area[0])+" "+OutFormat.doubleFormat(area[1]));
            }
        }
    }
    
    /*
     * 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"。
     */    
    public static void handle5(ArrayList<Point> ps) {
        PointInputError.wrongNumberOfPoints(ps, 5);
        int n = Judge.f(ps);
        Triangle a = new Triangle();
        
        switch(n) {
            case 1:a.setX(ps.get(2));a.setY(ps.get(3));a.setZ(ps.get(4));break;
            case 2:a.setX(ps.get(1));a.setY(ps.get(3));a.setZ(ps.get(4));break;
            case 3:a.setX(ps.get(1));a.setY(ps.get(2));a.setZ(ps.get(4));break;
            case 4:a.setX(ps.get(1));a.setY(ps.get(2));a.setZ(ps.get(3));break;
            case 0:{Quadrilateral q = new Quadrilateral(ps.get(1), ps.get(2), ps.get(3), ps.get(4));
                if(!q.isQuadrilateral()) {
                    System.out.println("not a quadrilateral or triangle");
                    System.exit(0);
                }
                if(q.isQuadrilateral()) {
                    if(q.isInside(ps.get(0))==0) {
                        System.out.println("on the quadrilateral");
                        return ;
                    }
                    if(q.isInside(ps.get(0))==-1) {
                        System.out.println("outof the quadrilateral");
                        return ;
                    }
                    System.out.println("in the quadrilateral");
                }
            }break;
        }
        if(n!=0) {
            if(!a.isTriangle()) {
                System.out.println("not a quadrilateral or triangle");
                return ;
            }
            else {
                if(a.isInside(ps.get(0))==0) {
                    System.out.println("on the triangle");
                    return ;
                }
                if(a.isInside(ps.get(0))==-1) {
                    System.out.println("outof the triangle");
                    return ;
                }
                System.out.println("in the triangle");
            }
        }
    }
}

class InputData {
    private int choice;;//用户输入的选择项
    private ArrayList<Point> points = new ArrayList<Point>();//用户输入的点坐标
    public int getChoice() {
        return choice;
    }
    public void setChoice(int choice) {
        this.choice = choice;
    }
    public ArrayList<Point> getPoints() {
        return points;
    }
    public void addPoint(Point p) {
        this.points.add(p);
    }
    
}

class Judge {
    /*
     * 输入：用户输入点集 
     * 返回：1:2 3 4构成三角形，2:1 3 4构成三角形，3:1 2 4构成三角形，4:1 2 3构成三角形，0：四个点不构成三角形
     */
    public static int f(ArrayList<Point> ps){
//        判断四个点是否构成三角形
        if(ps.size()==5) {
            Line L1 = new Line(ps.get(2), ps.get(4));//第二个点与第四个点构成的直线
            Line L2 = new Line(ps.get(1), ps.get(3));//第一个点与第三个点构成的直线
    
            if(L1.isBetween(ps.get(1))&& !L1.isBetween(ps.get(3))|| ps.get(1).isCoincide(ps.get(2))|| ps.get(1).isCoincide(ps.get(4))) {
                return 1;
            }
            else if(L2.isBetween(ps.get(2))&& !L2.isBetween(ps.get(4))|| ps.get(2).isCoincide(ps.get(1))|| ps.get(2).isCoincide(ps.get(3))) {
                return 2;
            }
            else if(L1.isBetween(ps.get(3))&& !L1.isBetween(ps.get(1))|| ps.get(3).isCoincide(ps.get(2))|| ps.get(3).isCoincide(ps.get(4))) {
                return 3;
            }
            else if(L2.isBetween(ps.get(4))&& !L2.isBetween(ps.get(2))|| ps.get(4).isCoincide(ps.get(1))|| ps.get(4).isCoincide(ps.get(3))) {
                return 4;
            }
            else
                return 0;
        }
        else {
            Line L1 = new Line(ps.get(2), ps.get(4));//第二个点与第四个点构成的直线
            Line L2 = new Line(ps.get(3), ps.get(5));//第一个点与第三个点构成的直线
    
            if(L2.isBetween(ps.get(2))&& !L2.isBetween(ps.get(4))|| ps.get(2).isCoincide(ps.get(3))|| ps.get(2).isCoincide(ps.get(5))) {
                return 1;
            }
            else if(L1.isBetween(ps.get(3))&& !L1.isBetween(ps.get(5))|| ps.get(3).isCoincide(ps.get(2))|| ps.get(3).isCoincide(ps.get(4))) {
                return 2;
            }
            else if(L2.isBetween(ps.get(4))&& !L2.isBetween(ps.get(2))|| ps.get(4).isCoincide(ps.get(3))|| ps.get(4).isCoincide(ps.get(5))) {
                return 3;
            }
            else if(L1.isBetween(ps.get(5))&& !L1.isBetween(ps.get(3))|| ps.get(5).isCoincide(ps.get(2))|| ps.get(5).isCoincide(ps.get(4))) {
                return 4;
            }
            else
                return 0;
        }
    }
}

class Line {
    private Point p1;//线上的第一个点
    private Point p2;//线上的第二个点


    public Line(double x1, double y1, double x2, double y2) {
        Point p1 = new Point(x1, y1);
        Point p2 = new Point(x2, y2);
        LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出
        this.p1 = p1;
        this.p2 = p2;
    }

    public Line(Point p1, Point p2) {
        LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出
        this.p1 = p1;
        this.p2 = p2;
    }

    /* 获取线条的斜率 */
    public Double getSlope() {
        // （x1-x2=0）注意考虑斜率不存在即返回double类型无穷大"Infinite"
        return (p2.getY() - p1.getY()) / (p2.getX() - p1.getX());
    }

    /* 判断x是否在线上 */
    public boolean isOnline(Point x) {
        //System.out.println("isOnline");
        //System.out.println(p1.x + "  " + p1.y + "  " + p2.x + "  " + p2.y + "  " + x.x + "  " + x.y + "  ");

        // 点重合
        if ((x.getX() == p1.getX() && x.getY() == p1.getY()) || (x.getX() == p2.getX() && x.getY() == p2.getY())) {
            return true;
        }
        Line l = new Line(p1, x);
        if (l.getSlope().isInfinite() && this.getSlope().isInfinite()) {
            return true;
        }

        double b1 = l.getSlope(), b2 = this.getSlope();

        return Math.abs(b1 - b2)  < 0.00000000001;// b1==b2;
    }

    public double getDistance(Point x) {
        double distY = p2.getY() - p1.getY();
        double distX = p2.getX() - p1.getX();
        return Math.abs(x.getX() * distY - x.getY() * distX - p1.getX() * distY + p1.getY() * distX)
                / p1.getDistance(p2);
    }

    public boolean isBetween(Point x) {
        if (!this.isOnline(x)) {
            return false;
        }
        if (x.equals(p1) || x.equals(p2)) {
            return false;
        }
        double d = p2.getDistance(p1);
        boolean b = x.getDistance(p2) < d && x.getDistance(p1) < d;
        return b;
    }

    public boolean isSameSide(Point x) {
        return isOnline(x) && !isBetween(x);
    }

    public Point getMiddlePoint() {
        Point p = new Point();
        p.setX((p1.getX() + p2.getX()) / 2);
        p.setY((p1.getY() + p2.getY()) / 2);
        return p;
    }

    public Point getPointA() {
        return p1;
    }

    public Point getPointB() {
        return p2;
    }

    public double getAngle(Line l) {
        double k2 = getSlope();
        double k1 = l.getSlope();
        return (double) (Math.atan(Math.abs((k2 - k1) / (1 + k1 * k2))) * 180.0 / Math.PI);// 返回值为角度
    }

    public boolean isParallel(Line l) {
        Double b1 = this.getSlope();
        Double b2 = l.getSlope();
        if ((b1.isInfinite()) && (b2.isInfinite())) {
            return true;
        } else {
            return (this.getSlope().doubleValue() == l.getSlope().doubleValue());
        }
    }


    public boolean isCoincide(Line l) {
        if (!this.isParallel(l)) {
            return false;
        }
        if (this.isOnline(l.p1)) {
            return true;
        }
        return false;
    }

    public Point getIntersection(Line l) {
        if (this.isParallel(l)) {
            return null;
        }
        if (p1.equals(l.p1) || p1.equals(l.p2)) {
            return p1;
        }
        if (p2.equals(l.p1) || p2.equals(l.p2)) {
            return p2;
        }
        Point p3 = l.p1, p4 = l.p2;
        double x_member, x_denominator, y_member, y_denominator;
        Point cross_point = new Point();
        x_denominator = p4.x * p2.y - p4.x * p1.y - p3.x * p2.y + p3.x * p1.y - p2.x * p4.y + p2.x * p3.y + p1.x * p4.y
                - p1.x * p3.y;

        x_member = p3.y * p4.x * p2.x - p4.y * p3.x * p2.x - p3.y * p4.x * p1.x + p4.y * p3.x * p1.x
                - p1.y * p2.x * p4.x + p2.y * p1.x * p4.x + p1.y * p2.x * p3.x - p2.y * p1.x * p3.x;

        if (x_denominator == 0)
            cross_point.x = 0;
        else
            cross_point.x = x_member / x_denominator;

        y_denominator = p4.y * p2.x - p4.y * p1.x - p3.y * p2.x + p1.x * p3.y - p2.y * p4.x + p2.y * p3.x + p1.y * p4.x
                - p1.y * p3.x;

        y_member = -p3.y * p4.x * p2.y + p4.y * p3.x * p2.y + p3.y * p4.x * p1.y - p4.y * p3.x * p1.y
                + p1.y * p2.x * p4.y - p1.y * p2.x * p3.y - p2.y * p1.x * p4.y + p2.y * p1.x * p3.y;

        if (y_denominator == 0)
            cross_point.y = 0;
        else
            cross_point.y = y_member / y_denominator;

        // System.out.println(cross_point.x + ","+cross_point.y);

        return cross_point; // 平行返回(0,0)
    }
}

class LineInputError {    

    // 直线的两点重合的错误判断和提示。
    public static void pointsCoincideError(Point p1, Point p2) {
        if ((p1.getX() == p2.getX()) && p1.getY() == p2.getY()) {
            System.out.println("points coincide");
            System.exit(0);
        }
    }

}

class OutFormat {
    //按要求格式化实数的输出。
    public static Double doubleFormat(double b) {
        DecimalFormat df = new DecimalFormat("#.000");
        Double output = Double.valueOf(df.format(b));
        return output;
    }
}

class ParseInput {
    public static void paseInput(String s, InputData d) {
        PointInputError.wrongChoice(s);        
        d.setChoice(getChoice(s));
        s = s.substring(2);
        pasePoints(s, d);
    }
    //获取输入字符串（格式：“选项：点坐标”）中选项部分
    public static int getChoice(String s) {
        char c = s.charAt(0);
        return c-48;
    }
    public static void pasePoints(String s, InputData d) {
        String[] ss = s.split(" ");
        if (ss.length == 0)
            return;
        for (int i = 0; i < ss.length; i++) {
            d.addPoint(readPoint(ss[i]));
        }
    }

    public static Point readPoint(String s) {
        PointInputError.wrongPointFormat(s);
        String[] ss = s.split(",");
        double x = Double.parseDouble(ss[0]);
        double y = Double.parseDouble(ss[1]);
        // System.out.println("match");
        return new Point(x, y);

    }
}

class Point {
    public double x;
    public double y;

    public Point() {

    }

    public Point(double x,double y) {
        this.x=x;
        this.y=y;
    }

    /* 设置坐标x，将输入参数赋值给属性x */
    public void setX(double x) {
        this.x = x;
    }

    /* 设置坐标y，将输入参数赋值给属性y */
    public void setY(double y) {
        this.y = y;
    }

    /* 获取坐标x，返回属性x的值 */
    public double getX() {
        return x;
    }

    /* 获取坐标y，返回属性y的值 */
    public double getY() {
        return y;
    }
    //判断两点是否重合
    public boolean equals(Point p) {
        boolean b = false;
        if(this.x==p.getX()&&this.y==p.getY()) {
            b=true;
        }
        return b;
    }

    /* 计算当前点和输入点p之间的距离 */
    public double getDistance(Point p) {
        return Math.sqrt(Math.pow(this.x-p.x, 2)+ Math.pow(this.y-p.y, 2));
    }
    
    /* 判断当前点和输入点p是否重合 */
    public boolean isCoincide(Point p) {
        return this.x == p.x&& this.y == p.y;
    }
}

class PointInputError {
    //判断从字符串中解析出的点的数量是否合格。
    public static void wrongNumberOfPoints(ArrayList<Point> ps, int num) {
        if (ps.size() != num) {
            System.out.println("wrong number of points");
            System.exit(0);
        }
    }
    //判断输入的字符串中点的坐标部分格式是否合格。若不符合，报错并退出程序
    public static void wrongPointFormat(String s) {
        if (!s.matches("[+-]?([1-9]\\d*|0)(\\.\\d+)?,[+-]?([1-9]\\d*|0)(\\.\\d+)?")) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }

    // 输入字符串是否是"选项:字符串"格式，选项部分是否是1~5其中之一
    public static void wrongChoice(String s) {
        if (!s.matches("[1-5]:.+")) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }

}

class Quadrilateral {
    private Point p1;
    private Point p2;
    private Point p3;
    private Point p4;
    private Line l1;
    private Line l2;
    private Line l3;
    private Line l4;

    public Quadrilateral(Point p1, Point p2, Point p3, Point p4) {
        
            this.p1 = p1;
            this.p2 = p2;
            this.p3 = p3;
            this.p4 = p4;
            this.l1 = new Line(p1, p2);
            this.l2 = new Line(p2, p3);
            this.l3 = new Line(p3, p4);
            this.l4 = new Line(p4, p1);
    }

    public Quadrilateral() {
    }

    public boolean isQuadrilateral() {
//        判断是否构成四边形
        if(l1.isParallel(l2)|| l1.isParallel(l4)|| l3.isParallel(l2)|| l3.isParallel(l4))
            return false;
        else if(l1.getIntersection(l3)!=null) {
            if(l1.isBetween(l1.getIntersection(l3))&& l3.isBetween(l1.getIntersection(l3))) {
                return false;
            }
            else {
                return true;
            }
        }
        else if(l2.getIntersection(l4)!=null) {
            if(l2.isBetween(l2.getIntersection(l4))&& l4.isBetween(l2.getIntersection(l4))) {
                return false;
            }
            else {
                return true;
            }
        }
        else
            return true;
    }
    
    public boolean isParallelogram() {
//        判断四边形是否为平行四边形
        if(p1.getDistance(p2) == p3.getDistance(p4)&& p2.getDistance(p3) == p1.getDistance(p4)) {
            return true;
        }
        else
            return false;
    }
    
    public boolean isDiamond() {
//        判断菱形
        if(isParallelogram()) {
            if(p1.getDistance(p2) == p2.getDistance(p3))
                return true;
            else
                return false;
        }
        else
            return false;
    }
    
    public boolean isDectangle() {
//        判断四边形是否为矩形
        if(isParallelogram()) {
            if(p1.getDistance(p3) == p2.getDistance(p4))
                return true;
            else
                return false;
        }
        else
            return false;
    }
    
    public boolean isSquare() {
//        正方形即为菱形和矩形
        if(isDiamond()&& isDectangle())
            return true;
        else
            return false;
    }
    
    public boolean isConcave() {
//        判断四边形是否为凸四边形
        Triangle a = new Triangle(p1,p2,p3);
        Triangle b = new Triangle(p3,p4,p1);
        Triangle c = new Triangle(p2,p3,p4);
        Triangle d = new Triangle(p4,p1,p2);
        if((a.getArea() + b.getArea()) == (c.getArea() + d.getArea()))
            return true;
        else
            return false;
    }
    
    public double getPerimeter() {
//        获取四边形的周长
        return p1.getDistance(p2)+p2.getDistance(p3)+p3.getDistance(p4)+p4.getDistance(p1);
    }
    
    public double getArea() {
//        获取四边形面积
        Line[] ls = getSideline();
        Point x = new Point(ls[0].getMiddlePoint().x, ls[0].getMiddlePoint().y);
        Point y = new Point(ls[2].getMiddlePoint().x, ls[2].getMiddlePoint().y);
        Point z = new Point(ls[1].getMiddlePoint().x, ls[1].getMiddlePoint().y);
        Line l = new Line(x, y);
        return (double)2 * l.getDistance(z) * x.getDistance(y);
    }
    
    public Line[] getSideline() {
//        获取四条线
        Line l1 = new Line(p1, p2);
        Line l2 = new Line(p2, p3);
        Line l3 = new Line(p3, p4);
        Line l4 = new Line(p4, p1);
        Line[] lines = { l1, l2, l3, l4 };
        return lines;
    }
    public int isInside(Point p) {
        if (this.isOnTheEdge(p)) {
            return 0;
        }
        if (isVertex(p)) {
            return 0;
        }
        Triangle a =new Triangle(p, p1, p2);
        Triangle b =new Triangle(p, p2, p3);
        Triangle c =new Triangle(p, p3, p4);
        Triangle d =new Triangle(p, p1, p4);
        
        if(Math.abs(this.getArea() - a.getArea()-b.getArea()-c.getArea()-d.getArea() )< 1E-10) {
            return 1;
        }
        if(this.getArea() < a.getArea()+b.getArea()+c.getArea()+d.getArea()) {
            return -1;
        }
        return 0;
    }
    
    private boolean isVertex(Point p) {
        return p.equals(p1) || p.equals(p2) || p.equals(p3) || p.equals(p4);
    }

    private boolean isOnTheEdge(Point p) {
        if(l1.isBetween(p)|| l2.isBetween(p)|| l3.isBetween(p)|| l4.isBetween(p))
            return true;
        else
            return false;
    }

    public ArrayList<Point> getIntersections(Line l) {
        ArrayList<Point> ps = new ArrayList<Point>();
        Line[] ls = getSideline();
        if(!judgeLineCoincide(l)) {
            if(l.isOnline(p1))
                ps.add(p1);
            if(l.isOnline(p2))
                ps.add(p2);
            if(l.isOnline(p3))
                ps.add(p3);
            if(l.isOnline(p4))
                ps.add(p4);
            if(l.getIntersection(ls[0])!=null) {
                if(ls[0].isBetween(l.getIntersection(ls[0]))) {
                ps.add(l.getIntersection(ls[0]));
                }
            }
            if(l.getIntersection(ls[1])!=null) {
                if(ls[1].isBetween(l.getIntersection(ls[1]))) {
                ps.add(l.getIntersection(ls[1]));
                }
            }
            if(l.getIntersection(ls[2])!=null) {
                if(ls[2].isBetween(l.getIntersection(ls[2]))) {
                    ps.add(l.getIntersection(ls[2]));
                }
            }
            if(l.getIntersection(ls[3])!=null) {
                if(ls[3].isBetween(l.getIntersection(ls[3]))) {
                    ps.add(l.getIntersection(ls[3]));
                }
            }
        }
        return ps;
    }
    public double[] calArea(Point p1, Point p2) {
        Line[] ls = getSideline();
        Triangle t = new Triangle();
        Quadrilateral q = new Quadrilateral();
        if(this.isVertex(p1)) {
            if(p1.equals(this.p1)) {
                if(ls[1].isBetween(p2)) {
                    t.setX(p1);t.setY(this.p2);t.setZ(p2);
                }
                else {
                    t.setX(p1);t.setY(this.p4);t.setZ(p2);
                }
             }
             else if(p1.equals(this.p2)) {
                 if(ls[2].isBetween(p2)) {
                     t.setX(p1);t.setY(this.p3);t.setZ(p2);
                 }
                 else {
                     t.setX(p1);t.setY(this.p1);t.setZ(p2);
                 }
             }
             else if(p1.equals(this.p3)){
                 if(ls[0].isBetween(p2)) {
                     t.setX(p1);t.setY(this.p2);t.setZ(p2);
                 }
                 else {
                     t.setX(p1);t.setY(this.p4);t.setZ(p2);
                 }
             }
             else if(p1.equals(this.p4)){
                 if(ls[0].isBetween(p2)) {
                     t.setX(p1);t.setY(this.p1);t.setZ(p2);
                 }
                 else {
                     t.setX(p1);t.setY(this.p3);t.setZ(p2);
                 }
             }
        }
        else {
            if((ls[0].isBetween(p1) && ls[1].isBetween(p2)) || (ls[0].isBetween(p2) && ls[1].isBetween(p1))) {
                t.setX(p1);t.setY(this.p2);t.setZ(p2);
            }
            if((ls[0].isBetween(p1) && ls[2].isBetween(p2)) || (ls[0].isBetween(p2) && ls[2].isBetween(p1))) {
                q.setP1(p1);q.setP2(this.p2);q.setP3(this.p3);q.setP4(p2);
            }
            if((ls[0].isBetween(p1) && ls[3].isBetween(p2)) || (ls[0].isBetween(p2) && ls[3].isBetween(p1))) {
                t.setX(p1);t.setY(this.p1);t.setZ(p2);
            }
            if((ls[1].isBetween(p1) && ls[2].isBetween(p2)) || (ls[1].isBetween(p2) && ls[2].isBetween(p1))) {
                t.setX(p1);t.setY(this.p3);t.setZ(p2);
            }
            if((ls[1].isBetween(p1) && ls[3].isBetween(p2)) || (ls[1].isBetween(p2) && ls[3].isBetween(p1))) {
                q.setP1(p1);q.setP2(this.p3);q.setP3(this.p4);q.setP4(p2);
            }
            if((ls[2].isBetween(p1) && ls[3].isBetween(p2)) || (ls[2].isBetween(p2) && ls[3].isBetween(p1))) {
                t.setX(p1);t.setY(this.p4);t.setZ(p2);
            }
        }
        if(t.getX()!=null) {
            double[] area =  {t.getArea(),this.calAreaDiffrence(t)};
            if(area[0]>area[1]) {
                double temp;
                temp=area[0];
                area[0]=area[1];
                area[1]=temp;
            }
            return area;
        }
        else {
            double[] area =  {q.getArea(),this.calAreaDiffrence(q)};
            if(area[0]>area[1]) {
                double temp;
                temp=area[0];
                area[0]=area[1];
                area[1]=temp;
            }
            return area;
        }
    }
    
    private double calAreaDiffrence(Triangle t) {
        double area = t.getArea();
        area = getArea() - area;
        return area;
    }

    private double calAreaDiffrence(Quadrilateral q) {
        double area = q.getArea();
        area = getArea() - area;
        return area;
    }
    
    public boolean judgeLineCoincide(Line l) {
        if(l.isCoincide(l1)|| l.isCoincide(l2)|| l.isCoincide(l3)|| l.isCoincide(l4))
            return true;
        else
            return false;
    }

    public void setP1(Point p1) {
        this.p1 = p1;
    }

    public void setP2(Point p2) {
        this.p2 = p2;
    }

    public void setP3(Point p3) {
        this.p3 = p3;
    }

    public void setP4(Point p4) {
        this.p4 = p4;
    }

}

class Triangle {
    private Point x;
    private Point y;
    private Point z;

    public Triangle(Point x, Point y, Point z) {
        this.x = x;
        this.y = y;
        this.z = z;

    }

    public Triangle() {
    }

    public boolean isTriangle() {
        if(x.getDistance(y)+ x.getDistance(z)> y.getDistance(z)
            && y.getDistance(z)+ y.getDistance(x)> x.getDistance(z)
            && z.getDistance(x)+ z.getDistance(y)> x.getDistance(y))
            return true;
        else
            return false;
                
    }

    public Point getMidpoint() {
        // 中点即重心，利用性质求解
        Point p = new Point();
        p.setX((this.x.getX() + this.y.getX() + this.z.getX()) / 3);
        p.setY((this.x.getY() + this.y.getY() + this.z.getY()) / 3);
        return p;
    }

    public Line[] getSideline() {
        Line line1 = new Line(x, y);

        Line line2 = new Line(x, z);
        Line line3 = new Line(y, z);

        Line[] lines = { line1, line2, line3 };
        return lines;
    }

    public double getArea() {
        double p = (x.getDistance(y)+ x.getDistance(z)+ y.getDistance(z))/2;
        return Math.sqrt(p* (p- x.getDistance(y))* (p-x.getDistance(z))* (p-y.getDistance(z)));
    }

    public double getPerimeter() {
        return x.getDistance(y) + y.getDistance(z) + z.getDistance(x);
    }

    public boolean isVertex(Point p) {
        return p.equals(x) || p.equals(y) || p.equals(z);
    }

    public int isInside(Point p) {
        if (this.isOnTheEdge(p)) {
            return 0;
        }
        if (isVertex(p)) {
            return 0;
        }
        Triangle a = new Triangle(p, x, y);
        Triangle b = new Triangle(p, x, z);
        Triangle c = new Triangle(p, z, y);
        if(Math.abs(this.getArea() - a.getArea()-b.getArea()-c.getArea()) <1E-10) {
            return 1;
        }
        if(this.getArea() < a.getArea()+b.getArea()+c.getArea()) {
            return -1;
        }
        return 0;
    }

    public ArrayList<Point> getIntersections(Line l) {
        ArrayList<Point> ps = new ArrayList<Point>();
        Line[] ls = getSideline();
        if(!judgeLineCoincide(l)) {
            if(l.isOnline(x))
                ps.add(x);
            if(l.isOnline(y))
                ps.add(y);
            if(l.isOnline(z))
                ps.add(z);
            if(l.getIntersection(ls[0])!=null) {
                if(ls[0].isBetween(l.getIntersection(ls[0]))) {
                    ps.add(l.getIntersection(ls[0]));
                }
            }
            if(l.getIntersection(ls[1])!=null) {
                if(ls[1].isBetween(l.getIntersection(ls[1]))) {
                    ps.add(l.getIntersection(ls[1]));
                }
            }
            if(l.getIntersection(ls[2])!=null) {
                if(ls[2].isBetween(l.getIntersection(ls[2]))) {
                    ps.add(l.getIntersection(ls[2]));
                }
            }
        }
        return ps;
    }


    public double[] calArea(Point p1, Point p2) {
        Line[] l= getSideline();
        Triangle t = new Triangle();
        if(this.isVertex(p1)) {
            if(p1.equals(x)) {
                t.setX(p1);t.setY(p2);t.setZ(y);
             }
             else if(p1.equals(y)) {
                t.setX(p1);t.setY(p2);t.setZ(z);
             }
             else {
                t.setX(p1);t.setY(p2);t.setZ(x);
             }
        }
        else {
            if((l[0].isBetween(p1)&& l[1].isBetween(p2))
                    || (l[0].isBetween(p1)&& l[1].isBetween(p2))){
                t.setX(p1);t.setY(p2);t.setZ(y);
            }
            if((l[1].isBetween(p1)&& l[2].isBetween(p2))
                    || (l[1].isBetween(p1)&& l[2].isBetween(p2))){
                t.setX(p1);t.setY(p2);t.setZ(z);
            }
            if((l[0].isBetween(p1)&& l[2].isBetween(p2))
                    || (l[0].isBetween(p1)&& l[2].isBetween(p2))){
                t = new Triangle(p1, p2, x);
            }
        }
        double[] area =  {t.getArea(),this.calAreaDiffrence(t)};
            if(area[0]>area[1]) {
                double temp;
                temp=area[0];
                area[0]=area[1];
                area[1]=temp;
            }
            return area;
    }


    
    public double calAreaDiffrence(Triangle t1) {
        double area = t1.getArea();
        area = getArea() - area;
        return area;
    }

    public boolean judgeLineCoincide(Line l) {
        Line[] ls = getSideline();
        if(l.isCoincide(ls[0])|| l.isCoincide(ls[1])|| l.isCoincide(ls[2]))
            return true;
        else
            return false;
    }

    public boolean isOnTheEdge(Point p) {
        Line[] l = getSideline();
        if(l[0].isBetween(p)|| l[1].isBetween(p)|| l[2].isBetween(p))
            return true;
        else
            return false;
    }

    public Point getX() {
        return x;
    }

    public void setX(Point x) {
        this.x = x;
    }

    public Point getY() {
        return y;
    }

    public void setY(Point y) {
        this.y = y;
    }

    public Point getZ() {
        return z;
    }

    public void setZ(Point z) {
        this.z = z;
    }
}

2.期中考试

　　7-1 点与线

　　（1）类图

　　（2）圈复杂度

 

 　　（3）解释

　　此题比较简单跟着题目类图和提示走，基本能完成。

　　（4）心得

　　根据题目提示了解到String.format("%.2f", data)格式化输出，更加了解使用Math类方法。

　　（5）整题源码

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        double a,b,c,d;
        Scanner in = new Scanner(System.in);
        a = in.nextDouble();
        b = in.nextDouble();
        c = in.nextDouble();
        d = in.nextDouble();
        String color = in.next();
        if(a<=0 || a>200 || b<=0 || b>200 || c<=0 || c>200 ||d<=0 || d>200 ) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        Point p1 = new Point(a, b);
        Point p2 = new Point(c, d);
        Line l = new Line(p1, p2, color);
        l.display();
        System.out.println("The line's begin point's Coordinate is:");
        p1.dsiplay();
        System.out.println("The line's end point's Coordinate is:");
        p2.dsiplay();
        System.out.println("The line's length is:"+String.format("%.2f", l.getDistance()));
    }

}

class Point {
    private double x;
    private double y;
    
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    
    public Point() {
        
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }
    
    public void dsiplay() {
        System.out.println("("+String.format("%.2f", this.x)+","+String.format("%.2f", this.y)+")");
    }
    
}

class Line {
    private Point point1;
    private Point point2;
    private String color;
    
    public Line() {
        
    }

    public Line(Point point1, Point point2, String color) {
        this.point1 = point1;
        this.point2 = point2;
        this.color = 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 void display() {
        System.out.println("The line's color is:"+this.color);
    }
    
    public double getDistance() {
        return Math.sqrt(Math.pow(point1.getX() - point2.getX(), 2) + Math.pow(point1.getY() - point2.getY(), 2));
    }
    
}

 

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

　　（1）类图

　　（2）圈复杂度

 

 　　（3）解释

　　此题当时考试前没接触过抽象接口，所以不知道abstract是什么，就没有把Element类设计成抽象类。Point，Line，Plane类继承与Element类。Main类复杂度过高是因为控制题目输入的时候选择语句过多。

if(a<=0 || a>200 || b<=0 || b>200 || c<=0 || c>200 ||d<=0 || d>200 ) {
            System.out.println("Wrong Format");
            System.exit(0);
        }

 

　　（4）心得

　　此题让我了解到了继承的魅力，为第五次的题目集打下很好的基础，题目中老师的一部分示例代码也让我知道父类对象的用法。

　　（5）整题源码

import java.util.Scanner;

public class Main {

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

    }

}

class Point extends Element{
    private double x;
    private double y;
    
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    
    public Point() {
        
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }
    @Override
    public void display() {
        System.out.println("("+String.format("%.2f", this.x)+","+String.format("%.2f", this.y)+")");
    }
    
}

class Line extends Element{
    private Point point1;
    private Point point2;
    private String color;
    public Line() {
        
    }

    public Line(Point point1, Point point2, String color) {
        this.point1 = point1;
        this.point2 = point2;
        this.color = 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;
    }
    @Override
    public void display() {
        System.out.println("The line's color is:"+this.color);
        System.out.println("The line's begin point's Coordinate is:");
        getPoint1().display();
        System.out.println("The line's end point's Coordinate is:");
        getPoint2().display();
        System.out.println("The line's length is:"+String.format("%.2f", getDistance()));;
    }
    
    public double getDistance() {
        return Math.sqrt(Math.pow(point1.getX() - point2.getX(), 2) + Math.pow(point1.getY() - point2.getY(), 2));
    }
    
}

class Plane extends Element{
    private String color;
    
    public Plane() {
        
    }

    public Plane(String color) {
        super();
        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:"+this.color);
    }
}

class Element {
    
    public void display() {
    }
}

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

　　（1）类图

　　（2）圈复杂度

 

 　　（3）解释

　　此题新加一个容器类，专门管理容器，而不是直接对容器进行操作。此题同样有一部分老师给的代码，方便了我们的编写。

　　（4）心得

　　此题亮眼的是新加的一个容器类，通过容器类的对象管理容器，这样可以大大降低程序出错的概率，也方便以后的修改。

public class GeometryObject {
    private ArrayList<Element> es = new ArrayList<Element>();

    public GeometryObject() {
    }
    
    public void add(Element element) {
        es.add(element);
    }
    
    public void remove(int index) {
        if(index>=1 && index<=es.size())
            es.remove(index-1);
    }

    public ArrayList<Element> getEs() {
        return es;
    }
    
}

　　（5）整题码源

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        double a,b,c,d;
        Scanner in = new Scanner(System.in);
        GeometryObject g = new GeometryObject();
        int choice = in.nextInt();
            while(choice != 0) {
                switch(choice) {
                case 1://insert Point object into list 
                    a = in.nextDouble();
                    b = in.nextDouble();
                    if(a<=0 || a>200 || b<=0 || b>200) {
                        System.out.println("Wrong Format");
                        System.exit(0);
                    }
                    Point p1 = new Point();
                    p1.setX(a);p1.setY(b);
                    g.add(p1);
                    break;
                case 2://insert Line object into list
                    Line line = new Line();
                    a = in.nextDouble();
                    b = in.nextDouble();
                    c = in.nextDouble();
                    d = in.nextDouble();
                    String color = in.next();
                    if(a<=0 || a>200 || b<=0 || b>200 || c<=0 || c>200 || d<=0 || d>200) {
                        System.out.println("Wrong Format");
                        System.exit(0);
                    }
                    Point p2 = new Point(a, b);
                    Point p3 = new Point(c, d);
                    line.setPoint1(p2);line.setPoint2(p3);line.setColor(color);
                    g.add(line);
                    break;
                case 3://insert Plane object into list
                    Plane plane = new Plane();
                    String co = in.next();
                    plane.setColor(co);
                    g.add(plane);
                    break;
                case 4://delete index - 1 object from list
                    int index = in.nextInt();
                    g.remove(index);
                }
                choice = in.nextInt();
            }
            for(Element e: g.getEs()) {
                e.display();
            }
    }

}

class Point extends Element{
    private double x;
    private double y;
    
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    
    public Point() {
        
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }
    @Override
    public void display() {
        System.out.println("("+String.format("%.2f", this.x)+","+String.format("%.2f", this.y)+")");
    }
    
}

class Line extends Element{
    private Point point1;
    private Point point2;
    private String color;
    public Line() {
        
    }

    public Line(Point point1, Point point2, String color) {
        this.point1 = point1;
        this.point2 = point2;
        this.color = 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;
    }
    @Override
    public void display() {
        System.out.println("The line's color is:"+this.color);
        System.out.println("The line's begin point's Coordinate is:");
        getPoint1().display();
        System.out.println("The line's end point's Coordinate is:");
        getPoint2().display();
        System.out.println("The line's length is:"+String.format("%.2f", getDistance()));;
    }
    
    public double getDistance() {
        return Math.sqrt(Math.pow(point1.getX() - point2.getX(), 2) + Math.pow(point1.getY() - point2.getY(), 2));
    }
    
}

class Plane extends Element{
    private String color;
    
    public Plane() {
        
    }

    public Plane(String color) {
        super();
        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:"+this.color);
    }
}

class Element {
    
    public void display() {
    }
}

class GeometryObject {
    private ArrayList<Element> es = new ArrayList<Element>();

    public GeometryObject() {
    }
    
    public void add(Element element) {
        es.add(element);
    }
    
    public void remove(int index) {
        if(index>=1 && index<=es.size())
            es.remove(index-1);
    }

    public ArrayList<Element> getEs() {
        return es;
    }
    
}

3.第五次题目集

　　（1）类图

　　（2）圈复杂度

 

 　　（3）解释

　　这里解释一下

　　1.对五边形面积的计算

　　　　读题后发现只需要求凸五边形的面积，所以这里直接将五边形直接分成了一个三角形和四边形计算面积；这里给出代码，至于三角形和四边形面积求法可查看上面代码

public double getArea() {
//        获取五边形面积
        Triangle t = new Triangle(p1, p2, p3);
        Quadrilateral q = new Quadrilateral(p3, p4, p5, p1);
        return t.getArea() + q.getArea();
    }

　　2.对去除冗余点的方法

　　　　冗余点的判断只需判断是否有点在图形的对角线上，然后中间的点即为冗余点然后去除，这里分为两次来求，先对五个点进行一次冗余，在对四个点进行冗余点，然后根据返回点集长度判断是  　　　　　　否有冗余点，对上一次题目集方法进行改进。代码如下

public class Judge1 {
//    判断五个点构成五边形还是四边形
    public static ArrayList<Point> f(ArrayList<Point> ps){
        ArrayList<Point> ps2 = new ArrayList<Point>();
        Line l1 = new Line(ps.get(0), ps.get(2));
        Line l2 = new Line(ps.get(0), ps.get(3));
        Line l3 = new Line(ps.get(1), ps.get(3));
        Line l4 = new Line(ps.get(1), ps.get(4));
        Line l5 = new Line(ps.get(2), ps.get(4));
        if(l1.isBetween(ps.get(1)) || ps.get(1).isCoincide(ps.get(0)) || ps.get(1).isCoincide(ps.get(2))) {
            ps2.add(ps.get(0));ps2.add(ps.get(2));ps2.add(ps.get(3));ps2.add(ps.get(4));
        }
        else if(l2.isBetween(ps.get(4)) || ps.get(4).isCoincide(ps.get(0)) || ps.get(4).isCoincide(ps.get(3))) {
            ps2.add(ps.get(0));ps2.add(ps.get(1));ps2.add(ps.get(2));ps2.add(ps.get(3));
        }
        else if(l3.isBetween(ps.get(2)) || ps.get(2).isCoincide(ps.get(1)) || ps.get(2).isCoincide(ps.get(3))) {
            ps2.add(ps.get(0));ps2.add(ps.get(1));ps2.add(ps.get(3));ps2.add(ps.get(4));
        }
        else if(l4.isBetween(ps.get(0)) || ps.get(0).isCoincide(ps.get(1)) || ps.get(0).isCoincide(ps.get(4))) {
            ps2.add(ps.get(1));ps2.add(ps.get(2));ps2.add(ps.get(3));ps2.add(ps.get(4));
        }
        else if(l5.isBetween(ps.get(3)) || ps.get(3).isCoincide(ps.get(2)) || ps.get(1).isCoincide(ps.get(4))) {
            ps2.add(ps.get(0));ps2.add(ps.get(1));ps2.add(ps.get(2));ps2.add(ps.get(4));
        }
        return ps2;
    }
}

public class Judge {
    /*
     * 输入：用户输入四个点点集 
     * 返回：构成三角形的点集，若构成四边形，则返回点集size为0 
     */
    public static ArrayList<Point> f(ArrayList<Point> ps){
//        判断四个点是否构成三角形
        ArrayList<Point> ps1 =new ArrayList<Point>();
        Line l1 = new Line(ps.get(1), ps.get(3));
        Line l2 = new Line(ps.get(0), ps.get(2));//对角线

        if(l1.isBetween(ps.get(0)) || ps.get(0).isCoincide(ps.get(1))|| ps.get(0).isCoincide(ps.get(3))) {
            ps1.add(ps.get(1));ps1.add(ps.get(2));ps1.add(ps.get(3));
        }
        else if(l2.isBetween(ps.get(1)) || ps.get(1).isCoincide(ps.get(0))|| ps.get(1).isCoincide(ps.get(2))) {
            ps1.add(ps.get(0));ps1.add(ps.get(2));ps1.add(ps.get(3));
        }
        else if(l1.isBetween(ps.get(2)) || ps.get(2).isCoincide(ps.get(1))|| ps.get(2).isCoincide(ps.get(3))) {
            ps1.add(ps.get(0));ps1.add(ps.get(1));ps1.add(ps.get(3));
        }
        else if(l2.isBetween(ps.get(3)) || ps.get(3).isCoincide(ps.get(0))|| ps.get(3).isCoincide(ps.get(2))) {
            ps1.add(ps.get(0));ps1.add(ps.get(1));ps1.add(ps.get(2));
        }
        return ps1;
    }
}

　　3.对五边形凹凸的判断（向量叉乘的方法）

　　　　向量叉乘正负同号即为顺时针或者逆时针排列，即可判断为凸五边形（实则不止五边形，四边形即以上都可用）。代码如下

public boolean isTPentagon() {
//        判断五边形凹凸性
        Line[] ls = getSideline();
        double v0 = ls[0].getchaji(ls[1]);
        double v1 = ls[1].getchaji(ls[2]);
        double v2 = ls[2].getchaji(ls[3]);
        double v3 = ls[3].getchaji(ls[4]);
        double v4 = ls[4].getchaji(ls[0]);
        if(v0 * v1 < 0 || v0 * v2 < 0 || v0 * v3 < 0 || v0 * v4 <0) {
            return false;
        }
        else
            return true;
    }

　　4.将点集中点顺时针化或逆时针化

　　　　通过对横坐标的比较和纵坐标的比较进行排序。代码如下

for (int i = 0; i <ps.size() - 1; i++) {
            for (int j = 0; j < ps.size() - 1 - i; j++) {
                if (SetSortRule(ps.get(j), ps.get(j+1))) {
                    double x=ps.get(j).getX();
                    double y=ps.get(j).getY();
                    ps.get(j).setX(ps.get(j+1).getX()); ps.get(j).setY(ps.get(j+1).getY());
                    ps.get(j+1).setX(x);ps.get(j+1).setY(y);
                }
            }
        }
        return ps;
    }
    private boolean SetSortRule(Point p1, Point p2) {
            if (p1.y > p2.y) {
                return true;
            }
            else if (p1.y == p2.y) {
                return (p1.x > p2.x);
            }
            else {
                return false;
            }
    }

　　5.对任意凸多边形传入的顺时针或逆时针点集求面积的方法

　　　　根据面积公式。代码如下

public static double area(ArrayList<Point> ps) {
        int point_num = ps.size();
        if(point_num < 3)return 0;
        double s = ps.get(0).y * (ps.get(point_num-1).x - ps.get(1).x);
        for(int i = 1; i < point_num; ++i)
            s += ps.get(i).y * (ps.get(i-1).x - ps.get((i+1)%point_num).x);
        return Math.abs(s/2.0);
    }

　　6.父类对象的使用

　　　　此题中的选项3、4、5、6中都创建了父类对象来代替子类操作，减少了代码量

　　（4）心得

　　对于此题，经过期中考试和实验，这题如果使用了继承多态是一个非常好的学习机会，大大减少代码量。在某些方面可以取巧，求五边形面积取巧，但后续可以改为通用的方法；学会了许多方法，判断点冗余、点集顺或逆时针化、点集构成多边形的面积、对容器的操作更加熟练。但在这段过程中最主要的还是学习到了Java的精髓--继承，方法覆盖，多态。

三、踩坑心得

　　1.第四次题目集中的判断冗余用的方法过于笨重，根据返回值来判断，后来改为根据返回点集判断，这样减少了代码量，也减小了圈复杂度。

public static ArrayList<Point> f(ArrayList<Point> ps){
//        判断四个点是否构成三角形
        ArrayList<Point> ps1 =new ArrayList<Point>();
        Line l1 = new Line(ps.get(1), ps.get(3));
        Line l2 = new Line(ps.get(0), ps.get(2));//对角线

        if(l1.isBetween(ps.get(0)) || ps.get(0).isCoincide(ps.get(1))|| ps.get(0).isCoincide(ps.get(3))) {
            ps1.add(ps.get(1));ps1.add(ps.get(2));ps1.add(ps.get(3));
        }
        else if(l2.isBetween(ps.get(1)) || ps.get(1).isCoincide(ps.get(0))|| ps.get(1).isCoincide(ps.get(2))) {
            ps1.add(ps.get(0));ps1.add(ps.get(2));ps1.add(ps.get(3));
        }
        else if(l1.isBetween(ps.get(2)) || ps.get(2).isCoincide(ps.get(1))|| ps.get(2).isCoincide(ps.get(3))) {
            ps1.add(ps.get(0));ps1.add(ps.get(1));ps1.add(ps.get(3));
        }
        else if(l2.isBetween(ps.get(3)) || ps.get(3).isCoincide(ps.get(0))|| ps.get(3).isCoincide(ps.get(2))) {
            ps1.add(ps.get(0));ps1.add(ps.get(1));ps1.add(ps.get(2));
        }
        return ps1;
    }

　　2.第四次中判断平行四边形开始使用一组对边平行且相等的方法判定，但是会导致漏情况，代码量也多。随后改为两组对边相等，完美解决这个问题。

　　3.第四次最后还有两个测试点没过，是因为三角形类中getsideline方法返回线数组不是按顺序来的，导致求三角形分为两个部分面积时出错。

　　4.第五次中的选项一中由于是输出TRUE或FALSE，但是当输入连续两个点重合时，构成线的地方会直接输出points coincide，并退出程序，所以在构造的地方加上判断。代码如下

public Pentagon(Point p1, Point p2, Point p3, Point p4, Point p5) {
//        构造
        super();
        if(p1.equals(p2)||p1.equals(p3)||p1.equals(p4)||p1.equals(p5)||p2.equals(p3)||p2.equals(p4)||p2.equals(p5)||p3.equals(p4)||p3.equals(p5)||p4.equals(p5)) {
            System.out.println("false");
            System.exit(0);
        }
        this.p1 = p1;
        this.p2 = p2;
        this.p3 = p3;
        this.p4 = p4;
        this.p5 = p5;
    }

　　5.第五次在判断两多边形重合时，输出结果少打了个with，检查很久才发现。还是要看清题目要求。

　　在许多地方代码复制时没有修改相应变化地方，同样导致要回头检查很久，还导致过不了测试点。double类型变量会有一定误差，要通过两个变量相见的绝对值判断是否相等。

四、改进建议

　　1.第四次中判断点冗余的方法改进。

public static ArrayList<Point> f(ArrayList<Point> ps){
//        判断四个点是否构成三角形
        ArrayList<Point> ps1 =new ArrayList<Point>();
        Line l1 = new Line(ps.get(1), ps.get(3));
        Line l2 = new Line(ps.get(0), ps.get(2));//对角线

        if(l1.isBetween(ps.get(0)) || ps.get(0).isCoincide(ps.get(1))|| ps.get(0).isCoincide(ps.get(3))) {
            ps1.add(ps.get(1));ps1.add(ps.get(2));ps1.add(ps.get(3));
        }
        else if(l2.isBetween(ps.get(1)) || ps.get(1).isCoincide(ps.get(0))|| ps.get(1).isCoincide(ps.get(2))) {
            ps1.add(ps.get(0));ps1.add(ps.get(2));ps1.add(ps.get(3));
        }
        else if(l1.isBetween(ps.get(2)) || ps.get(2).isCoincide(ps.get(1))|| ps.get(2).isCoincide(ps.get(3))) {
            ps1.add(ps.get(0));ps1.add(ps.get(1));ps1.add(ps.get(3));
        }
        else if(l2.isBetween(ps.get(3)) || ps.get(3).isCoincide(ps.get(0))|| ps.get(3).isCoincide(ps.get(2))) {
            ps1.add(ps.get(0));ps1.add(ps.get(1));ps1.add(ps.get(2));
        }
        return ps1;
    }

　　2.修改原本代码不对应的地方，如三角形类getsideline方法。

整体上，在父类Shapes类中getArea方法修改为通用的（运用点集），这样也可以减少代码量。

public double getArea（ArrayList ps）{
    return PolygonArea.area(ps) ；
}

在后续找到一个分割多边形的通用方法，减少代码量。

虽然本次用的判断点与多边形位置关系是用面积的方法，但后续可以改为老师要求的射线法，挑战自己。

五、总结

　　对于这一阶段大部分还是在继承方面走，但是明显感觉到再向抽象与接口这边走了，虽然没有用到。对于继承的学习，可能就作业来说到此结束，但是通过这阶段的学习（三个星期）不能说长，也不能说短，要说把继承学好也不可能，但是总能了解基础的用法。对于ArrayList容器来说，从网课开始老师就讲了，所以到现在也能熟练掌握其用法。学习到了许多几何方法，对特殊情况的判断特殊处理。到了现在，也基本达到从面对过程到面向对象的蜕变。对于作业这方面虽然不算多，但是都挤在一起就会没有时间写。作业和实验上，老师可以继续将作业发布可以把题目提前一点，可以在星期五的下午发布PTA，还有作业或实验提交在哪里也可以先发布。