题目集4_6的总结
作者：互联网
前言：
知识点：1、进一步对输入格式的判断，设置字符串进行输入，对于产生的字符串的切割使用的函数，string.split()对于从不需要的字符串进行切割，难度中等，涉及到每一道题目
2、在上一点的基础上，对于每一种坐标的内容进行判断，判断是否为三点一线，两直线是否平行等内容，难度中等，其主要是对上一题的衍生，大部分是初高中的知识，需要判断的内容较多
3、在上一题的基础上，对于产生的三角形进行综合判断，难度较大，所涉及的知识点较少
4、正则表达式的判断，难度相对较小，对于上面几道题可以得到提升，缩短代码，其中很多的都是判断
5、设计类，对于类与类之间的关系进行设计与构造设计，一个人存在多个账号和多个卡号的设计
6、学会设计点与线的关系，通过输入点来构造线
7、点线面之间的构造，通过继承和多态的联系来设计出类与类之间的关系，向上造型，方法重写，实现不同的对象做同一件事的不同效果的展示。
8、构造容器类，需要掌握ArraryList容器类的用法，对于其中的内容进行删除与添加对象，在继承与多态的基础上再次构造
题目集：
(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
设计思路：需要对输入格式的输入进行控制，判断是否为Wrong Format或者是wrong number of points（应该是要设计字符串的，不能单独设计数字，一开始我也想过用数字，但是失败了，如果你们有更好的欢 迎评论区留言）
本题没有采用正则表达式，如果用正则表达式会简便很多，推荐大家去学习一下，确实很方便，几个字符解决了很多的事情，真的是yyds。
首先我们需要找到其中的间隔的位置，才能对格式进行判断
for(;i<getlength();i ++) {
for(j = i;j<getlength();j++) {
if(getData().charAt(j) =='+'||getData().charAt(j) == '-')
add++;
if(getData().charAt(j) == '.')
dot++;
if(getData().charAt(j) != '.'&&(getData().charAt(j) != '+'&&getData().charAt(j) != '-')&&!Character.isDigit(getData().charAt(j))) {
i = j;
num++;//表示找到了几组
break; //找到断点
}
if(getData().charAt(j) == '.'&&!Character.isDigit(getData().charAt(j+1)))
return 0;//格式错误
if((getData().charAt(j) == '+'||getData().charAt(j) == '-')&&j != i)
return 0;//格式错误
if(getData().charAt(j) == '0'&&getData().charAt(j+1) == '0'&&j == i)
return 0;
}
if(j == getlength())
break;
if(add > 1||dot >1)
return 0;//格式错误
add = 0; dot =0;
if(num%2 == 0 &&getData().charAt(j) != ' ')
return 0;//格式错误
if(num%2 != 0 &&getData().charAt(j) !=',')
return 0;//格式错误
}
if(j == getlength()&&num == 3)
return 1;//表示格式正确，数据正确
if((num-3) %2 == 0&&num !=3)
return 2;//表示数据错误
if(num %2 !=0 )
return 1;//表示格式错误
else
return 0;
}
对于是字符串的类型，需要对首先的“+-”这两个符号进行判断，可能是存在或者是不存在，同时每一组只能出现一次，对于需要里面每次产生的内容都进行计数，这是非常重要的，其实这个代码还是 可以的拓展的，将其中的内容进行稍微的更改一下，就可以实现代码的拓展，当然，这个除了使用正则表达式的以外，还可以使用其中string.split函数，这个会帮你自动切割，是非常方便的以后我们 会用到的
踩坑新得：相对于这个代码中，找位置，一开始就有很多的点需要找，因此，需要设计好，一开始，我就没有计数，这样就导致了出现了bug，比如说没有考虑到00，++，1.这样的数字，都是一时难以考虑完全 的，需要大家自己慢慢去设计。
改进建议：可以使用正则表达式去更改，这样会更好，推荐大家去尝试一下
（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"，
设计思路：这一题是对上一题的衍生，其中很多的代码时直接可以复制粘贴过来使用的，不需要很多的设计，但是还是其中还有很多的需要判断三点共线的等等，推荐大家可以先布局，想好思路和算法，这样可 以节省很多的时间，推荐大家上网查找一些公式，这里很多都是要判断，斜率是否存在，这是比较麻烦的
以下是源码(确实写的很不好，但是可以实现)：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = "";
char chance = 0;
int mothod = 0;
scanner scan = new scanner();
scan.scan();//先输入
chance = scan.getFirstchar();
if(scan.getData().charAt(0) > '5' || scan.getData().charAt(0) < '1') {
System.out.println("Wrong Format");
System.exit(0);
}
if(chance == '1') {
mothod = scan.j();
if(mothod == 0)
System.out.println("Wrong Format");
if(mothod == 1) {
scan.get();
if(scan.getX1() == scan.getX2()&&scan.getY1() != scan.getY2())
System.out.println("Slope does not exist");
else if(scan.getX1() == scan.getX2()&&scan.getY1() == scan.getY2())
System.out.println("points coincide");
else {
System.out.println((scan.getY1()-scan.getY2())/(scan.getX1()-scan.getX2()));
}
}
if(mothod == 2)
System.out.println("wrong number of points");
}
/*=======================================================*/
else if(chance == '2') {
mothod = scan.j();
if(mothod == 0)
System.out.println("Wrong Format");
if(mothod == 1) {
scan.get();
if(scan.getX2() == scan.getX3()&&scan.getY2() == scan.getY3())
System.out.println("points coincide");
else if(scan.getX2() == scan.getX3()&&scan.getY2() != scan.getY3()) {
if(scan.getX1() == scan.getX2())
System.out.println("0.0");
else if(scan.getX1() != scan.getX2())
System.out.println(Math.abs(scan.getX1()-scan.getX2()));
}
else {
double k1 = (scan.getY1()-scan.getY2())/(scan.getX1()-scan.getX2());
double k2 = (scan.getY1()-scan.getY3())/(scan.getX1()-scan.getX3());
if(k1 != k2) {
if(scan.getX2() != scan.getX3()) {
double k = (scan.getY2()-scan.getY3())/(scan.getX2()-scan.getX3());
double feizi = Math.abs(k*scan.getX1()-scan.getY1()-k*scan.getX2()+scan.getY2());
double feimu = Math.sqrt(k*k+1);
double d = feizi/feimu;
System.out.println(d);
}
else if(scan.getX2() == scan.getX3()) {
double d = Math.abs(scan.getX1()-scan.getX2());
System.out.println(d);
}
}
if(k1 == k2)
System.out.println("0.0");
}
}
if(mothod == 2)
System.out.println("wrong number of points");
}
/*==================================================*/
else if(chance == '3') {
mothod = scan.j();
if(mothod == 0)
System.out.println("Wrong Format");
if(mothod == 1) {
scan.get();
if(scan.getX2() == scan.getX3()&&scan.getY2() == scan.getY3())
System.out.println("points coincide");
else if(scan.getX2() == scan.getX3()&&scan.getX1() == scan.getX3())
System.out.println("true");
else if(scan.getX2() == scan.getX3()&&scan.getX1() != scan.getX3())
System.out.println("false");
else {
double k1 = (scan.getY1()-scan.getY2())/(scan.getX1()-scan.getX2());
double k2 = (scan.getY1()-scan.getY3())/(scan.getX1()-scan.getX3());
if(k1 == k2)
System.out.println("true");
if(k1 != k2)
System.out.println("false");
}
}
if(mothod == 2)
System.out.println("wrong number of points");
}
/*================================================*/
else if(chance == '4') {
mothod = scan.j();
if(mothod == 0)
System.out.println("Wrong Format");
if(mothod == 1) {
scan.get();
if(scan.getX1() == scan.getX2()&&scan.getY1() == scan.getY2())
System.out.println("points coincide");
else if(scan.getX3() == scan.getX4()&&scan.getY3() == scan.getY4())
System.out.println("points coincide");
else if(scan.getX1() == scan.getX2()&&scan.getY1() != scan.getY2()&&scan.getX3() == scan.getX4()&&scan.getY3() != scan.getY4())
System.out.println("true");
else if(scan.getX1() == scan.getX2()&&scan.getY1() != scan.getY2()&&scan.getX3() != scan.getX4())
System.out.println("false");
else if(scan.getX1() != scan.getX2()&&scan.getX3() == scan.getX4()&&scan.getY3() != scan.getY4())
System.out.println("false");
else {
double k1 = (scan.getY1()-scan.getY2())/(scan.getX1()-scan.getX2());
double k2 = (scan.getY3()-scan.getY4())/(scan.getX3()-scan.getX4());
if(k1 == k2)
System.out.println("true");
if(k1 != k2)
System.out.println("false");
}
}
if(mothod == 2)
System.out.println("wrong number of points");
}
/*====================================================*/
else if(chance == '5') {
mothod = scan.j();
if(mothod == 0)
System.out.println("Wrong Format");
if(mothod == 1) {
scan.get();
if(scan.getX1() == scan.getX2()&&scan.getY1() == scan.getY2())
System.out.println("points coincide");
else if(scan.getX3() == scan.getX4()&&scan.getY3() == scan.getY4())
System.out.println("points coincide");
else if(scan.getX1() == scan.getX2()&&scan.getY1() != scan.getY2()&&scan.getX3() == scan.getX4()&&scan.getY3() != scan.getY4())
System.out.println("is parallel lines,have no intersection point");
/*一条在一条不存在*/else if(scan.getX1() == scan.getX2()&&scan.getY1() != scan.getY2()&&scan.getX3() != scan.getX4()) {
double k2 = (scan.getY3()-scan.getY4())/(scan.getX3()-scan.getX4());
double y = k2*scan.getX1()-k2*scan.getX3()+scan.getY3();
float x = (float) scan.getX1();
System.out.print(x+","+(float)y);
if((y - scan.getY1())*(y-scan.getY2()) <0||(scan.getX1() - scan.getX3())*(scan.getX1()-scan.getX4()) <0)
System.out.println(" true");
else
System.out.println(" false");
}
else if(scan.getX1() != scan.getX2()&&scan.getX3() == scan.getX4()&&scan.getY3() != scan.getY4()) {
double k2 = (scan.getY1()-scan.getY2())/(scan.getX1()-scan.getX2());
double y = k2*scan.getX3()-k2*scan.getX1()+scan.getY1();
float x = (float) scan.getX3();
System.out.print(scan.getX3()+","+(float)y);
if((scan.getX3() - scan.getX1())*(scan.getX3()-scan.getX2()) <0||(y - scan.getY3())*(y-scan.getY4()) <0)
System.out.println(" true");
else
System.out.println(" false");
}
else {
double k1 = (scan.getY1()-scan.getY2())/(scan.getX1()-scan.getX2());
double k2 = (scan.getY3()-scan.getY4())/(scan.getX3()-scan.getX4());
if(k1 == k2) {
System.out.println("is parallel lines,have no intersection point");
}
if(k1 != k2) {
double b1 = -k1*scan.getX1()+scan.getY1();
double b2 = -k2*scan.getX3()+scan.getY3();
double x = (b2-b1)/(k1-k2);
double y = k1*x-k1*scan.getX1()+scan.getY1();
System.out.print((float)x+","+(float)y);
if((x - scan.getX1())*(x-scan.getX2()) <0||(x - scan.getX3())*(x-scan.getX4()) <0)
System.out.println(" true");
else
System.out.println(" false");
}
}
}
if(mothod == 2)
System.out.println("wrong number of points");
}
}//方法
}//类
class scanner {//输入一组字符串
private int L = 0;
private String data = "";
private int pos [] = new int [100];
private double x1;
private double y1;
private double x2;
private double y2;
private double x3;
private double y3;
private double x4;
private double y4;
public scanner() {
super();
// TODO 自动生成的构造函数存根
}
public void scan() {
Scanner in = new Scanner(System.in);
data = in.nextLine();
L=data.length();
}
public int getlength() {
return L;
}
public String getData() {
return data;
}
public char getFirstchar() {
return data.charAt(0);
}
public double getX1() {
return x1;
}
public void setX1(double x1) {
this.x1 = x1;
}
public double getY1() {
return y1;
}
public void setY1(double y1) {
this.y1 = y1;
}
public double getX2() {
return x2;
}
public void setX2(double x2) {
this.x2 = x2;
}
public double getY2() {
return y2;
}
public void setY2(double y2) {
this.y2 = y2;
}
public double getX3() {
return x3;
}
public void setX3(double x3) {
this.x3 = x3;
}
public double getY3() {
return y3;
}
public void setY3(double y3) {
this.y3 = y3;
}
public double getX4() {
return x4;
}
public void setX4(double x4) {
this.x4 = x4;
}
public double getY4() {
return y4;
}
public void setY4(double y4) {
this.y4 = y4;
}
public int j() {
int j = 0,i = 2;
int add = 0,dot = 0,num = 0;
if(getData().charAt(0) =='1') {
if(getData().charAt(1) != ':')
return 0;//格式错误
for(;i<getlength();i ++) {
for(j = i;j<getlength();j++) {
if(getData().charAt(j) =='+'||getData().charAt(j) == '-')
add++;
if(getData().charAt(j) == '.')
dot++;
if(getData().charAt(j) != '.'&&(getData().charAt(j) != '+'&&getData().charAt(j) != '-')&&!Character.isDigit(getData().charAt(j))) {
i = j;
pos[num] = j;
num++;//表示找到了几组
break; //找到断点
}
if(getData().charAt(j) == '.'&&!Character.isDigit(getData().charAt(j+1)))
return 0;//格式错误
if((getData().charAt(j) == '+'||getData().charAt(j) == '-')&&j != i)
return 0;//格式错误
if(getData().charAt(j) == '0'&&j == i&&j+1<getlength()) {
if(Character.isDigit(getData().charAt(j+1)))
return 0;
}
}
if(j == getlength())
break;
if(add > 1||dot >1)
return 0;//格式错误
add = 0; dot =0;
if(num%2 == 0 &&getData().charAt(j) != ' ')
return 0;//格式错误
if(num%2 != 0 &&getData().charAt(j) !=',')
return 0;//格式错误
}
if(j == getlength()&&num == 3)
return 1;//表示格式正确，数据正确
else if(i == getlength()&&!Character.isDigit(getData().charAt(getlength()-1)))
return 0;
else if((num-3) %2 == 0&&num !=3)
return 2;//表示数据错误
else if(num %2 !=0 )
return 0;//表示格式错误
else
return 0;
}
else if(getData().charAt(0) =='2'||getData().charAt(0)=='3') {
if(getData().charAt(1) != ':')
return 0;//格式错误
for(;i<getlength();i ++) {
for(j = i;j<getlength();j++) {
if(getData().charAt(j) =='+'||getData().charAt(j) == '-')
add++;
if(getData().charAt(j) == '.')
dot++;
if(getData().charAt(j) != '.'&&(getData().charAt(j) != '+'&&getData().charAt(j) != '-')&&!Character.isDigit(getData().charAt(j))) {
i = j;
pos[num] = j;
num++;//表示找到了几组
break; //找到断点
}
if(getData().charAt(j) == '.'&&!Character.isDigit(getData().charAt(j+1)))
return 0;//格式错误
if((getData().charAt(j) == '+'||getData().charAt(j) == '-')&&j != i)
return 0;//格式错误
if(getData().charAt(j) == '0'&&j == i&&j+1<getlength()) {
if(Character.isDigit(getData().charAt(j+1)))
return 0;
}
}
if(j == getlength())
break;
if(add > 1||dot >1)
return 0;//格式错误
add = 0; dot =0;
if(num%2 == 0 &&getData().charAt(j) != ' ')
return 0;//格式错误
if(num%2 != 0 &&getData().charAt(j) !=',')
return 0;//格式错误
}
if(j == getlength()&&num == 5)
return 1;//表示格式正确，数据正确
else if(i == getlength()&&!Character.isDigit(getData().charAt(getlength()-1)))
return 0;
else if((num-3) %2 == 0&&num !=5)
return 2;//表示数据错误
else if(num %2 !=0 )
return 0;//表示格式错误
else
return 0;
}
else if(getData().charAt(0) =='4'||getData().charAt(0)=='5') {
if(getData().charAt(1) != ':')
return 0;//格式错误
for(;i<getlength();i ++) {
for(j = i;j<getlength();j++) {
if(getData().charAt(j) =='+'||getData().charAt(j) == '-')
add++;
if(getData().charAt(j) == '.')
dot++;
if(getData().charAt(j) != '.'&&(getData().charAt(j) != '+'&&getData().charAt(j) != '-')&&!Character.isDigit(getData().charAt(j))) {
i = j;
pos[num] = j;
num++;//表示找到了几组
break; //找到断点
}
if(getData().charAt(j) == '.'&&!Character.isDigit(getData().charAt(j+1)))
return 0;//格式错误
if((getData().charAt(j) == '+'||getData().charAt(j) == '-')&&j != i)
return 0;//格式错误
if(getData().charAt(j) == '0'&&j == i&&j+1<getlength()) {
if(Character.isDigit(getData().charAt(j+1)))
return 0;
}
}
if(j == getlength())
break;
if(add > 1||dot >1)
return 0;//格式错误
add = 0; dot =0;
if(num%2 == 0 &&getData().charAt(j) != ' ')
return 0;//格式错误
if(num%2 != 0 &&getData().charAt(j) !=',')
return 0;//格式错误
}
if(j == getlength()&&num == 7)
return 1;//表示格式正确，数据正确
else if(i == getlength()&&!Character.isDigit(getData().charAt(getlength()-1)))
return 0;
else if((num-3) %2 == 0&&num !=7)
return 2;//表示数据错误
else if(num %2 !=0 )
return 0;//表示格式错误
else
return 0;
}
else return 0;
}//方法的括号
public void get() {
String stringx1 ="";
String stringy1 ="";
String stringx2 ="";
String stringy2 ="";
String stringx3 ="";
String stringy3 ="";
String stringx4 ="";
String stringy4 ="";
if(getData().charAt(0)=='1') {
stringx1 = getData().substring(2,pos[0]);
stringy1 = getData().substring(pos[0]+1,pos[1]);
stringx2 = getData().substring(pos[1]+1,pos[2]);
stringy2 = getData().substring(pos[2]+1,getlength());
x1 = Double.valueOf(stringx1.toString());//将字符串转化为数字
y1 = Double.valueOf(stringy1.toString());//将字符串转化为数字
x2 = Double.valueOf(stringx2.toString());//将字符串转化为数字
y2 = Double.valueOf(stringy2.toString());//将字符串转化为数字
}
else if(getData().charAt(0)=='2'||getData().charAt(0)=='3') {
stringx1 = getData().substring(2,pos[0]);
stringy1 = getData().substring(pos[0]+1,pos[1]);
stringx2 = getData().substring(pos[1]+1,pos[2]);
stringy2 = getData().substring(pos[2]+1,pos[3]);
stringx3 = getData().substring(pos[3]+1,pos[4]);
stringy3 = getData().substring(pos[4]+1,getlength());
x1 = Double.valueOf(stringx1.toString());//将字符串转化为数字
y1 = Double.valueOf(stringy1.toString());//将字符串转化为数字
x2 = Double.valueOf(stringx2.toString());//将字符串转化为数字
y2 = Double.valueOf(stringy2.toString());//将字符串转化为数字
x3 = Double.valueOf(stringx3.toString());//将字符串转化为数字
y3 = Double.valueOf(stringy3.toString());//将字符串转化为数字
}
else if(getData().charAt(0)=='4'||getData().charAt(0)=='5') {
stringx1 = getData().substring(2,pos[0]);
stringy1 = getData().substring(pos[0]+1,pos[1]);
stringx2 = getData().substring(pos[1]+1,pos[2]);
stringy2 = getData().substring(pos[2]+1,pos[3]);
stringx3 = getData().substring(pos[3]+1,pos[4]);
stringy3 = getData().substring(pos[4]+1,pos[5]);
stringx4 = getData().substring(pos[5]+1,pos[6]);
stringy4 = getData().substring(pos[6]+1,getlength());
x1 = Double.valueOf(stringx1.toString());//将字符串转化为数字
y1 = Double.valueOf(stringy1.toString());//将字符串转化为数字
x2 = Double.valueOf(stringx2.toString());//将字符串转化为数字
y2 = Double.valueOf(stringy2.toString());//将字符串转化为数字
x3 = Double.valueOf(stringx3.toString());//将字符串转化为数字
y3 = Double.valueOf(stringy3.toString());//将字符串转化为数字
x4 = Double.valueOf(stringx4.toString());//将字符串转化为数字
y4 = Double.valueOf(stringy4.toString());//将字符串转化为数字
}
}
}//类的括号
View Code
其中的stringy1 = getData().substring(pos[0]+1,pos[1]);，这个时一个可以将其中的单独需要的内容提取出来，是比较方便的函数，同时我们还需要将其中的数字类型的字符出转换成double类型的数 字就需要用到一个函数Double.isvalueof()，这就可以将其中的内容，转换成Double类型的的数字
踩坑心得：其实在上面的设计思路中，我们就已经谈论到了，因为斜率不存在的问题，导致了我后面判断的时候写的很复杂，都是一直在讨论，强力推荐的大家好好的去构思一下，这个题目构思是非常重要的， 在写之前，一个单独的一点一点的将每一部分测试一下，就是比较好的方法，我再=在这里是吃了比较大的亏。
改进建议：这里面，改进的话，推荐大家采用一些叉乘的公式，这样就不用那么复杂的去讨论斜率存在，或者是不存在的问题，还不溶于出错，代码的行数比较少，特别好用，在写了这些题目后，才发现，真的 是，要想代码写的少，公式就要找的好，金玉良言。
设计ATM仿真系统，具体要求参见作业说明。
OO作业8-1题目说明.pdf
输入格式:
每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业务操作输入格式如下：
- 存款、取款功能输入数据格式：
卡号 密码 ATM机编号 金额（由一个或多个空格分隔），
其中，当金额大于0时，代表取款，否则代表存款。 - 查询余额功能输入数据格式：
卡号
输出格式:
①输入错误处理
- 如果输入卡号不存在，则输出
Sorry,this card does not exist.。 - 如果输入ATM机编号不存在，则输出
Sorry,the ATM's id is wrong.。 - 如果输入银行卡密码错误，则输出
Sorry,your password is wrong.。 - 如果输入取款金额大于账户余额，则输出
Sorry,your account balance is insufficient.。 - 如果检测为跨行存取款，则输出
Sorry,cross-bank withdrawal is not supported.。
②取款业务输出
输出共两行，格式分别为：
[用户姓名]在[银行名称]的[ATM编号]上取款¥[金额]
当前余额为¥[金额]
其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。
③存款业务输出
输出共两行，格式分别为：
[用户姓名]在[银行名称]的[ATM编号]上存款¥[金额]
当前余额为¥[金额]
其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。
④查询余额业务输出
¥[金额]
金额保留两位小数
设计思路：首先按照题目要求，构造出想要的类，对于每一个类，之间的方法，需要进行构思，对于一开始就没有设计好的好，产生了很多的重复代码，以至于代码长度会特别长，代码质量是不良的，所以我推 荐大家仅仅攻参考，这是像我这样学过c语言的人，比较难以摆脱的内容，需要慢慢向面向对象的方向进行走一走，设计时候，可以对于每个人的账号为一个类，采用继承的方式，每个人能的卡都继 承于同一个类，能够节省很多的重复的代码，实现代码的复用会好很多，而不是采用以每一个人来做一个类，我采用人的设计，导致后来产生了很多的问题
以下是源码（走了很多的弯路）：
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
operation op = new operation();
op.operate();
}
}
class operation {
datayang yang = new datayang();
dataguo guo = new dataguo();
datazhang zhang = new datazhang();
datawei wei = new datawei();
show sho = new show();
private String [] qq = new String [100];
private String q = "";
private int []size = new int [100];
public void operate() {
Scanner in = new Scanner(System.in);
int i = -1,j = -1;
int times = 0;
int []casee = new int [100];
while(true) {
i++;
qq[i] = in.nextLine();
size[i] = qq[i].length();
if(qq[i].equals("#"))
break;
}//先存储
while(true) {
j++;
if(qq[j].matches("^[0-9]{19}[ ]{1,}[0-9]{8}[ ]{1,}[0-9][0-9][ ]{1,}-?([1-9]\\d*.\\d*|0.\\d[1-9]\\d*)")) {
casee[j] = 1;times++;
}
else if(qq[j].matches("^[0-9]{19}")) {
casee[j] = 2;times++;
}
else if(qq[j].equals("#"))
break;
else
break;
}//再正则判断
for(j = 0;j < times;j++) {//j表示正确的数目
if(casee[j] == 1) {
// String x1 = qq[j].substring(0,19);//卡号
// String x2 = qq[j].substring(20,28);//密码
// String x3 = qq[j].substring(29,31);//机器
// String x4 = qq[j].substring(32,size[j]);//钱
String []x = qq[j].split("\\s+");
double money = Double.valueOf(x[3]);
String a = String.format("%.2f", money);
money = Double.valueOf(a);
if(x[0].equals(yang.getCard1())||x[0].equals(yang.getCard2())) {
if(x[1].equals("88888888")) {
if(x[2].equals("01")||x[2].equals("02")||x[2].equals("03")||x[2].equals("04")) {
if(money<=yang.getLastMoney1()) {
yang.setLastMoney1(yang.getLastMoney1()-money);
sho.showData1_1(yang, x[2], money);
}
else
System.out.println("Sorry,your account balance is insufficient.");
}
else if(x[2].equals("05")||x[2].equals("06"))
System.out.println("Sorry,cross-bank withdrawal is not supported.");
else
System.out.println("Sorry,the ATM's id is wrong.");
}
else
System.out.println("Sorry,your password is wrong.");
}
/*------------------------------*/
else if(x[0].equals(yang.getCard3())) {
if(x[1].equals("88888888")) {
if(x[2].equals("01")||x[2].equals("02")||x[2].equals("03")||x[2].equals("04")) {
if(money<=yang.getLastMoney2()) {
yang.setLastMoney2(yang.getLastMoney2()-money);
sho.showData1_3(yang, x[2], money);
}
else
System.out.println("Sorry,your account balance is insufficient.");
}
else if(x[2].equals("05")||x[2].equals("06"))
System.out.println("Sorry,cross-bank withdrawal is not supported.");
else
System.out.println("Sorry,the ATM's id is wrong.");
}
else
System.out.println("Sorry,your password is wrong.");
}
/*-----------------------------*/
else if(x[0].equals(guo.getCard2())) {
if(x[1].equals("88888888")) {
if(x[2].equals("01")||x[2].equals("02")||x[2].equals("03")||x[2].equals("04")) {
if(money<=guo.getLastMoney()) {
guo.setLastMoney(guo.getLastMoney()-money);
sho.showData2_1(guo, x[2], money);
}
else
System.out.println("Sorry,your account balance is insufficient.");
}
else if(x[2].equals("05")||x[2].equals("06"))
System.out.println("Sorry,cross-bank withdrawal is not supported.");
else
System.out.println("Sorry,the ATM's id is wrong.");
}
else
System.out.println("Sorry,your password is wrong.");
}
/*-------------------------------*/
else if(x[0].equals(zhang.getCard1())) {
if(x[1].equals("88888888")) {
if(x[2].equals("05")||x[2].equals("06")) {
if(money<=zhang.getLastMoney1()) {
zhang.setLastMoney1(zhang.getLastMoney1()-money);
sho.showData3_1(zhang, x[2], money);
}
else
System.out.println("Sorry,your account balance is insufficient.");
}
else if(x[2].equals("01")||x[2].equals("02")||x[2].equals("03")||x[2].equals("04"))
System.out.println("Sorry,cross-bank withdrawal is not supported.");
else
System.out.println("Sorry,the ATM's id is wrong.");
}
else
System.out.println("Sorry,your password is wrong.");
}
/*------------------------------*/
else if(x[0].equals(zhang.getCard2())) {
if(x[1].equals("88888888")) {
if(x[2].equals("05")||x[2].equals("06")) {
if(money<=zhang.getLastMoney2()) {
zhang.setLastMoney2(zhang.getLastMoney2()-money);
sho.showData3_3(zhang, x[2], money);
}
else
System.out.println("Sorry,your account balance is insufficient.");
}
else if(x[2].equals("01")||x[2].equals("02")||x[2].equals("03")||x[2].equals("04"))
System.out.println("Sorry,cross-bank withdrawal is not supported.");
else
System.out.println("Sorry,the ATM's id is wrong.");
}
else
System.out.println("Sorry,your password is wrong.");
}
/*-----------------------*/
else if(x[0].equals(zhang.getCard3())||x[0].equals(zhang.getCard4())) {
if(x[1].equals("88888888")) {
if(x[2].equals("05")||x[2].equals("06")) {
if(money<=zhang.getLastMoney3()) {
zhang.setLastMoney3(zhang.getLastMoney3()-money);
sho.showData3_5(zhang, x[2], money);
}
else
System.out.println("Sorry,your account balance is insufficient.");
}
else if(x[2].equals("01")||x[2].equals("02")||x[2].equals("03")||x[2].equals("04"))
System.out.println("Sorry,cross-bank withdrawal is not supported.");
else
System.out.println("Sorry,the ATM's id is wrong.");
}
else
System.out.println("Sorry,your password is wrong.");
}
/*----------------------------*/
else if(x[0].equals(wei.getCard1())) {
if(x[1].equals("88888888")) {
if(x[2].equals("05")||x[2].equals("06")) {
if(money<=wei.getLastMoney1()) {
wei.setLastMoney1(wei.getLastMoney1()-money);
sho.showData4_1(wei, x[2], money);
}
else
System.out.println("Sorry,your account balance is insufficient.");
}
else if(x[2].equals("01")||x[2].equals("02")||x[2].equals("03")||x[2].equals("04"))
System.out.println("Sorry,cross-bank withdrawal is not supported.");
else
System.out.println("Sorry,the ATM's id is wrong.");
}
else
System.out.println("Sorry,your password is wrong.");
}
/*------------------------------*/
else if(x[0].equals(wei.getCard2())) {
if(x[1].equals("88888888")) {
if(x[2].equals("05")||x[2].equals("06")) {
if(money<wei.getLastMoney2()) {
wei.setLastMoney2(wei.getLastMoney2()-money);
sho.showData4_3(wei, x[2], money);
}
else
System.out.println("Sorry,your account balance is insufficient.");
}
else if(x[2].equals("01")||x[2].equals("02")||x[2].equals("03")||x[2].equals("04"))
System.out.println("Sorry,cross-bank withdrawal is not supported.");
else
System.out.println("Sorry,the ATM's id is wrong.");
}
else
System.out.println("Sorry,your password is wrong.");
}
else
System.out.println("Sorry,this card does not exist.");
}
if(casee[j] == 2) {
String x1 = qq[j].substring(0,19);//卡号
if(x1.equals(yang.getCard1())||x1.equals(yang.getCard2()))
sho.showData1_2(yang);
else if(x1.equals(yang.getCard3()))
sho.showData1_4(yang);
else if(x1.equals(guo.getCard2()))
sho.showData2_2(guo);
else if(x1.equals(zhang.getCard1()))
sho.showData3_2(zhang);
else if(x1.equals(zhang.getCard2()))
sho.showData3_4(zhang);
else if(x1.equals(zhang.getCard3())||x1.equals(zhang.getCard4()))
sho.showData3_6(zhang);
else if(x1.equals(wei.getCard1()))
sho.showData4_2(wei);
else if(x1.equals(wei.getCard2()))
sho.showData4_4(wei);
else
System.out.println("Sorry,this card does not exist.");
}
}
}
}
class show {
public void showData1_1(datayang information,String machine,double num){
if(num>0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上取款¥"+new DecimalFormat("0.00").format(num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney1()));
}
else if(num<0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上存款¥"+new DecimalFormat("0.00").format(-num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney1()));
}
}
public void showData1_2(datayang information){
System.out.println("¥"+new DecimalFormat("0.00").format(information.getLastMoney1()));
}
//////////////////
public void showData1_3(datayang information,String machine,double num){
if(num>0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上取款¥"+new DecimalFormat("0.00").format(num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney2()));
}
else if(num<0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上存款¥"+new DecimalFormat("0.00").format(-num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney2()));
}
}
public void showData1_4(datayang information){
System.out.println("¥"+new DecimalFormat("0.00").format(information.getLastMoney2()));
}
///////////////////////
public void showData2_1(dataguo information,String machine,double num){
if(num>0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上取款¥"+new DecimalFormat("0.00").format(num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney()));
}
else if(num<0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上存款¥"+ new DecimalFormat("0.00").format(-num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney()));
}
}
public void showData2_2(dataguo information){
System.out.println("¥"+new DecimalFormat("0.00").format(information.getLastMoney()));
}
///////////////////////
public void showData3_1(datazhang information,String machine,double num){
if(num>0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上取款¥"+new DecimalFormat("0.00").format(num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney1()));
}
else if(num<0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上存款¥"+new DecimalFormat("0.00").format(-num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney1()));
}
}
public void showData3_2(datazhang information){
System.out.println("¥"+new DecimalFormat("0.00").format(information.getLastMoney1()));
}
///////////////////////
public void showData3_3(datazhang information,String machine,double num){
new DecimalFormat("0.00").format(num);
new DecimalFormat("0.00").format(information.getLastMoney2());
if(num>0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上取款¥"+new DecimalFormat("0.00").format(num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney2()));
}
else if(num<0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上存款¥"+new DecimalFormat("0.00").format(-num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney2()));
}
}
public void showData3_4(datazhang information){
System.out.println("¥"+new DecimalFormat("0.00").format(information.getLastMoney2()));
}
////////////////
public void showData3_5(datazhang information,String machine,double num){
if(num>0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上取款¥"+new DecimalFormat("0.00").format(num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney3()));
}
else if(num<0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上存款¥"+new DecimalFormat("0.00").format(-num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney3()));
}
}
public void showData3_6(datazhang information){
System.out.println("¥"+new DecimalFormat("0.00").format(information.getLastMoney3()));
}
//////////////////////
public void showData4_1(datawei information,String machine,double num){
new DecimalFormat("0.00").format(num);
new DecimalFormat("0.00").format(information.getLastMoney1());
if(num>0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上取款¥"+new DecimalFormat("0.00").format(num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney1()));
}
else if(num<0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上存款¥"+new DecimalFormat("0.00").format(-num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney1()));
}
}
public void showData4_2(datawei information){
System.out.println("¥"+new DecimalFormat("0.00").format(information.getLastMoney1()));
}
//////////////////////
public void showData4_3(datawei information,String machine,double num){
new DecimalFormat("0.00").format(num);
new DecimalFormat("0.00").format(information.getLastMoney2());
if(num>0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上取款¥"+new DecimalFormat("0.00").format(num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney2()));
}
else if(num<0) {
System.out.println(information.getName()+"在"+information.getBank()+"的"+machine+"号ATM机上存款¥"+new DecimalFormat("0.00").format(-num));
System.out.println("当前余额为¥"+new DecimalFormat("0.00").format(information.getLastMoney2()));
}
}
public void showData4_4(datawei information){
System.out.println("¥"+new DecimalFormat("0.00").format(information.getLastMoney2()));
}
}
class datayang {
private String name = "杨过";
private String bank = "中国建设银行";
private double lastMoney1 = 10000;
private double lastMoney2 = 10000;
private String bankCard1 = "3217000010041315709" ;
private String bankCard2 = "3217000010041315709" ;
private String card1 = "6217000010041315709";
private String card2 = "6217000010041315715";
private String card3 = "6217000010041315718";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getBank() {
return bank;
}
public void setBank(String bank) {
this.bank = bank;
}
public double getLastMoney1() {
return lastMoney1;
}
public void setLastMoney1(double lastMoney1) {
this.lastMoney1 = lastMoney1;
}
public double getLastMoney2() {
return lastMoney2;
}
public void setLastMoney2(double lastMoney2) {
this.lastMoney2 = lastMoney2;
}
public String getBankCard1() {
return bankCard1;
}
public void setBankCard1(String bankCard1) {
this.bankCard1 = bankCard1;
}
public String getBankCard2() {
return bankCard2;
}
public void setBankCard2(String bankCard2) {
this.bankCard2 = bankCard2;
}
public String getCard1() {
return card1;
}
public void setCard1(String card1) {
this.card1 = card1;
}
public String getCard2() {
return card2;
}
public void setCard2(String card2) {
this.card2 = card2;
}
public String getCard3() {
return card3;
}
public void setCard3(String card3) {
this.card3 = card3;
}
}
class dataguo {
private String name= "郭靖";
private String bank = "中国建设银行";
private double lastMoney = 10000;
private String bankCard = "3217000010051320007" ;
private String card2 = "6217000010051320007";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getBank() {
return bank;
}
public void setBank(String bank) {
this.bank = bank;
}
public double getLastMoney() {
return lastMoney;
}
public void setLastMoney(double lastMoney) {
this.lastMoney = lastMoney;
}
public String getBankCard() {
return bankCard;
}
public void setBankCard(String bankCard) {
this.bankCard = bankCard;
}
public String getCard2() {
return card2;
}
public void setCard2(String card2) {
this.card2 = card2;
}
}
class datazhang {
private String name = "张无忌";
private String bank = "中国工商银行";
private double lastMoney1 = 10000;
private double lastMoney2 = 10000;
private double lastMoney3 = 10000;
private String bankCard1 = "3222081502001312389" ;
private String bankCard2 = "3222081502001312390" ;
private String bankCard3 = "3222081502001312399" ;
private String card1 = "6222081502001312389";
private String card2 = "6222081502001312390";
private String card3 = "6222081502001312399";
private String card4 = "6222081502001312400";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getBank() {
return bank;
}
public void setBank(String bank) {
this.bank = bank;
}
public double getLastMoney1() {
return lastMoney1;
}
public void setLastMoney1(double lastMoney1) {
this.lastMoney1 = lastMoney1;
}
public double getLastMoney2() {
return lastMoney2;
}
public void setLastMoney2(double lastMoney2) {
this.lastMoney2 = lastMoney2;
}
public double getLastMoney3() {
return lastMoney3;
}
public void setLastMoney3(double lastMoney3) {
this.lastMoney3 = lastMoney3;
}
public String getBankCard1() {
return bankCard1;
}
public void setBankCard1(String bankCard1) {
this.bankCard1 = bankCard1;
}
public String getBankCard2() {
return bankCard2;
}
public void setBankCard2(String bankCard2) {
this.bankCard2 = bankCard2;
}
public String getBankCard3() {
return bankCard3;
}
public void setBankCard3(String bankCard3) {
this.bankCard3 = bankCard3;
}
public String getCard1() {
return card1;
}
public void setCard1(String card1) {
this.card1 = card1;
}
public String getCard2() {
return card2;
}
public void setCard2(String card2) {
this.card2 = card2;
}
public String getCard3() {
return card3;
}
public void setCard3(String card3) {
this.card3 = card3;
}
public String getCard4() {
return card4;
}
public void setCard4(String card4) {
this.card4 = card4;
}
}
class datawei {
private String name = "韦小宝";
private String bank = "中国工商银行";
private double lastMoney1 = 10000;
private double lastMoney2 = 10000;
private String bankCard1 = "3222081502051320785" ;
private String bankCard2 = "3222081502051320786" ;
private String card1 = "6222081502051320785";
private String card2 = "6222081502051320786";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getBank() {
return bank;
}
public void setBank(String bank) {
this.bank = bank;
}
public double getLastMoney1() {
return lastMoney1;
}
public void setLastMoney1(double lastMoney1) {
this.lastMoney1 = lastMoney1;
}
public double getLastMoney2() {
return lastMoney2;
}
public void setLastMoney2(double lastMoney2) {
this.lastMoney2 = lastMoney2;
}
public String getBankCard1() {
return bankCard1;
}
public void setBankCard1(String bankCard1) {
this.bankCard1 = bankCard1;
}
public String getBankCard2() {
return bankCard2;
}
public void setBankCard2(String bankCard2) {
this.bankCard2 = bankCard2;
}
public String getCard1() {
return card1;
}
public void setCard1(String card1) {
this.card1 = card1;
}
public String getCard2() {
return card2;
}
public void setCard2(String card2) {
this.card2 = card2;
}
}
View Code
踩坑新得：从上述可以看出来，这个类图十分混乱，而且，每一个里面的内容字段特别多，里面设计非常不合理，不推荐大家使用，包括里面还有很多的重复代码，十分不好，希望大家能够先罗列出一些好的 计方案，再去施行，这样才是对滴，别直接动手，最后花费的时间还会更多，设计好了在以后，还可以把以前的代码，再次拿来使用，这是比较好的方向，对于我们这些初学者，还是先设计，因为， 我们学习的java就是面向对象的设计，类与类之间就是要解除耦合，这样才能够在以后方便拓展和复用。
改进方案：采用继承的方式，将其中的重复的类进行继承，比如说，其中的每一个人的账户很多的内容都是相同的，我们可以了解一些继承的内容，然后去对这些账户内容复用，能够大大减少代码的行数，实现 好的代码。
-
设计一个类表示平面直角坐标系上的点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)方法。
设计思路：设计出一个Line类和Point类，其中，在Point类中进行输入，每次输入一个点，在Line类中创建两个Point的对象j,就可以实现，输入两个点，在每一个类中都存在独自的方法，比如说计算距离的 getDistance()，和disPlay()这样的方法，该题目相对于来说较为简单，比较好实现。
以下是源代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner in = new Scanner(System.in);
double x1 = in.nextDouble();
double y1 = in.nextDouble();
double x2 = in.nextDouble();
double y2 = in.nextDouble();
String color = in.next();
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,color);
line.display();
}
else
System.out.println("Wrong Format");
}
}
class Line {
private Point point1 = new Point();
private Point point2 = new Point();
private String color = "";
public Line() {
super();
// TODO 自动生成的构造函数存根
}
public Line(Point point1, Point point2, String color) {
super();
this.point1 = point1;
this.point2 = point2;
this.color = color;
}
public Point getPoint1() {
return point1;
}
public void setPoint1(Point point1) {
this.point1 = point1;
}
public Point getPoint2() {
return point2;
}
public void setPoint2(Point point2) {
this.point2 = point2;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getDistance() {
double distance = Math.sqrt(Math.pow(point1.getX() - point2.getX(),2) + Math.pow(point1.getY() - point2.getY(),2));
return distance;
}
public void display() {
System.out.println("The line's color is:" + color);
System.out.println("The line's begin point's Coordinate is:");
point1.display();
System.out.println("The line's end point's Coordinate is:");
point2.display();
System.out.printf("The line's length is:");
System.out.printf(String.format("%.2f", getDistance()));
}
}
class Point {
private double x = 0;
private double y = 0;
public Point() {
super();
// TODO 自动生成的构造函数存根
}
public Point(double x, double y) {
super();
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("(");
System.out.printf(String.format("%.2f", x));
System.out.printf(",");
System.out.printf(String.format("%.2f", y));
System.out.printf(")");
System.out.println("");
}
}
View Code
踩坑心得：不太清楚什么in.nextLine()，无法输入，一开始没有找到缺点，最后发现后改成了in.next()，就可以了，我也不知道是为什么，同时要对每一个点都要进行判断条件(0,200]，一开始就没有太注意，导 致犯了很严重的错误，自己也没有发现，希望大家能够，在写代码的时候，考虑完全，别丢三落四，忘掉了很多的条件，导致自己都不知道自己错在哪里了。这也是程序员比较忌讳的东西。
在“点与线（类设计）”题目基础上，对题目的类设计进行重构，以实现继承与多态的技术性需求。
- 对题目中的点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()；
设计思路：按照类图的要求，我们只需要在上一题的代码上进行迭代，就可以了。增加了一个plane的面类，将前三个都继承与Element类，三者都继承了Element的display方法，并且都进行了重写，实现了多态
在输出的时候，要使用向上转型，实现多态，一个对象做同一件事的不同效果，多态特性。
以下是源代码：写的还好吧，可以看看。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner in = new Scanner(System.in);
double x1 = in.nextDouble();
double y1 = in.nextDouble();
double x2 = in.nextDouble();
double y2 = in.nextDouble();
String color = in.next();
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);
Plane plane = new Plane(color);
Line line = new Line(point1,point2,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 Line extends Element{
private Point point1 = new Point();
private Point point2 = new Point();
private String color = "";
public Line() {
super();
// TODO 自动生成的构造函数存根
}
public Line(Point point1, Point point2, String color) {
super();
this.point1 = point1;
this.point2 = point2;
this.color = color;
}
public Point getPoint1() {
return point1;
}
public void setPoint1(Point point1) {
this.point1 = point1;
}
public Point getPoint2() {
return point2;
}
public void setPoint2(Point point2) {
this.point2 = point2;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getDistance() {
double distance = Math.sqrt(Math.pow(point1.getX() - point2.getX(),2) + Math.pow(point1.getY() - point2.getY(),2));
return distance;
}
public void display() {
System.out.println("The line's color is:" + color);
System.out.println("The line's begin point's Coordinate is:");
point1.display();
System.out.println("The line's end point's Coordinate is:");
point2.display();
System.out.printf("The line's length is:");
System.out.println(String.format("%.2f", getDistance()));
}
}
class Point extends Element{
private double x = 0;
private double y = 0;
public Point() {
super();
// TODO 自动生成的构造函数存根
}
public Point(double x, double y) {
super();
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("(");
System.out.printf(String.format("%.2f", x));
System.out.printf(",");
System.out.printf(String.format("%.2f", y));
System.out.printf(")");
System.out.println("");
}
}
abstract class Element {
public abstract void display();
}
class Plane extends Element{
private String color = "";
public Plane() {
super();
// TODO 自动生成的构造函数存根
}
public Plane(String color) {
super();
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void display() {
System.out.printf("The Plane's color is:" + color);
}
}
View Code
踩坑心得：说实话，这个题目，没什么坑，认真去写，多考虑以下，也就能够完成了。
在“点与线（继承与多态）”题目基础上，对题目的类设计进行重构，增加容器类保存点、线、面对象，并对该容器进行相应增、删、遍历操作。
- 在原有类设计的基础上，增加一个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()方法进行输出。
设计思路：在原有类设计的基础上，增加一个GeometryObject容器类，其属性为ArrayList<Element>类型的对象，其中里面设计出一个add和remove的方法，其实这个容器类，是java自带的比 较好用，可以多去了解一下，然后去使用一下，就可以实现
以下是源代码：
import java.util.Scanner;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner in = new Scanner(System.in);
GeometryObject geometryObject = new GeometryObject();
int choice = in.nextInt();
while(choice != 0) {
switch(choice) {
case 1:{//insert Point object into list 输入“点”对象的x，y值
double x1 = in.nextDouble();
double y1 = in.nextDouble();
if(x1 > 0&&x1 <= 200 &&y1 > 0&&y1 <= 200 ) {
Point point1 = new Point(x1,y1);
geometryObject.add(point1);
}
else
System.out.println("Wrong Format");
}
break;
case 2:{//insert Line object into list输入“线”对象两个端点的x，y值
double x1 = in.nextDouble();
double y1 = in.nextDouble();
double x2 = in.nextDouble();
double y2 = in.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);
String color = in.next();
Line line = new Line(point1,point2,color);
geometryObject.add(line);
}
else
System.out.println("Wrong Format");
}
break;
case 3:{//insert Plane object into list输入“面”对象的颜色值
String color = in.next();
Plane plane = new Plane(color);
geometryObject.add(plane);
}
break;
case 4:{//delete index - 1 object from list输入要删除的对象位置（从1开始） ...
int index = in.nextInt();
geometryObject.remove(index);
}
}
choice = in.nextInt();
}
for(Element e : geometryObject.getList()) {
e.display();
}
}
}
class Line extends Element{
private Point point1 = new Point();
private Point point2 = new Point();
private String color = "";
public Line() {
super();
// TODO 自动生成的构造函数存根
}
public Line(Point point1, Point point2, String color) {
super();
this.point1 = point1;
this.point2 = point2;
this.color = color;
}
public Point getPoint1() {
return point1;
}
public void setPoint1(Point point1) {
this.point1 = point1;
}
public Point getPoint2() {
return point2;
}
public void setPoint2(Point point2) {
this.point2 = point2;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getDistance() {
double distance = Math.sqrt(Math.pow(point1.getX() - point2.getX(),2) + Math.pow(point1.getY() - point2.getY(),2));
return distance;
}
public void display() {
System.out.println("The line's color is:" + color);
System.out.println("The line's begin point's Coordinate is:");
point1.display();
System.out.println("The line's end point's Coordinate is:");
point2.display();
System.out.printf("The line's length is:");
System.out.println(String.format("%.2f", getDistance()));
}
}
class Point extends Element{
private double x = 0;
private double y = 0;
public Point() {
super();
// TODO 自动生成的构造函数存根
}
public Point(double x, double y) {
super();
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("(");
System.out.printf(String.format("%.2f", x));
System.out.printf(",");
System.out.printf(String.format("%.2f", y));
System.out.printf(")");
System.out.println("");
}
}
abstract class Element {
public abstract void display();
}
class Plane extends Element{
private String color = "";
public Plane() {
super();
// TODO 自动生成的构造函数存根
}
public Plane(String color) {
super();
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void display() {
System.out.println("The Plane's color is:" + color);
}
}
class GeometryObject {
private ArrayList <Element> list = new ArrayList<>();
public GeometryObject() {
super();
// TODO 自动生成的构造函数存根
}
public void add(Element element) {
list.add(element);
}
public void remove(int index) {
if(index > 0&& index < list.size())
list.remove(index - 1);
}
public ArrayList<Element> getList() {
return list;
}
}
View Code
踩坑心得：对于ArrayList这个类，我掌握的不好，导致在这个上面花了很多的时间，最终还是没有怎么实现好，这是很麻烦的事情，希望大家能够先去将Array List这个类了解是什么，如何使用，会使用后，就能 够很熟练的掌握这些内容了
java链表的实现：单向链表和双向链表
很多的都是需要大家自己去理解的，难以讲解清楚：
package test47;
public interface DoubleListInterface<E> {
public boolean isEmpty();
public int getSize();
public E get(int index);
public void remove(int index);
public void add(int index, E theElement);
public void add(E element);
public void printList();
public E getFirst();
public E getLast();
}
package test47;
public class LList<E> implements DoubleListInterface<E> {
private Node<E> head;// 头结点（非第一个节点），当前节点，尾节点
private Node<E> curr;
private Node<E> tail;
private int size = 0;
public LList() {
super();
// TODO Auto-generated constructor stub
head = new Node<E>();
head.setNext(null);
head.setPrevious(null);
curr = tail = null;
this.size = 0;
}
@Override
public boolean isEmpty() {
// TODO Auto-generated method stub
return this.size == 0;
}
@Override
public int getSize() {
// TODO Auto-generated method stub
return this.size;
}
@Override
public E get(int index) {//查找
// TODO Auto-generated method stub
if(index < 1 || index > this.size) {
return null;
}
curr = head;
for(int i = 0; i < index; i ++) {
curr = curr.getNext();
}
return curr.getData();
}
@Override
public void remove(int index) {
// TODO Auto-generated method stub
if(index < 1 || index > this.size) {
return ;
}
curr = head;
if(index == 1) {
curr.getNext().setPrevious(head);
curr = head.getNext();
head.setNext(curr.getNext());
}else {//找到第index - 1个节点赋给curr
for(int i = 1;i < index; i++) {
curr = curr.getNext();
}
curr.getNext().getNext().setPrevious(curr);
curr.setNext(curr.getNext().getNext());
}
if(index == this.size) {//如果删除的是最后一个节点
tail = curr;
}
this.size --;//整个链表的节点数量-1
}
@Override
public void add(int index, E theElement) {//指定位置添加
// TODO Auto-generated method stub
if(index < 1 || index > this.size + 1) {
return ;
}
Node<E> curr = new Node<>();
curr.setData(theElement);
curr.setNext(null);
curr.setPrevious(null);
if(this.size == 0) {
head.setNext(curr);
tail = curr;
curr.setPrevious(head);
}else if(index == this.size + 1) {
this.tail.setNext(curr);
curr.setPrevious(tail);
tail = curr;
}else {
Node<E> tempNode = head;
for(int i = 1; i < index;i++) {
tempNode = tempNode.getNext();
}
curr.setNext(tempNode.getNext());
tempNode.getNext().setPrevious(curr);
curr.setPrevious(tempNode);
tempNode.setNext(curr);
// for(int i = size ; i >= index ; i-- ) {
// tail.getFront() =
// }
}
this.size ++;
}
@Override
public void add(E element) {
// TODO Auto-generated method stub
this.add(this.size + 1,element);
}
@Override
public void printList() {
// TODO Auto-generated method stub
curr = head.getNext();
for(int i = 1; i <= this.size;i ++) {
System.out.print(curr.getData() + " ");
curr = curr.getNext();
}
System.out.println("");
}
public E getLast() {
if(this.size != 0) {
return tail.getData();
}
return null;
}
public E getFirst() {
if(this.size != 0) {
return head.getNext().getData();
}
return null;
}package test47;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
LList<Integer> list = new LList<>();
list.add(2);
list.add(4);
list.add(6);
list.add(8);
list.printList();
list.remove(3);
list.printList();
list.add(2,100);
list.printList();
System.out.println(list.get(4));
}
}
package test47;
//Node
public class Node<E> {
private Node<E> previous;
private E data;
private Node<E> next;
public Node() {
}
public Node(E data, Node<E> next,Node<E> previous) {
super();
this.data = data;
this.next = next;
this.previous = previous;
}
public E getData() {
return data;
}
public void setData(E data) {
this.data = data;
}
public Node<E> getNext() {
return next;
}
public void setNext(Node<E> next) {
this.next = next;
}
public Node<E> getPrevious() {
return previous;
}
public void setPrevious(Node<E> previous) {
this.previous = previous;
}
}
}
双向链表
package asdfnz;
public class main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
List<String> list = new List<String>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
// list.printList();
list.remove(1);
list.add(3,"asd");
list.printList();
}
}
interface LinearListInterface<E> {
public boolean isEmpty();
public int size();
public E get(int index);
public void remove(int index);
public void add(int index, E theElement);
public void add(E element);
public void printList();
}
//LinkedList class
class LList<E>{
private Node<E> head,curr,tail;
private int size;
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
}
//Node
class Node<E>{
private E o;
private Node<E> next;
public E getO() {
return o;
}
public void setO(E o) {
this.o = o;
}
public Node<E> getNext() {
return next;
}
public void setNext(Node<E> next) {
this.next = next;
}
}
class List<E> implements LinearListInterface<E>{
private Node<E> head = new Node<E>();
private Node<E> curr = new Node<E>();
private Node<E> tail = new Node<E>();
int length = 0;
@Override
public boolean isEmpty() {
if(curr.getO() == null)
return true;
else
return false;
}
@Override
public int size() {
return 0;
}
@Override
public E get(int index) {
if(curr.getO() != null )
return curr.getO();
else
return null;
}
@Override
public void remove(int index) {//表示删除
Node<E> p = new Node<E>();
int i = 1;
if(head != tail) {
for(i = 1,p = head ;p != tail ; i++ , p = p.getNext()) {
if(i == index &&index == 1&&p.getNext() != null) {
head = p.getNext();
break;
}
else if(i == index-1 &&index != 1&&p.getNext().getNext() != null){
p.setNext(p.getNext().getNext());
break;
}
else if(i == index-1 &&index != 1&&p.getNext().getNext() == null){
tail = p;
break;
}
}
}
else {
head = null;
}
}
@Override
public void add(int index, E theElement) {//表示指定位置增加
//需要跳转节点
Node p = new Node();
Node q = new Node();
q.setO(theElement);
int i = 1;
if(head != tail)
for(i = 1,p = head ; p!=tail ; i++ , p = p.getNext()) {
if(index == 1&&i == index) {
head = q;
break;
}
else if(index != 1&& i == index-1) {
q.setNext(p.getNext());
p.setNext(q);
break;
}
else if(i == index-1 &&index != 1&&p.getNext().getNext() == null) {
tail.setNext(q);
q.setNext(null);
break;
}
}
}
@Override
public void add(E element) {//从最后面增加
Node curr1= new Node();
curr1.setO(element);
curr = curr1;
if(head.getO()== null) {
head = curr;
tail = curr;
head.setNext(null);
}
else {
tail.setNext(curr);
tail = curr;
tail.setNext(null);
}
}
@Override
public void printList() {
Node<E> p = new Node<E>();
if(head != tail) {
for( p = head;p != tail ;p = p.getNext() ) {
System.out.println(p.getO());
}
System.out.println(tail.getO());
}
else if(head == tail)
System.out.println(head.getO());
}
}
单向链表
说实话，下面这道题是最难的一道题，困扰了我很久，最后都没有完成，大家可以先浅看一下题目：
用户输入一组选项和数据，进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
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"
设计思路：对于一开始的那几道题，我的其中的很多的东西在这里是无法使用，因为设计的不好，代码比较长，包括判断，这个代码长度限制在了800行左右，难以实现，所以很多的代码，我都重 写了，并且能够用方法的全部使用了。设计思路是需要先用正则表达式判断是不是合法的输入，以及是不点重合，或者其中的点的数量是不是正确，这些都需要判断，其中，使用正则 表达式，只用了我几行代码，就完成了判断，这是一个比较好的方法：以下是判断的代码
String [] a = x.split(" ");
int i = 0;
if(a[0].matches("^[1-6][:]((-|[+])?(([1-9]+[0-9]{0,})|[0]))(\\.\\d+)?[,]((-|[+])?(([1-9]+[0-9]{0,})|[0]))(\\.\\d+)?") == true) {
for(i = 1 ; i < a.length ; i++) {
if(a[i].matches("^((-|[+])?(([1-9]+[0-9]{0,})|[0]))(\\.\\d+)?[,]((-|[+])?(([1-9]+[0-9]{0,})|[0]))(\\.\\d+)?") == false) {
System.out.print("Wrong Format");
System.exit(0);
}
}
if(i == a.length&& i != 1)
return i;//返回几个点]
else if(i == 1) {
System.out.print("wrong number of points");
System.exit(0);
}
}
else
System.out.print("Wrong Format");//存在一个超出范围的没有设置
return 0;
}
View Code
短短10行实现了多种类型的判断，同时也要使用循环判断的方式这样可以节省很多时间，还有提取数字的方法，也进行了修改，也从原来的单一方法变成了循环提取，这样又可以节省很多，将判断四 边形平行，四边形菱形，矩形正方形等，都单独设置一个方法，这样方便，以后调用，四边形的判断比较复杂，推荐在网上找好公式，不要自己轻易的去判断，很容易遗漏一些特殊的值，判断完是否 是四边形之后可以再次，在基础上判断是否是平行四边形，之后，在平行四边形的基础上，再次叠加判断菱形，矩形，正方形等，这是我们，编写代码之前必须做好的工作，判断是凸四边形还是凹四 边形的时候其实比较好判断，采用的方法对了，也就容易了，我们可以采用面积法，进行切割，这样可以很快的实现。嗯，进行到输入六个点坐标的时候就比较复杂了，新药判断是否是三角形或者构 成的点，是否是四边形，其中有很多是按顺序输入的，导致他可能会扭转在一起，这是一个比较难以判断的点，希望大家能够注意到，然后进行切割，判断面积，并计算出面积，输出面积，最后一点 是判断一个点是否在三角形或者四边形内，这还是可以采用面积法，这是比较容易的一次判断里面我们还需要一系列方法，比如说求两条直线的交点坐标，判断三点是否共线，这些都是需要我们单独 设立方法比较好的
以下是不完全代码：可以参考一下，大部分的内容还是实现了的。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner in = new Scanner(System.in);
String x = in.nextLine();
Judge judg = new Judge(x);
int chance = judg.judge();
double[] xy = new double[12];
xy = judg.getNum(chance);
if(x.charAt(0) == '1'){//第一种情况
if(chance == 4) {
if(judg.quadrabgle(xy) ==1) System.out.printf("true ");
else System.out.printf("false ");
if(judg.parallelogram(xy))System.out.println("true");
else System.out.println("false");
}
else
System.out.println("wrong number of points");
}
if(x.charAt(0) == '2') {
if(chance == 4) {
if(judg.quadrabgle(xy) == 0) {
System.out.print("not a quadrilateral");
System.exit(0);
}
if(judg.quadrabgle(xy) == 2) {
System.out.println("points coincide");
System.exit(0);
}
if(judg.rhombus(xy)) System.out.print("true ");
else System.out.print("false ");
if(judg.rectangle(xy)) System.out.print("true ");
else System.out.print("false ");
if(judg.square(xy)) System.out.println("true");
else System.out.println("false");
}
else
System.out.println("wrong number of points");
}
if(x.charAt(0) == '3') {
if(chance == 4) {
if(judg.quadrabgle(xy) == 0) {
System.out.print("not a quadrilateral");
System.exit(0);
}
double s1 = 0,s2 = 0,s3 = 0,s4 = 0;
s1 = Math.abs(xy[2]*xy[5]+xy[4]*xy[1]+xy[0]*xy[3]-xy[2]*xy[1]-xy[0]*xy[5]-xy[4]*xy[3]);//123
s2 = Math.abs(xy[2]*xy[7]+xy[6]*xy[1]+xy[0]*xy[3]-xy[2]*xy[1]-xy[0]*xy[7]-xy[6]*xy[3]);//124
s3 = Math.abs(xy[2]*xy[5]+xy[4]*xy[7]+xy[6]*xy[3]-xy[2]*xy[7]-xy[6]*xy[5]-xy[4]*xy[3]);//234
s4 = Math.abs(xy[4]*xy[7]+xy[6]*xy[1]+xy[0]*xy[5]-xy[4]*xy[1]-xy[0]*xy[7]-xy[6]*xy[5]);//134
double c = Math.sqrt(Math.pow(xy[0] - xy[2],2) + Math.pow(xy[1] - xy[3],2)) + Math.sqrt(Math.pow(xy[2] - xy[4],2) + Math.pow(xy[3] - xy[5],2))
+ Math.sqrt(Math.pow(xy[4] - xy[6],2) + Math.pow(xy[5] - xy[7],2)) + Math.sqrt(Math.pow(xy[0] - xy[6],2) + Math.pow(xy[1] - xy[7],2));
if(s1+s4 == s2+s3) {
System.out.print("true ");
System.out.print(Math.round(c*1000)/1000.0);
System.out.print(" ");
System.out.print(Math.round((s1 + s4)/2*1000)/1000.0);
}
else{
System.out.print("false ");
if(s1 + s4 < s2 + s3) {
System.out.print(Math.round(c*1000)/1000.0);
System.out.print(" ");
System.out.print(Math.round((s1 + s4)/2*1000)/1000.0 );
}
else {
System.out.print(Math.round(c*1000)/1000.0);
System.out.print(" ");
System.out.print(Math.round((s2 + s3)/2*1000)/1000.0);
}
}
}
else
System.out.println("Wrong Format");
}
if(x.charAt(0) == '5') {
if(chance == 5) {
judg.case5(xy);
}
else
System.out.println("Wrong Format");
}
if(x.charAt(0) == '4') {
if(chance == 6) {
judg.difficult(xy);
}
else
System.out.println("Wrong Format");
}
}
}
class Judge {
private String x;
private double [] num = new double[10];
public Judge(String x) {
super();
this.x = x;
}
public int judge() {
String [] a = x.split(" ");
int i = 0;
if(a[0].matches("^[1-6][:]((-|[+])?(([1-9]+[0-9]{0,})|[0]))(\\.\\d+)?[,]((-|[+])?(([1-9]+[0-9]{0,})|[0]))(\\.\\d+)?") == true) {
for(i = 1 ; i < a.length ; i++) {
if(a[i].matches("^((-|[+])?(([1-9]+[0-9]{0,})|[0]))(\\.\\d+)?[,]((-|[+])?(([1-9]+[0-9]{0,})|[0]))(\\.\\d+)?") == false) {
System.out.print("Wrong Format");
System.exit(0);
}
}
if(i == a.length&& i != 1)
return i;//返回几个点]
else if(i == 1) {
System.out.print("wrong number of points");
System.exit(0);
}
}
else
System.out.print("Wrong Format");//存在一个超出范围的没有设置
return 0;
}
public double[] getNum(int dot) {
String [] stringPlace = new String [12];
double [] place = new double [12];
int pos1 = 0;
int pos2 = 0;
String [] a = x.split(" ");//1:123,25;
for(int i = 1; ;i ++) {
if(x.charAt(i) == ',')
pos1 = i;
if(x.charAt(i) == ' ') {
pos2 = i;break;
}
}
stringPlace[0] = a[0].substring(2,pos1);
stringPlace[1] = a[0].substring(pos1+1,pos2);
for(int i = 1,j = 2;i < dot ;i ++,j = j + 2) {
String [] temp = a[i].split(",");
stringPlace[j] = temp[0];
stringPlace[j+1] = temp[1];
}
for(int i = 0 ;i < dot*2; i++) {
place[i] = Double.valueOf(stringPlace[i]);
}
return place;
}
public double pointX(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {
double x = -((x3-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y3-x3*y4))/((y3-y4)*(x1-x2)-(y1-y2)*(x3-x4));
return x;
}
public double pointY(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {//求焦点坐标
double y = -((y3-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x3-y3*x4))/((x3-x4)*(y1-y2)-(x1-x2)*(y3-y4));
return y;
}
public double getArea(double x1,double y1,double x2,double y2,double x3,double y3) {//已知三点求面积
double area = Math.abs(x2*y3 + x3*y1 + x1*y2 - x2*y1 - x1*y3 - x3*y2);
return area/2;
}
public double sumArea(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {//求四边形面积
double s1 = getArea(x1,y1,x2,y2,x3,y3);
double s2 = getArea(x1,y1,x3,y3,x4,y4);
double s3 = getArea(x1,y1,x2,y2,x4,y4);
double s4 = getArea(x2,y2,x3,y3,x4,y4);
if(s1 + s2 <= s3 +s4)
return s1 + s2;
else {
return s3 + s4;
}
}
public boolean judgejudge(double X,double Y,double x1,double y1,double x2,double y2) {
if((X-x1)*(X-x2) < 0&&(Y-y1)*(Y-y2) <= 0 ||(X-x1)*(X-x2) <= 0&&(Y-y1)*(Y-y2) < 0)
return true;
else
return false;
}
public int triangle(double xy[]) {
if(quadrabgle(xy) == 0||quadrabgle(xy) == 2) {//首先不是四边形
double d1 = getArea(xy[0],xy[1],xy[2],xy[3],xy[4],xy[5]);//123
double d2 = getArea(xy[0],xy[1],xy[2],xy[3],xy[6],xy[7]);//124
double d3 = getArea(xy[2],xy[3],xy[4],xy[5],xy[6],xy[7]);//234
double d4 = getArea(xy[0],xy[1],xy[4],xy[5],xy[6],xy[7]);//134
if(d1 == 0&&d2 !=0 && (judgejudge(xy[2],xy[3],xy[0],xy[1],xy[3],xy[4])||(xy[0] == xy[2]&&xy[1] == xy[3]||xy[4] == xy[2]&&xy[5] == xy[3]))){
return 1;
}
else if(d3 == 0&&d2 !=0 && (judgejudge(xy[4],xy[5],xy[2],xy[3],xy[6],xy[7])||(xy[2] == xy[4]&&xy[3] == xy[5]||xy[6] == xy[4]&&xy[7] == xy[5]))){
return 2;
}
else if(d4 == 0&&d1 !=0 && (judgejudge(xy[6],xy[7],xy[0],xy[1],xy[4],xy[5])||(xy[0] == xy[6]&&xy[1] == xy[7]||xy[4] == xy[6]&&xy[5] == xy[7]))){
return 3;
}
else if(d2 == 0&&d4 !=0 && (judgejudge(xy[0],xy[1],xy[2],xy[3],xy[6],xy[7])||(xy[2] == xy[0]&&xy[3] == xy[1]||xy[6] == xy[0]&&xy[7] == xy[1]))){
return 4;
}
else
return 0;
}
else
return 0;
}
public int quadrabgle(double xy[]) {//判断四边形
double x1 = pointX(xy[0],xy[1],xy[2],xy[3],xy[4],xy[5],xy[6],xy[7]);
double y1 = pointY(xy[0],xy[1],xy[2],xy[3],xy[4],xy[5],xy[6],xy[7]);
double x2 = pointX(xy[0],xy[1],xy[6],xy[7],xy[2],xy[3],xy[4],xy[5]);
double y2 = pointY(xy[0],xy[1],xy[6],xy[7],xy[2],xy[3],xy[4],xy[5]);
if((xy[0] == xy[2]&&xy[1] == xy[3])||(xy[2] == xy[4]&&xy[3] == xy[5])||(xy[4] == xy[6]&&xy[5] == xy[7])||(xy[0] == xy[6]&&xy[1] == xy[7])) {
return 2;
}
else if(getArea(xy[0],xy[1],xy[2],xy[3],xy[4],xy[5]) == 0 ||getArea(xy[0],xy[1],xy[2],xy[3],xy[6],xy[7]) == 0 ||
getArea(xy[6],xy[7],xy[2],xy[3],xy[4],xy[5]) == 0 ||getArea(xy[0],xy[1],xy[3],xy[4],xy[6],xy[7]) == 0 )
return 0;
else if(getArea(xy[4],xy[5],xy[0],xy[1],xy[2],xy[3]) == getArea(xy[6],xy[7],xy[0],xy[1],xy[2],xy[3])&&getArea(xy[2],xy[3],xy[0],xy[1],xy[6],xy[7]) != getArea(xy[4],xy[5],xy[0],xy[1],xy[6],xy[7])&&
(judgejudge(x2,y2,xy[2],xy[3],xy[4],xy[5])==true||judgejudge(x1,y1,xy[0],xy[1],xy[6],xy[7])==true)) //12和34平行
return 0;
else if(getArea(xy[4],xy[5],xy[0],xy[1],xy[2],xy[3]) != getArea(xy[6],xy[7],xy[0],xy[1],xy[2],xy[3])&&getArea(xy[2],xy[3],xy[0],xy[1],xy[6],xy[7]) == getArea(xy[4],xy[5],xy[0],xy[1],xy[6],xy[7])&&
(judgejudge(x2,y2,xy[2],xy[3],xy[4],xy[5])==true&&judgejudge(x1,y1,xy[0],xy[1],xy[6],xy[7])==true)) //14和23平行
return 0;
else if(getArea(xy[4],xy[5],xy[0],xy[1],xy[2],xy[3]) == getArea(xy[6],xy[7],xy[0],xy[1],xy[2],xy[3])&&getArea(xy[2],xy[3],xy[0],xy[1],xy[6],xy[7]) == getArea(xy[4],xy[5],xy[0],xy[1],xy[6],xy[7])) {
double x = pointX(xy[0],xy[1],xy[6],xy[7],xy[2],xy[3],xy[4],xy[5]);
double y = pointY(xy[0],xy[1],xy[6],xy[7],xy[2],xy[3],xy[4],xy[5]);
if(judgejudge(x,y,xy[0],xy[1],xy[6],xy[7])==true)
return 0;
else
return 1;
}
else if((judgejudge(x1,y1,xy[0],xy[1],xy[2],xy[3])==false&&judgejudge(x1,y1,xy[4],xy[5],xy[6],xy[7])==false)||(judgejudge(x2,y2,xy[2],xy[3],xy[4],xy[5])==false&&judgejudge(x1,y1,xy[0],xy[1],xy[6],xy[7])==false)) {
double d1 = getArea(xy[0],xy[1],xy[2],xy[3],xy[4],xy[5]);//123
double d2 = getArea(xy[0],xy[1],xy[2],xy[3],xy[6],xy[7]);//124
double d3 = getArea(xy[2],xy[3],xy[4],xy[5],xy[6],xy[7]);//234
double d4 = getArea(xy[0],xy[1],xy[4],xy[5],xy[6],xy[7]);//134
if(d1 != 0&&d2 != 0&&d3 != 0&&d4 != 0)
return 1;
else
return 0;
}
else
return 0;
}
public boolean parallelogram(double xy[]) {//判断平行四边形
if(quadrabgle(xy) == 1 ) {
double a = Math.pow((xy[0]-xy[2]),2)+Math.pow((xy[1]-xy[3]),2);
double b = Math.pow((xy[2]-xy[4]),2)+Math.pow((xy[3]-xy[5]),2);
double c = Math.pow((xy[4]-xy[6]),2)+Math.pow((xy[5]-xy[7]),2);
double d = Math.pow((xy[6]-xy[0]),2)+Math.pow((xy[7]-xy[1]),2);
if(a == c&&b == d)
return true;
else
return false;
}
else
return false;
}
public boolean rhombus(double xy[]) {//判断是菱形
if(parallelogram(xy) == true) {
double a = Math.pow((xy[0]-xy[2]),2)+Math.pow((xy[1]-xy[3]),2);
double b = Math.pow((xy[2]-xy[4]),2)+Math.pow((xy[3]-xy[5]),2);
double c = Math.pow((xy[4]-xy[6]),2)+Math.pow((xy[5]-xy[7]),2);
double d = Math.pow((xy[6]-xy[0]),2)+Math.pow((xy[7]-xy[1]),2);
if(a == b&&a == d)
return true;
else
return false;
}
else
return false;
}
public boolean rectangle(double xy[]) {//判断是矩形
if(parallelogram(xy) == true) {
double oppo1 = Math.pow((xy[0]-xy[4]),2)+Math.pow((xy[1]-xy[5]),2);
double oppo2 = Math.pow((xy[2]-xy[6]),2)+Math.pow((xy[3]-xy[7]),2);
if(oppo1 == oppo2)
return true;
else
return false;
}
else
return false;
}
public boolean square(double xy[]) {//判断是正方形
if(rectangle(xy) == true) {
double a = Math.pow((xy[0]-xy[2]),2)+Math.pow((xy[1]-xy[3]),2);
double b = Math.pow((xy[2]-xy[4]),2)+Math.pow((xy[3]-xy[5]),2);
if(a == b)
return true;
else
return false;
}
else
return false;
}
public boolean highAndShort(double xy[]) {//判断凸凹四边形：true是凸的，false是凹的
if(quadrabgle(xy) == 1 ) {
double s1 = 0,s2 = 0,s3 = 0,s4 = 0;
s1 = Math.abs(xy[2]*xy[5]+xy[4]*xy[1]+xy[0]*xy[3]-xy[2]*xy[1]-xy[0]*xy[5]-xy[4]*xy[3]);//123
s2 = Math.abs(xy[2]*xy[7]+xy[6]*xy[1]+xy[0]*xy[3]-xy[2]*xy[1]-xy[0]*xy[7]-xy[6]*xy[3]);//124
s3 = Math.abs(xy[2]*xy[5]+xy[4]*xy[7]+xy[6]*xy[3]-xy[2]*xy[7]-xy[6]*xy[5]-xy[4]*xy[3]);//234
s4 = Math.abs(xy[4]*xy[7]+xy[6]*xy[1]+xy[0]*xy[5]-xy[4]*xy[1]-xy[0]*xy[7]-xy[6]*xy[5]);//134
if(s1+s4 == s2+s3)
return true;
else
return false;
}
else
return false;
}
public void case5(double XY[]) {
double xy[] = {XY[2],XY[3],XY[4],XY[5],XY[6],XY[7],XY[8],XY[9]};
if(quadrabgle(xy) == 1) {
double d1 = getArea(XY[0],XY[1],xy[0],xy[1],xy[2],xy[3]);
double d2 = getArea(XY[0],XY[1],xy[2],xy[3],xy[4],xy[5]);
double d3 = getArea(XY[0],XY[1],xy[4],xy[5],xy[6],xy[7]);
double d4 = getArea(XY[0],XY[1],xy[6],xy[7],xy[0],xy[1]);
double s = sumArea(xy[0],xy[1],xy[2],xy[3],xy[4],xy[5],xy[6],xy[7]);
if((d1 == 0 ||d2 == 0 ||d3 == 0 ||d4 == 0 )&&(s == d1 + d2 + d3 + d4))
System.out.println("on the quadrilateral");
else if(s == d1 + d2 + d3 + d4)
System.out.println("in the quadrilateral");
else
System.out.println("outof the quadrilateral");
}
else if(triangle(xy) == 1) {
double d1 = getArea(XY[0],XY[1],xy[0],xy[1],xy[4],xy[5]);
double d2 = getArea(XY[0],XY[1],xy[0],xy[1],xy[6],xy[7]);
double d3 = getArea(XY[0],XY[1],xy[4],xy[5],xy[6],xy[7]);
double s = getArea(xy[0],xy[1],xy[4],xy[5],xy[6],xy[7]);
if((d1 == 0 ||d2 == 0 ||d3 == 0 )&&s == d1 + d2 + d3 )
System.out.println("on the triangle");
else if(s == d1 + d2 + d3 )
System.out.println("in the triangle");
else
System.out.println("outof the triangle");
}
else if(triangle(xy) == 2) {
double d1 = getArea(XY[0],XY[1],xy[0],xy[1],xy[2],xy[3]);
double d2 = getArea(XY[0],XY[1],xy[2],xy[3],xy[6],xy[7]);
double d3 = getArea(XY[0],XY[1],xy[0],xy[1],xy[6],xy[7]);
double s = getArea(xy[0],xy[1],xy[2],xy[3],xy[6],xy[7]);
if((d1 == 0 ||d2 == 0 ||d3 == 0 )&&s == d1 + d2 + d3 )
System.out.println("on the triangle");
else if(s == d1 + d2 + d3 )
System.out.println("in the triangle");
else
System.out.println("outof the triangle");
}
else if(triangle(xy) == 3) {
double d1 = getArea(XY[0],XY[1],xy[0],xy[1],xy[2],xy[3]);
double d2 = getArea(XY[0],XY[1],xy[0],xy[1],xy[4],xy[5]);
double d3 = getArea(XY[0],XY[1],xy[2],xy[3],xy[4],xy[5]);
double s = getArea(xy[0],xy[1],xy[2],xy[3],xy[4],xy[5]);
if((d1 == 0 ||d2 == 0 ||d3 == 0 )&&s == d1 + d2 + d3 )
System.out.println("on the triangle");
else if(s == d1 + d2 + d3 )
System.out.println("in the triangle");
else
System.out.println("outof the triangle");
}
else if(triangle(xy) == 4) {
double d1 = getArea(XY[0],XY[1],xy[2],xy[3],xy[6],xy[7]);
double d2 = getArea(XY[0],XY[1],xy[2],xy[3],xy[4],xy[5]);
double d3 = getArea(XY[0],XY[1],xy[4],xy[5],xy[6],xy[7]);
double s = getArea(xy[2],xy[3],xy[4],xy[5],xy[6],xy[7]);
if((d1 == 0 ||d2 == 0 ||d3 == 0 )&&s == d1 + d2 + d3 )
System.out.println("on the triangle");
else if(s == d1 + d2 + d3 )
System.out.println("in the triangle");
else
System.out.println("outof the triangle");
}
else
System.out.println("not a quadrilateral or triangle");
}
public void difficult(double XY[]) {//这里面有6个点，需要将前两个排除
double [] xy ={XY[4],XY[5],XY[6],XY[7],XY[8],XY[9],XY[10],XY[11]};//可能存在问题
if(XY[0] == XY[3]&&XY[1] == XY[4]) {//前面两个点重合
System.out.println("points coincide");
System.exit(0);
}
if(quadrabgle(xy) == 1) {//如果是四边形
//点到直线的距离，存在四条
double s = sumArea(xy[0],xy[1],xy[2],xy[3],xy[4],xy[5],xy[6],xy[7]);//求四边形面积
double d1 = getArea(XY[0],XY[1],XY[2],XY[3],xy[0],xy[1]);//1
double d2 = getArea(XY[0],XY[1],XY[2],XY[3],xy[2],xy[3]);//2
double d3 = getArea(XY[0],XY[1],XY[2],XY[3],xy[4],xy[5]);//3
double d4 = getArea(XY[0],XY[1],XY[2],XY[3],xy[6],xy[7]);//4
int num12 = 0,num23 = 0,num34 = 0,num41 = 0,sum = 0;
//求焦点坐标
double X1 = pointX(XY[0],XY[1],XY[2],XY[3],xy[0],xy[1],xy[2],xy[3]);
double Y1 = pointY(XY[0],XY[1],XY[2],XY[3],xy[0],xy[1],xy[2],xy[3]);//12
double X2 = pointX(XY[0],XY[1],XY[2],XY[3],xy[2],xy[3],xy[4],xy[5]);
double Y2 = pointY(XY[0],XY[1],XY[2],XY[3],xy[2],xy[3],xy[4],xy[5]);//23
double X3 = pointX(XY[0],XY[1],XY[2],XY[3],xy[4],xy[5],xy[6],xy[7]);
double Y3 = pointY(XY[0],XY[1],XY[2],XY[3],xy[4],xy[5],xy[6],xy[7]);//34
double X4 = pointX(XY[0],XY[1],XY[2],XY[3],xy[6],xy[7],xy[0],xy[1]);
double Y4 = pointY(XY[0],XY[1],XY[2],XY[3],xy[6],xy[7],xy[0],xy[1]);//41
//判断是否在线段内
if(judgejudge(X1,Y1,xy[0],xy[1],xy[2],xy[3]))//判断有几个焦点
num12++;//与12
if(judgejudge(X2,Y2,xy[2],xy[3],xy[4],xy[5]))
num23++;//23
if(judgejudge(X3,Y3,xy[4],xy[5],xy[6],xy[7]))
num34++;//34
if(judgejudge(X4,Y4,xy[6],xy[7],xy[0],xy[1]))
num41++;//41
sum = num12 + num23 + num34 + num41;
if((d1 == 0&&d4 == 0)||(d1 == 0&&d2 == 0)||(d2 == 0&&d3 == 0)||(d3 == 0&&d4 == 0)) {//表示两条线重合了
System.out.println("The line is coincide with one of the lines");
System.exit(0);
}
else if(d1 != 0&&d2 != 0&&d3 != 0&&d4 != 0) {//表示与顶点一个都不相交
System.out.println(sum);
if(num12 == 1&&num23 == 1&&num41 == 0&&num41 == 0) {
double s1 = getArea(X1,Y1,X2,Y2,xy[2],xy[3]);
System.out.print(s1 + " ");
System.out.println(s - s1);
System.exit(0);
}
else if(num23 == 1&&num34 == 1&&num41 == 0&& num12 == 0) {
double s1 = getArea(X2,Y2,X3,Y3,xy[4],xy[5]);
System.out.print(s1 + " ");
System.out.println(s - s1);
System.exit(0);
}
else if(num34 == 1&&num41 == 1&& num12 == 0&& num23 == 0) {
double s1 = getArea(X3,Y3,X4,Y4,xy[6],xy[7]);
System.out.print(s1 + " ");
System.out.println(s - s1);
System.exit(0);
}
else if(num41 == 1&&num12 == 1&& num23 == 0&& num34 == 0) {
double s1 = getArea(X4,Y4,X1,Y1,xy[0],xy[1]);
System.out.print(s1 + " ");
System.out.println(s - s1);
System.exit(0);
}
else if(num12 == 1&&num34 == 1&&num23 == 0&&num41 == 0) {//形成两个四边形
double s1 = sumArea(X1,Y1,X3,Y3,xy[0],xy[1],xy[6],xy[7]);
double s2 = sumArea(X1,Y1,X3,Y3,xy[2],xy[3],xy[4],xy[5]);
if(s1 <= s2) {
System.out.print(s1 + " ");
System.out.println(s - s1);
}
else {
System.out.print(s2 + " ");
System.out.println(s - s2);
}
}
else if(num23 == 1&&num41 == 1&&num12 == 0&&num34 == 0) {
double s1 = sumArea(X2,Y2,X4,Y4,xy[0],xy[1],xy[2],xy[3]);
double s2 = sumArea(X2,Y2,X4,Y4,xy[4],xy[5],xy[6],xy[7]);
if(s1 <= s2) {
System.out.print(s1 + " ");
System.out.println(s - s1);
}
else {
System.out.print(s2 + " ");
System.out.println(s - s2);
}
}
}
else if(d1 == 0&&d3 == 0||d2 == 0&&d4 == 0) {//存在连个端点相交,就是对角线相交
double s1 = 0,s2 = 0,s3 = 0,s4 = 0;
s1 = Math.abs(xy[2]*xy[5]+xy[4]*xy[1]+xy[0]*xy[3]-xy[2]*xy[1]-xy[0]*xy[5]-xy[4]*xy[3]);//123
s2 = Math.abs(xy[2]*xy[7]+xy[6]*xy[1]+xy[0]*xy[3]-xy[2]*xy[1]-xy[0]*xy[7]-xy[6]*xy[3]);//124
s3 = Math.abs(xy[2]*xy[5]+xy[4]*xy[7]+xy[6]*xy[3]-xy[2]*xy[7]-xy[6]*xy[5]-xy[4]*xy[3]);//234
s4 = Math.abs(xy[4]*xy[7]+xy[6]*xy[1]+xy[0]*xy[5]-xy[4]*xy[1]-xy[0]*xy[7]-xy[6]*xy[5]);//134
System.out.println("2");
if(highAndShort(xy)) {
System.out.print(s/2+" ");
System.out.println(s/2);
}
else if(!highAndShort(xy)&&d1 == 0&&d3 == 0) {
if(s1+s4 > s2+s3) {
System.out.print(s/2+" ");
System.out.println(s/2);
}
}
else if(!highAndShort(xy)&&d2 == 0&&d4 == 0) {
if(s1+s4 < s2+s3) {
System.out.print(s/2+" ");
System.out.println(s/2);
}
}
}
//只存在一个端点
else if(d1 == 0&&d2 != 0&&d3 != 0&&d4 != 0) {//并且要与四边形有两个交点
System.out.println(sum);
if(num23 == 1 && num12 == 0&& num34 ==0 &&num41 == 0) {
double s1 = getArea(xy[0],xy[1],xy[2],xy[3],X2,Y2);
double s2 = s - s1;
if(s1 <= s2) {
System.out.print(s1 + " ");
System.out.println(s - s1);
}
else {
System.out.print(s2 + " ");
System.out.println(s - s2);
}
}
if(num34 == 1&&num12 == 0&& num23 ==0 &&num41 == 0) {
double s1 = getArea(xy[0],xy[1],xy[6],xy[7],X3,Y3);
double s2 = s - s1;
if(s1 <= s2) {
System.out.print(s1 + " ");
System.out.println(s - s1);
}
else {
System.out.print(s2 + " ");
System.out.println(s - s2);
}
}
}
else if(d1 != 0&&d2 == 0&&d3 != 0&&d4 != 0) {//并且要与四边形有两个交点
System.out.println(sum);
if(num34 == 1&&num12 == 0&& num23 ==0 &&num41 == 0) {
double s1 = getArea(xy[2],xy[3],xy[4],xy[5],X3,Y3);
double s2 = s - s1;
if(s1 <= s2) {
System.out.print(s1 + " ");
System.out.println(s - s1);
}
else {
System.out.print(s2 + " ");
System.out.println(s - s2);
}
}
if(num41 == 1&&num12 == 0&& num23 ==0 &&num34 == 0) {
double s1 = getArea(xy[0],xy[1],xy[2],xy[3],X4,Y4);
double s2 = s - s1;
if(s1 <= s2) {
System.out.print(s1 + " ");
System.out.println(s - s1);
}
else {
System.out.print(s2 + " ");
System.out.println(s - s2);
}
}
}
else if(d1 != 0&&d2 != 0&&d3 == 0&&d4 != 0) {//并且要与四边形有两个交点
System.out.println(sum);
if(num12 == 1&&num23 == 0&& num34 ==0 &&num41 == 0) {
double s1 = getArea(xy[2],xy[3],xy[4],xy[5],X1,Y1);
double s2 = s - s1;
if(s1 <= s2) {
System.out.print(s1 + " ");
System.out.println(s - s1);
}
else {
System.out.print(s2 + " ");
System.out.println(s - s2);
}
}
if(num41 == 1&&num12 == 0&& num23 ==0 &&num34 == 0) {
double s1 = getArea(xy[4],xy[5],xy[6],xy[7],X4,Y4);
double s2 = s - s1;
if(s1 <= s2) {
System.out.print(s1 + " ");
System.out.println(s - s1);
}
else {
System.out.print(s2 + " ");
System.out.println(s - s2);
}
}
}
else if(d1 != 0&&d2 != 0&&d3 != 0&&d4 == 0) {//并且要与四边形有两个交点
System.out.println(sum);
if(num12 == 1&&num23 == 0&& num34 ==0 &&num41 == 0) {
double s1 = getArea(xy[6],xy[7],xy[0],xy[1],X1,Y1);
double s2 = s - s1;
if(s1 <= s2) {
System.out.print(s1 + " ");
System.out.println(s - s1);
}
else {
System.out.print(s2 + " ");
System.out.println(s - s2);
}
}
if(num23 == 1&&num12 == 0&& num34 ==0 &&num41 == 0) {
double s1 = getArea(xy[6],xy[7],xy[4],xy[5],X2,Y2);
double s2 = s - s1;
if(s1 <= s2) {
System.out.print(s1 + " ");
System.out.println(s - s1);
}
else {
System.out.print(s2 + " ");
System.out.println(s - s2);
}
}
}
}
}
}
View Code
踩坑心得：刚开始的四边形的公式就用错了，并且还自己判断特别复杂，推荐不要自己判断，并且，一定要先设计好第四个点的思路，这个会很复杂，对于细节，一定要实现好，我就是第四个没有实现完全，推 荐大家多多去考虑。很多的公式要使用那种不需要考虑斜率的，这个是非常有必要的。
总结：在这段时间的学习中，更多的是需要改变C语言的写法，从C语言中走向面向对象设计，实现很多方法的使用，也多多使用继承和多态，这样可以实现代码的复用，能够大大减少代码的数量，同时也要改 变当初的写程序的方法，比如说以前都是直接拿起来写，我们需要，刚开始就设计好，可以大大减少时间，而不是盲目的去写，思路上也变清晰了在这里，我们学习了很多，比如说继承多态，向上转型， 向下转型，以及很多字符串的用法，还有正则表达式，这是一个比较好的方法，值得去推荐，相比于之前来说，现在对于类与类之间的设计，变得更加清晰明确，对于面向对象设计也越来越近，希望自己 能够以后更加努力加油，也希望大家能够一起加油！
标签：总结,题目,scan,double,System,else,xy,out 来源： https://www.cnblogs.com/en-em-em/p/16213070.html