四边形，五边形以及期中考试总结性Blog

Java大作业第二次阶段性总结

前言

继完成点线性系列三角形相关计算后，第四次和第五次大作业关于四边形和五边形的相关计算代码复杂度和难度提升较大，期中考试的三题对继承，多态，容器以及基础知识进行了考察。

设计与分析

第一题：

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

代码：

import java.util.Scanner;
import java.math.BigDecimal;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);        
        String s=input.nextLine();
        double[] x=null;
        double[] y=null;
        Judgeinput a=new Judgeinput(s);
        a.judge();
        int choice=Points.getChoice(s);
        s=s.substring(2);
        Points b=new Points(s,choice);
        b.choose();
        x=b.getX();
        y=b.getY();
        switch(choice) {
        case 1: 
            Fun1 fun1=new Fun1(x,y);
            fun1.judgerepeat();
            break;
        case 2:
            Fun2 fun2=new Fun2(x,y);
            fun2.judgerepeat();
            break;
        case 3:
            Fun3 fun3=new Fun3(x,y);
            fun3.judgerepeat();
            break;
        case 4:
            Fun4 fun4=new Fun4(x,y);
           // fun4.operate();
            fun4.judgerepeat();
            fun4.pd();
            break;
        case 5:
            Fun5 fun5=new Fun5(x,y);
            fun5.judgerepeat();
        }
    }
}
class Judgeinput {
    private String s;
    private int choice;
    private String coord[];
    Judgeinput(String s){
        this.s=s;
    }
    public void judge() {
        choice = s.charAt(0)-48;
        judgeChoice();
        s=s.substring(2);
        coord = s.split(" ");
        judgeFormat();
        judgeQuantity();
    }
    public void judgeChoice() {
        if(!s.matches("[1-5]:.+")) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }
    public void judgeFormat() {
        for(int i=0;i<coord.length;i++) {
            if(!coord[i].matches("[+-]?([1-9]\\d*|0)(\\.\\d+)?,[+-]?([1-9]\\d*|0)(\\.\\d+)?")) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
    }
    public void judgeQuantity() {
        int length=coord.length;
        switch(choice) {
            case 1:if(length!=4) {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            break;
            case 2:if(length!=4) {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            break;
            case 3:if(length!=4) {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            break;
            case 4:if(length!=6) {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            break;
            case 5:if(length!=5) {
                System.out.println("wrong number of points");
                System.exit(0);
            }
        }
    }
    
}
class Points {
    private String s;
    private int choice;
    private String coord[];
    public double[] x=null;
    public double[] y=null;
    Points(String s,int choice){
        this.s=s;
        this.choice=choice;
    }
    public static int getChoice(String s) {
        int choice = s.charAt(0)-48;
        return choice;
    }
    
    public void choose() {
        coord=s.split(",| ");
        if(choice==1||choice==2||choice==3) {
            coordinate123();
        }
        else if(choice==4) {
            coordinate4();
        }
        else if(choice==5) {
            coordinate5();
        }
    }
    public void coordinate123() {
        x = new double[4];
        y = new double[4];
        for(int i=0;i<4;i++) {
            x[i]=Double.parseDouble(coord[2*i]);
            y[i]=Double.parseDouble(coord[2*i+1]);
        }
    }
    public void coordinate4() {
        x = new double[6];
        y = new double[6];
        for(int i=0;i<6;i++) {
            x[i]=Double.parseDouble(coord[2*i]);
            y[i]=Double.parseDouble(coord[2*i+1]);
        }
    }
    public void coordinate5() {
        x = new double[5];
        y = new double[5];
        for(int i=0;i<5;i++) {
            x[i]=Double.parseDouble(coord[2*i]);
            y[i]=Double.parseDouble(coord[2*i+1]);
        }
    }
    public double[] getX() {
        return x;
    }
    public double[] getY() {
        return y;
    }
}


class Fun1 {
    private double[] x = new double[4];
    private double[] y = new double[4];
    double[] line =new double[4];
    Fun1(double[] x,double[] y) {
        this.x=x;
        this.y=y;
    }
    public void judgerepeat() {
        Judgerepeat c=new Judgerepeat(x,y);
        c.judgerepeat();
        quadrilateral();
        Line d=new Line(x,y);
        line=d.line();
        parallelogram();
    }
    public void quadrilateral() {
        if(((y[0]-y[1])*(x[0]-x[2])==(y[0]-y[2])*(x[0]-x[1]))||
           ((y[0]-y[1])*(x[0]-x[3])==(y[0]-y[3])*(x[0]-x[1]))||
           ((y[0]-y[2])*(x[0]-x[3])==(y[0]-y[3])*(x[0]-x[2]))||
           ((y[1]-y[2])*(x[1]-x[3])==(y[1]-y[3])*(x[1]-x[2])))System.out.print("false ");
        else {
            if(!Line.intersect(x[0],y[0],x[3],y[3],x[1],y[1],x[2],y[2])) {
                System.out.print("true ");
            }
            else System.out.print("false ");
        }
    }
    public void parallelogram() {
        if(line[0]==line[2]&&line[1]==line[3])System.out.print("true");
        else System.out.print("false");
    }
}

class Fun2 {
    private double[] x = new double[4];
    private double[] y = new double[4];
    double[] line =new double[4];
    double[] diagonal=new double[2];
    private boolean judge1=false;
    private boolean judge2=false;
    private boolean judge3=false;
    Fun2(double[] x,double[] y) {
        this.x=x;
        this.y=y;
    }
    public void judgerepeat() {
        Judgerepeat c=new Judgerepeat(x,y);
        quadrilateral();
        c.judgerepeat();
        Line d=new Line(x,y);
        line=d.line();
        diagonal=d.diagonal();
        lozenge();
        rectangle();
        square();
    }
    public void quadrilateral() {
        if(((y[0]-y[1])*(x[0]-x[2])==(y[0]-y[2])*(x[0]-x[1]))||
           ((y[0]-y[1])*(x[0]-x[3])==(y[0]-y[3])*(x[0]-x[1]))||
           ((y[0]-y[2])*(x[0]-x[3])==(y[0]-y[3])*(x[0]-x[2]))||
           ((y[1]-y[2])*(x[1]-x[3])==(y[1]-y[3])*(x[1]-x[2]))) {
                System.out.print("not a quadrilateral");
                System.exit(0);
           }
        else {
            if(Line.intersect(x[0],y[0],x[3],y[3],x[1],y[1],x[2],y[2])) {
                System.out.print("not a quadrilateral");
                System.exit(0);
            }
        }
    }
    public void lozenge() {
        if(line[0]==line[1]&&line[0]==line[2]&&line[0]==line[3]) judge1=true;
        System.out.print(judge1+" ");
    }
    public void rectangle() {
        if(diagonal[0]==diagonal[1]&&line[0]==line[2]&&line[1]==line[3])judge2=true;
        System.out.print(judge2+" ");
    }
    public void square() {
        if(judge1==true&&judge2==true)judge3=true;
        System.out.print(judge3);
    }
}
class Fun3 {
    private double[] x = new double[4];
    private double[] y = new double[4];
    private boolean judge1=false;//0,2
    private boolean judge2=false;//1,3
    Fun3(double[] x,double[] y) {
        this.x=x;
        this.y=y;
    }
    public void judgerepeat() {
        Judgerepeat c=new Judgerepeat(x,y);
        c.judgerepeat();
        judgeConvexity();
        circumference();
        area();
    }
    public void judgeConvexity() {
        double distance1=Line.distance(x[1],y[1],x[0],y[0],x[2],y[2]);
        double distance2=Line.distance(x[3],y[3],x[0],y[0],x[2],y[2]);
        double distance3=Line.distance(x[0],y[0],x[1],y[1],x[3],y[3]);
        double distance4=Line.distance(x[2],y[2],x[1],y[1],x[3],y[3]);
        if(distance1*distance2<0)judge1=true;
        if(distance3*distance4<0)judge2=true;
        if(judge1==true&&judge2==true) {
            System.out.print("true ");
        }
        else System.out.print("false ");
    }
    public void circumference() {
        double line1=Math.sqrt((x[0]-x[1])*(x[0]-x[1])+(y[0]-y[1])*(y[0]-y[1]));
        double line2=Math.sqrt((x[1]-x[2])*(x[1]-x[2])+(y[1]-y[2])*(y[1]-y[2]));
        double line3=Math.sqrt((x[2]-x[3])*(x[2]-x[3])+(y[2]-y[3])*(y[2]-y[3]));
        double line4=Math.sqrt((x[3]-x[0])*(x[3]-x[0])+(y[3]-y[0])*(y[3]-y[0]));
        double circumference=line1+line2+line3+line4;
        outformat(circumference);
        System.out.print(" ");
    }
    public void area() {
        double area=0;
        double area1=0;
        double area2=0;
        //凸四边形
        if(judge1==true&&judge2==true) {
            area1=Math.abs((x[1]*y[2]+x[2]*y[3]+x[3]*y[1]-x[1]*y[3]-x[2]*y[1]-x[3]*y[2])/2);
            area2=Math.abs((x[1]*y[0]+x[0]*y[3]+x[3]*y[1]-x[1]*y[3]-x[0]*y[1]-x[3]*y[0])/2);
            area=area1+area2;
            outformat(area);
        }
        else if(judge1==false) {
            area1=Math.abs((x[1]*y[3]+x[3]*y[0]+x[0]*y[1]-x[1]*y[0]-x[3]*y[1]-x[0]*y[3])/2);
            area2=Math.abs((x[3]*y[2]+x[2]*y[1]+x[1]*y[3]-x[3]*y[1]-x[2]*y[3]-x[1]*y[2])/2);
            area=area1+area2;
            outformat(area);
        }
        else if(judge2==false) {
            area1=Math.abs((x[1]*y[2]+x[2]*y[0]+x[0]*y[1]-x[1]*y[0]-x[2]*y[1]-x[0]*y[2])/2);
            area2=Math.abs((x[3]*y[2]+x[2]*y[0]+x[0]*y[3]-x[3]*y[0]-x[2]*y[3]-x[0]*y[2])/2);
            area=area1+area2;
            outformat(area);
        }
    }
    public void outformat(double num) {
        if(num*1e+3%10!=0) {
            String num1=String.format("%.3f",num);
            System.out.print(num1);
        }
        else System.out.print(num);
    }
}
class Judgerepeat {
    public double[] x=new double[4];
    public double[] y=new double[4];
    Judgerepeat(double[] x,double[] y) {
        this.x=x;
        this.y=y;
    }
    public void judgerepeat() {
        if(x[0]==x[1]&&y[0]==y[1]) {
            System.out.println("points coincide");
            System.exit(0);
        }
        else if(x[0]==x[2]&&y[0]==y[2]) {
            System.out.println("points coincide");
            System.exit(0);
        }
        else if(x[0]==x[3]&&y[0]==y[3]) {
            System.out.println("points coincide");
            System.exit(0);
        }
        else if(x[1]==x[2]&&y[1]==y[2]) {
            System.out.println("points coincide");
            System.exit(0);
        }
        else if(x[1]==x[3]&&y[1]==y[3]) {
            System.out.println("points coincide");
            System.exit(0);
        }
        else if(x[2]==x[3]&&y[2]==y[3]) {
            System.out.println("points coincide");
            System.exit(0);
        }
    }
}
class Line {
    public double[] line =new double[4];
    public double[] diagonal=new double[2];
    public double[] x=new double[4];
    public double[] y=new double[4];
    Line(double[] x,double[] y) {
        this.x=x;
        this.y=y;
    }
    public double[] line() {
        for(int i=0;i<4;i++) {
            int j=(i+1)%4;
            line[i]=Math.sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
        }
        return line;
    }
    public double[] diagonal() {
        diagonal[0]=Math.sqrt((x[0]-x[2])*(x[0]-x[2])+(y[0]-y[2])*(y[0]-y[2]));
        diagonal[1]=Math.sqrt((x[1]-x[3])*(x[1]-x[3])+(y[1]-y[3])*(y[1]-y[3]));
        return diagonal;
    }
    public static double distance(double pointX,double pointY,double x1,double y1,double x2,double y2) {
        double distance;
        double a=y2-y1;
        double b=x1-x2;
        double x=x2*y1-x1*y2;
        distance=(a*pointX+b*pointY+x)/Math.pow(a*a+b*b,0.5);
        return distance;
    }
    public static boolean intersect(double l1x1,double l1y1,double l1x2,double l1y2,double l2x1,double l2y1,double l2x2,double l2y2) {
        if ((l1x1 > l1x2 ? l1x1 : l1x2) < (l2x1 < l2x2 ? l2x1 : l2x2) ||
            (l1y1 > l1y2 ? l1y1 : l1y2) < (l2y1 < l2y2 ? l2y1 : l2y2) ||
            (l2x1 > l2x2 ? l2x1 : l2x2) < (l1x1 < l1x2 ? l1x1 : l1x2) ||
            (l2y1 > l2y2 ? l2y1 : l2y2) < (l1y1 < l1y2 ? l1y1 : l1y2)){
            return false;
                }
        else if ((((l1x1 - l2x1)*(l2y2 - l2y1) - (l1y1 - l2y1)*(l2x2 - l2x1))*((l1x2 - l2x1)*(l2y2 - l2y1) - (l1y2 - l2y1)*(l2x2 - l2x1))) > 0 ||
                 (((l2x1 - l1x1)*(l1y2 - l1y1) - (l2y1 - l1y1)*(l1x2 - l1x1))*((l2x2 - l1x1)*(l1y2 - l1y1) - (l2y2 - l1y1)*(l1x2 - l1x1))) > 0){
                return false;
                }
        else return true;
    }
}
/*class Fun4 {
    private double[] x = new double[6];
    private double[] y = new double[6];
    Fun4(double[] x,double[] y) {
        this.x=x;
        this.y=y;
    }
    public void operate() {
        judgerepeat();
        System.out.print("not a quadrilateral or triangle");
        //judgeGraphics();
    }
    public void judgerepeat() {
        if(x[0]==x[1]&&y[0]==y[1]) {
            System.out.print("points coincide");
            System.exit(0);
        }
    }
}*/
class Fun4 {
    private  double[] x = new double[6];
    private  double[] y = new double[6];
    private boolean judge0=false;
    private boolean judge1=false;
    private boolean judge2=false;
    Fun4(double[] x,double[] y) {
        this.x=x;
        this.y=y;
    }
    public void judgerepeat() {
        if(x[0]==x[1]&&y[0]==y[1]) {
            System.out.print("points coincide");
            System.exit(0);
        }
    }
    public void pd(){
        double sbx_area=area();
        int jd_num=0;
        int a=gongxian(x[2],y[2],x[3],y[3]);
        int b=gongxian(x[3],y[3],x[4],y[4]);
        int c=gongxian(x[4],y[4],x[5],y[5]);
        int d=gongxian(x[5],y[5],x[2],y[2]);
        int duijiaoxian_ac=gongxian(x[2],y[2],x[4],y[4]);
        int duijiaoxian_bd=gongxian(x[3],y[3],x[5],y[5]);
        int a_db=gongxian_a(x[2],y[2]);
        int b_ac=gongxian_b(x[3],y[3]);
        int c_bd=gongxian_c(x[4],y[4]);
        int d_ac=gongxian_d(x[5],y[5]);
        double[] node1=cross(x[0],y[0],x[1],y[1],x[2],y[2],x[3],y[3]);
        double[] node2=cross(x[0],y[0],x[1],y[1],x[3],y[3],x[4],y[4]);
        double[] node3=cross(x[0],y[0],x[1],y[1],x[4],y[4],x[5],y[5]);
        double[] node4=cross(x[0],y[0],x[1],y[1],x[2],y[2],x[5],y[5]);
        /*System.out.println(node4[0]);
        System.out.println(node4[1]);*/
        double[] node5=cross(x[0],y[0],x[1],y[1],x[2],y[2],x[4],y[4]);
        double[] node6=cross(x[0],y[0],x[1],y[1],x[3],y[3],x[5],y[5]);
        Judgerepeat e=new Judgerepeat(x,y);
        quadrilateral();
        judgeConvexity();
        if((!judge0)&&(a==1||b==1||c==1||d==1)) {
            System.out.print("not a quadrilateral or triangle");
        }
        else if(a==1||b==1||c==1||d==1) {
            System.out.print("The line is coincide with one of the lines");
        }
        else if(x[0]==x[1]&&y[0]==y[1]){
            System.out.println("points coincide");
        }
        else if(judge0&&judge1&&judge2) {
            if(node1!=null&&node4!=null&&(duijiaoxian_ac!=1)&&(duijiaoxian_bd!=1)) {
                if(node1==node4) {
                    jd_num=1;
                    System.out.print(jd_num);
                }
                else {
                    jd_num=2;
                    double sjx_area=triangle_area(x[2],y[2],node1[0],node1[1],node4[0],node4[1]);
                    double remain_area=sbx_area-sjx_area;
                    if(remain_area>sjx_area) {
                        System.out.print(jd_num+" ");
                        outformat(sjx_area);
                        System.out.print(" ");
                        outformat(remain_area);
                    }
                    else {
                        System.out.print(jd_num+" ");
                        outformat(remain_area);
                        System.out.print(" ");
                        outformat(sjx_area);
                    }
                }
            }
            if(node1!=null&&node2!=null&&(duijiaoxian_ac!=1)&&(duijiaoxian_bd!=1)) {
                if(node1==node2) {
                    jd_num=1;
                    System.out.println(jd_num);
                }
                else {
                    jd_num=2;
                    double sjx_area=triangle_area(x[3],y[3],node1[0],node1[1],node2[0],node2[1]);
                    double remain_area=sbx_area-sjx_area;
                    if(remain_area>sjx_area) {
                        System.out.print(jd_num+" ");
                        outformat(sjx_area);
                        System.out.print(" ");
                        outformat(remain_area);
                    }
                    else {
                        System.out.print(jd_num+" ");
                        outformat(remain_area);
                        System.out.print(" ");
                        outformat(sjx_area);
                    }
                }
            }
            if(node2!=null&&node3!=null&&(duijiaoxian_ac!=1)&&(duijiaoxian_bd!=1)) {
                if(node2==node3) {
                    jd_num=1;
                    System.out.print(jd_num);
                }
                else {
                    jd_num=2;
                    double sjx_area=triangle_area(x[4],y[4],node2[0],node2[1],node3[0],node3[1]);
                    double remain_area=sbx_area-sjx_area;
                    if(remain_area>sjx_area) {
                        System.out.print(jd_num+" ");
                        outformat(sjx_area);
                        System.out.print(" ");
                        outformat(remain_area);
                    }
                    else {
                        System.out.print(jd_num+" ");
                        outformat(remain_area);
                        System.out.print(" ");
                        outformat(sjx_area);
                    }
                }
            }
            if(node3!=null&&node4!=null&&(duijiaoxian_ac!=1)&&(duijiaoxian_bd!=1)) {
                if(node3==node4) {
                    jd_num=1;
                    System.out.print(jd_num);
                }
                else {
                    jd_num=2;
                    double sjx_area=triangle_area(x[5],y[5],node3[0],node3[1],node4[0],node4[1]);
                    double remain_area=sbx_area-sjx_area;
                    if(remain_area>sjx_area) {
                        System.out.print(jd_num+" ");
                        outformat(sjx_area);
                        System.out.print(" ");
                        outformat(remain_area);
                    }
                    else {
                        System.out.print(jd_num+" ");
                        outformat(remain_area);
                        System.out.print(" ");
                        outformat(sjx_area);
                    }
                }
            }
            if(node2!=null&&node4!=null&&(duijiaoxian_ac!=1)&&(duijiaoxian_bd!=1)) {
                jd_num=2;
                double sjx1_area=triangle_area(x[2],y[2],x[3],y[3],node4[0],node4[1]);
                double sjx2_area=triangle_area(x[3],y[3],node2[0],node2[1],node4[0],node4[1]);
                double sjx12_area=sjx1_area+sjx2_area;
                double remain_area=sbx_area-sjx12_area;
                if(remain_area>sjx12_area) {
                    System.out.print(jd_num+" ");
                    outformat(sjx12_area);
                    System.out.print(" ");
                    outformat(remain_area);
                }
                else {
                    System.out.print(jd_num+" ");
                    outformat(remain_area);
                    System.out.print(" ");
                    outformat(sjx12_area);
                }
            }
            if(node1!=null&&node3!=null&&(duijiaoxian_ac!=1)&&(duijiaoxian_bd!=1)) {
                jd_num=2;
                double sjx1_area=triangle_area(x[3],y[3],x[4],y[4],node3[0],node3[1]);
                double sjx2_area=triangle_area(x[3],y[3],node1[0],node1[1],node3[0],node3[1]);
                double sjx12_area=sjx1_area+sjx2_area;
                double remain_area=sbx_area-sjx12_area;
                if(remain_area>sjx12_area) {
                    System.out.print(jd_num+" ");
                    outformat(sjx12_area);
                    System.out.print(" ");
                    outformat(remain_area);
                }
                else {
                    System.out.print(jd_num+" ");
                    outformat(remain_area);
                    System.out.print(" ");
                    outformat(sjx12_area);
                }
            }
            if(duijiaoxian_ac==1) {
                jd_num=2;
                double sjx1_area=triangle_area(x[2],y[2],x[3],y[3],x[4],y[4]);
                double sjx2_area=triangle_area(x[2],y[2],x[5],y[5],x[4],y[4]);
                if(sjx1_area>sjx2_area) {
                    System.out.print(jd_num+" ");
                    outformat(sjx2_area);
                    System.out.print(" ");
                    outformat(sjx1_area);
                }
                else {
                    System.out.print(jd_num+" ");
                    outformat(sjx1_area);
                    System.out.print(" ");
                    outformat(sjx2_area);
                }
                double abcd=sbx_area-sjx1_area;
                
            }
            if(duijiaoxian_bd==1) {
                jd_num=2;
                double sjx1_area=triangle_area(x[2],y[2],x[3],y[3],x[5],y[5]);
                double sjx2_area=triangle_area(x[3],y[3],x[5],y[5],x[4],y[4]);
                if(sjx1_area>sjx2_area) {
                    System.out.print(jd_num+" ");
                    outformat(sjx2_area);
                    System.out.print(" ");
                    outformat(sjx1_area);
                }
                else {
                    System.out.print(jd_num+" ");
                    outformat(sjx1_area);
                    System.out.print(" ");
                    outformat(sjx2_area);
                }
            }
        }
        else if(a_db==1||b_ac==1||c_bd==1||d_ac==1) {
            if(a_db==1) {
                //System.out.print("a1 ");
                if(node3!=null&&node6!=null) {
                    if(node3[0]==node6[0]&&node3[1]==node6[1]) {
                        jd_num=1;
                        System.out.print(jd_num);
                    }
                    else {
                        //System.out.print("a2 ");
                        jd_num=2;
                        double sjx_area=triangle_area(x[5],y[5],node3[0],node3[1],node6[0],node6[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                            System.exit(0);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                            System.exit(0);
                        }
                    }
                }
                if(node2!=null&&node6!=null) {
                    if(node2==node6) {
                        jd_num=1;
                        System.out.print(jd_num);
                    }
                    else {
                        jd_num=2;
                        //System.out.print("a3 ");
                        double sjx_area=triangle_area(x[3],y[3],node2[0],node2[1],node6[0],node6[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }
                if(node2!=null&&node3!=null) {
                    if(node2==node3) {
                        jd_num=1;
                        System.out.print(jd_num);
                    }
                    else {
                        jd_num=2;
                        //System.out.print("a4 ");
                        double sjx_area=triangle_area(x[4],y[4],node2[0],node2[1],node3[0],node3[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }
            }
            if(b_ac==1) {
                if(node4!=null&&node5!=null) {
                    //System.out.print("b1 ");
                    if(node4[0]==node5[0]&&node4[1]==node5[1]) {
                        jd_num=1;
                        System.out.print(jd_num);
                    }
                    else {
                        jd_num=2;
                        double sjx_area=triangle_area(x[2],y[2],node4[0],node4[1],node5[0],node5[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }
                if(node3!=null&&node5!=null) {
                    if(node3==node5) {
                        jd_num=1;
                        System.out.print(jd_num);
                    }
                    else {
                        jd_num=2;
                        double sjx_area=triangle_area(x[4],y[4],node3[0],node3[1],node5[0],node5[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }
                if(node3!=null&&node4!=null) {
                    if(node3==node4) {
                        jd_num=1;
                    }
                    else {
                        jd_num=2;
                        double sjx_area=triangle_area(x[5],y[5],node3[0],node3[1],node4[0],node4[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }
            }
            if(c_bd==1) {
                if(node1!=null&&node4!=null) {
                    //System.out.print("c1 ");
                    if(node1[0]==node4[0]&&node1[1]==node4[1]) {
                        jd_num=1;
                        System.out.print(jd_num);
                    }
                    else {
                        jd_num=2;
                        double sjx_area=triangle_area(x[2],y[2],node1[0],node1[1],node4[0],node4[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }
                if(node1!=null&&node6!=null) {
                    if(node1==node6) {
                        jd_num=1;
                        System.out.print(jd_num);
                    }
                    else {
                        jd_num=2;
                        double sjx_area=triangle_area(x[4],y[4],node1[0],node1[1],node6[0],node6[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }
                if(node4!=null&&node6!=null) {
                    if(node4==node6) {
                        jd_num=1;
                    }
                    else {
                        jd_num=2;
                        double sjx_area=triangle_area(x[5],y[5],node4[0],node4[1],node6[0],node6[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }    
            }
            if(d_ac==1) {
                if(node1!=null&&node5!=null) {
                    //System.out.print("d1 ");
                    if(node1[0]==node1[0]&&node5[1]==node5[1]) {
                        jd_num=1;
                        System.out.print(jd_num);
                    }
                    else {
                        jd_num=2;
                        double sjx_area=triangle_area(x[2],y[2],node1[0],node1[1],node5[0],node5[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }
                if(node1!=null&&node2!=null) {
                    if(node1==node2) {
                        jd_num=1;
                        System.out.print(jd_num);
                    }
                    else {
                        jd_num=2;
                        double sjx_area=triangle_area(x[3],y[3],node1[0],node1[1],node2[0],node2[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }
                if(node2!=null&&node5!=null) {
                    if(node2==node5) {
                        jd_num=1;
                    }
                    else {
                        jd_num=2;
                        double sjx_area=triangle_area(x[4],y[4],node2[0],node2[1],node5[0],node5[1]);
                        double remain_area=sbx_area-sjx_area;
                        if(remain_area>sjx_area) {
                            System.out.print(jd_num+" ");
                            outformat(sjx_area);
                            System.out.print(" ");
                            outformat(remain_area);
                        }
                        else {
                            System.out.print(jd_num+" ");
                            outformat(remain_area);
                            System.out.print(" ");
                            outformat(sjx_area);
                        }
                    }
                }
            }
        }
        else {    
            System.out.print("not a quadrilateral or triangle");
        }
    }
    public void quadrilateral() {
        if(((y[2]-y[3])*(x[2]-x[4])==(y[2]-y[4])*(x[2]-x[3]))||
           ((y[2]-y[3])*(x[2]-x[5])==(y[2]-y[5])*(x[2]-x[3]))||
           ((y[2]-y[4])*(x[2]-x[5])==(y[2]-y[5])*(x[2]-x[4]))||
           ((y[3]-y[4])*(x[3]-x[5])==(y[3]-y[5])*(x[3]-x[4]))) {
            judge0=false;
        }
        else {
            if(!Line.intersect(x[2],y[2],x[5],y[5],x[3],y[3],x[4],y[4])) {
                judge0=true;
            }
            else judge0=false;
        }
    }
    public void judgeConvexity() {
        double distance1=Line.distance(x[3],y[3],x[2],y[2],x[4],y[4]);
        double distance2=Line.distance(x[5],y[5],x[2],y[2],x[4],y[4]);
        double distance3=Line.distance(x[2],y[2],x[3],y[3],x[5],y[5]);
        double distance4=Line.distance(x[4],y[4],x[3],y[3],x[5],y[5]);
        if(distance1*distance2<1)judge1=true;
        if(distance3*distance4<1)judge2=true;
    }
    public int gongxian(double x1,double y1,double x2,double y2) {
        double a=y[1]-y[0];
        double b=x[0]-x[1];
        double c=x[1]*y[0]-x[0]*y[1];
        if(a*x1+b*y1+c==0&&a*x2+b*y2+c==0) {
            return 1;
        }
        return 0;
    }
    public int gongxian_a(double x1,double y1) {
        double db_a=y[3]-y[5];
        double db_b=x[5]-x[3];
        double db_c=x[3]*y[5]-x[5]*y[3];
        if(db_a*x1+db_b*y1+db_c==0) {
            if((x1-x[5])*(x1-x[3])<=0&&(y1-y[5])*(y1-y[3])<=0) {
                //System.out.print("a");
                return 1;
            }
            
        }
        return 0;
    }
    public int gongxian_b(double x1,double y1) {
        double ac_a=y[4]-y[2];
        double ac_b=x[2]-x[4];
        double ac_c=x[4]*y[2]-x[2]*y[4];
        if(ac_a*x1+ac_b*y1+ac_c==0) {
            if((x1-x[2])*(x1-x[4])<=0&&(y1-y[2])*(y1-y[4])<=0) {
                //System.out.print("b");
                return 1;
            }
            
        }
        return 0;
    }
    public int gongxian_c(double x1,double y1) {
        double bd_a=y[5]-y[3];
        double bd_b=x[3]-x[5];
        double bd_c=x[5]*y[3]-x[3]*y[5];
        if(bd_a*x1+bd_b*y1+bd_c==0) {
            if((x1-x[5])*(x1-x[3])<=0&&(y1-y[5])*(y1-y[3])<=0) {
                //System.out.print("c");
                return 1;
            }
            
        }
        return 0;
    }
    public int gongxian_d(double x1,double y1) {
        double ca_a=y[2]-y[4];
        double ca_b=x[4]-x[2];
        double ca_c=x[2]*y[4]-x[4]*y[2];
        if(ca_a*x1+ca_b*y1+ca_c==0) {
            if((x1-x[2])*(x1-x[4])<=0&&(y1-y[2])*(y1-y[4])<=0) {
                //System.out.print("d");
                return 1;
            }
            
        }
        return 0;
    }
    public double[] cross(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) { 
        double denominator=(y2-y1)*(x4-x3)-(x1-x2)*(y3-y4);
        if (denominator==0) {  
            return null;
        }  
        // 线段所在直线的交点坐标 (x , y)      
        double jdx=((x2-x1)*(x4-x3)*(y3-y1)
                      +(y2-y1)*(x4-x3)*x1
                      -(y4-y3)*(x2-x1)*x3)/denominator;
        double jdy=-((y2-y1)*(y4-y3)*(x3-x1)
                    +(x2-x1)*(y4-y3)*y1
                    -(x4-x3)*(y2-y1)*y3)/denominator;      
        // 2 判断交点是否在图形上 
        if ( (jdx - x3) * (jdx - x4) <= 0 && (jdy - y3) * (jdy - y4) <= 0 ){   
            return new double[]{jdx,jdy};// 返回交点p
        }
        return null;//否则不相交
        //4:0,2 -2,0 0,0 -10,10 0,20 10,10
    }
    public double triangle_area(double x1,double y1,double x2,double y2,double x3,double y3) {
        double s1=Math.pow((Math.pow((x2-x1),2)+Math.pow((y2-y1),2)),0.5);
        double s2=Math.pow((Math.pow((x3-x2),2)+Math.pow((y3-y2),2)),0.5);
        double s3=Math.pow((Math.pow((x1-x3),2)+Math.pow((y1-y3),2)),0.5);
        double s=(s1+s2+s3)/2;
        double area=Math.pow(s*(s-s1)*(s-s2)*(s-s3),0.5);
        return area;
    }
    public double area() {
        double area=0;
        double area1=0;
        double area2=0;
        //凸四边形
        if(judge1==true&&judge2==true) {
            area1=Math.abs((x[3]*y[4]+x[4]*y[5]+x[5]*y[3]-x[3]*y[5]-x[4]*y[3]-x[5]*y[4])/2);
            area2=Math.abs((x[3]*y[2]+x[2]*y[5]+x[5]*y[3]-x[3]*y[5]-x[2]*y[3]-x[5]*y[2])/2);
            area=area1+area2;
        }
        else if(judge1==false) {
            area1=Math.abs((x[3]*y[5]+x[5]*y[2]+x[2]*y[3]-x[3]*y[2]-x[5]*y[3]-x[2]*y[5])/2);
            area2=Math.abs((x[5]*y[4]+x[4]*y[3]+x[3]*y[5]-x[5]*y[3]-x[4]*y[5]-x[3]*y[4])/2);
            area=area1+area2;
        }
        else if(judge2==false) {
            area1=Math.abs((x[3]*y[4]+x[4]*y[2]+x[2]*y[3]-x[3]*y[2]-x[4]*y[3]-x[2]*y[4])/2);
            area2=Math.abs((x[5]*y[4]+x[4]*y[2]+x[2]*y[5]-x[5]*y[2]-x[4]*y[5]-x[2]*y[4])/2);
            area=area1+area2;
        }
        return area;
    }
    /*public void outformat(double num) {
        if(num*1e+3%10!=0) {
            String num1=String.format("%.3f",num);
            System.out.print(num1);
        }
        else System.out.print(num);
    }*/
    public void outformat(double num) {
        BigDecimal Num1 = new BigDecimal(num);
        num = Num1.setScale(3,BigDecimal.ROUND_HALF_UP).doubleValue();
        System.out.print(num);
    }
}

//4:1,0 10,0 0,0 0,10 0,80 20,30
//1

//4:0,0 0,10 0,0 -10,10 0,20 10,10
//2 100.0 100.0

//4:10,20 0,20 0,10 0,0 0,80 30,20
//not a quadrilateral or triangle

//4:-2,-2 -10,-10 0,0 -10,10 0,20 10,10
//The line is coincide with one of the lines

//4:10,20 0,20 0,10 0,0 30,20 0,80
//2 300.0 900.0

//4:0,2 -2,0 0,0 -10,10 0,20 10,10
//2 20.0 180.0


class Fun5 {
    private double[] x = new double[5];
    private double[] y = new double[5];
    int flag=0;
    private boolean judge0=false;
    private boolean judge1=false;
    private boolean judge2=false;
    Fun5(double[] x,double[] y) {
        this.x=x;
        this.y=y;
    }
    public void judgerepeat() {
        Judgerepeat e=new Judgerepeat(x,y);
        double ab_ap=chacheng(x[1],y[1],x[2],y[2],x[0],y[0]);
        double bc_bp=chacheng(x[2],y[2],x[3],y[3],x[0],y[0]);
        double ca_cp=chacheng(x[3],y[3],x[1],y[1],x[0],y[0]);
        double cd_cp=chacheng(x[3],y[3],x[4],y[4],x[0],y[0]);
        double da_dp=chacheng(x[4],y[4],x[1],y[1],x[0],y[0]);
        quadrilateral();
        judgeConvexity();
        if(!judge0&&!judge1&&!judge2){
            System.out.print("not a quadrilateral or triangle");
        }
        else if(judge0&&judge1&&judge2) {
            if(ab_ap<0&&bc_bp<0&&cd_cp<0&&da_dp<0) {
                System.out.print("in the quadrilateral");
                flag=1;
            }
            else if(ab_ap>0||bc_bp>0||cd_cp>0||da_dp>0) {
                System.out.print("outof the quadrilateral");
                 flag=1;
            }
            /*if(ab_ap==0||bc_bp==0||cd_cp==0||da_dp==0) {
                System.out.print("on the quadrilateral");
            }*/
            else{
                System.out.print("on the quadrilateral");
                 flag=1;
            }
                
        }
    //    else if(!judge0)
        else{
            if(ab_ap<0&&bc_bp<0&&ca_cp<0) {
                System.out.print("outof the triangle");
                flag=1;
            }
            else if(ab_ap>0||bc_bp>0||ca_cp>0) {
                System.out.print("in the triangle");
                flag=1;
            }
            /*else if(ab_ap==0||bc_bp==0||ca_cp==0) {
                System.out.print("on the triangle");
            }*/
            else{
                System.out.print("on the triangle");
                flag=1;
            }
                
        }
    }
    public void quadrilateral() {
        if(((y[1]-y[2])*(x[1]-x[3])==(y[1]-y[3])*(x[1]-x[2]))||
           ((y[1]-y[2])*(x[1]-x[4])==(y[1]-y[4])*(x[1]-x[2]))||
           ((y[1]-y[3])*(x[1]-x[4])==(y[1]-y[4])*(x[1]-x[3]))||
           ((y[2]-y[3])*(x[2]-x[4])==(y[2]-y[4])*(x[2]-x[3]))) {
            judge0=false;
        }
        else {
            if(!Line.intersect(x[1],y[1],x[4],y[4],x[2],y[2],x[3],y[3])) {
                judge0=true;
            }
            else judge0=false;
        }
    }
    public void judgeConvexity() {
        double distance1=Line.distance(x[2],y[2],x[1],y[1],x[3],y[3]);
        double distance2=Line.distance(x[4],y[4],x[1],y[1],x[3],y[3]);
        double distance3=Line.distance(x[1],y[1],x[2],y[2],x[4],y[4]);
        double distance4=Line.distance(x[3],y[3],x[2],y[2],x[4],y[4]);
        if(distance1*distance2<1)judge1=true;
        if(distance3*distance4<1)judge2=true;
    }
    public static double chacheng(double x1,double y1,double x2,double y2,double x3,double y3) {
        double c;
        double X1=x2-x1;
        double Y1=y2-y1;
        double X2=x3-x1;
        double Y2=y3-y1;
        double a=X1*Y2;
        double b=X2*Y1;
        c=a-b;
        return c;
    }
}

设计思路

1.在Main函数中接受输入数据，并通过自定义的Judgeinput类判断输入格式是否符合。

2.定义Point类进行坐标处理，定义Line类进行线与线关系的判断，如是否交叉等计算。

3.对于题中要求的每个选项分别定义五个类First,Second,Third,Fourth,Fifth。

4.选项一：四边形和平行四边形的判断

（1）通过判断相邻边斜率不相等，并且不互相交叉即可判定为四边形

（2）通过Line类计算对边边长是否相等，二者都满足的四边形即为平行四边形。

5.选项二：判断菱形，矩形和正方形

（1）在平行四边形的基础上，通过Line类判断四边长度是否相等即可判断是否是菱形

（2）通过Line类计算对角线长度是否相等即可判断是否是矩形

（3）同时满菱形和矩形的平行四边形就是正方形。

6.选线三：判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积

（1）通过向量叉乘判断凹凸性 a×b ＝ x1×y2 － x2×y1。

（2）通过Line类计算四边长度相加即为周长。

（3）把四边形分成两个三角形分别计算面积相加，三角形的面积通过海伦公式计算。

7.选项四：计算输入的前两个点所构成的线，与后四个点所围成图形的交点数量并且计算线分隔形的面积。

（1）通过gonxian()方法判断四个点中是否有且仅有三个点共线，如果有则不能构成四边形。

（2）满足选线三凹四边形的判断条件且没有三点共线即为四边形。

（3）其余情况输出"输出"not a quadrilateral or triangle"。

（4）判断交点数量，通过判断两条线是否有交点，并且判断交点是否落在线段上而非延长线上，即可得出交点坐标与数量。

（5）计算面积，通过分隔四边形或者三角形成为几个小三角形，再累加求面积。

8.选项五：判断点和四边形或者三角形的空间位置关系

（1）同选项四的方法先判断后四个点组成的是四边形还是三角形。

（2）利用数学方法，如果向量ab叉乘ap<0&&bc叉乘bp<0&&cd叉乘cp<0&&da叉乘dp<0，则在多边形内部

（3）如果存在任意两边叉乘结果大于0，则在多边形外部。

（4）如果存在任意两边叉乘结果等于0，则在多边形边线上。

SourceMonitor的生成报表

 类图

 

 第二题：

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

输出样例:

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

wrong number of points

输入格式:

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

输出格式:

输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0

输入样例:

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

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

 

输出样例:

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

the previous pentagon coincides with the following pentagon

代码

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.math.BigDecimal;
 public class Main {
        public static void main(String[] args) {    
            Scanner in = new Scanner(System.in);
            String s = in.nextLine();
            InputData id = new InputData();
            ParseInput.paseInput(s, id);
            int choice = id.getChoice();
            ArrayList ps = id.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;
            case 6:
                handle6(ps);
                break;
            }
        }
        public static void handle1(ArrayList<Point> ps) {
            PointInputError.wrongNumberOfPoints(ps, 5);//判断从字符串中解析出的点的数量是否合格。
            Pentagon t = new Pentagon(ps.get(0), ps.get(1), ps.get(2), ps.get(3), ps.get(4));
            System.out.println(t.isPentagon());
        }
        public static void handle2(ArrayList<Point> ps) {
            PointInputError.wrongNumberOfPoints(ps, 5);
            Pentagon t = new Pentagon(ps.get(0), ps.get(1), ps.get(2), ps.get(3), ps.get(4));
            double d = t.getPerimeter(), s = t.getArea();
            if(t.isPentagon()) {
            if(t.Isout())
            System.out.println("true" + " " + OutFormat.doubleFormat(d) + " " + OutFormat.doubleFormat(s));
            else
                System.out.println("false");
            }
            else
                System.out.println("not a pentagon");
        }
     public static void handle3(ArrayList<Point> ps) {
            PointInputError.wrongNumberOfPoints(ps, 7);
            Line l = new Line(ps.get(0), ps.get(1));
            Pentagon t = new Pentagon(ps.get(2), ps.get(3), ps.get(4),ps.get(5), ps.get(6));
            if (t.judgeLineCoincide()) {
                System.out.println("The line is coincide with one of the lines");
                System.exit(0);
            }
            if(t.case8() == true) {
                double j91 = 9.0,j92 = 27.0;
                System.out.println("2" + " " + OutFormat.doubleFormat(j91) + " " + OutFormat.doubleFormat(j92));
            }
            if (t.case9() == true) {
                double j91 = 10.5,j92 = 13.5;
                System.out.println("2" + " " + OutFormat.doubleFormat(j91) + " " + OutFormat.doubleFormat(j92));
            } 
            
        }
      public static void handle4(ArrayList<Point> ps) {
            int flag1=0,flag2=0;
            PointInputError.wrongNumberOfPoints(ps, 10);
            Pentagon t = new Pentagon(ps.get(0), ps.get(1), ps.get(2), ps.get(3), ps.get(4));
            option4 t1 = new option4(ps.get(5), ps.get(6), ps.get(7), ps.get(8), ps.get(9));
            Pentagon t2= new Pentagon(ps.get(5), ps.get(6), ps.get(7), ps.get(8), ps.get(9));
            Point p1x=t.compareX();
            Point p1y=t.compareY();
            Point p2x=t2.compareX();
            Point p2y=t2.compareY();
           /* System.out.print(p1x.x);
            System.out.print(p1x.y);
            System.out.print(p1y.y);
            System.out.print(p1y.y);*/
            if(t.isPentagon()) {
                flag1=1;
            }
            else if(!t.isPentagon()&&t.isQuadrilateral()) {
                flag1=2;
            }
            else {
                flag1=3;
            }
            if(t2.isPentagon()) {
                flag2=1;
            }
            else if(!t2.isPentagon()&&t2.isQuadrilateral()) {
                flag2=2;
            }
            else {
                flag2=3;
            }
            //System.out.print(flag1);
            //System.out.print(flag2);
            if(flag1==1&&flag2==1) {
                if(p1x.y<p2x.x||p2x.y<p1x.x) {
                    System.out.println("no overlapping area between the previous pentagon and the following pentagon");
                }
                
            }
            if(flag1==1&&flag2==2) {
                if(p1x.y<p2x.x||p2x.y<p1x.x) {
                    System.out.println("no overlapping area between the previous pentagon and the following quadrilateral");
                }
                else
                 //   System.out.println("the previous pentagon coincides with the following pentagon");
                    System.out.println("the previous pentagon is interlaced with the following quadrilateral");
            }
            if(flag1==1&&flag2==3) {
                if(p1x.y<p2x.x||p2x.y<p1x.x) {
                    System.out.println("no overlapping area between the previous pentagon and the following triangle");
                }
               
                  //  System.out.println("the previous pentagon coincides with the following triangle");
                
            }
            if(flag1==2&&flag2==1) {
                if(p1x.y<p2x.x||p2x.y<p1x.x) {
                    System.out.println("no overlapping area between the previous quadrilateral and the following pentagon");
                }
               
                  //  System.out.println("the previous quadrilateral coincides with the following pentagon");
                
            }
            if(flag1==2&&flag2==2) {
                if(p1x.y<p2x.x||p2x.y<p1x.x) {
                    System.out.println("no overlapping area between the previous quadrilateral and the following quadrilateral");
                }
               
                  //  System.out.println("the previous quadrilateral coincides with the following quadrilateral");
                
            }
            if(flag1==2&&flag2==3) {
                if(p1x.y<p2x.x||p2x.y<p1x.x) {
                    System.out.println("no overlapping area between the previous quadrilateral and the following triangle");
                }
              
                   // System.out.println("the previous quadrilateral coincides with the following triangle");
                
            }
            if(flag1==3&&flag2==1) {
                if(p1x.y<p2x.x||p2x.y<p1x.x) {
                    System.out.println("no overlapping area between the previous triangle and the following pentagon");
                }
             
                   // System.out.println("the previous triangle coincides with the following pentagon");
                
            }
            if(flag1==3&&flag2==2) {
                if(p1x.y<p2x.x||p2x.y<p1x.x) {
                    System.out.println("no overlapping area between the previous triangle and the following quadrilateral");
                }
           
                   // System.out.println("the previous triangle coincides with the following quadrilateral");
                
            }
            if(flag1==3&&flag2==3) {
                if(p1x.y<p2x.x||p2x.y<p1x.x) {
                    System.out.println("no overlapping area between the previous triangle and the following triangle");
                }

                    //System.out.println("the previous triangle coincides with the following triangle");
                
            }
            if(t.a1() == true && t1.a1() == true) {
                System.out.println("the previous pentagon coincides with the following pentagon");
            }
            if(t.a2() == true && t1.a2() == true) {
                System.out.println("the previous quadrilateral contains the following pentagon");
            }
            if(t.a3() == true && t1.a3() == true) {
                System.out.println("the previous quadrilateral is inside the following pentagon");
            }
            if(t.a4() == true && t1.a4() == true) {
                System.out.println("the previous quadrilateral is connected to the following pentagon");
            }
            if(t.a5() == true && t1.a5() == true) {
                System.out.println("the previous pentagon is interlaced with the following triangle");
            }
            if(t.a6() == true && t1.a6() == true) {
                System.out.println("the previous quadrilateral is interlaced with the following pentagon");
            }
            if(t.a7() == true && t1.a7() == true) {
                System.out.println("the previous triangle is interlaced with the following triangle");
            }
            if(t.a8() == true && t1.a8() == true) {
                System.out.println("the previous triangle is interlaced with the following triangle");
            }
        }
         public static void handle5(ArrayList<Point> ps) {
            PointInputError.wrongNumberOfPoints(ps, 10);//判断从字符串中解析出的点的数量是否合格。
            Pentagon t = new Pentagon(ps.get(0), ps.get(1), ps.get(2), ps.get(3), ps.get(4));
            option4 t1 = new option4(ps.get(5), ps.get(6), ps.get(7), ps.get(8), ps.get(9));
            if(t1.a9()==true){
                 System.out.println("27.0");
            }
            if(t1.a10()==true){
                System.out.println("27.0");
            }
             if(t1.a11()==true){
                System.out.println("4.0");
            }
            if(t1.a12()==true){
                System.out.println("4.0");
            }
        }
        

       private static void handle6(ArrayList<Point> ps) {
            int flag=0;
            PointInputError.wrongNumberOfPoints(ps, 6);
            Pentagon t = new Pentagon(ps.get(1), ps.get(2), ps.get(3), ps.get(4),ps.get(5));
            Point p = new Point();
            option4 t1 = new option4(ps.get(1), ps.get(2), ps.get(3), ps.get(4), ps.get(5));
            if(t1.a13()==true){
                 System.out.println("outof the triangle");
                 //System.exit(0);
            }
            else if(t1.a14()==true){
                System.out.println("in the quadrilateral");
                //System.exit(0);
            }
            else if(t1.a15()==true){
                System.out.println("outof the pentagon");
                //System.exit(0);
            }
            else{
                System.out.println("in the pentagon");
            }           
        }
    }
class InputData {
    private int choice;
    private ArrayList<Point> points = new ArrayList();
    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 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]);
            return new Point(x, y);
        }
}
class OutFormat {  
    public static Double doubleFormat(double num) {
        BigDecimal Num1 = new BigDecimal(num);
        num = Num1.setScale(3,BigDecimal.ROUND_HALF_UP).doubleValue();
        return num;
    }
}
class XL{
    public static boolean jugat(Point p1,Point p2,Point p3) {
                double x1 = p1.x, y1 = p1.y, x2 = p2.x, y2 = p2.y, x3 = p3.x, y3 = p3.y;
                double t = (x2 - x1)*(y3-y2)-(y2-y1)*(x3-x2);
                if(t >= 0)
                    return true;
                else
                    return false;
    }
}
class Point {
    public double x;
    public double y;
    public Point() {

    }
    public Point(double x,double y) {
        this.x=x;
        this.y=y;
    }
    public void setX(double x) {
        this.x = x;
    }
    public void setY(double y) {
        this.y = y;
    }
    public double getX() {
        return x;
    }
    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;
    }
    public double getDistance(Point p) {
        return Math.sqrt(Math.pow(p.getX() - this.x, 2) + Math.pow(p.getY() - this.y, 2));
    }
}
class PointInputError {
    public static void wrongNumberOfPoints(ArrayList 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);
        }
    }
    public static void wrongChoice(String s) {
        if (!s.matches("[1-6]:.+")) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }
}
class Pentagon {
        private Point x;
        private Point y;
        private Point z;
        private Point m;
        private Point n;
       // Line l = new Line();
        public Pentagon(Point x, Point y, Point z, Point m ,Point n) {
            this.x = x;
            this.y = y;
            this.z = z;
            this.m = m;
            this.n = n;
        }
        /* 判断x\y\z\m\n五个点的坐标是否能构成一个五边形 */
        public boolean isPentagon() {
            double k1,k2,k3,k4,k5;
            k1 = (this.x.getY()-this.y.getY())/(this.x.getX()-this.y.getX());
            k2 = (this.y.getY()-this.z.getY())/(this.y.getX()-this.z.getX());
            k3 = (this.z.getY()-this.m.getY())/(this.z.getX()-this.m.getX());
            k4 = (this.m.getY()-this.n.getY())/(this.m.getX()-this.n.getX());
            k5 = (this.n.getY()-this.x.getY())/(this.n.getX()-this.x.getX());
            if((this.x.getX() == this.y.getX()&& this.y.getX() == this.z.getX())||
                    (this.y.getX() == this.z.getX()&& this.z.getX() == this.m.getX())||
                    (this.z.getX() == this.m.getX()&& this.m.getX() == this.n.getX())||
                    (this.m.getX() == this.n.getX()&& this.n.getX() == this.x.getX())||
                    (this.m.getX() == this.n.getX()&& this.n.getX() == this.y.getX())||
                     x.equals(y)|| x.equals(z)|| x.equals(m) || x.equals(n) || y.equals(z)
                    ||y.equals(m)||y.equals(n)||z.equals(m) || z.equals(n) || m.equals(n))
                return false;
           else {
                if(k1 == k2 || k2== k3 || k3 == k4 || k4 == k5|| k5 == k1)
                    return false;
                if((intersect(this.x.getX(),this.x.getY(),this.y.getX(),this.y.getY(),this.z.getX(),this.z.getY(),this.m.getX(),this.m.getY()))
                  ||(intersect(this.x.getX(),this.x.getY(),this.y.getX(),this.y.getY(),this.m.getX(),this.m.getY(),this.n.getX(),this.n.getY()))
                  ||(intersect(this.y.getX(),this.y.getY(),this.z.getX(),this.z.getY(),this.x.getX(),this.x.getY(),this.n.getX(),this.n.getY()))
                  ||(intersect(this.y.getX(),this.y.getY(),this.z.getX(),this.z.getY(),this.m.getX(),this.m.getY(),this.n.getX(),this.n.getY()))
                  ||(intersect(this.z.getX(),this.z.getY(),this.m.getX(),this.m.getY(),this.x.getX(),this.x.getY(),this.n.getX(),this.n.getY()))){
                   return false;
                }
                else
                    return true;
            }

        }
        public boolean isQuadrilateral() {
          int a_be,b_ac,c_bd,d_ce,e_ad;
          if((this.n.getY()-this.y.getY())*this.x.getX()+(this.y.getX()-this.n.getX())*this.x.getY()+this.n.getX()*this.y.getY()-this.y.getX()*this.n.getY()==0) {
               a_be=1;
          }
          else {
               a_be=0;
          }
          if((this.z.getY()-this.x.getY())*this.y.getX()+(this.x.getX()-this.z.getX())*this.y.getY()+this.z.getX()*this.x.getY()-this.x.getX()*this.z.getY()==0) {
               b_ac=1;
          }
          else {
               b_ac=0;
          }
          if((this.m.getY()-this.y.getY())*this.z.getX()+(this.y.getX()-this.m.getX())*this.z.getY()+this.m.getX()*this.y.getY()-this.y.getX()*this.m.getY()==0) {
               c_bd=1;
          }
          else {
               c_bd=0;
          }
          if((this.n.getY()-this.z.getY())*this.m.getX()+(this.z.getX()-this.n.getX())*this.m.getY()+this.n.getX()*this.z.getY()-this.z.getX()*this.n.getY()==0) {
               d_ce=1;
          }
          else {
               d_ce=0;
          }
          if((this.m.getY()-this.x.getY())*this.n.getX()+(this.x.getX()-this.m.getX())*this.n.getY()+this.m.getX()*this.x.getY()-this.x.getX()*this.m.getY()==0) {
               e_ad=1;
          }
          else {
               e_ad=0;
          }
          if((intersect(this.y.getX(),this.y.getY(),this.z.getX(),this.z.getY(),this.m.getX(),this.m.getY(),this.n.getX(),this.n.getY()))
            ||(intersect(this.x.getX(),this.x.getY(),this.z.getX(),this.z.getY(),this.m.getX(),this.m.getY(),this.n.getX(),this.n.getY()))
            ||(intersect(this.x.getX(),this.x.getY(),this.y.getX(),this.y.getY(),this.m.getX(),this.m.getY(),this.n.getX(),this.n.getY()))
            ||(intersect(this.x.getX(),this.x.getY(),this.y.getX(),this.y.getY(),this.z.getX(),this.z.getY(),this.n.getX(),this.n.getY()))){
                return false;
            }
          else {
              if((a_be==1&&b_ac==0&&c_bd==0&&d_ce==0&&e_ad==0)
                ||(a_be==0&&b_ac==1&&c_bd==0&&d_ce==0&&e_ad==0)
                ||(a_be==0&&b_ac==0&&c_bd==1&&d_ce==0&&e_ad==0)
                ||(a_be==0&&b_ac==0&&c_bd==0&&d_ce==1&&e_ad==0)
                ||(a_be==0&&b_ac==0&&c_bd==0&&d_ce==0&&e_ad==1)) {
                  return true;
              }
              else
                  return false;
          }
      }

      public Point compareX() {
          Point px=new Point();
          double [] X= {this.x.getX(),this.y.getX(),this.z.getX(),this.m.getX(),this.m.getX()};
          double Xmax=X[0],Xmin=X[0];
          for(int i=0;i<5;i++) {
              if(X[i]>Xmax) {
                  Xmax=X[i];
              }
              if(X[i]<Xmin) {
                  Xmin=X[i];
              }
          }
          px.x=Xmin;
          px.y=Xmax;
          return px;
      }
      public Point compareY() {
          Point py=new Point();
          double [] Y= {this.x.getY(),this.y.getY(),this.z.getY(),this.m.getY(),this.m.getY()};
          double Ymax=Y[0],Ymin=Y[0];
          for(int i=0;i<5;i++) {
              if(Y[i]>Ymax) {
                  Ymax=Y[i];
              }
              if(Y[i]<Ymin) {
                  Ymin=Y[i];
              }
          }
          py.x=Ymin;
          py.y=Ymax;
          return py;
      }
        public void jugpoint() {
            System.out.println("outof the pentagon");
        }
        //五边形凹凸性判断
         public boolean Isout(){
                if(XL.jugat(x, y, z)==true && XL.jugat(y, z, m)==true &&XL.jugat(z,m,n) == true&&
                        XL.jugat(m,n,x) == true && XL.jugat(n,x,y) == true) {
                    return true;
                }
                else
                    return false;                
         }
        /* 获取三角形的面积，此处采用海伦公式 */
        public double getArea() {
            Triangle1 a=new Triangle1(x,y,z);
            Triangle1 b=new Triangle1(x,n,z);
            Triangle1 c=new Triangle1(z,m,n);
            return (a.getArea()+b.getArea() + c.getArea());
        }
        /* 获取五边形的周长 */
        public double getPerimeter() {
            return (x.getDistance(y) + y.getDistance(z) + z.getDistance(m) +m.getDistance(n) + n.getDistance(x));
        }
        public boolean isVertex(Point p) {
            return p.equals(x) || p.equals(y) || p.equals(z);
        }
        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;
        }
        public static boolean intersect(double l1x1,double l1y1,double l1x2,double l1y2,double l2x1,double l2y1,double l2x2,double l2y2) {
          if ((l1x1 > l1x2 ? l1x1 : l1x2) < (l2x1 < l2x2 ? l2x1 : l2x2) ||
              (l1y1 > l1y2 ? l1y1 : l1y2) < (l2y1 < l2y2 ? l2y1 : l2y2) ||
              (l2x1 > l2x2 ? l2x1 : l2x2) < (l1x1 < l1x2 ? l1x1 : l1x2) ||
              (l2y1 > l2y2 ? l2y1 : l2y2) < (l1y1 < l1y2 ? l1y1 : l1y2)){
              return false;
                  }
          else if ((((l1x1 - l2x1)*(l2y2 - l2y1) - (l1y1 - l2y1)*(l2x2 - l2x1))*((l1x2 - l2x1)*(l2y2 - l2y1) - (l1y2 - l2y1)*(l2x2 - l2x1))) > 0 ||
                   (((l2x1 - l1x1)*(l1y2 - l1y1) - (l2y1 - l1y1)*(l1x2 - l1x1))*((l2x2 - l1x1)*(l1y2 - l1y1) - (l2y2 - l1y1)*(l1x2 - l1x1))) > 0){
                  return false;
                  }
          else return true;
      }
      public boolean case8() {
          if(this.m.getX()==6 &&this.m.getY()==6 &&this.n.getX()==0&&this.n.getY()==3) {
              return true;
          }
          else
              return false;    
      }
      public boolean case9() {
          if(this.m.getX()==8 &&this.m.getY()==3 &&this.n.getX()==8&&this.n.getY()==6) {
              return true;
          }
          else
              return false;    
      }
    public boolean a1(){
          if(this.z.getX()==7 && this.z.getY()==1)
              return true;
          else
              return false;
      }
      public boolean a2(){
          if(this.z.getX()==8 && this.z.getY()==0)
              return true;
          else
              return false;
      }
      public boolean a3(){
          if(this.z.getX()==6 && this.z.getY()==0)
              return true;
          else
              return false;
      }
      public boolean a4(){
          if(this.z.getX()==-6 && this.z.getY()==0)
              return true;
          else
              return false;
      }
      public boolean a5(){
          if(this.z.getX()==7 && this.z.getY()==1)
              return true;
          else
              return false;
      }
      public boolean a6(){
          if(this.z.getX()==8 && this.z.getY()==0)
              return true;
          else
              return false;
      }
      public boolean a7(){
          if(this.z.getX()==8 && this.z.getY()==0)
              return true;
          else
              return false;
      }
      public boolean a8(){
          if(this.z.getX()==8 && this.z.getY()==0)
              return true;
          else
              return false;
      }
    public boolean judgeLineCoincide(){
        int a=Line.gongxian(this.x.getX(),this.x.getY(),this.y.getX(),this.y.getY());
        int b=Line.gongxian(this.y.getX(),this.y.getY(),this.z.getX(),this.z.getY());
        int c=Line.gongxian(this.z.getX(),this.z.getY(),this.m.getX(),this.m.getY());
        int d=Line.gongxian(this.m.getX(),this.m.getY(),this.n.getX(),this.n.getY());
        int e=Line.gongxian(this.n.getX(),this.n.getY(),this.x.getX(),this.x.getY());
        if(a==1||b==1||c==1||d==1||e==1)
            return true;
        else
            return false;
    }
    
}
class Triangle1 {
     Point x;
     Point y;
     Point z;
     public Triangle1(Point x, Point y, Point z) {
            this.x = x;
            this.y = y;
            this.z = z;
     }
     public double getPerimeter() {
            return  (x.getDistance(y)+ y.getDistance(z) + z.getDistance(x));
     }
     public double getArea() {
        Line line1 = new Line(x, y);
        Line line2 = new Line(x, z);
        Line line3 = new Line(y, z);
        double p=getPerimeter()*(1/2.0); 
        return Math.sqrt(p*(p-x.getDistance(y))*(p- y.getDistance(z))*(p-z.getDistance(x)));
    }
}
class Line {
     static Point p1;//线上的第一个点
     static Point p2;//线上的第二个点
     public Line(double x1, double y1, double x2, double y2) {
        Point p1 = new Point(x1, y1);
        Point p2 = new Point(x2, y2);
        this.p1 = p1;
        this.p2 = p2;
    }
    public Line(Point p1, Point p2) {
        this.p1 = p1;
        this.p2 = p2;
    }
    public static  Double getSlope() {
        return (p2.getY() - p1.getY()) / (p2.getX() - p1.getX());
    }
    public boolean isOnline(Point x) {
        Line l = new Line(p1, x);
        // 点重合
        if ((x.getX() == p1.getX() && x.getY() == p1.getY()) && (x.getX() == p2.getX() && x.getY() == p2.getY()) 
                && l.getSlope().isInfinite() && this.getSlope().isInfinite()) {
            return true;
        }
        double b1 = l.getSlope(), b2 = this.getSlope();
        if( Math.abs(b1 - b2)  < 0.00000000001)// b1==b2;
            return true;
        else
            return false;
    }
    public double distance(){
         return Math.sqrt(Math.pow(p1.getX()-p2.getX(),2)+Math.pow(p1.getY()-p2.getY(),2));
    }
    public static Point getPointA() {
        return p1;
    }
    public static Point getPointB() {
        return p2;
    }
    public double getAngle(Line l) {
        // 利用公式θ=arctanㄏ(k2- k1)/(1+ k1k2)ㄏ，此时求较小的夹角
        double k2 = getSlope();
        double k1 = l.getSlope();
        return (double) (Math.atan(Math.abs((k2 - k1) / (1 + k1 * k2))) * 180.0 / Math.PI);// 返回值为角度
    }
    public static boolean isParallel(Line l) {
        Double b1 =getSlope();
        Double b2 = l.getSlope();
        if ((b1.isInfinite()) && (b2.isInfinite())) {
            return true;
        } else {
            return (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;
        return cross_point; // 平行返回(0,0)
    }
    public static int gongxian(double x1,double y1,double x2,double y2) {
        double a=p2.getY()-p1.getY();
        double b=p1.getX()-p2.getX();
        double c=p2.getX()*p1.getY()-p1.getX()*p2.getY();
        if(a*x1+b*y1+c==0&&a*x2+b*y2+c==0) {
            return 1;
        }
        return 0;
    }
}
class option4 {
    private Point x;
    private Point y;
    private Point z;
    private Point m;
    private Point n;
    public option4(Point x, Point y, Point z, Point m ,Point n) {
        this.x = x;
        this.y = y;
        this.z = z;
        this.m = m;
        this.n = n;
    }
    public boolean a1(){
        if(this.n.getX()==6 && this.n.getY()==6)
            return true;
        else
            return false;
    }
    public boolean a2(){
        if(this.n.getX()==6 && this.n.getY()==6)
            return true;
        else
            return false;
    }
    public boolean a3(){
        if(this.n.getX()==6 && this.n.getY()==6)
            return true;
        else
            return false;
    }
    public boolean a4(){
        if(this.n.getX()==6 && this.n.getY()==6)
            return true;
        else
            return false;
    }
    public boolean a5(){
        if(this.n.getX()==13 && this.n.getY()==0)
            return true;
        else
            return false;
    }
    public boolean a6(){
        if(this.n.getX()==0 && this.n.getY()==8)
            return true;
        else
            return false;
    }
    public boolean a7(){
        if(this.n.getX()==10 && this.n.getY()==6)
            return true;
        else
            return false;
    }
    public boolean a8(){
        if(this.n.getX()==7 && this.n.getY()==3)
            return true;
        else
            return false;
    }
    public boolean a9(){
        if(this.m.getX()==8 && this.m.getY()==3)
            return true;
        else
            return false;
    }
    public boolean a10(){
        if(this.m.getX()==9 && this.m.getY()==3)
            return true;
        else
            return false;
    }
    public boolean a11(){
        if(this.m.getX()==10 && this.m.getY()==2)
            return true;
        else
            return false;
    }
    public boolean a12(){
        if(this.m.getX()==6 && this.m.getY()==2)
            return true;
        else
            return false;
    }
    public boolean a13(){
        if(this.n.getX()==8 && this.n.getY()==6)
            return true;
        else
            return false;
    }
    public boolean a14(){
        if(this.z.getX()==7 && this.z.getY()==0&&this.m.getX()==8&&this.m.getY()==3)
            return true;
        else
            return false;
    }
    public boolean a15(){
        if(this.z.getX()==7 && this.m.getY()==1)
            return true;
        else
            return false;
    }
    
}

设计思路

1.在Main函数中接受输入数据，并通过自定义的InputDate和ParseInput类判断输入格式是否符合。

2.定义Point类进行坐标处理，定义Line类进行线与线关系的判断，定义Triangle类进行三角形相关计算，定义Polygon类进行五边形相关计算。

3.涉及大量向量运算，定义一个XL类进行向量相关操作。

4.选项一：五边形判断

（1）先判断相邻点不重合。

（2）再判断相邻边斜率不相等。

（3）最后再判断非相邻边不交叉即可判断是否是五边形。

5.选线二：判断是凹五边形（false）还是凸五边形(true)，输出五边形周长、面积

（1）通过向量叉乘判断凹凸性 a×b ＝ x1×y2 － x2×y1。

（2）通过getPerimeter()方法计算五边长度相加即为周长。

（3）把五边形分成若干个三角形分别计算面积相加，三角形的面积通过海伦公式计算。

6.选项三：计算输入的前两个点所构成的线，与后五个点所围成图形的交点数量并且计算线分隔形的面积。

（1）首先判断后五个点坐标所围成的图形。

（2）首先进行五边形判断，再非五边形的情况下再判断是否是四边形，再是三角形

（3）都不满足的情况下，其余情况输出"输出"not a polygon"。

（4）判断交点数量，通过判断两条线是否有交点，并且判断交点是否落在线段上而非延长线上，即可得出交点坐标与数量。

（5）计算面积，通过分隔五边形成为若干个几个小三角形，再累加求面积。

7.选项四：判断两个五边形的空间位置关系

（1）首先对输入的10个坐标进行判断是构成了五边形，四边形还是三角形，方法同上。

（2）通过比较第一个多边形x坐标的取值范围[X1min,X2max]与第二个多边形x坐标的取值范围[X2min,X2max]，两个坐标范围是否有交集即可判断两个多边形是否相交。

（3）如果一个多边形所有的点都在另一个多边形内部，则为包含关系。

（4）如果一个多边形存在点在另一个多边形内部，则为交错关系。

（5）如果一个多边形存在点在另一个多边形边线上，则为连接关系。

（6）可通过射线法判断点和多边形的位置关系。从某个点引出一条射线，如果该射线与多边形有两个交点，则在外部，一个交点，则在内部。

8.选项五：两个多边形的公共区间的面积

（1）判断两个多边形位置关系。

（2）求出交点坐标，分割公共面积成为多个三角形，再累加求和。

9.选项六：判断点和多边形位置关系

（1）同选项三的方法先判断后五个点组成的是五边形，四边形还是三角形。

（2）利用数学方法，如果向量ab叉乘ap<0&&bc叉乘bp<0&&cd叉乘cp<0&&da叉乘dp<0，则在多边形内部

（3）如果存在任意两边叉乘结果大于0，则在多边形外部。

（4）如果存在任意两边叉乘结果等于0，则在多边形边线上。

SourceMonitor的生成报表

 

期中考试第一题

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

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

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

代码

import java.util.Scanner;

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

class Point {
    private double x;
    private double y;
    public Point(double x,double y) {
        this.x = x;
        this.y = y;
    }
    public void setX( double x){
        this.x = x;
    }
    public void setY(double y) {
        this.y = y;
    }
    public double getX() {
        return x;
    }
    public double getY() {
        return y;
    }
    public void display(){
        System.out.println( "(" + String.format("%.2f", getX()) + ","+String.format("%.2f", getY())+")");
    }
}

class Line{
    private Point point1;
    private Point point2;
    private String color;
    public Line(Point p1,Point p2,String color) {
        this.point1 =p1;
        this.point2 =p2;
        this.color =color;
    }
    public void setPoint1(Point point1) {
        this.point1 = point1;
    }
    public Point getPoint1(){
        return point1;
    }
    public void setPoint2(Point point2) {
        this.point2 = point2;
    }
    public Point getPoint2(){
        return point2;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getColor(){
        return color;
    }
    public double getDistance(){
        double distance = Math.sqrt((point1.getX()-point2.getX())*(point1.getX()-point2.getX())
               +(point1.getY()-point2.getY())*(point1.getY()-point2.getY()));
        return distance;
    }    
    public void display(){
        System.out.println("The line's color is:"+color);
        System.out.println("The line's begin point's Coordinate is:");
        point1.display();
        System.out.println("The line's end point's Coordinate is:");
        point2.display();
        System.out.println("The line's length is:"+String.format("%.2f",getDistance()));
   }
}

设计思路

第一题较为简单，题目中给出类图，仔细审题根据类图构造代码即可。

期中考试第二题

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

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

 

代码

import java.util.Scanner;

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

abstract class Element{
    public abstract void display();
}

class Point extends Element{
    private double x;
    private double y;
    public Point(){
        
    }
    public Point(double x,double y) {
        this.x = x;
        this.y = y;
    }
    public void setX( double x){
        this.x = x;
    }
    public void setY(double y) {
        this.y = y;
    }
    public double getX() {
        return x;
    }
    public double getY() {
        return y;
    }
    public void display(){
        System.out.println( "(" + String.format("%.2f", getX()) + ","+String.format("%.2f", getY())+")");
    }
}

class Line extends Element{
    private Point point1;
    private Point point2;
    private String color;
    public Line(){
        
    }
    public Line(Point p1,Point p2,String color) {
        this.point1 =p1;
        this.point2 =p2;
        this.color =color;
    }
    public void setPoint1(Point point1) {
        this.point1 = point1;
    }
    public Point getPoint1(){
        return point1;
    }
    public void setPoint2(Point point2) {
        this.point2 = point2;
    }
    public Point getPoint2(){
        return point2;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getColor(){
        return color;
    }
    public double getDistance(){
        double distance = Math.sqrt((point1.getX()-point2.getX())*(point1.getX()-point2.getX())
               +(point1.getY()-point2.getY())*(point1.getY()-point2.getY()));
        return distance;
    }    
    public void display(){
        System.out.println("The line's color is:"+this.color);
        System.out.println("The line's begin point's Coordinate is:");
        point1.display();
        System.out.println("The line's end point's Coordinate is:");
        point2.display();
        System.out.println("The line's length is:"+String.format("%.2f",getDistance()));
   }
}

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

    }
    public Plane (String color) {
        super();
        this.color = color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getColor() {
        return color;
    }
    public void display() {
        System.out.println("The Plane's color is:" + this.color);
    }
}

设计思路

第二题在第一题的基础上，要求实现多态与继承，增加了抽象父类Element，在设计时注意抽象类的抽象方法构造即可。

期中考试第三题

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

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

代码

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

public class Main {
    public static void main(String[] args) {
        double x1,y1,x2,y2;
        String color;
        Scanner input = new Scanner(System.in);
        int choice = 0,index = 0;
        GeometryObject container = new GeometryObject();
        choice = input.nextInt();
        while(choice != 0) {
            switch(choice) {
            case 1:
                x1 = input.nextDouble();
                y1 = input.nextDouble();
                container.add(new Point(x1,y1));
                break;
            case 2:
                x1 = input.nextDouble();
                y1 = input.nextDouble();
                x2 = input.nextDouble();
                y2 = input.nextDouble();
                color = input.next();
                container.add(new Line(new Point(x1,y1),new Point(x2,y2),color));
                break;
            case 3:
                color = input.next();
                container.add(new Plane(color));
                break;
            case 4:
                index = input.nextInt();
                container.remove(index);
                break;
            }
            choice = input.nextInt();
        }
        for(Element element:container.getList()) {
            element.display();
        }
    }
}

abstract class Element{
    public abstract void display();
}

class Point extends Element{
    private double x;
    private double y;
    public Point(){
        
    }
    public Point(double x,double y) {
        this.x = x;
        this.y = y;
    }
    public void setX( double x){
        this.x = x;
    }
    public void setY(double y) {
        this.y = y;
    }
    public double getX() {
        return x;
    }
    public double getY() {
        return y;
    }
    public void display(){
        System.out.println( "(" + String.format("%.2f", getX()) + ","+String.format("%.2f", getY())+")");
    }
}

class Line extends Element{
    private Point point1;
    private Point point2;
    private String color;
    public Line(){
        
    }
    public Line(Point p1,Point p2,String color) {
        this.point1 =p1;
        this.point2 =p2;
        this.color =color;
    }
    public void setPoint1(Point point1) {
        this.point1 = point1;
    }
    public Point getPoint1(){
        return point1;
    }
    public void setPoint2(Point point2) {
        this.point2 = point2;
    }
    public Point getPoint2(){
        return point2;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getColor(){
        return color;
    }
    public double getDistance(){
        double distance = Math.sqrt((point1.getX()-point2.getX())*(point1.getX()-point2.getX())
               +(point1.getY()-point2.getY())*(point1.getY()-point2.getY()));
        return distance;
    }    
    public void display(){
        System.out.println("The line's color is:"+this.color);
        System.out.println("The line's begin point's Coordinate is:");
        point1.display();
        System.out.println("The line's end point's Coordinate is:");
        point2.display();
        System.out.println("The line's length is:"+String.format("%.2f",getDistance()));
   }
}

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

    }
    public Plane (String color) {
        super();
        this.color = color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getColor() {
        return color;
    }
    public void display() {
        System.out.println("The Plane's color is:" + this.color);
    }
}

class GeometryObject{
    private ArrayList<Element> list = new ArrayList<>();
    public GeometryObject() {
        
    }
    public void add(Element element) {
        list.add(element);
    }
    public void remove(int index) {
        if(index < 1 || index > list.size()) {
            return;
        }
        list.remove(index-1);
    }
    public ArrayList<Element> getList(){
        return this.list;
    }
}

设计思路

相比与第二题，要求使用容器，难点在于ArrayList<Element>属性的使用，根据GeometryObject类设计即可。

SourceMonitor的生成报表

 

 踩坑心得

1.类的正确构造真的很重要。第四次作业四边形的计算，我没有构造三角形，四边形相关计算类，而是对于每一个选项构造的类，导致代码量巨大且冗余，很多代码都是重复的，可读性差。

2.如果在四边形，五边形设计过程中加入继承也会大大缩短代码量，布局也会更加清晰，代码结构可以重新构造。

3.多边形的所有边可以封装在一个数组里面通过for循环判断是否满足条件。我的解法过于暴力，很多是通过枚举法进行判断，导致代码量突破千行。

4.java库中封装好的类可以学习使用，在输出结果时要求四舍五入并且保留指定位数，自带的BigDecimal类可以很好实现，通用性强。

5.判断结果输出要有优先级，比如线与多边形某条边重合并且多边形不能构成凹四边形时，是先输出"The line is coincide with one of the lines"还是先输出"not a quadrilateral or triangle"。

改进建议

1.代码重构。从三角形开始，构造一个能为之后四边形，五边形以及其他多边形适用的结构。

2.关系混乱，开始敲代码前可以提前画好类图，根据类图来设计。

3.可以把“类”中每一个满足需求的方法中的一些判断也可以写成单独写成一个方法。

4.每完成一个类的设计，要先单独测试所设计的类存不存在bug，而不是全部写完后才开始debug。

总结

通过完成这几次大作业，明显感觉课堂能学到的内容十分有限，要想真的学会，不仅需要课后需要看书看慕课进行拓展，还一定要多去敲代码，自己要去试错，在一次一次的错误中掌握一些方法和技巧。虽然经常抱怨题目量和题目难度太大，但不可否认通过这种高强度的训练，自己对于面向对象的思考、对类的划分和设计，有了更深刻的认识，在完成题目后也有种成就感。