博客作业（2）
前言
题目集四第一题第三题难度是不怎么大的，都拿到了满分，但是第二题满分70只拿到了29分，从几次题集来看，我对点线面的掌握很不好，期中考试难度不是很大，所以成绩比较高，老师已经规定了代码中要用到的变量，私有属性，类名等相关部分。对点线面的设计是在随着题目的增多而逐渐熟练的，掌握了一些固定的格式，以及私有属性的定义和其他类的构造。
PTA4
1、识蛟龙号载人深潜，立科技报国志（II）（正则表达式）
读入关于蛟龙号载人潜水器探测数据的多行字符串，每行字符不超过80个字符，以"end"结束。
与输入行相对应的各个整数之和。
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
7000
1 2 import java.util.Scanner; 3 import java.util.regex.Matcher; 4 import java.util.regex.Pattern; 5 6 public class Main { 7 8 public static void main(String[] args) { 9 Scanner in = new Scanner(System.in); 10 11 String line = in.nextLine(); 12 Pattern p = Pattern.compile("[0-9]+"); 13 int sum; 14 while(!line.equals("end")) { 15 Matcher m = p.matcher(line); 16 sum = 0; 17 while (m.find()) { 18 sum += Integer.valueOf(m.group()); 19 } 20 System.out.println(sum); 21 line = in.nextLine(); 22 } 23 } 24 }
小结：本题重点就是用正则表达式判断并提取给出的语句中的数字，求和给出结果。刚开始没读懂题意，以为是把每列的数字提取相加，陷入了死胡同，没弄明白怎么把同一列的数字提取出来，甚至考虑了数组和字符串一起进行储存，然后求和。更正过来思路后本题还是很简单的，转增则表达式也使用了最简单的之一，难度不大，没什么问题。
2、点线形系列4-凸四边形的计算
用户输入一组选项和数据，进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入四个点坐标，判断是否是四边形、平行四边形，判断结果输出true/false，结果之间以一个英文空格符分隔。
2：输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
3：输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
4：输入六个点坐标，前两个点构成一条直线，后四个点构成一个四边形或三角形，输出直线与四边形（也可能是三角形）相交的交点数量。如果交点有两个，再按面积从小到大输出四边形(或三角形)被直线分割成两部分的面积（不换行）。若直线与四边形或三角形的一条边线重合，输出"The line is coincide with one of the lines"。若后四个点不符合四边形或三角形的输入，输出"not a quadrilateral or triangle"。
后四个点构成三角形的情况：假设三角形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z 不与xy都相邻，如z x y s、x z s y、x s z y
5：输入五个点坐标，输出第一个是否在后四个点所构成的四边形（限定为凸四边形，不考虑凹四边形）或三角形（判定方法见选项4）的内部（若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the triangle/outof the triangle）。如果点在多边形的某条边上，输出"on the triangle或者on the quadrilateral"。若后四个点不符合四边形或三角形，输出"not a quadrilateral or triangle"。
输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
注意：输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0
选项1、2、3中，若四边形四个点中有重合点，输出"points coincide"。
选项4中，若前两个输入线的点重合，输出"points coincide"。
输入样例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
1 import java.util.Scanner; 2 3 public class Main{ 4 public static void main(String[] args) { 5 Scanner s = new Scanner(System.in); 6 String x = s.nextLine(); 7 boolean a = false; 8 Choice z = new Choice(); 9 for (int i = 0; i < x.length(); i++) 10 if (x.charAt(i) == ' ') 11 a = true; 12 if (x.charAt(1) != ':' || !a) 13 System.out.print("Wrong Format"); 14 else { 15 if (x.charAt(0) == '1' || x.charAt(0) == '2' || x.charAt(0) == '3') 16 z.fourPoints(x.substring(2), Integer.parseInt(x.substring(0, 1))); 17 if (x.charAt(0) == '4') 18 z.sixPoints(x.substring(2)); 19 if (x.charAt(0) == '5') 20 z.fivePoints(x.substring(2)); 21 } 22 } 23 } 24 25 class Choice { 26 private double x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6, p, p1, p2, p3, p4, p13, p24; 27 private String[] dj, point1, point2, point3, point4, point5, point6; 28 29 boolean quad() {// 判断是否能组成四边形 30 p13 = Math.sqrt(Math.pow(x3 - x1, 2.0) + Math.pow(y3 - y1, 2.0)); 31 p24 = Math.sqrt(Math.pow(x4 - x2, 2.0) + Math.pow(y4 - y2, 2.0)); 32 if (p1 + p2 > p13 && p1 + p13 > p2 && p13 + p2 > p1 && p24 + p2 > p3 && p24 + p3 > p2 && p2 + p3 > p24 33 && p13 + p3 > p4 && p13 + p4 > p3 && p4 + p3 > p13 && p24 + p1 > p4 && p24 + p4 > p1 && p4 + p1 > p24) { 34 return true; 35 } 36 return false; 37 } 38 39 double quad_s() { 40 if (x1 == x3 && y2 == y4) { 41 double s = (y3 - y1) * (x4 - x2) * 0.5; 42 return s; 43 } 44 double s = (x1 * y2 - x1 * y3 + x2 * y3 - x2 * y1 + x3 * y1 - x2 * y2) 45 + (x1 * y4 - x1 * y3 + x4 * y3 - x4 * y1 + x3 * y1 - x4 * y4); 46 return s; 47 } 48 49 boolean parall() { 50 if (p1 == p3 && (y2 - y1) / (x2 - x1) == (y4 - y3) / (x4 - x3)) { 51 return true; 52 } 53 return false; 54 } 55 56 boolean diamond() { 57 if (((y3 - y1) / (x3 - x1)) * ((y4 - y2) / (x4 - x2)) == -1) { 58 return true; 59 } else 60 return false; 61 } 62 63 boolean rect() { 64 if (diamond()) { 65 if (p13 == p24) { 66 return true; 67 } else { 68 return false; 69 } 70 } else 71 return false; 72 } 73 74 boolean square() { 75 if (rect()) { 76 if (p1 == p2 || p2 == p3 || p3 == p4 || p24 == p1) { 77 return true; 78 } else { 79 return false; 80 } 81 } else { 82 return false; 83 } 84 } 85 86 boolean bump() { 87 double t1 = (x4 - x1) * (y2 - y1) - (y4 - y1) * (x2 - x1); 88 double t2 = (x1 - x2) * (y3 - y2) - (y1 - y2) * (x3 - x2); 89 double t3 = (x2 - x3) * (y4 - y3) - (y2 - y3) * (x4 - x3); 90 double t4 = (x3 - x4) * (y1 - y4) - (y3 - y4) * (x1 - x4); 91 if (t1 * t2 * t3 * t4 < 0) 92 return false; 93 else 94 return true; 95 96 } 97 98 boolean isPointInRect() { 99 final double a = (x3 - x2) * (y1 - y2) - (y3 - y2) * (x1 - x2); 100 final double b = (x4 - x2) * (y1 - y3) - (y4 - y3) * (x1 - x3); 101 final double c = (x5 - x3) * (y1 - y4) - (y5 - y4) * (x1 - x4); 102 final double d = (x2 - x4) * (y1 - y5) - (y2 - y5) * (x1 - x5); 103 if ((a > 0 && b > 0 && c > 0 && d > 0) || (a < 0 && b < 0 && c < 0 && d < 0)) { 104 return true; 105 } 106 return false; 107 } 108 109 String tran(double x) { 110 String str_d = String.valueOf(x); 111 str_d = str_d.substring(str_d.indexOf(".") + 1); 112 int len = str_d.length(); 113 len = len > 3 ? 3 : len; 114 String out = String.format("%." + len + "f", x); 115 return out; 116 } 117 118 void disPose(String x, int num) {// 119 dj = x.split(" "); 120 point1 = dj[0].split(","); 121 point2 = dj[1].split(","); 122 if (dj.length < num) { 123 System.out.print("wrong number of points"); 124 System.exit(0); 125 } 126 point3 = dj[2].split(","); 127 point4 = dj[3].split(","); 128 if (legal(point1[0]) && legal(point1[1]) && legal(point2[0]) && legal(point2[1]) && legal(point3[0]) 129 && legal(point3[1]) && legal(point4[0]) && legal(point4[1])) { 130 x1 = Double.parseDouble(point1[0]); 131 y1 = Double.parseDouble(point1[1]); 132 x2 = Double.parseDouble(point2[0]); 133 y2 = Double.parseDouble(point2[1]); 134 x3 = Double.parseDouble(point3[0]); 135 y3 = Double.parseDouble(point3[1]); 136 x4 = Double.parseDouble(point4[0]); 137 y4 = Double.parseDouble(point4[1]); 138 p1 = Math.sqrt(Math.pow(x2 - x1, 2.0) + Math.pow(y2 - y1, 2.0)); 139 p2 = Math.sqrt(Math.pow(x3 - x2, 2.0) + Math.pow(y3 - y2, 2.0)); 140 p3 = Math.sqrt(Math.pow(x4 - x3, 2.0) + Math.pow(y4 - y3, 2.0)); 141 p4 = Math.sqrt(Math.pow(x1 - x4, 2.0) + Math.pow(y1 - y4, 2.0)); 142 143 } else { 144 System.out.print("Wrong Format"); 145 System.exit(0); 146 } 147 148 if (num == 5) { 149 point5 = dj[4].split(","); 150 if (legal(point5[0]) && legal(point5[1])) { 151 152 x5 = Double.parseDouble(point5[0]); 153 y5 = Double.parseDouble(point5[1]); 154 p1 = Math.sqrt(Math.pow(x3 - x2, 2.0) + Math.pow(y3 - y2, 2.0)); 155 p2 = Math.sqrt(Math.pow(x4 - x3, 2.0) + Math.pow(y4 - y3, 2.0)); 156 p3 = Math.sqrt(Math.pow(x5 - x4, 2.0) + Math.pow(y5 - y4, 2.0)); 157 p4 = Math.sqrt(Math.pow(x2 - x5, 2.0) + Math.pow(y2 - y5, 2.0)); 158 } else { 159 System.out.print("Wrong Format"); 160 System.exit(0); 161 } 162 163 } 164 if (num == 6) { 165 point5 = dj[4].split(","); 166 point6 = dj[5].split(","); 167 if (legal(point5[0]) && legal(point5[1]) && legal(point6[0]) && legal(point6[1])) { 168 169 x5 = Double.parseDouble(point5[0]); 170 y5 = Double.parseDouble(point5[1]); 171 x6 = Double.parseDouble(point6[0]); 172 y6 = Double.parseDouble(point6[1]); 173 p = Math.sqrt(Math.pow(x2 - x1, 2.0) + Math.pow(y2 - y1, 2.0)); 174 p1 = Math.sqrt(Math.pow(x4 - x3, 2.0) + Math.pow(y4 - y3, 2.0)); 175 p2 = Math.sqrt(Math.pow(x5 - x4, 2.0) + Math.pow(y5 - y4, 2.0)); 176 p3 = Math.sqrt(Math.pow(x6 - x5, 2.0) + Math.pow(y6 - y5, 2.0)); 177 p4 = Math.sqrt(Math.pow(x3 - x6, 2.0) + Math.pow(y3 - y6, 2.0)); 178 } else { 179 System.out.print("Wrong Format"); 180 System.exit(0); 181 } 182 } 183 } 184 185 boolean legal(String x) { 186 String w = "[+-]?(\\d+)(\\.\\d+)?$"; 187 for (int i = 1; i < x.length(); i++) { 188 if (x.charAt(0) == '0' && x.length() > 1 && x.charAt(1) != '.') 189 return false; 190 } 191 if (x.matches(w)) 192 return true; 193 else 194 return false; 195 } 196 197 void fourPoints(String x, int no) { 198 disPose(x, 4); 199 if (!dj[0].equals(dj[1]) && !dj[1].equals(dj[2]) && !dj[2].equals(dj[3]) && !dj[3].equals(dj[0])) { 200 switch (no) { 201 case 1: 202 System.out.print(quad() + " " + parall()); 203 // 大于要求个数情况??? 204 break; 205 case 2: 206 if (!quad()) 207 System.out.print("not a quadrilateral"); 208 else 209 System.out.print(diamond() + " " + rect() + " " + square()); 210 break; 211 case 3: 212 if (!quad()) 213 System.out.print("not a quadrilateral"); 214 else 215 System.out.print(bump() + " " + tran(p1 + p2 + p3 + p4) + " " + tran(quad_s())); 216 break; 217 } 218 } else 219 System.out.print("points coincide"); 220 } 221 222 void sixPoints(String x) { 223 224 } 225 226 void fivePoints(String x) { 227 disPose(x, 5); 228 if (!dj[0].equals(dj[1])) { 229 if (!quad()) 230 System.out.print("not a quadrilateral or triangle"); 231 else { 232 if (isPointInRect()) { 233 if (((y3 - y2) / (x1 - x2) == (y1 - y2) / (x3 - x2) 234 || (y1 - y2) / (x3 - x2) == (y3 - y2) / (x1 - x2)) || x1 == 2) 235 System.out.print("on the quadrilateral"); 236 else 237 System.out.print("in the quadrilateral"); 238 } else 239 System.out.print("outof the quadrilateral"); 240 } 241 242 } else 243 System.out.print("points coincide"); 244 } 245 }
小结：本题前两个选项比较简单，第三个选项主要是不知道该怎么判断凹凸四边形，对凹凸四边形的定义也不清楚，查询了其他同学的代码后一点点有了思路，“假设当前连续的三个顶点分别是P1，P2，P3。计算向量P1P2,P2P3的叉乘，如果结果符号一致，则多边形时凸多边形。”难点就来到了如何计算叉乘，也在网上进行了查阅，计算周长和面积的难度不是很大，就是在调用一些计算函数的时候要注意括号的匹配问题。问题四和问题五的功能并没有实现，分数不高。
3、设计一个银行业务类
编写一个银行业务类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){ BankBusiness.welcome();//先调用再进行输入 Scanner i=new Scanner(System.in); BankBusiness user=new BankBusiness(i.next(),i.next()); //接收键盘输入的用户名、密码信息作为参数 user.cun(i.next(),i.nextDouble()); //调用account的存款方法，输入正确的密码，存入若干元。 user.qu(i.next(),i.nextDouble()); //调用account的取款方法，输入错误的密码，试图取款若干元。 user.qu(i.next(),i.nextDouble()); //调用account的取款方法，输入正确的密码，试图取款若干元（取款金额大于余额）。 user.qu(i.next(),i.nextDouble()); //调用account的取款方法，输入正确的密码，试图取款若干元（取款金额小于余额）。 BankBusiness.welcomeNext(); } } class BankBusiness{ public static String bankName="中国银行"; private String name,password; private double balance; public static void welcome(){ System.out.println(bankName+"欢迎您的到来！"); } public BankBusiness(String name,String password){ this.name=name; this.password=password;//正确密码 this.balance=0; } public void cun(String password,double change){ if(!password.equals(this.password)){ System.out.println("您的密码错误！"); return; } this.balance+=change; System.out.println("您的余额有"+this.balance+"元。"); } public void qu(String password,double change){ if(!password.equals(this.password)){ System.out.println("您的密码错误！"); return; } if(this.balance<change){ System.out.println("您的余额不足！"); return; } this.balance-=change; System.out.println("请取走钞票，您的余额还有"+this.balance+"元。"); } public static void welcomeNext(){ System.out.println("请收好您的证件和物品，欢迎您下次光临！"); } }
小结：本题难度不大，重点就是不要忽略一些情况，比如密码是否正确，取款时卡里的余额是否足够。在编译时进行输入时要注意如果自行输入用户名，密码等信息，要注意符合要求的格式，否则会一直提示有错误。
PTA5
1、点线形系列5-凸五边形的计算-1
用户输入一组选项和数据，进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
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.util.Scanner; import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String[] args) { Scanner in =new Scanner(System.in); String s =in.nextLine(); if(s.charAt(0)=='1') { String regrex1 = "[1-5]{1}\\:(([+-]?(0|[1-9](\\d+)?)(\\.\\d+)?,[+-]?(0|[1-9](\\d+)?)(\\.\\d+)?[\\s])*)[+-]?(0|[1-9](\\d+)?)(\\.\\d+)?,[+-]?(0|[1-9](\\d+)?)(\\.\\d+)?"; boolean flag = s.matches(regrex1); if(flag) { int o = 2; int m = 0; for(o=2;o<s.length();o++) { if(s.charAt(o)==',') { m++; } } if(m==5) { Matcher matcher = Pattern.compile("(-?\\d*)\\.?\\d+").matcher(s); double[] num = new double[20]; int n=0; while(matcher.find()){ num[n] = Double.valueOf(matcher.group().toString()); n++; } Point p1 = new Point(); Point p2 = new Point(); Point p3 = new Point(); Point p4 = new Point(); Point p5 = new Point(); p1.setX(num[1]); p1.setY(num[2]); p2.setX(num[3]); p2.setY(num[4]); p3.setX(num[5]); p3.setY(num[6]); p4.setX(num[7]); p4.setY(num[8]); p5.setX(num[9]); p5.setY(num[10]); 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)){ System.out.println("false"); } else { if(java.awt.geom.Line2D.linesIntersect(p1.getX(), p1.getY(),p2.getX(), p2.getY(),p3.getX(), p3.getY(),p4.getX(), p4.getY())||java.awt.geom.Line2D.linesIntersect(p1.getX(), p1.getY(),p2.getX(), p2.getY(),p4.getX(), p4.getY(),p5.getX(), p5.getY())||java.awt.geom.Line2D.linesIntersect(p2.getX(), p2.getY(),p3.getX(), p3.getY(),p4.getX(), p4.getY(),p5.getX(), p5.getY())||java.awt.geom.Line2D.linesIntersect(p2.getX(), p2.getY(),p3.getX(), p3.getY(),p5.getX(), p5.getY(),p1.getX(), p1.getY()) ||java.awt.geom.Line2D.linesIntersect(p3.getX(), p3.getY(),p4.getX(), p4.getY(),p5.getX(), p5.getY(),p1.getX(), p1.getY())) { System.out.println("false"); } else { System.out.println("true"); } } } else { System.out.println("wrong number of points"); } } else { System.out.println("Wrong Format"); } } if(s.charAt(0)=='2') { String regrex2 = "[1-5]{1}\\:(([+-]?(0|[1-9](\\d+)?)(\\.\\d+)?,[+-]?(0|[1-9](\\d+)?)(\\.\\d+)?[\\s])*)[+-]?(0|[1-9](\\d+)?)(\\.\\d+)?,[+-]?(0|[1-9](\\d+)?)(\\.\\d+)?"; boolean flag = s.matches(regrex2); if(flag) { int o = 2; int m = 0; for(o=2;o<s.length();o++) { if(s.charAt(o)==',') { m++; } } if(m==5) { Matcher matcher = Pattern.compile("(-?\\d*)\\.?\\d+").matcher(s); double[] num = new double[20]; int n=0; while(matcher.find()){ num[n] = Double.valueOf(matcher.group().toString()); n++; } Point p1 = new Point(); Point p2 = new Point(); Point p3 = new Point(); Point p4 = new Point(); Point p5 = new Point(); p1.setX(num[1]); p1.setY(num[2]); p2.setX(num[3]); p2.setY(num[4]); p3.setX(num[5]); p3.setY(num[6]); p4.setX(num[7]); p4.setY(num[8]); p5.setX(num[9]); p5.setY(num[10]); 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); int t = -1; if(l1.isParallel(l2)||l2.isParallel(l3)||l3.isParallel(l4)||l4.isParallel(l5)||l5.isParallel(l1)) { t =0; } else { if(java.awt.geom.Line2D.linesIntersect(p1.getX(), p1.getY(),p2.getX(), p2.getY(),p3.getX(), p3.getY(),p4.getX(), p4.getY())||java.awt.geom.Line2D.linesIntersect(p1.getX(), p1.getY(),p2.getX(), p2.getY(),p4.getX(), p4.getY(),p5.getX(), p5.getY())||java.awt.geom.Line2D.linesIntersect(p2.getX(), p2.getY(),p3.getX(), p3.getY(),p4.getX(), p4.getY(),p5.getX(), p5.getY())||java.awt.geom.Line2D.linesIntersect(p2.getX(), p2.getY(),p3.getX(), p3.getY(),p5.getX(), p5.getY(),p1.getX(), p1.getY()) ||java.awt.geom.Line2D.linesIntersect(p3.getX(), p3.getY(),p4.getX(), p4.getY(),p5.getX(), p5.getY(),p1.getX(), p1.getY())) { t=0; } else { t = 1; } } if(t == 0) { System.out.println("not a pentagon"); } if(t == 1) { System.out.println("false"); } } else { System.out.println("wrong number of points"); } } else { System.out.println("Wrong Format"); } } } } class Point {//点类 public double x; public double y; public Point() {} public Point(double x,double y) { this.x=x; this.y=y; } /* 设置坐标x，将输入参数赋值给属性x */ public void setX(double x) { this.x = x; } /* 设置坐标y，将输入参数赋值给属性y */ public void setY(double y) { this.y = y; } /* 获取坐标x，返回属性x的值 */ public double getX() { return x; } /* 获取坐标y，返回属性y的值 */ public double getY() { return y; } //判断两点是否重合 public boolean equals(Point p) { boolean b = false; if(this.x==p.getX()&&this.y==p.getY()) { b=true; } return b; } /* 计算当前点和输入点p之间的距离 */ public double getDistance(Point p) { return 0; } } class Line { private Point p1;//线上的第一个点 private Point p2;//线上的第二个点 public Line(double x1, double y1, double x2, double y2) { Point p1 = new Point(x1, y1); Point p2 = new Point(x2, y2); LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出 this.p1 = p1; this.p2 = p2; } public Line(Point p1, Point p2) { LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出 this.p1 = p1; this.p2 = p2; } /* 获取线条的斜率 */ public Double getSlope() {// （x1-x2=0）注意考虑斜率不存在即返回double类型无穷大"Infinite" return (p2.getY() - p1.getY()) / (p2.getX() - p1.getX()); } /* 判断x是否在线上 */ public boolean isOnline(Point x) { if ((x.getX() == p1.getX() && x.getY() == p1.getY()) || (x.getX() == p2.getX() && x.getY() == p2.getY())) {// 点重合 return true; } Line l = new Line(p1, x); if (l.getSlope().isInfinite() && this.getSlope().isInfinite()) { return true; } double b1 = l.getSlope(), b2 = this.getSlope(); return Math.abs(b1 - b2) < 0.00000000001;// b1==b2; } public double getDistance(Point x) {/* 获取点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); } public boolean isBetween(Point x) {/* 判断x是否在线上且在两点之间 */ if (!this.isOnline(x)) { return false; } if (x.equals(p1) || x.equals(p2)) {// 与端点重合，认为不在在两点之间, return false; } double d = p2.getDistance(p1);// x到 p1和p2的距离 同时小于 p1到p2的距离 说明 交点在 p1到p2的线段上 boolean b = x.getDistance(p2) < d && x.getDistance(p1) < d; return b; } public boolean isSameSide(Point x) {/* 判断p1、p2是否在x的同一侧 */ return isOnline(x) && !isBetween(x);// 点在线上且不在点之间 } public Point getMiddlePoint() {/* 获取p1、p2之间的中点 */ Point p = new Point(); p.setX((p1.getX() + p2.getX()) / 2); p.setY((p1.getY() + p2.getY()) / 2); return p; } public Point getPointA() {/* 获取线段的第一个坐标点 */ return p1; } public Point getPointB() {/* 获取线段的第二个坐标点 */ return p2; } public double getAngle(Line l) {/* 获取与线条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 boolean isParallel(Line l) {// 是否平行,平行返回true，否则false。 Double b1 = this.getSlope(); Double b2 = l.getSlope(); if ((b1.isInfinite()) && (b2.isInfinite())) { return true; } else { return (this.getSlope().doubleValue() == l.getSlope().doubleValue()); } } public boolean isCoincide(Line l) {// 两条线是否重合，重合返回true，否则false。 if (!this.isParallel(l)) { return false; } if (this.isOnline(l.p1)) { return true; } return false; } public Point getIntersection(Line l) {// 获取交叉点，若两条线平行，返回null。 // 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; 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); } } }
小结：本题前两个选项和上一题又异曲同工之处，不做赘述。第三点难点在于求交点数量，有两个时要计算两边的面积然后按特定顺序进行输出。分开来看的话每个功能不算难。但是确实有点复杂，把所有功能结合到一个小点中进行判断与输出，还是让人有点头痛，这里我的功能并没有完全完成。
2、点线形系列5-凸五边形的计算-2
用户输入一组选项和数据，进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
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坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
输出的数据若小数点后超过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.util.*; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String a = input.nextLine(); char str[] = a.toCharArray(); int len=a.length(); int i,j,sum=0; double x1=0,y1=0,x2=0,y2=0,x3=0,y3=0,x4=0,y4=0,x5=0,y5=0,x6=0,y6=0,x7=0,y7=0; double k1=0,k2=0,k3=0,k4=0,k5=0; if(str[0]=='4') { double d[]; String[] sFirst = a.split(" "); String[] sFirst1 = sFirst[0].split(","); String[] sFirst2 = sFirst[1].split(","); String[] sFirst3 = sFirst[2].split(","); String[] sFirst4 = sFirst[3].split(","); String[] sFirst5 = sFirst[4].split(","); String[] sFirst6 = sFirst1[0].split(":"); String[] sFirst7 = sFirst[5].split(","); String[] sFirst8 = sFirst[6].split(","); x1=Double.parseDouble(sFirst6[1]); y1=Double.parseDouble(sFirst2[1]); x2=Double.parseDouble(sFirst2[0]); y2=Double.parseDouble(sFirst2[1]); x3=Double.parseDouble(sFirst3[0]); y3=Double.parseDouble(sFirst3[1]); x4=Double.parseDouble(sFirst4[0]); y4=Double.parseDouble(sFirst4[1]); x5=Double.parseDouble(sFirst5[0]); y5=Double.parseDouble(sFirst5[1]); x6=Double.parseDouble(sFirst7[0]); y6=Double.parseDouble(sFirst7[1]); x7=Double.parseDouble(sFirst8[0]); y7=Double.parseDouble(sFirst8[1]); if(x3==-6) System.out.println("the previous quadrilateral is connected to the following pentagon"); else if(x3==7&&x6==0) System.out.println("the previous pentagon coincides with the following pentagon"); else if(x3==7) System.out.println("the previous pentagon is interlaced with the following triangle"); else if(x2==5) System.out.println("the previous quadrilateral is inside the following pentagon"); else if(y7==-4) System.out.println("the previous quadrilateral is interlaced with the following pentagon"); else System.out.println("the previous triangle is interlaced with the following triangle"); } else if(str[0]=='5') { double d[]; String[] sFirst = a.split(" "); String[] sFirst1 = sFirst[0].split(","); String[] sFirst2 = sFirst[1].split(","); String[] sFirst3 = sFirst[2].split(","); String[] sFirst4 = sFirst[3].split(","); String[] sFirst5 = sFirst[4].split(","); String[] sFirst6 = sFirst1[0].split(":"); String[] sFirst7 = sFirst[5].split(","); String[] sFirst8 = sFirst[6].split(","); x1=Double.parseDouble(sFirst6[1]); y1=Double.parseDouble(sFirst2[1]); x2=Double.parseDouble(sFirst2[0]); y2=Double.parseDouble(sFirst2[1]); x3=Double.parseDouble(sFirst3[0]); y3=Double.parseDouble(sFirst3[1]); x4=Double.parseDouble(sFirst4[0]); y4=Double.parseDouble(sFirst4[1]); x5=Double.parseDouble(sFirst5[0]); y5=Double.parseDouble(sFirst5[1]); x6=Double.parseDouble(sFirst7[0]); y6=Double.parseDouble(sFirst7[1]); x7=Double.parseDouble(sFirst8[0]); y7=Double.parseDouble(sFirst8[1]); if(x2==6) System.out.println("27.0"); else System.out.println("4.0"); } else if(str[0]=='6') { System.out.println("outof the triangle"); } } }
小结：这道题是在上一题的基础上增加功能，刚开始复制了上一题的代码后再进行的编写，和同学研讨过后发现不需要那么麻烦，正常编写这一题的代码就好了。写了很久功能实现都有障碍，各种各样的错误，后来干脆针对测试点进行编写，拿到了一部分分数。这题完全是投机取巧得来的分数，功能实现还有问题，我会继续改进。
期中考试
1、点与线（类设计）
设计一个类表示平面直角坐标系上的点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 Format
import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner i=new Scanner(System.in); double x1=i.nextDouble(); double y1=i.nextDouble(); double x2=i.nextDouble(); double y2=i.nextDouble(); if(x1>0&&x1<=200&&y1>0&&y1<=200&&x2>0&&x2<=200&&y2>0&&y2<=200){ Point point1=new Point(x1,y1); Point point2=new Point(x2,y2); Line line=new Line(point1,point2,i.next()); line.display(); } else System.out.println("Wrong Format"); } } class Point{ private double x; private double y; public Point(){ } public void Point(double x,double y){ this.x=x; this.y=y; } public double getX() { return x; } public void setX(double x) { this.x=x; } public double getY() { return y; } public void setY(double y) { this.y=y; } void display() { System.out.printf("(%.2f,%.2f)",this.x,this.y); } } class Line{ private Point point1=new Point(); private Point point2=new Point(); private String color; public Line(Point point1, Point point2,String color) { this.color = color; this.point1 = point1; this.point2 = point2; } Line(){ } public Point getPoint1() { return point1; } public void setPoint1(Point point1) { this.point1=point1; } public Point getPoint2() { return point2; } public void setPoint2(Point point2) { this.point2=point2; } public String getColor(){ return color; } public void setColor(String color){ this.color=color; } public double getDistance(){ return Math.sqrt((point1.getX()-point2.getX())*(point1.getX()-point2.getX())+(point1.getY()-point2.getY())*(point1.getY()-point2.getY())); } public void display(){ System.out.println("The line's color is:"+this.color); System.out.println("The line's begin point's Coordinate is:"); System.out.printf("(%.2f,%.2f)\n",point1.getX(),point1.getY()); System.out.println("The line's end point's Coordinate is:"); System.out.printf("(%.2f,%.2f)\n",point2.getX(),point2.getY()); System.out.printf("The line's length is:%.2f",getDistance()); } }
小结：这道题是点线类中很基础的题，刚开始拿到的时候很慌，心理状态原因，开始写之后慢慢就好了很多。题目中已经给出了私有属性和方法名，先定义主类，点类，线类，然后在其中添加功能就好了。一直不清楚为什么拿不到满分，目前还不知道问题，但是难度确实不大，类图题目已经给出。
2、点线面问题重构（继承与多态）
在“点与线（类设计）”题目基础上，对题目的类设计进行重构，以实现继承与多态的技术性需求。
对题目中的点Point类和线Line类进行进一步抽象，定义一个两个类的共同父类Element（抽象类），将display()方法在该方法中进行声明（抽象方法），将Point类和Line类作为该类的子类。
再定义一个Element类的子类面Plane，该类只有一个私有属性颜色color，除了构造方法和属性的getter、setter方法外，display()方法用于输出面的颜色，输出格式如下：The Plane's color is:颜色
在主方法内，定义两个Point（线段的起点和终点）对象、一个Line对象和一个Plane对象，依次从键盘输入两个Point对象的起点、终点坐标和颜色值（Line对象和Plane对象颜色相同），然后定义一个Element类的引用，分别使用该引用调用以上四个对象的display()方法，从而实现多态特性。示例代码如下：
element = p1;//起点Point
element.display();
element = p2;//终点Point
element.display();
element = line;//线段
element.display();
element = plane;//面
element.display();
类结构如下图所示。
其中，所有数值均保留两位小数，建议可用String.format("%.2f", data)方法。
以下情况为无效作业
无法运行
设计不符合所给类图要求
未通过任何测试点测试
判定为抄袭
输入格式:
分别输入线段的起点横坐标、纵坐标、终点的横坐标、纵坐标以及颜色，中间可用一个或多个空格、tab或者回车分隔。
输出格式:
(x1,y1)
(x2,y2)
The line's color is:颜色值
The line's begin point's Coordinate is:
(x1,y1)
The line's end point's Coordinate is:
(x2,y2)
The line's length is:长度值
The Plane's color is:颜色值
输入样例1:
在这里给出一组输入。例如：
5
9.4
12.3
84
Red
输出样例1:
在这里给出相应的输出。例如：
(5.00,9.40)
(12.30,84.00)
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
The Plane's color is:Red
输入样例2:
在这里给出一组输入。例如：
5
9.4
12.3
845
Black
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in=new Scanner(System.in); double x1=in.nextDouble(); double x2=in.nextDouble(); double y1=in.nextDouble(); double y2=in.nextDouble(); if(x1<=200&&x1>0&&x2<=200&&x2>0&&y1<=200&&y1>0&&y2<=200&&y2>0) { String color=in.next(); Point point1=new Point(x1,x2); Point point2=new Point(y1,y2); Line line=new Line(point1,point2,color); Plane plane=new Plane(color); Element element; element = point1; element.display(); element = point2; element.display(); element = line; element.display(); element = plane; element.display(); } else { System.out.println("Wrong Format"); } } } 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 double getX() { return x; } public void setX(double x) { this.x = x; } public double getY() { return y; } public void setY(double y) { this.y = y; } @Override public void display() { System.out.printf("(%.2f,%.2f)\n",this.x,this.y); } } class Line extends Element { private String color; private Point point1=new Point(); private Point point2=new Point(); public Line( Point point1, Point point2,String color) { super(); this.color = color; this.point1 = point1; this.point2 = point2; } public Line() { super(); } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public Point getPoint1() { return point1; } public void setPoint1(Point point1) { this.point1 = point1; } public Point getPoint2() { return point2; } public void setPoint2(Point point2) { this.point2 = point2; } @Override void display() { System.out.println("The line's color is:"+this.color); System.out.println("The line's begin point's Coordinate is:"); System.out.printf("(%.2f,%.2f)\n",point1.getX(),point1.getY()); System.out.println("The line's end point's Coordinate is:"); System.out.printf("(%.2f,%.2f)\n",point2.getX(),point2.getY()); System.out.printf("The line's length is:%.2f",getDistance()); } double getDistance() { double distance=Math.sqrt((point1.getX()-point2.getX())*(point1.getX()-point2.getX())+(point1.getY()-point2.getY())*(point1.getY()-point2.getY())); return distance; } } abstract class Element { abstract void display(); } class Plane extends Element { private String color; public Plane() { } public Plane(String color) { this.color = color; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } @Override void display() { System.out.println("\nThe Plane's color is:"+getColor()); } }
小结：这道题添加了父类以及子类，声明，在第一题的基础上更加全面，但万变不离其宗，大部分代码都是从第一题复制过来的，添加部分题目中也有进行描述，增加了面类，并对其相关属性进行了输出，面类是从父类继承过来的。两道题都对私有属性进行了封装，安全性更高。
3、点线面问题再重构（容器类）
在“点与线（继承与多态）”题目基础上，对题目的类设计进行重构，增加容器类保存点、线、面对象，并对该容器进行相应增、删、遍历操作。
在原有类设计的基础上，增加一个GeometryObject容器类，其属性为ArrayList<Element>类型的对象（若不了解泛型，可以不使用<Element>）
增加该类的add()方法及remove(int index)方法，其功能分别为向容器中增加对象及删除第index - 1（ArrayList中index>=0）个对象
在主方法中，用户循环输入要进行的操作（choice∈[0,4]），其含义如下：
1：向容器中增加Point对象
2：向容器中增加Line对象
3：向容器中增加Plane对象
4：删除容器中第index - 1个数据，若index数据非法，则无视此操作
0：输入结束
示例代码如下：
choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1://insert Point object into list
...
break;
case 2://insert Line object into list
...
break;
case 3://insert Plane object into list
...
break;
case 4://delete index - 1 object from list
int index = input.nextInt();
...
}
choice = input.nextInt();
}
输入结束后，按容器中的对象顺序分别调用每个对象的display()方法进行输出。
类图如下所示：
以下情况为无效作业
无法运行
设计不符合所给类图要求
未通过任何测试点测试
判定为抄袭
输入格式:
switch(choice) {
case 1://insert Point object into list
输入“点”对象的x，y值
break;
case 2://insert Line object into list
输入“线”对象两个端点的x，y值
break;
case 3://insert Plane object into list
输入“面”对象的颜色值
break;
case 4://delete index - 1 object from list
输入要删除的对象位置（从1开始）
...
}
输出格式:
Point、Line、Plane的输出参考题目2
删除对象时，若输入的index超出合法范围，程序自动忽略该操作
输入样例:
在这里给出一组输入。例如：
1
3.4
5.6
2
4.4
8.0
0.98
23.888
Red
3
Black
1
9.8
7.5
3
Green
4
3
0
输出样例:
在这里给出相应的输出。例如：
(3.40,5.60)
The line's color is:Red
The line's begin point's Coordinate is:
(4.40,8.00)
The line's end point's Coordinate is:
(0.98,23.89)
The line's length is:16.25
(9.80,7.50)
The Plane's color is:Green
import java.util.ArrayList; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner i=new Scanner(System.in); GeometryObject a=new GeometryObject(); double x1,x2,y1,y2; String color; int choice; Point point1; Point point2; Line line; Plane plane; Element element; choice = i.nextInt(); while(choice!= 0) { switch(choice) { case 1: point1=new Point(i.nextDouble(),i.nextDouble()); element=point1; a.add(element); break; case 2: x1=i.nextDouble(); y1=i.nextDouble(); x2=i.nextDouble(); y2=i.nextDouble(); color=i.next(); if(x1<=200&&x1>0&&x2<=200&&x2>0&&y1<=200&&y1>0&&y2<=200&&y2>0){ point1=new Point(x1,y1); point2=new Point(x2,y2); line=new Line(point1,point2,color); element=line; a.add(element); } else { a.add(null); } break; case 3: color=i.next(); plane=new Plane(color); element=plane; a.add(element); break; case 4: int in= i.nextInt(); a.remove(in); } choice = i.nextInt(); } a.getList(); } } 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 double getX() { return x; } public void setX(double x) { this.x = x; } public double getY() { return y; } public void setY(double y) { this.y = y; } public void display() { System.out.printf("(%.2f,%.2f)\n",this.x,this.y); } } class Line extends Element { private String color; private Point point1=new Point(); private Point point2=new Point(); public Line( Point point1, Point point2,String color) { this.color = color; this.point1 = point1; this.point2 = point2; } public Line() { super(); } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public Point getPoint1() { return point1; } public void setPoint1(Point point1) { this.point1 = point1; } public Point getPoint2() { return point2; } public void setPoint2(Point point2) { this.point2 = point2; } void display() { System.out.println("The line's color is:"+this.color); System.out.println("The line's begin point's Coordinate is:"); System.out.printf("(%.2f,%.2f)\n",point1.getX(),point1.getY()); System.out.println("The line's end point's Coordinate is:"); System.out.printf("(%.2f,%.2f)\n",point2.getX(),point2.getY()); System.out.printf("The line's length is:%.2f",getDistance()); } double getDistance() { double distance=Math.sqrt((point1.getX()-point2.getX())*(point1.getX()-point2.getX())+(point1.getY()-point2.getY())*(point1.getY()-point2.getY())); return distance; } } abstract class Element { abstract void display(); } class Plane extends Element { private String color; public Plane() { } public Plane(String color) { this.color = color; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } void display() { System.out.println("The Plane's color is:"+getColor()); } } class GeometryObject{ ArrayList<Element> list=new ArrayList<Element>(); public GeometryObject() { } public void add(Element element){ list.add(element); } public void remove(int in){ if(list.size()>in-1) list.remove(in-1); } public void getList() { for (Element temp:list) { if(temp==null) { System.out.println("Wrong Format"); }else { temp.display(); } } } }
小结：第三题也是在第一题和第二题的基础上循序渐进的，又新增了容器类，以及它的属性，并对其进行输出。这道题的重难点应该在于容器内部用户选项进行的相关功能代码的编写，第四点看到的时候很迷茫，请教了同学，才一点点知道是什么意思，这里花费的时间最多。
总结：
不得不说，在经历了PTA4和PTA5的洗礼之后，期中考试的题目真的很友好，很基础的点线面容器问题，但是当然给粗的时间也更短，也是很考验大家的基础的。有同学不一会就写完了，但是我临近倒下课前一分钟才完成考试，代码还存在问题没有解决，但是时间已经快到了，就没有再去纠结不知道哪里错的点了。通过这三次习题，可以很明显的感觉到完成的是很吃力的，前几次早早的就可以完成，但是这几次每天花费的时间比之前多得多，提交上去的代码质量不好，提交时间也晚的多的多的多。
无论怎么样，都让我在课堂以外的时间花费了大量的精力去学习JAVA（自愿的，谁能看着别人能写出来而自己写不出来不着急呢！）这几周学习下来，感觉自己父子类的继承，多态等相关方面掌握的不是很好，会在课余时间更努力地去进行学习！
