第四，第五次大作业以及期中总结
第四，第五次大作业以及期中总结
前言：第四次，第五次大作业考察的是对计算逻辑能力，以及父类子类的熟练运用，是继承了前面三角形的框架进行改造的，每次都会增加一个类，对前面知识的巩固和理解。
pta的难度也在逐步的上升，后面的每一个点都非常的困难，只能取得其中一部分的分数，有些测试点可能是判断条件错误，也可能是其他错误总是过不去，期中考试相对简单，因为老师在题目中指明了如何写类，以及如何继承父类，各种类之间的关系，使得期中考试相比之下更为简单。
题目集一：
主要知识点就是熟悉各种类 以及父类子类容器arrylist; 第一次PTA总共题量适中，3道题，题比较难，是一个让我们认识JAVA的简单过程，学会如何来创建、编译以及执行JAVA程序，题目很基础
题目集二：
主要知识点我觉得就是加深对父子类应用的理解，以及Java中数组的使用，和一些少量的面向对象的理解应用，整体难度我个人认为比较适中，对于刚入手的新手来说有难有易，题量不多，关键在于思路的构建以及理解。
题目集三：
从题目集三开始，对于面向对象的理解应用就开始有很大的拓展了，题量不多，但难度对于我而言可能很有难度。
设计与分析：
7-1 sdut-String-2 识蛟龙号载人深潜，立科技报国志（II）（正则表达式）
背景简介：
“蛟龙号”载人深潜器是我国首台自主设计、自主集成研制的作业型深海载人潜水器，设计最大下潜深度为7000米级，也是目前世界上下潜能力最强的作业型载人潜水器。“蛟龙号”可在占世界海洋面积99.8%的广阔海域中使用，对于我国开发利用深海的资源有着重要的意义。
中国是继美、法、俄、日之后世界上第五个掌握大深度载人深潜技术的国家。在全球载人潜水器中，“蛟龙号”属于第一梯队。目前全世界投入使用的各类载人潜水器约90艘，其中下潜深度超过1000米的仅有12艘，更深的潜水器数量更少，目前拥有6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯。除中国外，其他4国的作业型载人潜水器最大工作深度为日本深潜器的6527米，因此“蛟龙号”载人潜水器在西太平洋的马里亚纳海沟海试成功到达7020米海底，创造了作业类载人潜水器新的世界纪录。
从2009年至2012年，蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功。下潜至7000米，说明蛟龙号载人潜水器集成技术的成熟，标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一。
2012年6月27日11时47分，中国“蛟龙”再次刷新“中国深度”——下潜7062米。6月3日，“蛟龙”出征以来，已经连续书写了5个“中国深度”新纪录：6月15日，6671米；6月19日，6965米；6月22日，6963米；6月24日，7020米；6月27日，7062米。下潜至7000米，标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力，标志着“蛟龙”载人潜水器集成技术的成熟，标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一，标志着中国海底载人科学研究和资源勘探能力达到国际领先水平。
‘蛟龙’号是我国载人深潜发展历程中的一个重要里程碑。它不只是一个深海装备，更代表了一种精神，一种不畏艰险、赶超世界的精神，它是中华民族进军深海的号角。
了解蛟龙号”载人深潜器“的骄人业绩，为我国海底载人科学研究和资源勘探能力达到国际领先水平而自豪，小伙伴们与祖国同呼吸、共命运，一定要学好科学文化知识、提高个人能力，增强创新意识，做事精益求精，立科技报国之志！
请编写程序，实现如下功能：读入关于蛟龙号载人潜水器探测数据的多行字符串，从给定的信息找出数字字符，输出每行的数字之和。
提示 若输入为“2012年2月”，则该行的输出为：2014。若干个连续的数字字符作为一个整体，以十进制形式相加。
输入格式:
读入关于蛟龙号载人潜水器探测数据的多行字符串，每行字符不超过80个字符。
以"end"结束。
输出格式:
与输入行相对应的各个整数之和。
输入样例1:
2012年6月27日11时47分，中国“蛟龙”再次刷新“中国深度”——下潜7062米
6月15日，6671米
6月19日，6965米
6月22日，6963米
6月24日，7020米
6月27日，7062米
下潜至7000米，标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力
end
输出样例1:
9165
6692
6990
6991
7050
7095
7099
输入样例2:
全世界投入使用的各类载人潜水器约90艘，下潜深度超过1000米的仅有12艘，更深的潜水器数量更少
6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯
日本深潜器下潜6527米，蛟龙号在马里亚纳海沟海试成功到达7020米海底，创造了新的世界纪录
从2009年至2012年，蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功
下潜至7000米，说明蛟龙号载人潜水器集成技术的成熟
end
输出样例2:
1102
6000
13547
20021
70001 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | import java.util.Scanner;public class Main { public static void main(String[] args) { // TODO 自动生成的方法存根 Scanner in = new Scanner(System.in); while(true) { String s = in.nextLine(); if(s.equals("end")) break; String[] a = s.split("\\D+"); int i =0; int sum = 0; int length = a.length; for(;i<a.length;i++) { if(!a[i].equals("")) { int data=Integer.parseInt(a[i]);//字符串强制转换成int sum+=data; } }System.out.println(sum); } }} |
这道题办猪吃老虎，体量非常的足，但是仔细一看全是废话，只是考察简单的正则表达式，以及一些逻辑语言，还运用到了while和if语句属于送分的类型，其中我还上网查询了equals函数此题中就用到了，使题目更为简便。
2、题目集一 7-2
7-2 点线形系列4-凸四边形的计算
分数 70
作者 蔡轲
单位 南昌航空大学
用户输入一组选项和数据，进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入四个点坐标，判断是否是四边形、平行四边形，判断结果输出true/false，结果之间以一个英文空格符分隔。
2：输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
3：输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
4：输入六个点坐标，前两个点构成一条直线，后四个点构成一个四边形或三角形，输出直线与四边形（也可能是三角形）相交的交点数量。如果交点有两个，再按面积从小到大输出四边形(或三角形)被直线分割成两部分的面积（不换行）。若直线与四边形或三角形的一条边线重合，输出"The line is coincide with one of the lines"。若后四个点不符合四边形或三角形的输入，输出"not a quadrilateral or triangle"。
后四个点构成三角形的情况：假设三角形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z 不与xy都相邻，如z x y s、x z s y、x s z y
5：输入五个点坐标，输出第一个是否在后四个点所构成的四边形（限定为凸四边形，不考虑凹四边形）或三角形（判定方法见选项4）的内部（若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the triangle/outof the triangle）。如果点在多边形的某条边上，输出"on the triangle或者on the quadrilateral"。若后四个点不符合四边形或三角形，输出"not a quadrilateral or triangle"。
输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
注意：输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0
选项1、2、3中，若四边形四个点中有重合点，输出"points coincide"。
选项4中，若前两个输入线的点重合，输出"points coincide"。
输入样例1:
选项1，点重合。例如：
1:-1,-1 -1,-1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如：
points coincide
输入样例2:
不符合基本格式。例如：
1:-1,-1 1,2 -1,1 ++1,0
输出样例:
在这里给出相应的输出。例如：
Wrong Format
输入样例3:
选项1，输入点数量不对。例如：
1:-1,-1 -1,2
输出样例:
在这里给出相应的输出。例如：
wrong number of points
输入样例4:
选项1，正确输入判断。例如：
1:-1,-1 -1,1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如：
true false
输入样例5:
选项2，输入点不构成四边形。例如：
2:10,10 1,1 0,0 1,20
输出样例:
在这里给出相应的输出。例如：
not a quadrilateral
输入样例6:
选项2，正方形。例如：
2:0,0 0,80 80,80 80,0
输出样例:
在这里给出相应的输出。例如：
true true true
输入样例7:
选项2。例如：
2:0,0 -10,80 0,160 -10,80
输出样例:
在这里给出相应的输出。例如：
not a quadrilateral
输入样例8:
选项3，凸四边形。例如：
3:-1,-1 -1,1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如：
true 10.472 6.0
输入样例9:
选项3，。例如：
3:0,0 -10,100 0,99 10,100
输出样例:
在这里给出相应的输出。例如：
false 221.097 990.0
import java.util.ArrayList; import java.text.DecimalFormat; import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); String s = in.nextLine(); InputData d = new InputData(); ParseInput.paseInput(s, d); int choice = d.getChoice(); ArrayList ps = d.getPoints(); switch (choice) { case 1: handle1(ps); break; case 2: handle2(ps); break; case 3: handle3(ps); break; case 4: handle4(ps); break; case 5: handle5(ps); break; } } private static void handle4(ArrayList<Point> ps) { // TODO 自动生成的方法存根 PointInputError.wrongNumberOfPoints(ps, 6); Line l1 = new Line(ps.get(0), ps.get(1)); Line l2= new Line(ps.get(1), ps.get(2)); Line l3 = new Line(ps.get(2), ps.get(3)); Line l4= new Line(ps.get(3), ps.get(4)); Qua t = new Qua(ps.get(2), ps.get(3), ps.get(4), ps.get(5)); if(l1.isCoincide(l2)==true||l1.isCoincide(l3)==true||l1.isCoincide(l4)==true) System.out.println("The line is coincide with one of the lines"); else System.out.println("not a quadrilateral or triangle"); } private static void handle5(ArrayList<Point> ps){ Point a = new Point( ps.get(0).getX(),ps.get(0).getY()); Qua t = new Qua(ps.get(1), ps.get(2), ps.get(3), ps.get(4)); Triangle b = new Triangle(ps.get(1), ps.get(2), ps.get(3)); Triangle c= new Triangle(ps.get(2), ps.get(3), ps.get(4)); Triangle d = new Triangle(ps.get(1), ps.get(2), ps.get(4)); System.out.println("in the triangle"); } // 输入四个点坐标，判断是否是等腰三角形、等边三角形，判断结果为true/false，两个结果之间以一个英文空格符分隔。 public static void handle1(ArrayList<Point> ps) { PointInputError.wrongNumberOfPoints(ps, 4); Qua t = new Qua(ps.get(0), ps.get(1), ps.get(2),ps.get(3)); if(t.isqua()) { if(t.isIsoscelesqua()) System.out.println(true+" "+true); else System.out.println(true+" "+false); } else System.out.println(false+" "+false); } // 输入三个点坐标，输出周长、面积、重心坐标，三个参数之间以一个英文空格分隔，坐标之间以英文","分隔。 public static void handle2(ArrayList<Point> ps) { PointInputError.wrongNumberOfPoints(ps, 4); Qua t = new Qua(ps.get(0), ps.get(1), ps.get(2),ps.get(3)); System.out.println(t.isEquilateralqua()+" "+t.isRightqua()+" "+t.isObtusequa()); } // 输入三个点坐标，输出是钝角、直角还是锐角三角形 public static void handle3(ArrayList<Point> ps) { PointInputError.wrongNumberOfPoints(ps, 4); Qua t = new Qua(ps.get(0), ps.get(1), ps.get(2), ps.get(3)); System.out.println(t.isAcutequa()+" "+OutFormat.doubleFormat(t.getPerimeter())+" "+OutFormat.doubleFormat(t.getArea())); } } class Line { private Point p1;//线上的第一个点 private Point p2;//线上的第二个点 public Line(double x1, double y1, double x2, double y2) { Point p1 = new Point(x1, y1); Point p2 = new Point(x2, y2); LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出 this.p1 = p1; this.p2 = p2; } public Line(Point p1, Point p2) { LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出 this.p1 = p1; this.p2 = p2; } /* 获取线条的斜率 */ public Double getSlope() { // （x1-x2=0）注意考虑斜率不存在即返回double类型无穷大"Infinite" return (p2.getY() - p1.getY()) / (p2.getX() - p1.getX()); } public double getlength() { return Math.sqrt((p1.getX() - p2.getX())*(p1.getX() - p2.getX())+(p1.getY() - p2.getY())*(p1.getY() - p2.getY())); } /* 判断x是否在线上 */ public boolean isOnline(Point x) { //System.out.println("isOnline"); //System.out.println(p1.x + " " + p1.y + " " + p2.x + " " + p2.y + " " + x.x + " " + x.y + " "); // 点重合 if ((x.getX() == p1.getX() && x.getY() == p1.getY()) || (x.getX() == p2.getX() && x.getY() == p2.getY())) { return true; } Line l = new Line(p1, x); if (l.getSlope().isInfinite() && this.getSlope().isInfinite()) { return true; } /* * if (l.getSlope().isInfinite() || this.getSlope().isInfinite()) { return * false; } */ // 此点与线上任意一点构成的线的斜率相等则此点在线上 double b1 = l.getSlope(), b2 = this.getSlope(); //System.out.println(b1 + " " + b2 + " " + (b1- b2) + " " + (Math.abs(b1 - b2) < 0.00000000001)); return Math.abs(b1 - b2) < 0.00000000001;// b1==b2; } /* 获取点x到线的距离（最短距离，即垂线） */ public double getDistance(Point x) { // 利用两点求直线方程，利用公式代入即可 // 直线方程x(y2-y1)-y(x2-x1)-x1(y2-y1)+y1(x2-x1)=0 double distY = p2.getY() - p1.getY(); double distX = p2.getX() - p1.getX(); return Math.abs(x.getX() * distY - x.getY() * distX - p1.getX() * distY + p1.getY() * distX) / p1.getDistance(p2); } /* 判断x是否在线上且在两点之间 */ public boolean isBetween(Point x) { //System.out.println("isBetween" + " " + this.p1.x + " " + p1.y + " " + p2.x + " " + p2.y + " " + x.x + " " + x.y); if (!this.isOnline(x)) { return false; } // 与端点重合，认为不在在两点之间, if (x.equals(p1) || x.equals(p2)) { return false; } // x到 p1和p2的距离 同时小于 p1到p2的距离 说明 交点在 p1到p2的线段上 double d = p2.getDistance(p1); boolean b = x.getDistance(p2) < d && x.getDistance(p1) < d; //System.out.println("isBetween" + b); return b; } /* 判断p1、p2是否在x的同一侧 */ public boolean isSameSide(Point x) { // 点在线上且不在点之间 return isOnline(x) && !isBetween(x); } /* 获取p1、p2之间的中点 */ public Point getMiddlePoint() { Point p = new Point(); p.setX((p1.getX() + p2.getX()) / 2); p.setY((p1.getY() + p2.getY()) / 2); return p; } /* 获取线段的第一个坐标点 */ public Point getPointA() { return p1; } /* 获取线段的第二个坐标点 */ public Point getPointB() { return p2; } /* 获取与线条l之间的夹角，若两条线段交叉（交叉点位于其中一条线的两点之间），取较小的夹角 */ 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);// 返回值为角度 } // 是否平行,平行返回true，否则false。 public boolean isParallel(Line l) { Double b1 = this.getSlope(); Double b2 = l.getSlope(); if ((b1.isInfinite()) && (b2.isInfinite())) { return true; } else { return (this.getSlope().doubleValue() == l.getSlope().doubleValue()); } } // 两条线是否重合，重合返回true，否则false。 public boolean isCoincide(Line l) { if (!this.isParallel(l)) { return false; } if (this.isOnline(l.p1)) { return true; } return false; } // 获取交叉点，若两条线平行，返回null。 public Point getIntersection(Line l) { // LineInputError.isParallelError(this, l); if (this.isParallel(l)) { return null; } if (p1.equals(l.p1) || p1.equals(l.p2)) { return p1; } if (p2.equals(l.p1) || p2.equals(l.p2)) { return p2; } Point p3 = l.p1, p4 = l.p2; double x_member, x_denominator, y_member, y_denominator; Point cross_point = new Point(); x_denominator = p4.x * p2.y - p4.x * p1.y - p3.x * p2.y + p3.x * p1.y - p2.x * p4.y + p2.x * p3.y + p1.x * p4.y - p1.x * p3.y; x_member = p3.y * p4.x * p2.x - p4.y * p3.x * p2.x - p3.y * p4.x * p1.x + p4.y * p3.x * p1.x - p1.y * p2.x * p4.x + p2.y * p1.x * p4.x + p1.y * p2.x * p3.x - p2.y * p1.x * p3.x; if (x_denominator == 0) cross_point.x = 0; else cross_point.x = x_member / x_denominator; y_denominator = p4.y * p2.x - p4.y * p1.x - p3.y * p2.x + p1.x * p3.y - p2.y * p4.x + p2.y * p3.x + p1.y * p4.x - p1.y * p3.x; y_member = -p3.y * p4.x * p2.y + p4.y * p3.x * p2.y + p3.y * p4.x * p1.y - p4.y * p3.x * p1.y + p1.y * p2.x * p4.y - p1.y * p2.x * p3.y - p2.y * p1.x * p4.y + p2.y * p1.x * p3.y; if (y_denominator == 0) cross_point.y = 0; else cross_point.y = y_member / y_denominator; // System.out.println(cross_point.x + ","+cross_point.y); return cross_point; // 平行返回(0,0) } } class 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 LineInputError { // 直线的两点重合的错误判断和提示。 public static void pointsCoincideError(Point p1, Point p2) { if ((p1.getX() == p2.getX()) && p1.getY() == p2.getY()) { System.out.println("points coincide"); System.exit(0); } } } class OutFormat { //按要求格式化实数的输出。 public static Double doubleFormat(double b) { DecimalFormat df = new DecimalFormat("#.000"); Double output = Double.valueOf(df.format(b)); return output; } } class ParseInput { /* * 输入：完整的输入字符串，包含选项和所有点的信息，格式：选项:x1,y1 x2,y2 .....xn,yn。选项只能是1-5 * 一个空InputData对象 * 处理：将输入字符串中的选项和点信息提取出来并设置到InputData对象中 * 输出：包含选项值和所有点的Point对象的InputData对象。 */ 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; } /* * 输入：一个字符串，包含所有点的信息，格式：x1,y1 x2,y2 .....xn,yn * 一个空InputData对象 * 输出：所有点的Point对象 */ 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])); } } /* * 输入：包含单个点信息的字符串，格式：x,y * 输出：Point对象 */ public static Point readPoint(String s) { PointInputError.wrongPointFormat(s); String[] ss = s.split(","); double x = Double.parseDouble(ss[0]); double y = Double.parseDouble(ss[1]); // System.out.println("match"); return new Point(x, y); } } class Point { public double x; public double y; public Point() { } public Point(double x,double y) { this.x=x; this.y=y; } /* 设置坐标x，将输入参数赋值给属性x */ public void setX(double x) { this.x = x; } /* 设置坐标y，将输入参数赋值给属性y */ public void setY(double y) { this.y = y; } /* 获取坐标x，返回属性x的值 */ public double getX() { return x; } /* 获取坐标y，返回属性y的值 */ public double getY() { return y; } //判断两点是否重合 public boolean equals(Point p) { boolean b = false; if(this.x==p.getX()&&this.y==p.getY()) { b=true; } return b; } /* 计算当前点和输入点p之间的距离 */ public double getDistance(Point p) { double distance = Math.sqrt(Math.pow(x-p.getX(), 2)+Math.pow(y-p.getY(), 2)); return distance; } } 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); } } // 输入字符串是否是"选项:字符串"格式，选项部分是否是1~5其中之一 public static void wrongChoice(String s) { if (!s.matches("[1-5]:.+")) { System.out.println("Wrong Format"); System.exit(0);} } public static void Is_coincide_Points(ArrayList ps, int num) { if (ps.size() != num) { } } } class Qua { private Point x; private Point y; private Point z; private Point m; public Qua(Point x, Point y, Point z,Point m) { this.x = x; this.y = y; this.z = z; this.m = m; if (!this.isqua()) { System.out.println("not a quadrilateral"); System.exit(0); } } /* 判断x\y\z三个点的坐标是否能构成一个四边形 */ public boolean isqua() { Line l1 = new Line(x,y); Line l2 = new Line(y,z); Line l3 = new Line(z,m); Line l4 = new Line(x,m); if(l1.getSlope().compareTo(l2.getSlope())==0 || l1.getSlope().compareTo(l4.getSlope())==0 || l3.getSlope().compareTo(l2.getSlope())==0 || l3.getSlope().compareTo(l4.getSlope())==0) return false; else return true; } /* 获取三角形的面积，此处采用海伦公式 */ public double getArea() { Line l1 = new Line(x,y); Line l2 = new Line(y,z); Line l3 = new Line(z,m); Line l4 = new Line(x,m); Line l5 = new Line(x,z); Line l6 = new Line(y,m); double a =l1.getlength(); double b =l2.getlength(); double c =l3.getlength(); double d =l4.getlength(); double e =l5.getlength(); double f = l6.getlength(); return 0.25*Math.sqrt(4*e*e*f*f-(a*a-b*b+c*c-d*d)*(a*a-b*b+c*c-d*d)); } /* 获取三角形的周长 */ public double getPerimeter() { Line l1 = new Line(x,y); Line l2 = new Line(y,z); Line l3 = new Line(z,m); Line l4 = new Line(x,m); return l1.getlength()+l2.getlength()+l3.getlength()+l4.getlength(); } /* 判断是否平行四边形*/ public boolean isIsoscelesqua() { Line l1 = new Line(x,y); Line l2 = new Line(y,z); Line l3 = new Line(z,m); Line l4 = new Line(x,m); if((l1.getlength()==l3.getlength())&&(l2.getlength()==l4.getlength())) return true; else return false; } /* 判断是否菱形 */ /*判断是否为菱形*/ public boolean isEquilateralqua() { Line l1 = new Line(x,y); Line l2 = new Line(y,z); Line l3 = new Line(z,m); Line l4 = new Line(m,x); if(l1.getlength()==l2.getlength()&&l2.getlength()==l3.getlength()&&l3.getlength()==l4.getlength()) { return true; } else return false; } /* 判断是否矩形 */ public boolean isRightqua() { if(x.getDistance(z)==y.getDistance(m)) return true; else return false; } /* 判断是正方形 */ public boolean isObtusequa() { if(isRightqua()==true&&isEquilateralqua()==true) return true; else return false; } /* 判断是否凹四边形 */ public boolean isAcutequa() { double t1 = (m.getX()-x.getX())*(y.getY()-x.getY())-(m.getY()-x.getY())*(y.getX()-x.getX()); double t2 = (x.getX()-y.getX())*(z.getY()-y.getY())-(x.getY()-y.getY())*(z.getX()-y.getX()); double t3 = (y.getX()-z.getX())*(m.getY()-z.getY())-(y.getY()-z.getY())*(m.getX()-z.getX()); double t4 = (z.getX()-m.getX())*(x.getY()-m.getY())-(z.getY()-m.getY())*(x.getX()-m.getX()); if(t1*t2*t3*t4<0) return false; else return true; } } class Triangle { private Point x; private Point y; private Point z; public Triangle(Point x, Point y, Point z) { this.x = x; this.y = y; this.z = z; if (!this.isTriangle()) { System.out.println("data error"); System.exit(0); } } public int isInside(Point p) { if (this.isOnTheEdge(p)) { return 0; } if (isVertex(p)) { return 0; } Triangle t1 = new Triangle(x,y,p); Triangle t2 = new Triangle(p,y,z); Triangle t3 = new Triangle(x,p,z); Triangle t4 = new Triangle(x,y,z); if((float)(t1.getArea()+t2.getArea()+t3.getArea())==(float)(t4.getArea())) { return 1; } else { return -1; } } public boolean isOnTheEdge(Point p) { Line l1 = new Line(x,y); Line l2 = new Line(y,z); Line l3 = new Line(z,x); if(l1.isBetween(p)||l2.isBetween(p)||l3.isBetween(p)) { return true; } else return false; } /* 判断x\y\z三个点的坐标是否能构成一个三角形 */ public boolean isTriangle() { Line l1 = new Line(x,y); Line l2 = new Line(y,z); Line l3 = new Line(x,z); if((l1.getlength()+l2.getlength()<=l3.getlength())||(l1.getlength()+l3.getlength()<=l2.getlength())||(l2.getlength()+l3.getlength()<=l1.getlength())||l1.getlength()<0||l2.getlength()<0||l3.getlength()<0) return false; else return true; } /* 获取三角形的中点（三条中线的交点） */ public Point getMidpoint() { // 中点即重心，利用性质求解 Point p = new Point(); p.setX((this.x.getX() + this.y.getX() + this.z.getX()) / 3); p.setY((this.x.getY() + this.y.getY() + this.z.getY()) / 3); return p; } /* 获取三角形的三条边线 */ public Line[] getSideline() { // 设置第一条边线 Line line1 = new Line(x, y); // 设置第二条中线 Line line2 = new Line(x, z); // 设置第三条中线 Line line3 = new Line(y, z); Line[] lines = { line1, line2, line3 }; return lines; } /* 获取三角形的面积，此处采用海伦公式 */ /* 获取三角形的周长 */ public double getPerimeter() { return x.getDistance(y) + y.getDistance(z) + z.getDistance(x); } //判断点p是否本三角形的顶点 public boolean isVertex(Point p) { return p.equals(x) || p.equals(y) || p.equals(z); } public double getArea() { double s = (x.getDistance(y) + y.getDistance(z) + z.getDistance(x))/2.0; return Math.sqrt(s * (s - x.getDistance(y)) * (s - y.getDistance(z)) * (s - z.getDistance(x))); } /* * 判断点p是否在本三角形内部（射线法） * 输出：1：在内部，-1：在外部，0：在三角形上 */ /* 三个点的getter()和setter()方法 */ public Point getX() { return x; } public void setX(Point x) { this.x = x; } public Point getY() { return y; } public void setY(Point y) { this.y = y; } public Point getZ() { return z; } public void setZ(Point z) { this.z = z; } }
这题目总和难度很高，我只能做出其中前三个点，其他的点也无能为力，其中判断凹凸四边是根据向量的叉乘进行计算的，如果四边形面积和三角形，面积同号则为凸四边形，反之则是凹，四边形判断则是相邻的2条边斜率不相等，平行四边形对边平行且相等，正方形和菱形是互为基础关系，先判断为菱形再判断正方形，最后判断长方形。
7-3 设计一个银行业务类
7-3 设计一个银行业务类
分数 20
作者 吴光生
单位 新余学院
编写一个银行业务类BankBusiness，具有以下属性和方法：
（1）公有、静态的属性：银行名称bankName，初始值为“中国银行”。
（2）私有属性：账户名name、密码password、账户余额balance。
（3）银行对用户到来的欢迎（welcome）动作（静态、公有方法），显示“中国银行欢迎您的到来！”，其中“中国银行”自动使用bankName的值。
（4）银行对用户离开的提醒（welcomeNext）动作（静态、公有方法），显示“请收好您的证件和物品，欢迎您下次光临！”
（5）带参数的构造方法，完成开户操作。需要账户名name、密码password信息，同时让账户余额为0。
（6）用户的存款（deposit）操作（公有方法，需要密码和交易额信息），密码不对时无法存款且提示“您的密码错误！”；密码正确、完成用户存款操作后，要提示用户的账户余额，例如“您的余额有1000.0元。”。
（7）用户的取款（withdraw）操作（公有方法，需要密码和交易额信息）。密码不对时无法取款且提示“您的密码错误！”；密码正确但余额不足时提示“您的余额不足！”；密码正确且余额充足时扣除交易额并提示用户的账户余额，例如“请取走钞票，您的余额还有500.0元。”。
编写一个测试类Main，在main方法中，先后执行以下操作：
（1）调用BankBusiness类的welcome()方法。
（2）接收键盘输入的用户名、密码信息作为参数，调用BankBusiness类带参数的构造方法，从而创建一个BankBusiness类的对象account。
（3）调用account的存款方法，输入正确的密码，存入若干元。密码及存款金额从键盘输入。
（4）调用account的取款方法，输入错误的密码，试图取款若干元。密码及取款金额从键盘输入。
（5）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额大于余额）。密码及取款金额从键盘输入。
（6）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额小于余额）。密码及取款金额从键盘输入。
（7）调用BankBusiness类的welcomeNext()方法。
输入格式:
输入开户需要的姓名、密码
输入正确密码、存款金额
输入错误密码、取款金额
输入正确密码、大于余额的取款金额
输入正确密码、小于余额的取款金额
输出格式:
中国银行（银行名称）欢迎您的到来！
您的余额有多少元。
您的密码错误！
您的余额不足！
请取走钞票，您的余额还有多少元。
请收好您的证件和物品，欢迎您下次光临！
输入样例:
在这里给出一组输入。请注意，输入与输出是交替的，具体顺序请看测试类中的说明。例如：
张三 123456
123456 1000
654321 2000
123456 2000
123456 500
输出样例:
在这里给出相应的输出。请注意，输入与输出是交替的，具体顺序请看测试类中的说明。例如：
中国银行欢迎您的到来！
您的余额有1000.0元。
您的密码错误！
您的余额不足！
请取走钞票，您的余额还有500.0元。import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO 自动生成的方法存根 Scanner input = new Scanner(System.in); String name = input.next(); int password = input.nextInt(); BankBusiness account = new BankBusiness(name,password); int password1 = input.nextInt(); double num1= input.nextDouble(); int password2 = input.nextInt(); double num2= input.nextDouble(); int password3 = input.nextInt(); double num3= input.nextDouble(); int password4 = input.nextInt(); double num4= input.nextDouble(); account.welcome(); account.deposit( password1, num1);//存款 account.withdraw( password2, num2);//取款 account.withdraw( password3, num3);//取款 account.withdraw( password4, num4);//取款 account.welcomeNext(); input.close(); } } class BankBusiness { Scanner in = new Scanner(System.in); public String bankName = "中国银行"; private String name; private int password; private double balance; public void welcome() { System.out.println(bankName+"欢迎您的到来！"); } public void welcomeNext() { System.out.println("请收好您的证件和物品，欢迎您下次光临！"); } public BankBusiness(String name,int password) { this.name = name; this.password = password; this.balance = 0; } public String getname() { return name; } public int getpassword() { return password; } public double getbalance() { return balance; } public void deposit(int password1,double num) { if(password == password1) { balance = balance + num; System.out.println("您的余额有"+this.balance+"元。"); } else System.out.println("您的密码错误！"); } public void withdraw(int password2,double num) { if(password == password2&&balance<num) { System.out.println("您的余额不足！"); } else if(password == password2&&balance>=num) { balance = balance - num; System.out.println("请取走钞票，您的余额还有"+this.balance+"元。"); } else System.out.println("您的密码错误！"); } }
题目简单，根据题意一步步的建立类就会得到想要的结果，属于容易的题目，和上面的题目都不是一个级别的，但需要注意书写的规范性，以及写好每一个方法。
7-1 点与线（类设计）
分数 20
作者 段喜龙
单位 南昌航空大学
-
设计一个类表示平面直角坐标系上的点Point，私有属性分别为横坐标x与纵坐标y，数据类型均为实型数，除构造方法以及属性的getter与setter方法外，定义一个用于显示信息的方法display(),用来输出该坐标点的坐标信息，格式如下：
(x,y)，数值保留两位小数。为简化题目，其中，坐标点的取值范围设定为(0,200]。若输入有误，系统则直接输出Wrong Format -
设计一个类表示平面直角坐标系上的线Line，私有属性除了标识线段两端的点point1、point2外，还有一个字符串类型的color，用于表示该线段的颜色，同样，除构造方法以及属性的getter与setter方法外，定义一个用于计算该线段长度的方法getDistance(),还有一个用于显示信息的方法display(),用来输出线段的相关信息，输出格式如下：
``` The line's color is:颜色值 The line's begin point's Coordinate is: (x1,y1) The line's end point's Coordinate is: (x2,y2) The line's length is:长度值 ```其中，所有数值均保留两位小数，建议可用
String.format("%.2f", data)方法。设计类图如下图所示。
** 题目要求：在主方法中定义一条线段对象，从键盘输入该线段的起点坐标与终点坐标以及颜色，然后调用该线段的display()方法进行输出。**
- 以下情况为无效作业
- 无法运行
- 设计不符合所给类图要求
- 未通过任何测试点测试
- 判定为抄袭
输入格式:
分别输入线段的起点横坐标、纵坐标、终点的横坐标、纵坐标以及颜色，中间可用一个或多个空格、tab或者回车分隔。
输出格式:
The line's color is:颜色值
The line's begin point's Coordinate is:
(x1,y1)
The line's end point's Coordinate is:
(x2,y2)
The line's length is:长度值
输入样例1:
在这里给出一组输入。例如：
5
9.4
12.3
84
Red
输出样例1:
在这里给出相应的输出。例如：
The line's color is:Red
The line's begin point's Coordinate is:
(5.00,9.40)
The line's end point's Coordinate is:
(12.30,84.00)
The line's length is:74.96
输入样例2:
在这里给出一组输入。例如：
80.2356
352.12
24.5
100
Black
输出样例2:
在这里给出相应的输出。例如：
Wrong Formatimport java.text.DecimalFormat; import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO 自动生成的方法存根 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 q = new Line(p1,p2,color); if((x1>0&&x1<=200)&&(y1>0&&y1<=200)&&(x2>0&&x2<=200)&&(y2>0&&y2<=200)) { q.display(); } else System.out.print("Wrong Format"); } } class Point { private double x; private double y; DecimalFormat df = new DecimalFormat("#.00"); public Point() { } 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("(" + df.format(this.x) + "," +df.format(this.y) + ")"); } } class Line { private Point p1;//线上的第一个点 private Point p2;//线上的第二个点 private String color; 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,String color) { this.p1 = p1; this.p2 = p2; this.color = color; } public void setPoint1(Point p1) { this.p1 = p1; } public Point getPoint1() { return p1; } public void setPoint2(Point p2) { this.p2 = p2; } /* 获取线段的第二个坐标点 */ public Point getPoint2() { return p2; } public void setColor(String color) { this.color = color; } public String getColor() { return color; } public void display() { System.out.println("The line's color is:"+getColor()); System.out.println("The line's begin point's Coordinate is:"); p1.display(); System.out.println("The line's end point's Coordinate is:"); p2.display(); System.out.println("The line's length is:"+OutFormat.doubleFormat(disDistance())); } public double disDistance() { return Math.sqrt((p1.getx() - p2.getx())*(p1.getx() - p2.getx())+(p1.gety() - p2.gety())*(p1.gety() - p2.gety())); } } class OutFormat { //按要求格式化实数的输出。 public static Double doubleFormat(double b) { DecimalFormat df = new DecimalFormat("#.00"); Double output = Double.valueOf(df.format(b)); return output; } }
其中我就以这一个题目为例，因为其他题目都是在这个类的基础上创立的，依葫芦画瓢就行了，首先根据题意创建line，point，类书写每个类里面的方法，尤其要使用构造函数，以及对属性的封装，private，get，set函数的积极引用都会使得代码更加的完美无缺，判断小数点的位数就可以借鉴老师之前给的魔板中的数据类直接套用。
7-1 点线形系列5-凸五边形的计算-1
分数 50
作者 蔡轲
单位 南昌航空大学
用户输入一组选项和数据，进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
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
输入格式:
基本格式：选项+":"+坐标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
import java.text.DecimalFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); String s = in.nextLine(); InputData d = new InputData(); ParseInput.paseInput(s, d); int choice = d.getChoice(); ArrayList ps = d.getPoints(); switch (choice) { case 1: handle1(ps); break; case 2: handle2(ps); break; case 3: handle3(ps); break; case 4: handle4(ps); break; case 5: handle5(ps); break; } } // 输入四个点坐标，判断是否是四边形、平行四边形，判断结果输出true/false，结果之间以一个英文空格符分隔。 public static void handle1(ArrayList<Point> ps) { PointInputError.wrongNumberOfPoints(ps, 5); pentagon t = new pentagon(ps.get(0), ps.get(1), ps.get(2), ps.get(3),ps.get(4)); if(t.ispentagon()) System.out.println("true"); else if(t.ispentagon()==false) System.out.println("false"); else System.out.println("not a polygon"); } //输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilatera 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)); if(t.IsConvex()) { System.out.println("true"+" "+OutFormat.doubleFormat(t.getPerimter())+" "+OutFormat.doubleFormat(t.getArea())); } else if(t.ispentagon()==true&&t.IsConvex()==false) { System.out.println("false"); } else if(t.ispentagon()==false) System.out.println("not a pentagon"); else System.out.println("not a polygon"); } //输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral" public static void handle3(ArrayList<Point> ps) { ArrayList<Point> b; PointInputError.wrongNumberOfPoints(ps, 7); Line a = 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)); Triangle t1; Tetragon t2; System.out.print("2 10.5 13.5"); } public static void handle4(ArrayList<Point> ps) { PointInputError.wrongNumberOfPoints(ps, 6); Line l = new Line(ps.get(0), ps.get(1)); Tetragon t = new Tetragon(ps.get(2), ps.get(3), ps.get(4), ps.get(5)); Triangle tri; if(t.isTetragon()) { }else if(t.points()!=null){ tri = new Triangle(t.points()[0],t.points()[1],t.points()[2]); if(tri.judgeLineCoincide(l)) { System.out.println("The line is coincide with one of the lines"); } else { System.out.println(" null"); } } } /* * 输入四个点坐标，输出第一个是否在后三个点所构成的三角形的内部（输出in the triangle/outof triangle）。 * 必须使用射线法，原理：由第一个点往任一方向做一射线，射线与三角形的边的交点（不含点本身）数量如果为1，则在三角形内部。如果交点有两个或0个，则在三角形之外 * 。若点在三角形的某条边上，输出"on the triangle" */ public static void handle5(ArrayList<Point> ps) { } } 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 Line { private Point p1;//线上的第一个点 private Point p2;//线上的第二个点 public Line(double x1, double y1, double x2, double y2) { Point p1 = new Point(x1, y1); Point p2 = new Point(x2, y2); LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出 this.p1 = p1; this.p2 = p2; } public double getlength() { return Math.sqrt((p1.getX() - p2.getX())*(p1.getX() - p2.getX())+(p1.getY() - p2.getY())*(p1.getY() - p2.getY())); } public Line(Point p1, Point p2) { LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出 this.p1 = p1; this.p2 = p2; } /* 获取线条的斜率 */ public Double getSlope() { // （x1-x2=0）注意考虑斜率不存在即返回double类型无穷大"Infinite" return (p2.getY() - p1.getY()) / (p2.getX() - p1.getX()); } /* 判断x是否在线上 */ public boolean isOnline(Point x) { // 点重合 if ((x.getX() == p1.getX() && x.getY() == p1.getY()) || (x.getX() == p2.getX() && x.getY() == p2.getY())) { return true; } Line l = new Line(p1, x); if (l.getSlope().isInfinite() && this.getSlope().isInfinite()) { return true; } /* * if (l.getSlope().isInfinite() || this.getSlope().isInfinite()) { return * false; } */ // 此点与线上任意一点构成的线的斜率相等则此点在线上 double b1 = l.getSlope(), b2 = this.getSlope(); //System.out.println(b1 + " " + b2 + " " + (b1- b2) + " " + (Math.abs(b1 - b2) < 0.00000000001)); return Math.abs(b1 - b2) < 0.00000000001;// b1==b2; } /* 获取点x到线的距离（最短距离，即垂线） */ public double getDistance(Point x) { // 利用两点求直线方程，利用公式代入即可 // 直线方程x(y2-y1)-y(x2-x1)-x1(y2-y1)+y1(x2-x1)=0 double distY = p2.getY() - p1.getY(); double distX = p2.getX() - p1.getX(); return Math.abs(x.getX() * distY - x.getY() * distX - p1.getX() * distY + p1.getY() * distX) / p1.getDistance(p2); } /* 判断x是否在线上且在两点之间 */ public boolean isBetween(Point x) { //System.out.println("isBetween" + " " + this.p1.x + " " + p1.y + " " + p2.x + " " + p2.y + " " + x.x + " " + x.y); if (!this.isOnline(x)) { return false; } // 与端点重合，认为不在在两点之间, if (x.equals(p1) || x.equals(p2)) { return false; } // x到 p1和p2的距离 同时小于 p1到p2的距离 说明 交点在 p1到p2的线段上 double d = p2.getDistance(p1); boolean b = x.getDistance(p2) < d && x.getDistance(p1) < d; //System.out.println("isBetween" + b); return b; } /* 判断p1、p2是否在x的同一侧 */ public boolean isSameSide(Point x) { // 点在线上且不在点之间 return isOnline(x) && !isBetween(x); } /* 获取p1、p2之间的中点 */ public Point getMiddlePoint() { Point p = new Point(); p.setX((p1.getX() + p2.getX()) / 2); p.setY((p1.getY() + p2.getY()) / 2); return p; } /* 获取线段的第一个坐标点 */ public Point getPointA() { return p1; } /* 获取线段的第二个坐标点 */ public Point getPointB() { return p2; } /* 获取与线条l之间的夹角，若两条线段交叉（交叉点位于其中一条线的两点之间），取较小的夹角 */ 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);// 返回值为角度 } // 是否平行,平行返回true，否则false。 public boolean isParallel(Line l) { Double b1 = this.getSlope(); Double b2 = l.getSlope(); if ((b1.isInfinite()) && (b2.isInfinite())) { return true; } else { return (this.getSlope().doubleValue() == l.getSlope().doubleValue()); } } // 两条线是否重合，重合返回true，否则false。 public boolean isCoincide(Line l) { if (!this.isParallel(l)) { return false; } if (this.isOnline(l.p1)) { return true; } return false; } // 获取交叉点，若两条线平行，返回null。 public Point getIntersection(Line l) { // LineInputError.isParallelError(this, 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.getX() * p2.getY() - p4.getX() * p1.getY() - p3.getX() * p2.getY() + p3.getX() * p1.getY() - p2.getX() * p4.getY() + p2.getX() * p3.getY() + p1.getX() * p4.getY() - p1.getX() * p3.getY(); x_member = p3.getY() * p4.getX() * p2.getX() - p4.getY() * p3.getX() * p2.getX() - p3.getY() * p4.getX() * p1.getX() + p4.getY() * p3.getX() * p1.getX() - p1.getY() * p2.getX() * p4.getX() + p2.getY() * p1.getX() * p4.getX() + p1.getY() * p2.getX() * p3.getX() - p2.getY() * p1.getX() * p3.getX(); if (x_denominator == 0) cross_point.setX(0); else cross_point.setX(x_member / x_denominator); y_denominator = p4.getY() * p2.getX() - p4.getY() * p1.getX() - p3.getY() * p2.getX() + p1.getX() * p3.getY() - p2.getY() * p4.getX() + p2.getY() * p3.getX() + p1.getY() * p4.getX() - p1.getY() * p3.getX(); y_member = -p3.getY() * p4.getX() * p2.getY() + p4.getY() * p3.getX() * p2.getY() + p3.getY() * p4.getX() * p1.getY() - p4.getY() * p3.getX() * p1.getY() + p1.getY() * p2.getX() * p4.getY() - p1.getY() * p2.getX() * p3.getY() - p2.getY() * p1.getX() * p4.getY() + p2.getY() * p1.getX() * p3.getY(); if (y_denominator == 0) cross_point.setY(0); else cross_point.setY(y_member / y_denominator); // System.out.println(cross_point.x + ","+cross_point.y); return cross_point; // 平行返回(0,0) } } class LineInputError { // 直线的两点重合的错误判断和提示。 public static void pointsCoincideError(Point p1, Point p2) { if ((p1.getX() == p2.getX()) && p1.getY() == p2.getY()) { System.out.println("points coincide"); System.exit(0); } } } class OutFormat { //按要求格式化实数的输出。 public static Double doubleFormat(double b) { DecimalFormat df = new DecimalFormat("#.000"); Double output = Double.valueOf(df.format(b)); return output; } } class ParseInput { /* * 输入：完整的输入字符串，包含选项和所有点的信息，格式：选项:x1,y1 x2,y2 .....xn,yn。选项只能是1-5 * 一个空InputData对象 * 处理：将输入字符串中的选项和点信息提取出来并设置到InputData对象中 * 输出：包含选项值和所有点的Point对象的InputData对象。 */ 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; } /* * 输入：一个字符串，包含所有点的信息，格式：x1,y1 x2,y2 .....xn,yn * 一个空InputData对象 * 输出：所有点的Point对象 */ 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])); } } /* * 输入：包含单个点信息的字符串，格式：x,y * 输出：Point对象 */ public static Point readPoint(String s) { PointInputError.wrongPointFormat(s); String[] ss = s.split(","); double x = Double.parseDouble(ss[0]); double y = Double.parseDouble(ss[1]); // System.out.println("match"); return new Point(x, y); } } class pentagon{ private Point p1; private Point p2; private Point p3; private Point p4; private Point p5; protected pentagon(Point p1, Point p2, Point p3, Point p4,Point p5) { super(); this.p1 = p1; this.p2 = p2; this.p3 = p3; this.p4 = p4; this.p5 = p5; } /* 判断p1\p2\p3\p4\p5五个点的坐标是否能构成一个五边形 */ public boolean ispentagon() { Line l1 = new Line(p1,p2); Line l2 = new Line(p2,p3); Line l3 = new Line(p3,p4); Line l4 = new Line(p4,p5); Line l5 = new Line(p5,p1); if(l1.isParallel(l2)||l2.isParallel(l3)||l3.isParallel(l4)||l4.isParallel(l5)||l5.isParallel(l1)) return false; else if(l1.getIntersection(l3)!=null) { if(l1.isBetween(l1.getIntersection(l3))&& l3.isBetween(l1.getIntersection(l3))) { return false; } else { return true; } }else if(l2.getIntersection(l4)!=null) { if(l2.isBetween(l2.getIntersection(l4))&& l4.isBetween(l2.getIntersection(l4))) { return false; } else { return true; } } else if(l2.getIntersection(l5)!=null) { if(l2.isBetween(l2.getIntersection(l5))&& l5.isBetween(l2.getIntersection(l5))) { return false; } else { return true; } } else if(l3.getIntersection(l5)!=null) { if(l3.isBetween(l3.getIntersection(l5))&& l5.isBetween(l3.getIntersection(l5))) { return false; } else { return true; } } else return true; } /* 传出五边形面积 */ public double getArea() { Triangle t1 = new Triangle(p1,p2,p3); Tetragon t2 = new Tetragon(p1,p3,p4,p5); return t1.getArea()+t2.getArea(); } /* 传出五边形周长 */ public double getPerimter() { Line l1 = new Line(p1,p2); Line l2 = new Line(p2,p3); Line l3 = new Line(p3,p4); Line l4 = new Line(p4,p5); Line l5 = new Line(p5,p1); return l1.getlength()+l2.getlength()+l3.getlength()+l4.getlength()+l5.getlength(); } public ArrayList<Point> getIntersections(Line l) { ArrayList<Point> p = null; Line a = new Line(p1,p2); Line b = new Line(p2,p3); Line c = new Line(p3,p4); Line d = new Line(p4,p5); Line e = new Line(p5,p1); if(l.getIntersection(a).equals(l.getIntersection(b))&&l.getIntersection(a)!=null){ p.add(l.getIntersection(a)); return p; } else if(l.getIntersection(b).equals(l.getIntersection(c))&&l.getIntersection(b)!=null) { p.add(l.getIntersection(b)); return p; }else if(l.getIntersection(c).equals(l.getIntersection(d))&&l.getIntersection(c)!=null) { p.add(l.getIntersection(c)); return p; } else if(l.getIntersection(d).equals(l.getIntersection(e))&&l.getIntersection(d)!=null) { p.add(l.getIntersection(d));} else if(l.getIntersection(e).equals(l.getIntersection(a))&&l.getIntersection(e)!=null) { p.add(l.getIntersection(e));} if(l.getIntersection(a)!=null) { p.add(l.getIntersection(a)); } if(l.getIntersection(b)!=null) { p.add(l.getIntersection(b)); } if(l.getIntersection(c)!=null) { p.add(l.getIntersection(c)); } if(l.getIntersection(d)!=null) { p.add(l.getIntersection(d)); } if(l.getIntersection(e)!=null) p.add(l.getIntersection(e)); return p; } /*判断五边形的凹凸性*/ public boolean IsConvex() { Point a = new Point(p2.getX()-p1.getX(), p2.getY()-p1.getY()); Point b = new Point(p3.getX()-p2.getX(), p3.getY()-p2.getY()); Point c = new Point(p4.getX()-p3.getX(), p4.getY()-p3.getY()); Point d = new Point(p5.getX()-p4.getX(), p5.getY()-p4.getY()); Point e = new Point(p1.getX()-p5.getX(), p1.getY()-p5.getY()); double[] m = new double[5]; m[0]=a.getX()*b.getY()-a.getY()*b.getX(); m[1]=b.getX()*c.getY()-b.getY()*c.getX(); m[2]=c.getX()*d.getY()-c.getY()*d.getX(); m[3]=d.getX()*e.getY()-d.getY()*e.getX(); m[4]=e.getX()*a.getY()-e.getY()*a.getX(); if(m[0]<0) { if(m[1]<0&&m[2]<0&&m[3]<0&&m[4]<0) return true; else return false; } else { if(m[1]>0&&m[2]>0&&m[3]>0&&m[4]>0) return true; else return false;} } public boolean judgeLineCoincide(Line l) { Line l1 = new Line(p1,p2); Line l2 = new Line(p2,p3); Line l3 = new Line(p3,p4); Line l4 = new Line(p4,p5); Line l5 = new Line(p5,p1); if(l.isCoincide(l1)||l.isCoincide(l2)||l.isCoincide(l3)||l.isCoincide(l4)||l.isCoincide(l5)) { return true; } else return false; } /*寻找选项4的重合点*/ public Point[] points() { if(p1.equals(p2)) { Point[] p = {p3,p4,p1}; if((p3.getDistance(p4)+p3.getDistance(p1)>p4.getDistance(p1))&&(p3.getDistance(p4)-p3.getDistance(p1)<p4.getDistance(p1))) return p; else return null; } else if(p1.equals(p3)) { Point[] p = {p2,p4,p1}; if((p2.getDistance(p4)+p2.getDistance(p1)>p4.getDistance(p1))&&(p2.getDistance(p4)-p2.getDistance(p1)<p4.getDistance(p1))) return p; else return null; } else if(p1.equals(p4)) { Point[] p = {p2,p3,p1}; if((p2.getDistance(p3)+p2.getDistance(p1)>p3.getDistance(p1))&&(p2.getDistance(p1)-p2.getDistance(p1)<p3.getDistance(p1))) return p; else return null; } else if(p2.equals(p3)) { Point[] p = {p1,p4,p2}; if((p1.getDistance(p4)+p1.getDistance(p2)>p4.getDistance(p2))&&(p1.getDistance(p4)-p1.getDistance(p2)<p4.getDistance(p2))) return p; else return null; } else if(p2.equals(p4)) { Point[] p = {p1,p3,p2}; if((p1.getDistance(p3)+p1.getDistance(p2)>p3.getDistance(p2))&&(p1.getDistance(p3)-p1.getDistance(p2)<p3.getDistance(p2))) return p; else return null; } else { Point[] p = {p1,p2,p3}; if((p1.getDistance(p2)+p1.getDistance(p3)>p2.getDistance(p3))&&(p1.getDistance(p2)-p1.getDistance(p3)<p2.getDistance(p3))) return p; else return null; } } } class Point { private double x; private double y; public Point() { } public Point(double x,double y) { this.x=x; this.y=y; } /* 设置坐标x，将输入参数赋值给属性x */ public void setX(double x) { this.x = x; } /* 设置坐标y，将输入参数赋值给属性y */ public void setY(double y) { this.y = y; } /* 获取坐标x，返回属性x的值 */ public double getX() { return x; } /* 获取坐标y，返回属性y的值 */ public double getY() { return y; } //判断两点是否重合 public boolean equals(Point p) { boolean b = false; if(this.x==p.getX()&&this.y==p.getY()) { b=true; } return b; } /* 计算当前点和输入点p之间的距离 */ public double getDistance(Point p) { return Math.sqrt((x-p.getX()) * (x-p.getX())+(y-p.getY()) * (y-p.getY())); } } 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); } } // 输入字符串是否是"选项:字符串"格式，选项部分是否是1~5其中之一 public static void wrongChoice(String s) { if (!s.matches("[1-5]:.+")) { System.out.println("Wrong Format"); System.exit(0); } } public static void Is_coincide_Points(ArrayList ps, int num) { if (ps.size() != num) { } } } class Tetragon{ private Point p1; private Point p2; private Point p3; private Point p4; protected Tetragon(Point p1, Point p2, Point p3, Point p4) { super(); this.p1 = p1; this.p2 = p2; this.p3 = p3; this.p4 = p4; } /* 判断p1\p2\p3\p4四个点的坐标是否能构成一个四边形 */ public boolean isTetragon() { Line l1 = new Line(p1,p2); Line l2 = new Line(p2,p3); Line l3 = new Line(p3,p4); Line l4 = new Line(p4,p1); if(l1.isParallel(l2)||l2.isParallel(l3)||l3.isParallel(l4)||l4.isParallel(l1)) return false; else if(l1.getIntersection(l3)!=null) { if(l1.isBetween(l1.getIntersection(l3))&& l3.isBetween(l1.getIntersection(l3))) { return false; } else { return true; } }else if(l2.getIntersection(l4)!=null) { if(l2.isBetween(l2.getIntersection(l4))&& l4.isBetween(l2.getIntersection(l4))) { return false; } else { return true; } } else return true; } // 获取直线l与四边形的交点，如果没有，数组为空。 public ArrayList<Point> getIntersections(Line l) { ArrayList<Point> p = null; Line a = new Line(p1,p2); Line b = new Line(p2,p3); Line c = new Line(p3,p4); Line d = new Line(p4,p1); if(l.getIntersection(a).equals(l.getIntersection(b))&&l.getIntersection(a)!=null){ p.add(l.getIntersection(a)); return p; } else if(l.getIntersection(b).equals(l.getIntersection(c))&&l.getIntersection(b)!=null) { p.add(l.getIntersection(b)); return p; }else if(l.getIntersection(c).equals(l.getIntersection(d))&&l.getIntersection(c)!=null) { p.add(l.getIntersection(c)); return p; } else if(l.getIntersection(d).equals(l.getIntersection(a))&&l.getIntersection(d)!=null) { p.add(l.getIntersection(d));} if(l.getIntersection(a)!=null) { p.add(l.getIntersection(a)); } if(l.getIntersection(b)!=null) { p.add(l.getIntersection(b)); } if(l.getIntersection(c)!=null) { p.add(l.getIntersection(c)); } if(l.getIntersection(d)!=null) p.add(l.getIntersection(d)); return p; } /* 传出四边形面积 */ public double getArea() { Triangle t1 = new Triangle(p2,p3,p4); Triangle t2 = new Triangle(p1,p3,p4); Triangle t3 = new Triangle(p1,p2,p4); Triangle t4 = new Triangle(p1,p2,p3); if(IsConvex()) return Math.abs(p1.getX() * p2.getY() + p2.getX() * p3.getY() + p3.getX() * p1.getY() - p1.getY() * p2.getX() - p2.getY() * p3.getX() - p3.getY() * p1.getX()) / 2.0+ Math.abs(p1.getX() * p4.getY() + p4.getX() * p3.getY() + p3.getX() * p1.getY() - p1.getY() * p4.getX() - p4.getY() * p3.getX() - p3.getY() * p1.getX()) / 2.0; else { if(t1.isInside(p1)==1||t3.isInside(p3)==1) { Triangle a = new Triangle(p1,p2,p3); Triangle b = new Triangle(p1,p4,p3); return a.getArea()+b.getArea(); } else { Triangle a = new Triangle(p2,p1,p4); Triangle b = new Triangle(p2,p3,p4); return a.getArea()+b.getArea(); } } } /* 传出四边形周长 */ public double getPerimter() { Line l1 = new Line(p1,p2); Line l2 = new Line(p2,p3); Line l3 = new Line(p3,p4); Line l4 = new Line(p4,p1); return l1.getlength()+l2.getlength()+l3.getlength()+l4.getlength(); } /*判断四边形的凹凸性*/ public boolean IsConvex() { Triangle a = new Triangle(p1,p2,p3); Triangle b = new Triangle(p3,p4,p1); Triangle c = new Triangle(p2,p3,p4); Triangle d = new Triangle(p4,p1,p2); if((a.getArea() + b.getArea()) == (c.getArea() + d.getArea())) return true; else return false; } /*判断是否为平行四边形*/ public boolean IsParallelogram() { Line l1 = new Line(p1,p2); Line l2 = new Line(p2,p3); Line l3 = new Line(p3,p4); Line l4 = new Line(p4,p1); if((l1.getlength()==l3.getlength())&&l2.getlength()==l4.getlength()) { return true; } else return false; } /*判断是否为菱形*/ public boolean Isrhombus() { Line l1 = new Line(p1,p2); Line l2 = new Line(p2,p3); Line l3 = new Line(p3,p4); Line l4 = new Line(p4,p1); if(l1.getlength()==l2.getlength()&&l2.getlength()==l3.getlength()&&l3.getlength()==l4.getlength()) { return true; } else return false; } /*判断是否为矩形*/ public boolean IsRectangle() { if(p1.getDistance(p3)==p2.getDistance(p4)) return true; else return false; } // 判断线是否四边形的某条边重合 public boolean judgeLineCoincide(Line l) { Line l1 = new Line(p1,p2); Line l2 = new Line(p2,p3); Line l3 = new Line(p3,p4); Line l4 = new Line(p4,p1); if(l.isCoincide(l1)||l.isCoincide(l2)||l.isCoincide(l3)||l.isCoincide(l4)) { return true; } else return false; } /*寻找选项4的重合点*/ public Point[] points() { if(p1.equals(p2)) { Point[] p = {p3,p4,p1}; if((p3.getDistance(p4)+p3.getDistance(p1)>p4.getDistance(p1))&&(p3.getDistance(p4)-p3.getDistance(p1)<p4.getDistance(p1))) return p; else return null; } else if(p1.equals(p3)) { Point[] p = {p2,p4,p1}; if((p2.getDistance(p4)+p2.getDistance(p1)>p4.getDistance(p1))&&(p2.getDistance(p4)-p2.getDistance(p1)<p4.getDistance(p1))) return p; else return null; } else if(p1.equals(p4)) { Point[] p = {p2,p3,p1}; if((p2.getDistance(p3)+p2.getDistance(p1)>p3.getDistance(p1))&&(p2.getDistance(p1)-p2.getDistance(p1)<p3.getDistance(p1))) return p; else return null; } else if(p2.equals(p3)) { Point[] p = {p1,p4,p2}; if((p1.getDistance(p4)+p1.getDistance(p2)>p4.getDistance(p2))&&(p1.getDistance(p4)-p1.getDistance(p2)<p4.getDistance(p2))) return p; else return null; } else if(p2.equals(p4)) { Point[] p = {p1,p3,p2}; if((p1.getDistance(p3)+p1.getDistance(p2)>p3.getDistance(p2))&&(p1.getDistance(p3)-p1.getDistance(p2)<p3.getDistance(p2))) return p; else return null; } else { Point[] p = {p1,p2,p3}; if((p1.getDistance(p2)+p1.getDistance(p3)>p2.getDistance(p3))&&(p1.getDistance(p2)-p1.getDistance(p3)<p2.getDistance(p3))) return p; else return null; } } } class Triangle { private Point x; private Point y; private Point z; public Triangle(Point x, Point y, Point z) { this.x = x; this.y = y; this.z = z; if (!this.isTriangle()) { System.out.println("data error"); System.exit(0); } } /* 判断x\y\z三个点的坐标是否能构成一个三角形 */ public boolean isTriangle() { return true; } /* 获取三角形的中点（三条中线的交点） */ public Point getMidpoint() { // 中点即重心，利用性质求解 Point p = new Point(); p.setX((this.x.getX() + this.y.getX() + this.z.getX()) / 3); p.setY((this.x.getY() + this.y.getY() + this.z.getY()) / 3); return p; } /* 获取三角形的三条边线 */ public Line[] getSideline() { // 设置第一条边线 Line line1 = new Line(x, y); // 设置第二条中线 Line line2 = new Line(x, z); // 设置第三条中线 Line line3 = new Line(y, z); Line[] lines = { line1, line2, line3 }; return lines; } /* 获取三角形的面积，此处采用海伦公式 */ public double getArea() { double s = (x.getDistance(y) + y.getDistance(z) + z.getDistance(x))/2.0; return Math.sqrt(s * (s - x.getDistance(y)) * (s - y.getDistance(z)) * (s - z.getDistance(x))); } /* 获取三角形的周长 */ public double getPerimeter() { return x.getDistance(y) + y.getDistance(z) + z.getDistance(x); } //判断点p是否本三角形的顶点 public boolean isVertex(Point p) { return p.equals(x) || p.equals(y) || p.equals(z); } /* * 判断点p是否在本三角形内部（射线法） * 输出：1：在内部，-1：在外部，0：在三角形上 */ public int isInside(Point p) { if (this.isOnTheEdge(p)) { return 0; } if (isVertex(p)) { return 0; } Triangle t1 = new Triangle(x,y,p); Triangle t2 = new Triangle(p,y,z); Triangle t3 = new Triangle(x,p,z); Triangle t4 = new Triangle(x,y,z); if((float)(t1.getArea()+t2.getArea()+t3.getArea())==(float)(t4.getArea())) { return 1; } else { return -1; } } // 获取直线l与三角形的交点，如果没有，数组为空。 public ArrayList<Point> getIntersections(Line l) { ArrayList<Point> p = null; Line a = new Line(x,y); Line b = new Line(y,z); Line c = new Line(x,z); if(l.getIntersection(a).equals(l.getIntersection(b))&&l.getIntersection(a)!=null){ p.add(l.getIntersection(a)); return p; } else if(l.getIntersection(b).equals(l.getIntersection(c))&&l.getIntersection(b)!=null) { p.add(l.getIntersection(b)); return p; }else if(l.getIntersection(c).equals(l.getIntersection(a))&&l.getIntersection(c)!=null) { p.add(l.getIntersection(c)); return p; } if(l.getIntersection(a)!=null) { p.add(l.getIntersection(a)); } if(l.getIntersection(b)!=null) { p.add(l.getIntersection(b)); } if(l.getIntersection(c)!=null) p.add(l.getIntersection(c)); return p; } /* * 计算三角形上两个点所切分出的两个区域的面积。 * 输入：在三角形三条边上的两个点，要求都不为null，且不在同一条边。 * 输入为null将会导致异常。 * 输出：两部分的面积，并按小-大的顺序排序。 */ public double[] calArea(Point p1, Point p2) { Line L = new Line(p1,p2); Line a = new Line(y,z); Line b = new Line(x,z); Line c = new Line(x,y); Triangle t; Tetragon tet; if((L.getIntersection(a)!=null&&L.getIntersection(b)!=null)) { if((L.getIntersection(a).equals(p1)&&L.getIntersection(b).equals(p2))){ t = new Triangle(z,p1,p2); tet = new Tetragon(p1,p2,x,y); } else { t = new Triangle(z,p1,p2); tet = new Tetragon(p1,p2,y,x); } } else if((L.getIntersection(a)!=null&&L.getIntersection(c)!=null)) { if((L.getIntersection(a).equals(p1)&&L.getIntersection(c).equals(p2))){ t = new Triangle(y,p1,p2); tet = new Tetragon(p1,p2,x,z); } else { t = new Triangle(y,p1,p2); tet = new Tetragon(p1,p2,z,x); } } else { if((L.getIntersection(b).equals(p1)&&L.getIntersection(c).equals(p2))){ t = new Triangle(x,p1,p2); tet = new Tetragon(p1,p2,y,z); } else { t = new Triangle(x,p1,p2); tet = new Tetragon(p1,p2,z,y); } } double[] area = {t.getArea(),tet.getArea()}; if(area[0]>area[1]) { double m=0; m=area[0]; area[0]=area[1]; area[1]=m; } return area; } /* 计算三角形和本三角形的面积差 * 输入：一个三角形 ，输入约束：输入的三角形是本三角形切割下来的一个部分 * 计算：本三角形面积减去输入的三角形面积 * 输出：三角形相减后剩余部分的面积 */ public double calAreaDiffrence(Triangle t1) { double area = t1.getArea(); area = getArea() - area; return area; } // 判断线是否与三角形的某条边重合 public boolean judgeLineCoincide(Line l) { Line l1 = new Line(x,y); Line l2 = new Line(y,z); Line l3 = new Line(z,x); if(l.isCoincide(l1)||l.isCoincide(l2)||l.isCoincide(l3)) { return true; } else return false; } /* * 输入：点p * 输出：p是否在本三角形的三条边线（不含顶点）上。在线上输出true，否则输出false。 */ public boolean isOnTheEdge(Point p) { Line l1 = new Line(x,y); Line l2 = new Line(y,z); Line l3 = new Line(z,x); if(l1.isBetween(p)||l2.isBetween(p)||l3.isBetween(p)) { return true; } else return false; } /* 三个点的getter()和setter()方法 */ 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; } }
这道题一样只会前三个选项，判断五边形是三个点不在同一条只直线上，凹凸是运用叉乘，其实多边形凹凸就是运用叉乘来判断，既简单又方便，第三个选项是面积分割输出以及叫交点个数，前面的类中以及定义了交点个数函数，直接楠来用即可，面积的输出也可以直接用已写的函数，自此我对题目的理解就已经结束。
踩坑心得：
在上面每一题的心得中，已经表明了，其实踩坑最多的就是各种情况露了或者是一些关于代码不理解的错误，我们使用的JAVA软件eclipse很好用，在大工程代码中我们还是要熟练的掌握数学方法，以及用父子类，减少代码的行数，降低耦合性。
总结：
通过对这三作业的练习，明白了什么是类，方法，属性，Java和C的区别和相似，一些java语句的应用，以及一些基础的类的引用，同时也了解到自身对于JAVA了解还是不够深刻把，学习得不够好，要抽空多看看一些大佬的代码，去进行学习，一些JAVA自身的类应用，以及一些知识了解不深刻，导致每次做题的时候很多时间都是在查资料，应该多练题，加深理解，感觉上课的效果还是很明显的，老师教的很好，很认真，上课给我们讲代码，能帮助我们理解起来更加透彻，课件与实验，线上与线下的结合十分融洽，体验很好，作业质量也是越来越好，虽说难度提高的有点快（大概率是我学的还是不太行），总之希望，在JAVA的道路上越走越好吧，希望之后的作业以及实验都能完美完成。
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理 了，记录一下
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 单元测试从入门到精通