一、前言
题目集一：
知识点：Java基本语法，简单的运算，逻辑判断，字符串数组基本操作。
题量：比较多。
难度：较简单，基础。
题目集二：
知识点：Java基本语法，字符串与数组的基本处理，Java对象，类和方法基础。
题量：适中。
难度：较简单，基础。
题目集三：
知识点：类的处理，使用，面向对象思想，正则表达式匹配字符串，输出处理。
题量：适中。
难度：难。
二、设计与分析
题目集一：
7-7 判断三角形类型
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。
输出格式:
（1）如果输入数据非法，则输出“Wrong Format”；
（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；
（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；
（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；
（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；
（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；
（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。
圈复杂度分析：
这题比较简单，整体的思路和题目含义清晰，不需要使用面向对象创建多个类去完成，只需要Main类就能实功能，先判定出正确格式，然后不断使用if-else语句不断判断筛选，得出相应的输出，但是在判断等腰直角三角形的时候测试点通不过。
主要代码分析：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner data=new Scanner (System.in);
double a,b,c;
a=data.nextDouble();
b=data.nextDouble();
c=data.nextDouble();
if(a<1||a>200||b<1||b>200||c<1||c>200){
System.out.println("Wrong Format");
return;
}
else if(a+b<=c||a+c<=b||b+c<=a){
System.out.println("Not a triangle");
}
else if(a==b&&b==c){
System.out.println("Equilateral triangle");
}
else if((a==b)||(b==c)||(c==a)){
if((a*a+b*b==c*c)||(a*a+c*c==b*b)||(b*b+c*c==a*a)){
System.out.println("Isosceles right-angled triangle");
}
else{
System.out.println("Isosceles triangle");
}
}
else if((a*a+b*b==c*c)||(a*a+c*c==b*b)||(b*b+c*c==a*a)){
System.out.println("Right-angled triangle");
}
else {
System.out.println("General triangle");
}
}
}代码思路：使用if-else语句，先判断该三角形输入的数据是否合法（1-200），合法的话再判断是否能构成三角形（两边之和大于第三边的定理），如果能构成三角形，再判断是等边三角形或者等腰直角三角形或者等腰三角形或者直角三角形或者一般三角形，其中判断等腰直角三角形的时候，测试点通不过，后来问同学才知道double类型数据计算时会损失部分精度。
优缺点：
优点：整体if-else语句的判断条件比较清晰，便于理解，并且可操作性强。
缺点：1.if-else语句的使用过多，导致代码繁杂。
2.判定是否为直角三角形时未测试其计算精度，导致判断结果有误差，一些无理数边长数据被省略。
题目集二：
7-2 串口字符解析
RS232是串口常用的通信协议，在异步通信模式下，串口可以一次发送5~8位数据，收发双方之间没有数据发送时线路维持高电平，相当于接收方持续收到数据“1”（称为空闲位），发送方有数据发送时，会在有效数据（5~8位，具体位数由通信双方提前设置）前加上1位起始位“0”，在有效数据之后加上1位可选的奇偶校验位和1位结束位“1”。请编写程序，模拟串口接收处理程序，注：假定有效数据是8位，奇偶校验位采用奇校验。
输入格式:
由0、1组成的二进制数据流。例如：11110111010111111001001101111111011111111101111
输出格式:
过滤掉空闲、起始、结束以及奇偶校验位之后的数据，数据之前加上序号和英文冒号。
如有多个数据，每个数据单独一行显示。
若数据不足11位或者输入数据全1没有起始位，则输出"null data"，
若某个数据的结束符不为1，则输出“validate error”。
若某个数据奇偶校验错误，则输出“parity check error”。
若数据结束符和奇偶校验均不合格，输出“validate error”。
如：11011或11111111111111111。
例如：
1:11101011
2:01001101
3:validate error
圈复杂度分析：
该题目是对串口字符解析，做起来有些绕，只用一个Main类就可以，首先得对该题目进行详细的分析，经过查询相关奇偶效验性的含义，明白奇偶效验是判断“1”的个数为奇数还是偶数，并是采用的是奇效验，判定的数据段为有效数据和其后一位计算判定，将接收到的字符串存到数组中再判断，再到for循环里检验，注意范围。解答该题目。
主要代码分析：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner data=new Scanner(System.in);
String s=data.next();
char []a=new char[1000];
int sum=0;//记录数据是否全是1
for(int i=0;i<s.length();i++){
a[i]=s.charAt(i);
if(a[i]=='1')
sum++;
}
if(sum==s.length()||s.length()<11){
System.out.println("null data");
return ;
}
else{
int n=1;
for(int i=0;i<s.length();i++){
if(a[i]=='0'&&i+10<s.length()){
int k=0;
String s1=s.substring(i+1,i+9);
for(int j=i+1;j<=i+9;j++){
if(a[j]=='1'){//!!!
k++;
}
}
if(k%2!=0&&a[i+10]=='1'){
System.out.println(n+":"+s1);
n++;
}
else if(k%2==0&&a[i+10]=='1'){
System.out.println(n+":"+"parity check error");
n++;
}
else {
System.out.println(n+":"+"validate error");
n++;
}
i=i+10;//！！！
}
}
}
}
}代码思路：先将接收到的字符串存到数组，在for循环中判断输入数据格式是否错误，如果正确再用for语句对输入的字符串进行解析，用sum记录1的个数，如果全是1或长度不够11则输出"null data"，正确时，继续用for循环判断第一个开始字符为0，且后面10位要小于字符串长度，再截取此位置到加十之间的字符，用k判断1的个数，如果最后k不能整除2且最后一位是1则正确，如果整除2，则打印“parity check error”，如果都不符合则打印“validate error”。得出相应的结果。
优缺点：
优点：1.使用数组，for循环理解简单，明了。
2.能够较为精准的对字符串解析，并依照题意得出对应结果。
缺点：1.标识符多，阅读者容易混淆。
题目集三：
7-1 点线形系列1-计算两点之间的距离
输入连个点的坐标，计算两点之间的距离
输入格式:
4个double类型的实数，两个点的x，y坐标，依次是x1、y1、x2、y2，两个点的坐标之间以空格分隔，每个点的x,y坐标以英文“,”分隔。例如：0,0 1,1或0.1,-0.3 +3.5,15.6。
若输入格式非法，输出"Wrong Format"。
若输入格式合法但坐标点的数量超过两个，输出“wrong number of points”。
输出格式:
计算所得的两点之间的距离。例如：1.4142135623730951
圈复杂度：
该题目整体思路清晰，但是自己还是没弄明白类，所有的还是交给Main类处理，主要注意的地方是判断输入格式非法的地方要严谨准确（讨论多种情况），使用新学习的split方法进行分割字符串，il-else语句等，判断输入格式合法且没超过2个点后输出距离。
主要代码分析：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner str=new Scanner(System.in);
String s=str.nextLine();
String []a=s.split(" ");
String []b=null;
for(String i:a){
b=i.split(",");
for(String j:b){
if(!j.matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$")){
System.out.print("Wrong Format");
return ;
}
}
}
if(a.length!=2){
System.out.print("wrong number of points");
return ;
}
b=a[0].split(",");
Double x1=Double.valueOf(b[0]);
Double y1=Double.valueOf(b[1]);
b=a[1].split(",");
Double x2=Double.valueOf(b[0]);
Double y2=Double.valueOf(b[1]);
if(x1==x2&&y1==y2){
System.out.print("Wrong Format");
return;
}
System.out.print(Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)));
}
}代码思路：先输入的字符串按照空格和逗号分隔存到不同的数组，用以判断输入数据的合法性以及判断点的数目是否正确，然后再计算距离。
优缺点：
优点：1.for循环语句条件简明，且运用了新学习的valueOf（）方法和split（）方法。
缺点：1.没有掌握类的用法。
7-2 点线形系列2-线的计算
用户输入一组选项和数据，进行与直线有关的计算。选项包括：
1：输入两点坐标，计算斜率，若线条垂直于X轴，输出"Slope does not exist"。
2：输入三个点坐标，输出第一个点与另外两点连线的垂直距离。
3：输入三个点坐标，判断三个点是否在一条线上，输出true或者false。
4：输入四个点坐标，判断前两个点所构成的直线与后两点构成的直线是否平行，输出true或者false.
5：输入四个点坐标，计算输出前两个点所构成的直线与后两点构成的直线的交点坐标，x、y坐标之间以英文分隔","，并输出交叉点是否在两条线段之内（不含四个端点）的判断结果(true/false)，判断结果与坐标之间以一个英文空格分隔。若两条线平行，没有交叉点，则输出"is parallel lines,have no intersection point"。
输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。
例如：1:0,0 1,1
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
不论哪个选项，如果格式、点数量都符合要求，但构成任一条线的两个点坐标重合，输出"points coincide"，
输出格式:
见题目描述。
圈复杂度分析：
该题目跟7-1的输入格式判断非法类似，在此题目中慢慢学习用类的方法去做，该题我创建了Point类（点）和Line类（方法）和Main类（方法），并且我对输入数据的长度和字符数量进行了判断。通过Main类，Point类，Line类共同完成该题。
主要代码分析：
import java.util.Scanner;
import static java.lang.StrictMath.abs;
public class Main{
public static void main(String[] args){
Scanner str=new Scanner(System.in);
String s=str.nextLine();
if(cheakgeshi(s)) return;
if(cheakdiannum(s)) return;
String [] a=s.split(":");
String []p=a[1].split(" ");
String []b=null;
switch(a[0]){
case "1":{
b=p[0].split(",");
Double x1=Double.valueOf(b[0]);
Double y1=Double.valueOf(b[1]);
b=p[1].split(",");
Double x2=Double.valueOf(b[0]);
Double y2=Double.valueOf(b[1]);
Point point=new Point();Point point1=new Point();
point.x=x1; point.y=y1;
point1.x=x2; point1.y=y2;
if(point.x==point1.x&&point.y==point1.y) {//!!!
System.out.println("points coincide");
return ;
}
System.out.println(point1.xilv(point));
break;
}
case "2":{
b=p[0].split(",");
Double x1=Double.valueOf(b[0]);
Double y1=Double.valueOf(b[1]);
b=p[1].split(",");
Double x2=Double.valueOf(b[0]);
Double y2=Double.valueOf(b[1]);
b=p[2].split(",");
Double x3=Double.valueOf(b[0]);
Double y3=Double.valueOf(b[1]);
Point point=new Point();Point point1=new Point();
Point point2=new Point();
point.input(x1,y1);
point1.input(x2,y2);
point2.input(x3,y3);
if(point2.x==point1.x&&point2.y==point1.y) {//!!!
System.out.println("points coincide");
return ;
}
Line line=new Line(point1,point2);
System.out.println(line.distance(point));
break;
}
case "3":{
b=p[0].split(",");
Double x1=Double.valueOf(b[0]);
Double y1=Double.valueOf(b[1]);
b=p[1].split(",");
Double x2=Double.valueOf(b[0]);
Double y2=Double.valueOf(b[1]);
b=p[2].split(",");
Double x3=Double.valueOf(b[0]);
Double y3=Double.valueOf(b[1]);
Point point=new Point();Point point1=new Point();
Point point2=new Point();
point.input(x1,y1);
point1.input(x2,y2);
point2.input(x3,y3);
Line line=new Line(point1,point2);
System.out.println(line.sameline(point));
break;
}
case "4":{
b=p[0].split(",");
Double x1=Double.valueOf(b[0]);
Double y1=Double.valueOf(b[1]);
b=p[1].split(",");
Double x2=Double.valueOf(b[0]);
Double y2=Double.valueOf(b[1]);
b=p[2].split(",");
Double x3=Double.valueOf(b[0]);
Double y3=Double.valueOf(b[1]);
b=p[3].split(",");
Double x4=Double.valueOf(b[0]);
Double y4=Double.valueOf(b[1]);
Point point=new Point();Point point1=new Point();
Point point2=new Point();Point point3=new Point();
point.input(x1,y1);
point1.input(x2,y2);
point2.input(x3,y3);point3.input(x4,y4);
if((point.x==point1.x&&point.y==point1.y)||(point2.x==point3.x&&point2.y==point3.y)){
System.out.println("points coincide");
return ;
}
Line line=new Line(point1,point);
Line line1=new Line (point3,point2);
System.out.println(line.pingxing(line1));
break;
}
case "5":{
b=p[0].split(",");
Double x1=Double.valueOf(b[0]);
Double y1=Double.valueOf(b[1]);
b=p[1].split(",");
Double x2=Double.valueOf(b[0]);
Double y2=Double.valueOf(b[1]);
b=p[2].split(",");
Double x3=Double.valueOf(b[0]);
Double y3=Double.valueOf(b[1]);
b=p[3].split(",");
Double x4=Double.valueOf(b[0]);
Double y4=Double.valueOf(b[1]);
Point point=new Point();Point point1=new Point();
Point point2=new Point();Point point3=new Point();
point.input(x1,y1);
point1.input(x2,y2);
point2.input(x3,y3);point3.input(x4,y4);
Line line=new Line(point1,point);
Line line1=new Line (point3,point2);
if((point.x==point1.x&&point.y==point1.y)||(point2.x==point3.x&&point2.y==point3.y)){
System.out.println("points coincide");
return ;
}
Point c=new Point();
c=line.jiaodian(line1);
System.out.print(c.x+","+c.y);
System.out.print(" ");
if((c.y>y1&&c.y<y2)||(c.y>y2&&c.y<y1)||(c.y>y3&&c.y<y4)||(c.y>y4&&c.y<y3))
System.out.println(true);
else
System.out.println(false);
break;
}
}
}
public static boolean cheakgeshi(String s){
String ss =s.substring(0,2);
if(! ss.matches("[1-5]{1}\\:")){
System.out.println("Wrong Format");
return true;
}
String []a=s.split(":");
String []p=a[1].split(" ");
String []b=null;
if(!a[0].matches("^[1-5]{1}$")){
System.out.println("Wrong Format");
return true;
}
for(String i:p){
b=i.split(",");
for(String j:b){
if(!j.matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$")){
System.out.println("Wrong Format");
return true;
}
}
}
// if(!s.matches("^[1-5][:](([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))[,]([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))\\s?)+$")){
// System.out.println("Wrong Format");
// return;
// }
return false;
}
public static boolean cheakdiannum(String s){
String []a=s.split(":");
String []p=a[1].split(" ");
int n=p.length;
if(s.charAt(0)=='1'&&n!=2){
System.out.println("wrong number of points");
return true;
}
else if(s.charAt(0)=='2'&&n!=3){
System.out.println("wrong number of points");
return true;
}
else if(s.charAt(0)=='3'&&n!=3){
System.out.println("wrong number of points");
return true ;
}
else if(s.charAt(0)=='4'&&n!=4){
System.out.println("wrong number of points");
return true;
}
else if(s.charAt(0)=='5'&&n!=4){
System.out.println("wrong number of points");
return true;
}
return false;
}
static class Point {
double x,y;
void input(double a,double b){
this.x=a;
this.y=b;
}
public double getx(){
return x;
}
public double gety(){
return y;
}
public double juli(Point p){
return Math.sqrt((this.x-p.x )*(this.x-p.x )+(this.y-p.y )*(this.y-p.y));
}
public void chonghe (Point p){
if(Math.abs(this.x-p.x)==0&&Math.abs(this.y-p.y)==0){
System.out.println("points coincide");
return ;
}
}
public double xilv(Point p){
if(this.x==p.x) {
System.out.println("Slope does not exist");
System.exit(0);
}
return (this.y-p.y)/(this.x-p.x);
}
}
public static class Line {
Point x,y;
Line (Point a, Point b){
this.x=a;
this.y=b;
}
double distance(Point p){
if(this.x.x==this.y.x){
return abs(p.x-this.x.x);
}
else{
double e=(this.x.y-this.y.y)/(this.x.x-this.y.x);
double b=this.x.y-(e*this.x.x);
return abs((e*p.x-p.y+b)/Math.sqrt(e*e+1));
}
}
boolean sameline(Point p){
if(this.x.x==this.y.x&&this.y.x==p.x)
return true;
double e=(this.x.y-this.y.y)/(this.x.x-this.y.x);
double b=this.x.y-(e*this.x.x);
if((e*p.x-p.y+b)==0)
return true;
else
return false;
}
//
boolean pingxing (Line a) {
if ((a.x.x == a.y.x) && (this.x.x == this.y.x))
return true;
if ((a.x.x == a.y.x) && (this.x.x != this.y.x))
return false;
if ((a.x.x != a.y.x) && (this.x.x == this.y.x))
return false;
double e = a.x.xilv(a.y);
double e1 = this.x.xilv(this.y);
if (e == e1)
return true;
else return false;
}
Point jiaodian(Line a){
Point p=new Point();
if((this.x.x==this.y.x)&&(a.x.x==a.y.x)){
System.out.println("is parallel lines,have no intersection point");
System.exit(0);
}
else if((this.x.x==this.y.x)&&(a.x.x!=a.y.x)){
double dx=this.x.x;
double e=a.x.xilv(a.y);
double b=a.x.y-e*a.x.x;
double dy=e*dx+b;
p.input(dx,dy);
}
else if((this.x.x!=this.y.x)&&(a.x.x==a.y.x)){
double dx=a.x.x;
double e1=this.x.xilv(this.y);
double b1=this.x.y-e1*this.x.x;
double dy=e1*dx+b1;
p.input(dx,dy);
}else {
double e = a.x.xilv(a.y);
double e1 = this.x.xilv(this.y);
if (e != e1) {
double b = a.x.y - e * a.x.x;
double b1 = this.x.y - e1 * this.x.x;
double dx = (b - b1) / (e1 - e);
double dy = e * dx + b;
p.input(dx, dy);
} else {
System.out.println("is parallel lines,have no intersection point");
System.exit(0);
}
}
return p;
}
}
}代码思路：
先调用判断格式是否正确和点的数目是否正确的方法判断是否可以正常进行，然后用split（）方法切割，在switch语句中判断是那个选项，在每个选项中根据题意调用点类和线类进行计算，操作。但最后有几个格式和点的一个的测试点通不过，
优缺点：
优点：1.运用point类和Line类和Main类让程序结构不会出现太多重复创建点的代码，但还是存在一些。
2.对非法格式和选项的方法进行详细分析，找出多种可能存在的情况。
缺点：1.程序过长，每个选项都创建了大量double型数据，过于繁杂。
2.选项五求交点的方法使用平常数学方法不能通过测试点，需使用另外的方法，测试样例能通过，但测试点却无法通过。
3.使用正则表达式匹配输入格式时，可能还没考虑到其他的方式，测试点几个没通过。
7-3 点线形系列3-三角形的计算
用户输入一组选项和数据，进行与三角形有关的计算。选项包括：
1：输入三个点坐标，判断是否是等腰三角形、等边三角形，判断结果输出true/false，两个结果之间以一个英文空格符分隔。
2：输入三个点坐标，输出周长、面积、重心坐标，三个参数之间以一个英文空格分隔，坐标之间以英文","分隔。
3：输入三个点坐标，输出是钝角、直角还是锐角三角形，依次输出三个判断结果（true/false），以一个英文空格分隔，
4：输入五个点坐标，输出前两个点所在的直线与三个点所构成的三角形相交的交点数量，如果交点有两个，则按面积大小依次输出三角形被直线分割成两部分的面积。若直线与三角形一条线重合，输出"The point is on the edge of the triangle"
5：输入四个点坐标，输出第一个是否在后三个点所构成的三角形的内部（输出in the triangle/outof triangle）。
必须使用射线法，原理：由第一个点往任一方向做一射线，射线与三角形的边的交点（不含点本身）数量如果为1，则在三角形内部。如果交点有两个或0个，则在三角形之外。若点在三角形的某条边上，输出"on the triangle"
输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
如果输入的三个点无法构成三角形，输出"data error"。
注意：输出的数据若小数点后超过6位，只保留小数点后6位，多余部分采用四舍五入规则进到最低位。小数点后若不足6位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333333，1.0按格式输出为1.0
选项4中所输入线的两个点坐标重合，输出"points coincide"，
圈复杂度分析：
该题目看起来和第二题一样，只不过增加了几个选项，做起来却不尽如人意，直接套用前面的Point 类 Line 类，再创建Sanjiao 类和Main类。通过Main类，Point类，Line类和Sanjiao 类共同完成该题。
主要代码分析：
import java.util.Arrays;
import java.util.Scanner;
import java.text.NumberFormat;
import static java.lang.StrictMath.abs;
public class Main {
public static void main(String[] args) {
Scanner str = new Scanner(System.in);
String s = str.nextLine();
if (cheakgeshi(s)) return;
if (cheakdiannum(s)) return;
String[] a = s.split(":");
String[] p = a[1].split(" ");
String[] b = null;
switch (a[0]) {
case "1": {
b = p[0].split(",");
Double x1 = Double.valueOf(b[0]);
Double y1 = Double.valueOf(b[1]);
b = p[1].split(",");
Double x2 = Double.valueOf(b[0]);
Double y2 = Double.valueOf(b[1]);
b = p[2].split(",");
Double x3 = Double.valueOf(b[0]);
Double y3 = Double.valueOf(b[1]);
Point point = new Point();
Point point1 = new Point();
Point point2 = new Point();
point.x = x1;
point.y= y1;
point1.x = x2;point1.y = y2;
point2.x = x3;point2.y = y3;
Sanjiao S=new Sanjiao(point,point1,point2);//!!!(参数)
if(S.gouchengsanjiao()){
System.out.println("data error");
return;
}
else
System.out.println(S.dengyao ()+" "+S.qaundeng ());
break;
}
case "2":{
b = p[0].split(",");
Double x1 = Double.valueOf(b[0]);
Double y1 = Double.valueOf(b[1]);
b = p[1].split(",");
Double x2 = Double.valueOf(b[0]);
Double y2 = Double.valueOf(b[1]);
b = p[2].split(",");
Double x3 = Double.valueOf(b[0]);
Double y3 = Double.valueOf(b[1]);
Point point = new Point();
Point point1 = new Point();
Point point2 = new Point();
point.x = x1;point.y= y1;
point1.x = x2;point1.y = y2;
point2.x = x3;point2.y = y3;
Sanjiao S=new Sanjiao(point,point1,point2);//!!!(参数)
if(S.gouchengsanjiao()){
System.out.println("data error");
return;
}
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(6);
System.out.println(nf.format(S.zhouchang())+" "+nf.format(S.mianji())+" "+(float)(S.zhongxin().x)+","+nf.format(S.zhongxin().y));
break;
}
case "3":{
b = p[0].split(",");
Double x1 = Double.valueOf(b[0]);
Double y1 = Double.valueOf(b[1]);
b = p[1].split(",");
Double x2 = Double.valueOf(b[0]);
Double y2 = Double.valueOf(b[1]);
b = p[2].split(",");
Double x3 = Double.valueOf(b[0]);
Double y3 = Double.valueOf(b[1]);
Point point = new Point();
Point point1 = new Point();
Point point2 = new Point();
point.x = x1;point.y= y1;
point1.x = x2;point1.y = y2;
point2.x = x3;point2.y = y3;
Sanjiao S=new Sanjiao(point,point1,point2);//!!!(参数)
if(S.gouchengsanjiao()){
System.out.println("data error");
return;
}
else{
if(S.type()==0)
System.out.println("false false true");
else if(S.type()==1)
System.out.println("false true false");
else System.out.println("true false false");
}
break;
}
}
}
public static boolean cheakgeshi(String s) {
String ss = s.substring(0, 2);
if (!ss.matches("[1-5]{1}\\:")) {
System.out.println("Wrong Format");
return true;
}
String[] a = s.split(":");
String[] p = a[1].split(" ");
String[] b = null;
if (!a[0].matches("^[1-5]{1}$")) {
System.out.println("Wrong Format");
return true;
}
for (String i : p) {
b = i.split(",");
for (String j : b) {
if (!j.matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$")) {
System.out.println("Wrong Format");
return true;
}
}
}
// if(!s.matches("^[1-5][:](([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))[,]([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))\\s?)+$")){
// System.out.println("Wrong Format");
// return;
// }
return false;
}
public static boolean cheakdiannum(String s) {
String[] a = s.split(":");
String[] p = a[1].split(" ");
int n = p.length;
if (s.charAt(0) == '1' && n != 3) {
System.out.println("wrong number of points");
return true;
} else if (s.charAt(0) == '2' && n != 3) {
System.out.println("wrong number of points");
return true;
} else if (s.charAt(0) == '3' && n != 3) {
System.out.println("wrong number of points");
return true;
} else if (s.charAt(0) == '4' && n != 5) {
System.out.println("wrong number of points");
return true;
} else if (s.charAt(0) == '5' && n != 4) {
System.out.println("wrong number of points");
return true;
}
return false;
}
static class Point {
double x,y;
public void input(double a,double b){
this.x=a;
this.y=b;
}
public double getx(){
return x;
}
public double gety(){
return y;
}
public double juli(Point p){
return Math.sqrt((this.x-p.x )*(this.x-p.x )+(this.y-p.y )*(this.y-p.y));
}
public boolean chonghe (Point p){
if(Math.abs(this.x-p.x)==0&&Math.abs(this.y-p.y)==0){
return true;
}
return false;
}
public double xilv(Point p){
if(this.x==p.x){
System.out.println("Slope does not exist");
System.exit(0);
}
return (this.y-p.y)/(this.x-p.x);
}
}
static class Line {
Point x,y;
Line (Point a, Point b){
this.x=a;
this.y=b;
}
double length(){
return this.x.juli(this.y);
}
double distance(Point p){
if(this.x.x==this.y.x){
return abs(p.x-this.x.x);
}
else{
double e=(this.x.y-this.y.y)/(this.x.x-this.y.x);
double b=this.x.y-(e*this.x.x);
return abs((e*p.x-p.y+b)/Math.sqrt(e*e+1));
}
}
boolean sameline(Point p){
if(this.x.x==this.y.x&&this.y.x==p.x)
return true;
double e=(this.x.y-this.y.y)/(this.x.x-this.y.x);
double b=this.x.y-(e*this.x.x);
if((e*p.x-p.y+b)==0)
return true;
else
return false;
}
boolean pingxing (Line a){
if((a.x.x==a.y.x )&&(this.x.x==this.y.x))
return true;
if((a.x.x==a.y.x)&&(this.x.x!=this.y.x))
return false;
if((a.x.x!=a.y.x)&&(this.x.x==this.y.x))
return false;
double e=a.x.xilv(a.y);
double e1=this.x.xilv(this.y);
if(e==e1)
return true;
else return false;
}
Point jiaodian(Line a){
Point p=new Point();
if((this.x.x==this.y.x)&&(a.x.x==a.y.x)){
System.out.println("is parallel lines,have no intersection point");
System.exit(0);
}
if((this.x.x==this.y.x)&&(a.x.x!=a.y.x)){
double dx=this.x.x;
double e=a.x.xilv(a.y);
double b=a.x.y-e*a.x.x;
double dy=e*dx+b;
p.input(dx,dy);
}
if((this.x.x!=this.y.x)&&(a.x.x==a.y.x)){
double dx=a.x.x;
double e1=this.x.xilv(this.y);
double b1=this.x.y-e1*this.x.x;
double dy=e1*dx+b1;
p.input(dx,dy);
}
double e=a.x.xilv(a.y);
double e1=this.x.xilv(this.y);
if(e!=e1){
double b=a.x.y-e*a.x.x;
double b1=this.x.y-e1*this.x.x;
double dx=(b-b1)/(e1-e);
double dy=e*dx+b;
p.input(dx,dy);
}
else
System.out.println("is parallel lines,have no intersection point");
return p;
}
}
static class Sanjiao {
Point sx,sy,sz;
Line sa,sb,sc;
Sanjiao (Point a, Point b, Point c){
this.sx=a;
this.sy=b;
this.sz=c;
this.sa=new Line(b,c);
this.sb=new Line(a,c);
this.sc=new Line(a,b);
}
public boolean gouchengsanjiao(){
if(((this.sa.length()+this.sb.length())<=this.sc.length())||((this.sa.length()+this.sc.length())<=this.sb.length())||((this.sb.length()+this.sc.length())<=this.sa.length())){
return true;
}
else return false;
}
public boolean dengyao(){
return (Math.abs(this.sa.length()-this.sb.length())<0.1||Math.abs(this.sa.length()-this.sc.length())<0.1||Math.abs(this.sc.length()-this.sb.length())<0.1);
}
public boolean qaundeng (){
return ((this.sa.length()==this.sb.length())&&(this.sb.length()==this.sc.length()));
}
public double zhouchang(){
return (this.sa.length()+this.sb.length()+this.sc.length());
}
public double mianji(){
return Math.abs(this.sx.x*this.sy.y-this.sx.x*this.sz.y+this.sy.x*this.sz.y-this.sy.x*this.sx.y+this.sz.x*this.sx.y-this.sy.x*this.sy.y)/2;
}
public Point zhongxin(){
Point zx = new Point();
double x= (this.sx.x + this.sy.x + this.sz.x) / 3;
double y = (this.sx.y + this.sy.y + this.sz.y) / 3;
zx.input(x,y);
return zx;
}
public int type(){
double[] num = new double[3];
num[0] = this.sa.length();num[1] = this.sb.length();num[2] = this.sc.length();
Arrays.sort(num);
double tmp = Math.pow(num[0],2) + Math.pow(num[1],2) - Math.pow(num[2],2);
if(Math.abs(tmp) < 0.0000001) return 1;
if(tmp < 0) return 2;
return 0;
}
}
}代码思路：
接收字符串，在Main类中main方法中调用格式判断方法和判断点数目的方法，然后通过split方法按照冒号分隔，判断是哪个选项，然后再switch语句中执行相应的操作，在每个操作中都会先调用Sanjiao类的是否能构成三角形的方法，再进行后面的操作，调用相关类的相关方法。
优缺点：
优点：1.对每个方法的计算严谨，尽量减少了存在的误差。
2.使用了面向过程，创建多个类，进行协同完成。
缺点：1.在构造点且赋值的时候繁琐，容易出现混乱。
2.由于时间和水平的有限，没能完成全部的选项。
三、踩坑心得：
1.在题目集一中第二题最后输出结果时要强制转换为float，不然不能通过测试点。第六题中字符串的比较不能使用”==“，要用equals方法。在第八题二进制数值提取中接收时很自然的用了next()，但是在测试点中有对输入字符串空格或其他的字符的判断，要改用next Line()。第九题中在判断等腰直角三角形中使用"=="时一直错误，原来使用double时会有精度的损失，要用<0.0001来判断。
2.在题目集二中第一题在判断输入是否合法时，在不合法时相应的标志值加一以外，应该结束这个循环，不然他后面标志值变为原始值，结果是错误的。第二题中就是要注意此题目奇偶效验性判断的时候要注意不仅有效数据还有有效数据后一位，共九位都需要进行判断，并且这个是嵌套循环，使用每判断完一串有效数据后i需要加10，进行下一段字符串的判断，这个坑就是需要注意循环时数据判断位数准确。
3.在题目集三中格式的判断是很重要的，其中要考虑的情况也多，我的格式总是有一两测试点通不过，在第二题中求交点的选项一个测试点总是通不过，在输出交点的时候结果总是不符合测试点，输出时要强制转换为float型。
四、改进建议：
学习了圈复杂度的计算方法，发现我这几次的代码感觉的有点复杂了，下次作业我尽量少写if-else，多写switch，case减少复杂度，而且每一题尽量使用面向对象的思路，多分类和把每个方法都写的简洁明了。由SourceMonitor的评测图结果可以可知，题目集三中每个题目的圈复杂度之高，因为使用的是普通的if-else语句，并且类设计的也十分简陋，大致跟面向过程差不多，应该使用switch语句进行选项进行选择的判断，并且可以再创建方法类和线类，进行交互使用，让复杂度降低，让代码简洁明了。在以后的学习中，做此类题目应该使用正则表达式降低代码繁杂和复杂度，也要多将类与类之间的关系进行调用，体现java面向对象的特点。
五、总结：
通过java这阶段的学习，发现自己对java的基础知识有很多的欠缺，基础的知识也不知道，写作业的时候很累，也很烦，总是出现bug，但是还是只能静下心来一点一点的学习，请教同学和网上搜集资料，只有学好这些基础的类知识，才能为后面更好的学习做准备，让我从之前学C语言的习惯改到面向对象的java，我对java的了解还很浅显，需要学习更多的结构、语法知识来充实java的学习。在优化代码和减少复杂度的方面有所欠缺，需要在这方面改进。上课认真听课，课后也需要自己多了解java的知识，许多知识还需要自学，多巩固基础函数语法知识，更易于理解和吸收，防止在平常编写代码时忘记一些基础知识。
