7-1 sdut-String-2 识蛟龙号载人深潜，立科技报国志（II）（正则表达式） 分数 10 作者 周雪芹 单位 山东理工大学
背景简介：
“蛟龙号”载人深潜器是我国首台自主设计、自主集成研制的作业型深海载人潜水器，设计最大下潜深度为7000米级，也是目前世界上下潜能力最强的作业型载人潜水器。“蛟龙号”可在占世界海洋面积99.8%的广阔海域中使用，对于我国开发利用深海的资源有着重要的意义。
中国是继美、法、俄、日之后世界上第五个掌握大深度载人深潜技术的国家。在全球载人潜水器中，“蛟龙号”属于第一梯队。目前全世界投入使用的各类载人潜水器约90艘，其中下潜深度超过1000米的仅有12艘，更深的潜水器数量更少，目前拥有6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯。除中国外，其他4国的作业型载人潜水器最大工作深度为日本深潜器的6527米，因此“蛟龙号”载人潜水器在西太平洋的马里亚纳海沟海试成功到达7020米海底，创造了作业类载人潜水器新的世界纪录。
从2009年至2012年，蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功。下潜至7000米，说明蛟龙号载人潜水器集成技术的成熟，标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一。
2012年6月27日11时47分，中国“蛟龙”再次刷新“中国深度”——下潜7062米。6月3日，“蛟龙”出征以来，已经连续书写了5个“中国深度”新纪录：6月15日，6671米；6月19日，6965米；6月22日，6963米；6月24日，7020米；6月27日，7062米。下潜至7000米，标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力，标志着“蛟龙”载人潜水器集成技术的成熟，标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一，标志着中国海底载人科学研究和资源勘探能力达到国际领先水平。
‘蛟龙’号是我国载人深潜发展历程中的一个重要里程碑。它不只是一个深海装备，更代表了一种精神，一种不畏艰险、赶超世界的精神，它是中华民族进军深海的号角。
了解蛟龙号”载人深潜器“的骄人业绩，为我国海底载人科学研究和资源勘探能力达到国际领先水平而自豪，小伙伴们与祖国同呼吸、共命运，一定要学好科学文化知识、提高个人能力，增强创新意识，做事精益求精，立科技报国之志！
请编写程序，实现如下功能：读入关于蛟龙号载人潜水器探测数据的多行字符串，从给定的信息找出数字字符，输出每行的数字之和。
提示 若输入为“2012年2月”，则该行的输出为：2014。若干个连续的数字字符作为一个整体，以十进制形式相加。
输入格式:
读入关于蛟龙号载人潜水器探测数据的多行字符串，每行字符不超过80个字符。
以"end"结束。
输出格式:
与输入行相对应的各个整数之和。
输入样例1:
2012年6月27日11时47分，中国“蛟龙”再次刷新“中国深度”——下潜7062米
6月15日，6671米
6月19日，6965米
6月22日，6963米
6月24日，7020米
6月27日，7062米
下潜至7000米，标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力
end输出样例1:
9165
6692
6990
6991
7050
7095
7099输入样例2:
全世界投入使用的各类载人潜水器约90艘，下潜深度超过1000米的仅有12艘，更深的潜水器数量更少
6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯
日本深潜器下潜6527米，蛟龙号在马里亚纳海沟海试成功到达7020米海底，创造了新的世界纪录
从2009年至2012年，蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功
下潜至7000米，说明蛟龙号载人潜水器集成技术的成熟
end输出样例2:
1102
6000
13547
20021
7000该题考查对于正则表达式的运用，可以使用一个Pattern类加一个正则表达式作为模板去限制他，因为这题需要从文本中搜寻数字，所以pattern的正则应该是(\\d)+，即Pattern p=Pattern.compile("(\\d)+");有了模板使用Matcher类去寻找满足Pattern中正则表达式模板的字符串，存入group(0)中。group(1)会记录当前所搜寻字符串的下标的下一位，如果使用循环不断搜寻，Matcher会从group(1)中下标的地方继续寻找，从而达到搜寻每一个满足模板的字符串。核心代码如下:
Pattern p=Pattern.compile("(\\d)+");
String s=input.nextLine();
while(!s.equals("end")){
int number=0;
Matcher m=p.matcher(s);
while(m.find()){
number+=Integer.parseInt(m.group(0));
}
System.out.println(number);
s=input.nextLine();
}用户输入一组选项和数据，进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入四个点坐标，判断是否是四边形、平行四边形，判断结果输出true/false，结果之间以一个英文空格符分隔。
2：输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
3：输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
4：输入六个点坐标，前两个点构成一条直线，后四个点构成一个四边形或三角形，输出直线与四边形（也可能是三角形）相交的交点数量。如果交点有两个，再按面积从小到大输出四边形(或三角形)被直线分割成两部分的面积（不换行）。若直线与四边形或三角形的一条边线重合，输出"The line is coincide with one of the lines"。若后四个点不符合四边形或三角形的输入，输出"not a quadrilateral or triangle"。
后四个点构成三角形的情况：假设三角形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z 不与xy都相邻，如z x y s、x z s y、x s z y
5：输入五个点坐标，输出第一个是否在后四个点所构成的四边形（限定为凸四边形，不考虑凹四边形）或三角形（判定方法见选项4）的内部（若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the triangle/outof the triangle）。如果点在多边形的某条边上，输出"on the triangle或者on the quadrilateral"。若后四个点不符合四边形或三角形，输出"not a quadrilateral or triangle"。
输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
注意：输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0
选项1、2、3中，若四边形四个点中有重合点，输出"points coincide"。
选项4中，若前两个输入线的点重合，输出"points coincide"。
输入样例1:
选项1，点重合。例如：
1:-1,-1 -1,-1 1,2 1,-2输出样例:
在这里给出相应的输出。例如：
points coincide输入样例2:
不符合基本格式。例如：
1:-1,-1 1,2 -1,1 ++1,0输出样例:
在这里给出相应的输出。例如：
Wrong Format输入样例3:
选项1，输入点数量不对。例如：
1:-1,-1 -1,2 输出样例:
在这里给出相应的输出。例如：
wrong number of points输入样例4:
选项1，正确输入判断。例如：
1:-1,-1 -1,1 1,2 1,-2输出样例:
在这里给出相应的输出。例如：
true false输入样例5:
选项2，输入点不构成四边形。例如：
2:10,10 1,1 0,0 1,20输出样例:
在这里给出相应的输出。例如：
not a quadrilateral输入样例6:
选项2，正方形。例如：
2:0,0 0,80 80,80 80,0输出样例:
在这里给出相应的输出。例如：
true true true输入样例7:
选项2。例如：
2:0,0 -10,80 0,160 -10,80输出样例:
在这里给出相应的输出。例如：
not a quadrilateral输入样例8:
选项3，凸四边形。例如：
3:-1,-1 -1,1 1,2 1,-2输出样例:
在这里给出相应的输出。例如：
true 10.472 6.0输入样例9:
选项3，。例如：
3:0,0 -10,100 0,99 10,100输出样例:
在这里给出相应的输出。例如：
false 221.097 990.0
所以在判定是否为四边形时，需要考虑这种情况。判断是否为平行四边形就相对简单了，只需要判定两组对边平行即可。选项1相关代码如下：
boolean JudgeQuadrilateral(){
if(this.p1.JudgeSuperposition(this.p2)||this.p1.JudgeSuperposition(this.p3) ||
this.p1.JudgeSuperposition(this.p4)||this.p2.JudgeSuperposition(p3)||
this.p2.JudgeSuperposition(p4)||this.p3.JudgeSuperposition(p4))
return false;
if(l1.parallel(l2)||l2.parallel(l3)||l3.parallel(l4)||l4.parallel(l1))
return false;
if(!this.l1.LineSegment(l3)&&!this.l2.LineSegment(l4))
return true;
else
return false;
}
boolean JudgeParallelogram(){
boolean whether=false;
if(l1.parallel(l3)&&l2.parallel(l4))
whether= true;
return whether;
}选项2，需要判断他是否为菱形、矩形和正方形。如果无法构成四边形，则输出"not a quadrilateral"。只需要先判断是否构成四边形，如果构成四边形，则先判定是否为菱形。菱形的判定条件只需要判断4条边长度相等即可。判断其为矩形，通过初中知识可知，我们只需要先判定其是平行四边形，在5证明有一个角是直角就可以求证出他为矩形。所以调用判断他是否为平行四边形的函数判定一次，在通过计算相邻两条边的向量点乘是否为0判断直角。如果点乘为0则说明该角为直角。判断正方形只需要同时满足是矩形和菱形即可。选项2相关代码如下：
boolean JudgeLozenge(){
double d1,d2,d3,d4;
d1=Math.sqrt(Math.pow((this.p1.x-this.p2.x),2)+Math.pow((this.p1.y-this.p2.y),2));
d2=Math.sqrt(Math.pow((this.p2.x-this.p3.x),2)+Math.pow((this.p2.y-this.p3.y),2));
d3=Math.sqrt(Math.pow((this.p3.x-this.p4.x),2)+Math.pow((this.p3.y-this.p4.y),2));
d4=Math.sqrt(Math.pow((this.p4.x-this.p1.x),2)+Math.pow((this.p4.y-this.p1.y),2));
if(Math.abs(d1-d2)<1e-3&&Math.abs(d1-d3)<1e-3&&Math.abs((d1-d4))<1e-3)
return true;
else
return false;
}
boolean JudgeRectangle(){
if(!JudgeParallelogram())
return false;
else{
double x1,x2,y1,y2;
x1=this.p1.x-this.p2.x;
y1=this.p1.y-this.p2.y;
x2=this.p2.x-this.p3.x;
y2=this.p2.y-this.p3.y;
if(x1*x2+y1*y2==0)
return true;
else
return false;
}
}
boolean JudgeSquare(){
if(JudgeRectangle()&&JudgeLozenge())
return true;
else
return false;
}选项3我用的方法就很烂了，先判断他是否为凹四边形。如下图所示：
如果是凹四边形，他会满足3个3点组成的三角形的面积和等于一个最大的三角形。如果是上图则是S▲123+S▲134+S▲234=S▲124。如图：
而该四边形的面积就是S▲124-S▲234。如果是凸四边形面积即对角三角形面积和。选项3相关代码如下：
void JudgeOutofSide(){
double s1,s2,s3,s4;
double d1,d2,d3,d4;
d1=Math.sqrt(Math.pow((this.p1.x-this.p2.x),2)+Math.pow((this.p1.y-this.p2.y),2));
d2=Math.sqrt(Math.pow((this.p2.x-this.p3.x),2)+Math.pow((this.p2.y-this.p3.y),2));
d3=Math.sqrt(Math.pow((this.p3.x-this.p4.x),2)+Math.pow((this.p3.y-this.p4.y),2));
d4=Math.sqrt(Math.pow((this.p4.x-this.p1.x),2)+Math.pow((this.p4.y-this.p1.y),2));
s1=Area(this.p1,this.p2,this.p4);
s2=Area(this.p2,this.p3,this.p4);
s3=Area(this.p1,this.p3,this.p4);
s4=Area(this.p1,this.p2,this.p3);
if(s1>=s2&&s1>=s3&&s1>=s4) {
if (s4 + s3 + s2 == s1) {
System.out.print("false ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s1 - s2);
} else {
System.out.print("true ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s1 + s2);
}
}
else if(s2>=s1&&s2>=s3&&s2>=s4) {
if (s4 + s3 + s1 == s2) {
System.out.print("false ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s2-s1);
} else {
System.out.print("true ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s1 + s2);
}
}
else if(s3>=s1&&s3>=s2&&s3>=s4) {
if (s4 +s2+s1== s3) {
System.out.print("false ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s3-s4);
} else {
System.out.print("true ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s1 + s2);
}
}
else if(s4>=s1&&s4>=s3&&s4>=s2) {
if (s1 + s3 + s2 == s4) {
System.out.print("false ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s4-s3);
} else {
System.out.print("true ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s1 + s2);
}
}
}选项四，需要判断直线与后四个点构成的多边形相交的交点数量。如果交点数量为2个，则按面积从小到大输出被分割的两块面积。如果直线与后四个点构成的多边形的任意一条边重合，则输出"The line is coincide with one of the lines"。如果后四个点无法构成四边形或三角形则输出"not a quadrilateral or triangle"。先判断后四个点是否能构成三角形或者四边形。在判断其是否构成三角形和四边形的时候，我最初的想法是如果四个点不是四边形或者四个点构成的三角形中间顶点不在两个端点中间。则输出"not a quadrilateral or triangle"。但是总有测试点没过。后来我发现有一种情况需要特判。
这种情况居然也属于三角形，所以我在前面加了一个对这种情况的特判。
而求交点以及如果交点的个数为2，则求分割面积。我的方法是使用三个point数组去记录，分别为交点数组、在直线上方点的数组、在直线下方点的数组。使用for循环不断将直线与4条边求交点，将交点存入交点数组。再将四个端点分别带入直线一般式中，如果ax+by+c>0则说明该点在直线上方，存入在直线上方点的数组，如果ax+by+c<0则说明该点在直线的下方，存入在直线下方点的数组。通过交点数组的个数可以判断交点个数，在交点个数有两个的情况下，因为只有交点有两个才需要求面积，在直线上方点的数组中元素个数有3种情况分别在直线上方点有1个、2个、3个。如果为1个，则直线下方说明有三个点，求面积可以求出上面直线上方的点和两个交点的三角形面积、以及用四边形或三角形面积减去之前那个三角形面积，其他情况同理。
选项4相关代码如下：
void JudgeQuadrilateralIntersection(line l){
line[] lines={l1,l2,l3,l4};
point[] points={this.p1,this.p2,this.p3,this.p4};
if(this.p1.JudgeSuperposition(p3)){
if(l1.parallel(l3)){
System.out.println("not a quadrilateral or triangle");
return;
}
else{
point[] jdpoint = new point[10];
point[] spoint = new point[10];
point[] xpoint = new point[10];
int cnt1=0,cnt2=0,cnt3=0;
line l5=new line(p2,p4);
line[] lines01={l1,l3,l5};
point[] points01={p1,p2,p4};
for(int i=0;i<3;i++){
if(l.JudgeIntersection(l, lines01[i])!=null) {
boolean weather = true;
for (int j = 0; j < cnt1; j++) {
if (jdpoint[j].x == l.JudgeIntersection(l, lines01[i]).x && jdpoint[j].y == l.JudgeIntersection(l, lines01[i]).y)
weather = false;
}
if (weather == true)
jdpoint[cnt1++] = l.JudgeIntersection(l, lines01[i]);
}
if(l.JudgePointHighLine(points01[i])){
spoint[cnt2++] = points01[i];
}
else{
xpoint[cnt3++] = points[i];
}
}
if (cnt1 != 2) {
System.out.println(cnt1);
}
else{
System.out.print(cnt1 + " ");
if (cnt2 == 1) {
accuracy(Math.min(Area(spoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(spoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], jdpoint[0], jdpoint[1])));
}
else if(cnt3==1){
accuracy(Math.min(Area(xpoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(xpoint[0], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(xpoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(xpoint[0], jdpoint[0], jdpoint[1])));
}
else if(cnt2==0||cnt3==0){
System.out.print(0+" ");
accuracy(Area(this.p1, this.p2, this.p3, this.p4));
}
else {
accuracy(Math.min(Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1])));
}
return;
}
}
}
if(!JudgeQuadrilateral()&&!JudgeTri(p1,p2,p3,p4)){
System.out.println("not a quadrilateral or triangle");
return;
}
if(!Judge_Tri(this.p1,this.p2,this.p3)||!Judge_Tri(this.p2,this.p3,this.p4)||!Judge_Tri(this.p3,this.p4,this.p1)||!Judge_Tri(this.p4,this.p1,this.p1)){
System.out.println("not a quadrilateral or triangle");
return;
}
if(this.l1.parallel(this.l2)&&this.l2.parallel(l3)&&this.l3.parallel(l4)&&this.l4.parallel(l1)){
System.out.println("not a quadrilateral or triangle");
return;
}
if(l.Superposition(this.l1)||l.Superposition(this.l2)||l.Superposition(this.l3)||l.Superposition(this.l4)){
System.out.println("The line is coincide with one of the lines");
return;
}
point[] jdpoint = new point[10];
point[] spoint = new point[10];
point[] xpoint = new point[10];
int cnt1 = 0, cnt2 = 0, cnt3 = 0;
for (int i = 0; i < 4; i++) {
if (l.JudgeIntersection(l, lines[i]) != null) {
boolean weather = true;
for (int j = 0; j < cnt1; j++) {
if (jdpoint[j].x == l.JudgeIntersection(l, lines[i]).x && jdpoint[j].y == l.JudgeIntersection(l, lines[i]).y)
weather = false;
}
if (weather == true)
jdpoint[cnt1++] = l.JudgeIntersection(l, lines[i]);
}
if (l.JudgePointHighLine(points[i])) {
spoint[cnt2++] = points[i];
} else {
xpoint[cnt3++] = points[i];
}
}
if (cnt1 != 2) {
System.out.println(cnt1);
} else {
System.out.print(cnt1 + " ");
if (cnt2 == 1) {
accuracy(Math.min(Area(spoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(spoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], jdpoint[0], jdpoint[1])));
}
else if(cnt3==1){
accuracy(Math.min(Area(xpoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(xpoint[0], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(xpoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(xpoint[0], jdpoint[0], jdpoint[1])));
}
else if(cnt2==0||cnt3==0){
System.out.print(0+" ");
accuracy(Area(this.p1, this.p2, this.p3, this.p4));
}
else {
accuracy(Math.min(Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1])));
}
}
}选项5需要判断前一个点是否在后四个点所构成的四边形内部。我是先判断后四个点是构成三角形还是四边形，如果是三角形再去判定点是否在该图形内部，四边形同理。而判断点是否在图形内部通过面积法判定，如果该点与相邻两点所构成的三角形面积和等于四点构成图形的面积，则说明点在多边形内部。选项五代码如下：
void JudgePointIsInside(point p){
if(!JudgeQuadrilateral()&&!JudgeTri(p1,p2,p3,p4)){
System.out.println("not a quadrilateral or triangle");
return;
}
if(l1.parallel(l2)||l2.parallel(l3)||l3.parallel(l4)||l4.parallel(l1)||this.p2.JudgeSuperposition(p3)||this.p1.JudgeSuperposition(p2)||this.p3.JudgeSuperposition(p4)||this.p4.JudgeSuperposition(p1)){
if(this.l1.JudgePointInLine(p)||this.l2.JudgePointInLine(p)||this.l3.JudgePointInLine(p)||this.l4.JudgePointInLine(p)){
System.out.println("on the triangle");
return;
}
if(Inside(p))
System.out.println("in the triangle");
else
System.out.println("outof the triangle");
}
else{
if(this.l1.JudgePointInLine(p)||this.l2.JudgePointInLine(p)||this.l3.JudgePointInLine(p)||this.l4.JudgePointInLine(p)){
System.out.println("on the quadrilateral");
return;
}
if(Inside(p))
System.out.println("in the quadrilateral");
else
System.out.println("outof the quadrilateral");
}
}点类
class point{
double x,y;
point(double a,double b){
x=a;
y=b;
}
boolean JudgeInLine(line l){
if(this.x>=Math.min(l.p1.x,l.p2.x)&&this.x<=Math.max(l.p1.x,l.p2.x)&&this.y>=Math.min(l.p1.y,l.p2.y)&&this.y<=Math.max(l.p1.y,l.p2.y)){
return true;
}
else
return false;
}
boolean JudgeSuperposition(point p){
if(p.x==this.x&&p.y==this.y)
return true;
return false;
}
double distance(point p2){
return Math.sqrt(Math.pow((this.x-p2.x),2)+Math.pow((this.y-p2.y),2));
}
}线类
class line{
double a,b,c;
point p1,p2;
line(point p1,point p2){
a=p2.y-p1.y;
b=p1.x-p2.x;
c=p2.x*p1.y-p1.x*p2.y;
this.p1=p1;
this.p2=p2;
}
boolean JudgePointHighLine(point p){
if(a*p.x+b*p.y+c>0)
return true;
else
return false;
}
boolean JudgePointInLine(point p){
if(a*p.x+b*p.y+c==0&&(p.x<=Math.max(this.p1.x,this.p2.x)&&p.x>=Math.min(this.p1.x,this.p2.x)&&p.y<=Math.max(this.p1.y,this.p2.y)&&p.y>=Math.min(this.p1.y,this.p2.y)))
return true;
else
return false;
}
point JudgeIntersection(line l1,line l2){
if(l1.parallel(l2))
return null;
double x=(l2.c*l1.b-l1.c*l2.b)/(l1.a*l2.b-l2.a*l1.b);
double y=(l1.c*l2.a-l2.c*l1.a)/(l1.a*l2.b-l2.a*l1.b);
if(x>=Math.min(l2.p1.x,l2.p2.x)&&x<=Math.max(l2.p1.x,l2.p2.x)&&y>=Math.min(l2.p1.y,l2.p2.y)&&y<=Math.max(l2.p1.y,l2.p2.y)){
point p=new point(x,y);
return p;
}
else
return null;
}
boolean parallel(line l){
if(this.a==0){
if(l.a==0)
return true;
else
return false;
}
else if(this.b==0){
if(l.b==0)
return true;
else
return false;
}
else{
if(l.a/l.b==this.a/this.b)
return true;
else
return false;
}
}
boolean Superposition(line l){
if((l.p1.x!=l.p2.x&&l.p1.y!=l.p2.y)&&(a*l.p1.x+b*l.p1.y+c==0&&a*l.p2.x+b*l.p2.y+c==0))
return true;
return false;
}
boolean LineSegment(line l){
if(l.parallel(this))
return false;
if(Math.max(this.p1.x,this.p2.x)<=Math.min(l.p1.x,l.p2.x)||Math.max(l.p1.x,l.p2.x)<=Math.min(this.p1.x,this.p2.x)||Math.max(this.p1.y,this.p2.y)<=Math.min(l.p1.y,l.p2.y)||Math.max(l.p1.y,l.p2.y)<=Math.min(this.p1.y,this.p2.y))
return false;
else
return true;
}
}四边形类中相关函数
double Area(point p1,point p2,point p3){
return Math.abs(0.5*((p1.x*p2.y-p2.x*p1.y)+(p2.x*p3.y-p3.x*p2.y)+(p3.x*p1.y-p1.x*p3.y)));
}
double Area(point p1,point p2,point p3,point p4){
double s1,s2,s3,s4;
s1=Area(p1,p2,p4);
s2=Area(p2,p3,p4);
s3=Area(p1,p3,p4);
s4=Area(p1,p2,p3);
if(s1>=s2&&s1>=s3&&s1>=s4) {
if(s2==0||s3==0||s4==0)
return s1;
if (s4 + s3 + s2 == s1) {
return s1 - s2;
} else {
return s1 + s2;
}
}
else if(s2>=s1&&s2>=s3&&s2>=s4) {
if(s1==0||s3==0||s4==0)
return s2;
if (s4 + s3 + s1 == s2) {
return s2-s1;
} else {
return s1 + s2;
}
}
else if(s3>=s1&&s3>=s2&&s3>=s4) {
if(s1==0||s2==0||s4==0)
return s3;
if (s4 +s2+s1== s3) {
return s3-s4;
} else {
return s1 + s2;
}
}
else {
if(s1==0||s2==0||s3==0)
return s4;
if (s1 + s3 + s2 == s4) {
return s4-s3;
} else {
return s1 + s2;
}
}
}
void accuracy(double a){
String s=Double.toString(a);
String str=s.substring(s.indexOf(".")+1);
if(str.length()>3)
System.out.printf("%.3f",a);
else
System.out.print(a);
}
boolean Judge_Tri(point p1,point p2,point p3){
line l1=new line(p1,p2);
line l2=new line(p1,p3);
if(l1.parallel(l2)&&(p2.x>Math.max(p1.x,p3.x)||p2.x<Math.min(p1.x,p3.x)||p2.y>Math.max(p1.y,p3.y)||p2.y<Math.min(p1.y,p3.y)))
return false;
return true;
}
boolean JudgeTri(point p1,point p2,point p3,point p4){
if(p1.JudgeSuperposition(p2)||p1.JudgeSuperposition(p4)||p4.distance(p1)+p1.distance(p2)==p4.distance(p2))
return true;
if(p2.JudgeSuperposition(p3)||p1.JudgeSuperposition(p2)||p2.distance(p1)+p2.distance(p3)==p1.distance(p3))
return true;
if(p3.JudgeSuperposition(p2)||p3.JudgeSuperposition(p4)||p3.distance(p2)+p3.distance(p4)==p2.distance(p4))
return true;
if(p4.JudgeSuperposition(p3)||p4.JudgeSuperposition(p1)||p4.distance(p1)+p4.distance(p3)==p3.distance(p1))
return true;
return false;
}
boolean Inside(point p){
double s1=Area(p,this.p1,this.p2);
double s2=Area(p,this.p2,this.p3);
double s3=Area(p,this.p3,this.p4);
double s4=Area(p,this.p4,this.p1);
double S=Area(this.p1,this.p2,this.p3,this.p4);
if(S==s1+s2+s3+s4)
return true;
return false;
}class Quadrilateral{
point p1,p2,p3,p4;
line l1,l2,l3,l4;
point[] points={p1,p2,p3,p4};
Quadrilateral(point p1,point p2,point p3,point p4){
this.p1=p1;
this.p2=p2;
this.p3=p3;
this.p4=p4;
this.l1=new line(p1,p2);
this.l2=new line(p2,p3);
this.l3=new line(p3,p4);
this.l4=new line(p4,p1);
}
boolean JudgeQuadrilateral(){
if(this.p1.JudgeSuperposition(this.p2)||this.p1.JudgeSuperposition(this.p3) ||
this.p1.JudgeSuperposition(this.p4)||this.p2.JudgeSuperposition(p3)||
this.p2.JudgeSuperposition(p4)||this.p3.JudgeSuperposition(p4))
return false;
if(l1.parallel(l2)||l2.parallel(l3)||l3.parallel(l4)||l4.parallel(l1))
return false;
if(!this.l1.LineSegment(l3)&&!this.l2.LineSegment(l4))
return true;
else
return false;
}
boolean JudgeParallelogram(){
boolean whether=false;
if(l1.parallel(l3)&&l2.parallel(l4))
whether= true;
return whether;
}
boolean JudgeLozenge(){
double d1,d2,d3,d4;
d1=Math.sqrt(Math.pow((this.p1.x-this.p2.x),2)+Math.pow((this.p1.y-this.p2.y),2));
d2=Math.sqrt(Math.pow((this.p2.x-this.p3.x),2)+Math.pow((this.p2.y-this.p3.y),2));
d3=Math.sqrt(Math.pow((this.p3.x-this.p4.x),2)+Math.pow((this.p3.y-this.p4.y),2));
d4=Math.sqrt(Math.pow((this.p4.x-this.p1.x),2)+Math.pow((this.p4.y-this.p1.y),2));
if(Math.abs(d1-d2)<1e-3&&Math.abs(d1-d3)<1e-3&&Math.abs((d1-d4))<1e-3)
return true;
else
return false;
}
boolean JudgeRectangle(){
if(!JudgeParallelogram())
return false;
else{
double x1,x2,y1,y2;
x1=this.p1.x-this.p2.x;
y1=this.p1.y-this.p2.y;
x2=this.p2.x-this.p3.x;
y2=this.p2.y-this.p3.y;
if(x1*x2+y1*y2==0)
return true;
else
return false;
}
}
boolean JudgeSquare(){
if(JudgeRectangle()&&JudgeLozenge())
return true;
else
return false;
}
void JudgeOutofSide(){
double s1,s2,s3,s4;
double d1,d2,d3,d4;
d1=Math.sqrt(Math.pow((this.p1.x-this.p2.x),2)+Math.pow((this.p1.y-this.p2.y),2));
d2=Math.sqrt(Math.pow((this.p2.x-this.p3.x),2)+Math.pow((this.p2.y-this.p3.y),2));
d3=Math.sqrt(Math.pow((this.p3.x-this.p4.x),2)+Math.pow((this.p3.y-this.p4.y),2));
d4=Math.sqrt(Math.pow((this.p4.x-this.p1.x),2)+Math.pow((this.p4.y-this.p1.y),2));
s1=Area(this.p1,this.p2,this.p4);
s2=Area(this.p2,this.p3,this.p4);
s3=Area(this.p1,this.p3,this.p4);
s4=Area(this.p1,this.p2,this.p3);
if(s1>=s2&&s1>=s3&&s1>=s4) {
if (s4 + s3 + s2 == s1) {
System.out.print("false ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s1 - s2);
} else {
System.out.print("true ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s1 + s2);
}
}
else if(s2>=s1&&s2>=s3&&s2>=s4) {
if (s4 + s3 + s1 == s2) {
System.out.print("false ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s2-s1);
} else {
System.out.print("true ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s1 + s2);
}
}
else if(s3>=s1&&s3>=s2&&s3>=s4) {
if (s4 +s2+s1== s3) {
System.out.print("false ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s3-s4);
} else {
System.out.print("true ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s1 + s2);
}
}
else if(s4>=s1&&s4>=s3&&s4>=s2) {
if (s1 + s3 + s2 == s4) {
System.out.print("false ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s4-s3);
} else {
System.out.print("true ");
accuracy(d1 + d2 + d3 + d4);
System.out.print(" ");
accuracy(s1 + s2);
}
}
}
void JudgeQuadrilateralIntersection(line l){
line[] lines={l1,l2,l3,l4};
point[] points={this.p1,this.p2,this.p3,this.p4};
if(this.p1.JudgeSuperposition(p3)){
if(l1.parallel(l3)){
System.out.println("not a quadrilateral or triangle");
return;
}
else{
point[] jdpoint = new point[10];
point[] spoint = new point[10];
point[] xpoint = new point[10];
int cnt1=0,cnt2=0,cnt3=0;
line l5=new line(p2,p4);
line[] lines01={l1,l3,l5};
point[] points01={p1,p2,p4};
for(int i=0;i<3;i++){
if(l.JudgeIntersection(l, lines01[i])!=null) {
boolean weather = true;
for (int j = 0; j < cnt1; j++) {
if (jdpoint[j].x == l.JudgeIntersection(l, lines01[i]).x && jdpoint[j].y == l.JudgeIntersection(l, lines01[i]).y)
weather = false;
}
if (weather == true)
jdpoint[cnt1++] = l.JudgeIntersection(l, lines01[i]);
}
if(l.JudgePointHighLine(points01[i])){
spoint[cnt2++] = points01[i];
}
else{
xpoint[cnt3++] = points[i];
}
}
if (cnt1 != 2) {
System.out.println(cnt1);
}
else{
System.out.print(cnt1 + " ");
if (cnt2 == 1) {
accuracy(Math.min(Area(spoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(spoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], jdpoint[0], jdpoint[1])));
}
else if(cnt3==1){
accuracy(Math.min(Area(xpoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(xpoint[0], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(xpoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(xpoint[0], jdpoint[0], jdpoint[1])));
}
else if(cnt2==0||cnt3==0){
System.out.print(0+" ");
accuracy(Area(this.p1, this.p2, this.p3, this.p4));
}
else {
accuracy(Math.min(Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1])));
}
return;
}
}
}
if(!JudgeQuadrilateral()&&!JudgeTri(p1,p2,p3,p4)){
System.out.println("not a quadrilateral or triangle");
return;
}
if(!Judge_Tri(this.p1,this.p2,this.p3)||!Judge_Tri(this.p2,this.p3,this.p4)||!Judge_Tri(this.p3,this.p4,this.p1)||!Judge_Tri(this.p4,this.p1,this.p1)){
System.out.println("not a quadrilateral or triangle");
return;
}
if(this.l1.parallel(this.l2)&&this.l2.parallel(l3)&&this.l3.parallel(l4)&&this.l4.parallel(l1)){
System.out.println("not a quadrilateral or triangle");
return;
}
if(l.Superposition(this.l1)||l.Superposition(this.l2)||l.Superposition(this.l3)||l.Superposition(this.l4)){
System.out.println("The line is coincide with one of the lines");
return;
}
point[] jdpoint = new point[10];
point[] spoint = new point[10];
point[] xpoint = new point[10];
int cnt1 = 0, cnt2 = 0, cnt3 = 0;
for (int i = 0; i < 4; i++) {
if (l.JudgeIntersection(l, lines[i]) != null) {
boolean weather = true;
for (int j = 0; j < cnt1; j++) {
if (jdpoint[j].x == l.JudgeIntersection(l, lines[i]).x && jdpoint[j].y == l.JudgeIntersection(l, lines[i]).y)
weather = false;
}
if (weather == true)
jdpoint[cnt1++] = l.JudgeIntersection(l, lines[i]);
}
if (l.JudgePointHighLine(points[i])) {
spoint[cnt2++] = points[i];
} else {
xpoint[cnt3++] = points[i];
}
}
if (cnt1 != 2) {
System.out.println(cnt1);
} else {
System.out.print(cnt1 + " ");
if (cnt2 == 1) {
accuracy(Math.min(Area(spoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(spoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], jdpoint[0], jdpoint[1])));
}
else if(cnt3==1){
accuracy(Math.min(Area(xpoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(xpoint[0], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(xpoint[0], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(xpoint[0], jdpoint[0], jdpoint[1])));
}
else if(cnt2==0||cnt3==0){
System.out.print(0+" ");
accuracy(Area(this.p1, this.p2, this.p3, this.p4));
}
else {
accuracy(Math.min(Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1])));
System.out.print(" ");
accuracy(Math.max(Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1]),Area(this.p1, this.p2, this.p3, this.p4) - Area(spoint[0], spoint[1], jdpoint[0], jdpoint[1])));
}
}
}
void JudgePointIsInside(point p){
if(!JudgeQuadrilateral()&&!JudgeTri(p1,p2,p3,p4)){
System.out.println("not a quadrilateral or triangle");
return;
}
if(l1.parallel(l2)||l2.parallel(l3)||l3.parallel(l4)||l4.parallel(l1)||this.p2.JudgeSuperposition(p3)||this.p1.JudgeSuperposition(p2)||this.p3.JudgeSuperposition(p4)||this.p4.JudgeSuperposition(p1)){
if(this.l1.JudgePointInLine(p)||this.l2.JudgePointInLine(p)||this.l3.JudgePointInLine(p)||this.l4.JudgePointInLine(p)){
System.out.println("on the triangle");
return;
}
if(Inside(p))
System.out.println("in the triangle");
else
System.out.println("outof the triangle");
}
else{
if(this.l1.JudgePointInLine(p)||this.l2.JudgePointInLine(p)||this.l3.JudgePointInLine(p)||this.l4.JudgePointInLine(p)){
System.out.println("on the quadrilateral");
return;
}
if(Inside(p))
System.out.println("in the quadrilateral");
else
System.out.println("outof the quadrilateral");
}
}
double Area(point p1,point p2,point p3){
return Math.abs(0.5*((p1.x*p2.y-p2.x*p1.y)+(p2.x*p3.y-p3.x*p2.y)+(p3.x*p1.y-p1.x*p3.y)));
}
double Area(point p1,point p2,point p3,point p4){
double s1,s2,s3,s4;
s1=Area(p1,p2,p4);
s2=Area(p2,p3,p4);
s3=Area(p1,p3,p4);
s4=Area(p1,p2,p3);
if(s1>=s2&&s1>=s3&&s1>=s4) {
if(s2==0||s3==0||s4==0)
return s1;
if (s4 + s3 + s2 == s1) {
return s1 - s2;
} else {
return s1 + s2;
}
}
else if(s2>=s1&&s2>=s3&&s2>=s4) {
if(s1==0||s3==0||s4==0)
return s2;
if (s4 + s3 + s1 == s2) {
return s2-s1;
} else {
return s1 + s2;
}
}
else if(s3>=s1&&s3>=s2&&s3>=s4) {
if(s1==0||s2==0||s4==0)
return s3;
if (s4 +s2+s1== s3) {
return s3-s4;
} else {
return s1 + s2;
}
}
else {
if(s1==0||s2==0||s3==0)
return s4;
if (s1 + s3 + s2 == s4) {
return s4-s3;
} else {
return s1 + s2;
}
}
}
void accuracy(double a){
String s=Double.toString(a);
String str=s.substring(s.indexOf(".")+1);
if(str.length()>3)
System.out.printf("%.3f",a);
else
System.out.print(a);
}
boolean Judge_Tri(point p1,point p2,point p3){
line l1=new line(p1,p2);
line l2=new line(p1,p3);
if(l1.parallel(l2)&&(p2.x>Math.max(p1.x,p3.x)||p2.x<Math.min(p1.x,p3.x)||p2.y>Math.max(p1.y,p3.y)||p2.y<Math.min(p1.y,p3.y)))
return false;
return true;
}
boolean JudgeTri(point p1,point p2,point p3,point p4){
if(p1.JudgeSuperposition(p2)||p1.JudgeSuperposition(p4)||p4.distance(p1)+p1.distance(p2)==p4.distance(p2))
return true;
if(p2.JudgeSuperposition(p3)||p1.JudgeSuperposition(p2)||p2.distance(p1)+p2.distance(p3)==p1.distance(p3))
return true;
if(p3.JudgeSuperposition(p2)||p3.JudgeSuperposition(p4)||p3.distance(p2)+p3.distance(p4)==p2.distance(p4))
return true;
if(p4.JudgeSuperposition(p3)||p4.JudgeSuperposition(p1)||p4.distance(p1)+p4.distance(p3)==p3.distance(p1))
return true;
return false;
}
boolean Inside(point p){
double s1=Area(p,this.p1,this.p2);
double s2=Area(p,this.p2,this.p3);
double s3=Area(p,this.p3,this.p4);
double s4=Area(p,this.p4,this.p1);
double S=Area(this.p1,this.p2,this.p3,this.p4);
if(S==s1+s2+s3+s4)
return true;
return false;
}
}
实验冗余代码仍然较多，且复杂度较高，需要继续改进。
7-3 设计一个银行业务类 分数 20 作者 吴光生 单位 新余学院编写一个银行业务类BankBusiness，具有以下属性和方法：
（1）公有、静态的属性：银行名称bankName，初始值为“中国银行”。
（2）私有属性：账户名name、密码password、账户余额balance。
（3）银行对用户到来的欢迎（welcome）动作（静态、公有方法），显示“中国银行欢迎您的到来！”，其中“中国银行”自动使用bankName的值。
（4）银行对用户离开的提醒（welcomeNext）动作（静态、公有方法），显示“请收好您的证件和物品，欢迎您下次光临！”
（5）带参数的构造方法，完成开户操作。需要账户名name、密码password信息，同时让账户余额为0。
（6）用户的存款（deposit）操作（公有方法，需要密码和交易额信息），密码不对时无法存款且提示“您的密码错误！”；密码正确、完成用户存款操作后，要提示用户的账户余额，例如“您的余额有1000.0元。”。
（7）用户的取款（withdraw）操作（公有方法，需要密码和交易额信息）。密码不对时无法取款且提示“您的密码错误！”；密码正确但余额不足时提示“您的余额不足！”；密码正确且余额充足时扣除交易额并提示用户的账户余额，例如“请取走钞票，您的余额还有500.0元。”。
编写一个测试类Main，在main方法中，先后执行以下操作：
（1）调用BankBusiness类的welcome()方法。
（2）接收键盘输入的用户名、密码信息作为参数，调用BankBusiness类带参数的构造方法，从而创建一个BankBusiness类的对象account。
（3）调用account的存款方法，输入正确的密码，存入若干元。密码及存款金额从键盘输入。
（4）调用account的取款方法，输入错误的密码，试图取款若干元。密码及取款金额从键盘输入。
（5）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额大于余额）。密码及取款金额从键盘输入。
（6）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额小于余额）。密码及取款金额从键盘输入。
（7）调用BankBusiness类的welcomeNext()方法。
输入格式:
输入开户需要的姓名、密码
输入正确密码、存款金额
输入错误密码、取款金额
输入正确密码、大于余额的取款金额
输入正确密码、小于余额的取款金额
输出格式:
中国银行（银行名称）欢迎您的到来！
您的余额有多少元。
您的密码错误！
您的余额不足！
请取走钞票，您的余额还有多少元。
请收好您的证件和物品，欢迎您下次光临！
输入样例:
在这里给出一组输入。请注意，输入与输出是交替的，具体顺序请看测试类中的说明。例如：
张三 123456
123456 1000
654321 2000
123456 2000
123456 500输出样例:
在这里给出相应的输出。请注意，输入与输出是交替的，具体顺序请看测试类中的说明。例如：
中国银行欢迎您的到来！
您的余额有1000.0元。
您的密码错误！
您的余额不足！
请取走钞票，您的余额还有500.0元。
请收好您的证件和物品，欢迎您下次光临！
按照题意实现相关函数即可，相关代码如下：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
BankBusiness Bank=new BankBusiness();
Bank.welcome(Bank.bankName);
String name=input.next();
String password=input.next();
Bank.creat_account(name,password);
String psword=input.next();
double money=input.nextDouble();
Bank.act.deposit(psword,money);
psword=input.next();
money=input.nextDouble();
Bank.act.withdraw(psword,money);
psword=input.next();
money=input.nextDouble();
Bank.act.withdraw(psword,money);
psword=input.next();
money=input.nextDouble();
Bank.act.withdraw(psword,money);
Bank.welcomeNext();
}
}
class BankBusiness{
String bankName="中国银行";
account act;
void creat_account(String name,String password){
Scanner input=new Scanner(System.in);
account ac=new account(name,password);
this.act=ac;
}
void welcome(String bankName){
System.out.println(bankName+"欢迎您的到来！");
}
void welcomeNext(){
System.out.println("请收好您的证件和物品，欢迎您下次光临！");
}
static class account{
private String name,password;
private double balance;
account(String Name,String Password){
this.name=Name;
this.password=Password;
this.balance=0;
}
void deposit(String pword, double money){
if(pword.equals(this.password)){
this.balance+=money;
System.out.println("您的余额有"+this.balance+"元。");
}
else{
System.out.println("您的密码错误！");
}
}
void withdraw(String pword,double money){
if(pword.equals(this.password)){
if(this.balance<money){
System.out.println("您的余额不足！");
}
else{
this.balance-=money;
System.out.println("请取走钞票，您的余额还有"+this.balance+"元。");
}
}
else{
System.out.println("您的密码错误！");
}
}
}
}标签：p2,p1,nchu,s2,s1,s4,s3,oop,2022 From： https://www.cnblogs.com/pillowtalk/p/16834142.html