面向对象程序设计第四次大作业心得
背景简介：
“蛟龙号”载人深潜器是我国首台自主设计、自主集成研制的作业型深海载人潜水器，设计最大下潜深度为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简要思路:
首先逐行接收进字符语句,然后对当前这段字符串进行匹配,匹配式子为//d+(即匹配数字),把当前字符串中的数字字串进行数据类型转化之后执行简单的累加操作并输出最后结果即可即可 , 这题没什么易错点,主要考察对字符匹配的使用情况
核心代码如下:
import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Main{
public static void main(String[] args){
Scanner scan=new Scanner(System.in);
int mix=0,num;
String s=scan.nextLine();
Pattern p=Pattern.compile("\\d+");
while(!s.equals("end")){
Matcher m=p.matcher(s);
while(m.find()){
num=Integer.valueOf(m.group(0));
mix+=num;
}
System.out.println(mix);
mix=0;
s=scan.nextLine();
}
}
}
题目集四 7-2
用户输入一组选项和数据，进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
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简要思路及核心代码:
main函数进行一个简单的字符串接收处理,判断输入格式是否合法,然后用split方法对字符串进行切割,分离出所需的功能号码以及点的坐标,根据功能号码进一步判断点的数量是否合法,如果合法则调用way类中对应的功能方法继续进行后续功能
main核心代码如下:
public class Main{
public static void main(String[] args){
Scanner scan=new Scanner(System.in);
String str=scan.nextLine();
String reg="[1-5]:(-|\\+)?\\d(.*)*";
String reg1="^(-|\\+)?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?),(-|\\+)?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?)";
boolean geshi=true;
if(!str.matches(reg)) System.out.println("Wrong Format");
else {//符合正则1
String[] str1=str.split(":");
String[] str2=str1[1].split(" ");
for(int q=0;q<str2.length&&geshi;q++)//遍历检测每个点是否合法
if(!str2[q].matches(reg1)) geshi=false;
if(!geshi) System.out.println("Wrong Format");
else {//每个点格式均合法
switch (str1[0]) {//switch
case "1":
if(str2.length!=4) System.out.println("wrong number of points");
else way.gongneng1(str2);
break;
case "2":
if(str2.length!=4) System.out.println("wrong number of points");
else way.gongneng2(str2);
break;
case "3":
if(str2.length!=4) System.out.println("wrong number of points");
else way.gongneng3(str2);
break;
case "4":
if(str2.length!=6) System.out.println("wrong number of points");
else way.gongneng4(str2);
break;
case "5":
if(str2.length!=5) System.out.println("wrong number of points");
else way.gongneng5(str2);
break;
}//switch
}//每个点格式均合法
}//符合正则一
}
}
接下来就是way类里的功能一方法的实现,首先是对接收进来的字符串数组进行处理,调用get函数,将字符串转化为double类型并存入Quadrangle对象q的点数组中,先判断是否有点重合,然后判断能否构成四边形和平行四边形并将结果输出即可
功能一 核心代码如下:
public static void gongneng1(String[] str) {
Quadrangle q=new Quadrangle();
for(int a=0;a<6;a++)
q.p[a]=new point();
for(int a=0;a<4;a++)
q.p[a].get(str[a]);
if(point.chonghe(q.p[0],q.p[1])||point.chonghe(q.p[0],q.p[2])||point.chonghe(q.p[0],q.p[3])||point.chonghe(q.p[1],q.p[2])||point.chonghe(q.p[1],q.p[3])||point.chonghe(q.p[2],q.p[3]))
System.out.println("points coincide");
else {//四点不重合
if(!q.pandaun(q.p[0],q.p[1],q.p[2],q.p[3])) System.out.print("false ");
else System.out.print("true ");
if(q.pxQua()&&q.pandaun(q.p[0],q.p[1],q.p[2],q.p[3])) System.out.println("true");
else System.out.println("false");
}//四点不重合
}
功能一中调用的方法panduan核心思路为,依次将点存入直线中,保证l[a]的第一个点p1为p[a],第二个点p2为p[(a+1)%n](n为点的数量-1),然后对边进行遍历,如果出现相邻边平行则说明不能构成四边形,或者出现对边有交点,也说明不能构成四边形
能构成四边形的两个条件:
1.任意相邻边不平行
2.任意对边无焦点
该功能核心代码如下:
boolean pandaun(point p0,point p1,point p2,point p3){//判断四点能否构成四边形
point p=new point();
this.l[1]=new line();this.l[2]=new line();this.l[3]=new line();this.l[0]=new line();
this.l[0].panduan(p0,p1);
this.l[1].panduan(p1,p2);
this.l[2].panduan(p2,p3);
this.l[3].panduan(p3,p0);
this.p[0]=p0;
this.p[1]=p1;
this.p[2]=p2;
this.p[3]=p3;
if(line.pingxing(this.l[0],this.l[1])||line.pingxing(this.l[1],this.l[2])||line.pingxing(this.l[2],this.l[3])||line.pingxing(this.l[3],this.l[0])){//相邻边不平行
return false;
}//相邻边不平行
else {//判断对边有无交点
if((!line.pingxing(this.l[0],this.l[2])&&line.jiaodian(this.l[0],this.l[2],p)&&line.jiaodian(this.l[2],this.l[0],p))||(!line.pingxing(this.l[1],this.l[3])&&line.jiaodian(this.l[1],this.l[3],p)&&line.jiaodian(this.l[3],this.l[1],p))) return false;
else return true;
}//判断对边有无交点
}判断是否构成平行四边形就比较简单了,在能构成四边形的情况下,所有对边相互平行即可,代码非常简短且简单,在此不表
功能二:
与功能一相同,先对接收来的字符串数组进行处理,调用get函数将字符串进行类型转换,并存入多边形类的对象q中,先调用上文的panduan方法和pxQua方法判断能否构成平行四边形,然后依次判断能否构成菱形,矩形和正方形并输出结果即可
判断条件:
1. 菱形: 任选一组临边判断边长是否相等
2. 矩形: 任选一组临边判断是否垂直
3. 正方形:任选一组临边同时满足边长相等和临边垂直
public static void gongneng2(String[] str){
Quadrangle q=new Quadrangle();
for(int a=0;a<6;a++)
q.p[a]=new point();
for(int a=0;a<4;a++)
q.p[a].get(str[a]);
if(point.chonghe(q.p[0],q.p[1])||point.chonghe(q.p[0],q.p[2])||point.chonghe(q.p[0],q.p[3])||point.chonghe(q.p[1],q.p[2])||point.chonghe(q.p[1],q.p[3])||point.chonghe(q.p[2],q.p[3]))
System.out.println("not a quadrilateral");
else {//四点不重合
if(!q.pandaun(q.p[0],q.p[1],q.p[2],q.p[3])) System.out.println("not a quadrilateral");
else {//可以构成四边形
if(!q.pxQua()) System.out.print("false false false");//不构成平行四边形
else{//可以构成平行四边形
if (line.bianchang(q.p[0],q.p[1])==line.bianchang(q.p[1],q.p[2])) System.out.print("true ");
else System.out.print("false ");
if (line.chuizhi(q.l[0],q.l[1])) System.out.print("true ");
else System.out.print("false ");
if (line.bianchang(q.p[0],q.p[1])==line.bianchang(q.p[1],q.p[2])&& line.chuizhi(q.l[0],q.l[1]))
System.out.println("true");
else System.out.println("false");
}//可以构成平行四边形
}//可以构成四边形
}//四点不重合
}/*
两个调用方法
double bianchang的作用为输入两个点坐标返回两点之间距离
boolean chuizhi的作用为输入两条直线,如果两条直线垂直则返回true,否则返回false
*/
public static double bianchang(point p1,point p2){
return Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
}
public static boolean chuizhi(line l1,line l2){
if(Math.abs(l1.a*l2.a+l1.b*l2.b)<=1e-6) return true;
else return false;
}功能三:
功能三首先要判断凹凸边形,我们可以通过判断对边是否有交点来确定凹凸性,如下图所示(电脑手绘有点粗糙,凑合着看):
然后就是调用方法计算出面积和边长并输出
核心代码如下:
public static void gongneng3(String[] str){
Quadrangle q=new Quadrangle();
for(int a=0;a<6;a++)
q.p[a]=new point();
for(int a=0;a<4;a++)
q.p[a].get(str[a]);
if(point.chonghe(q.p[0],q.p[1])||point.chonghe(q.p[0],q.p[2])||point.chonghe(q.p[0],q.p[3])||point.chonghe(q.p[1],q.p[2])||point.chonghe(q.p[1],q.p[3])||point.chonghe(q.p[2],q.p[3]))
System.out.println("not a quadrilateral");
else {//四点不重合
if(!q.pandaun(q.p[0],q.p[1],q.p[2],q.p[3])) System.out.println("not a quadrilateral");
else {//可以构成四边形
line djx1=new line(),djx2=new line();
point pz=new point();
djx1.panduan(q.p[0],q.p[2]);
djx2.panduan(q.p[1],q.p[3]);
if(line.jiaodian(djx1,djx2,pz)&&line.jiaodian(djx2,djx1,pz)) System.out.print("true ");
else System.out.print("false ");
double zc=line.bianchang(q.p[0],q.p[1])+line.bianchang(q.p[1],q.p[2])+line.bianchang(q.p[2],q.p[3])+line.bianchang(q.p[3],q.p[0]);
way.shuchu(zc);
System.out.print(" ");
double mj=Triangle.mianji(q.p[0],q.p[1],q.p[2])+Triangle.mianji(q.p[0],q.p[2],q.p[3]);
if(Triangle.mianji(q.p[0],q.p[1],q.p[3])+Triangle.mianji(q.p[2],q.p[1],q.p[3])<mj) mj=Triangle.mianji(q.p[0],q.p[1],q.p[3])+Triangle.mianji(q.p[2],q.p[1],q.p[3]);
way.shuchu(mj);
}//可以构成四边形
}//四点不重合
}功能四:
我该功能函数写的其实不好,有更好更完善的多边形类方法,我在本次作业中使用的方法并不推荐,建议看我第五次大作业中该功能的方法
临边有交点:
对边有交点:
我在这次作业中采用的方法:先判断能否构成四边形或者三角形,然后对点和边进行遍历,设置一个记录point数组(索引与边对应的)(point坐标初始值全为999),如果索引所对应的边上有交点则将交点存入记录数组所对应的位置,然后对索引表进行遍历,判断是对边有交点还是临边有交点,先计算出一个多边形的面积,然后用总面积减去第一个多边形的面积即可算出两个多边形的面积
1.临边有交点:第一个面积计算方式为 计算三角形面积,三个点为两个交点和两个交点之间那个端点
2.对边有交点:第一个面积计算方式为 计算四边形面积,四个点为两个交点,第二次出现的交点后面两个端点
核心代码如下:
public static void gongneng4(String[] str){
boolean ch=false;
line l=new line(),l1=new line(),l2=new line();
Quadrangle q=new Quadrangle();
Triangle t=new Triangle();
point p[]=new point[6];
for(int a=0;a<6;a++)
p[a]=new point();
for(int a=0;a<6;a++)
p[a].get(str[a]);
if(l.panduan(p[0],p[1])) System.out.print("points coincide");
else {//直线端点不重合
if(q.pandaun(p[2],p[3],p[4],p[5])){//能构成四边形
point jd=new point();
double s1,s2;
double mj=Triangle.mianji(q.p[0],q.p[1],q.p[2])+Triangle.mianji(q.p[0],q.p[2],q.p[3]);
if(Triangle.mianji(q.p[0],q.p[1],q.p[3])+Triangle.mianji(q.p[2],q.p[1],q.p[3])<mj) mj=Triangle.mianji(q.p[0],q.p[1],q.p[3])+Triangle.mianji(q.p[2],q.p[1],q.p[3]);
int jdgeshu=0,lb=9,db=9;
point[] jiaodian=new point[4];
for(int a=0;a<4&&!ch;a++){
jiaodian[a]=new point();
if(line.pingxing(l,q.l[a])&&line.chonghe(l,q.l[a])) ch=true;//边和直线重合
else if(line.pingxing(l,q.l[a])||!line.jiaodian(l,q.l[a],jiaodian[a])) {
jiaodian[a].x=999;
jiaodian[a].y=999;
}//如果边上没有jiaodian集合会被赋999
if(l.gongxian(q.p[a])) {//端点在直线上
jiaodian[a].x=q.p[a].x;
jiaodian[a].y=q.p[a].y;
}//端点在直线上
}
if(ch) System.out.print("The line is coincide with one of the lines");
else {//没有边重合
for(int a=0;a<4;a++){
if(jiaodian[a].x!=999&&jiaodian[a].y!=999){//当前下标的边有交点
if(jiaodian[(a-1+4)%4].x!=999&&jiaodian[(a-1+4)%4].y!=999){//临边也有交点
lb=a;
}//临边也有交点
if(jiaodian[(a-2+4)%4].x!=999&&jiaodian[(a-2+4)%4].y!=999){//对边也有交点
db=a;
}//对边也有交点
jdgeshu++;
}//当前下标为交点
}
if(jdgeshu==2){
if(lb!=9){//交点在临边上
s1=Triangle.mianji(q.p[lb],jiaodian[lb],jiaodian[(lb-1+4)%4]);
s2=mj-s1;
if(s1<s2) System.out.print("2 "+s1+" "+s2);
else System.out.print("2 "+s2+" "+s1);
}//交点在临边上
if(db!=9){//交点在对边上
if(point.chonghe(jiaodian[db],q.p[db])&&point.chonghe(jiaodian[(db-2+4)%4],q.p[(db-2+4)%4])) {//对角线
s1=Triangle.mianji(q.p[db],jiaodian[(db-2+4)%4],q.p[(db+1)%4]);
s2=mj-s1;
if(s1<s2) System.out.print("2 "+s1+" "+s2);
else System.out.print("2 "+s2+" "+s1);
}//对角线
else {
s1=Triangle.mianji(jiaodian[db],q.p[(db-1+4)%4],q.p[db])+Triangle.mianji(jiaodian[db],q.p[(db-1+4)%4],jiaodian[(db-2+4)%4]);
if(Triangle.mianji(q.p[db],jiaodian[(db-2+4)%4],q.p[(db-1+4)%4])+Triangle.mianji(q.p[db],jiaodian[(db-2+4)%4],jiaodian[db])<s1) s1=Triangle.mianji(q.p[db],jiaodian[(db-2+4)%4],q.p[(db-1+4)%4])+Triangle.mianji(q.p[db],jiaodian[(db-2+4)%4],jiaodian[db]);
s2=mj-s1;
if(s1<s2) System.out.print("2 "+s1+" "+s2);
else System.out.print("2 "+s2+" "+s1);
}
}//交点在对边上
}
else System.out.println(jdgeshu);
}//没有边重合
}//能构成四边形
else if(t.sjpanduan(q.p)){//能构成三角形
t.sjx(p[0],p[1]);
}//能构成三角形
else System.out.println("not a quadrilateral or triangle");
}//直线端点不重合
}功能五:
功能五较为简单,简要思路就是对第一个多边形的每个点进行遍历,看是否均在第二个多边形内即可,判断点是否在多边形内可用面积法
public static void gongneng5(String[] str){
double s1=0;
Quadrangle q=new Quadrangle();
Triangle t=new Triangle();
point p[]=new point[6];
for(int a=0;a<5;a++)
p[a]=new point();
for(int a=0;a<5;a++)
p[a].get(str[a]);
if(q.pandaun(p[1],p[2],p[3],p[4])){//能构成四边形
double mj=Triangle.mianji(q.p[0],q.p[1],q.p[2])+Triangle.mianji(q.p[0],q.p[2],q.p[3]);
for(int a=0;a<4;a++)
s1+=Triangle.mianji(p[0],q.p[a],q.p[(a+1)%4]);
if(s1==mj) {
if(q.l[0].gongxian(p[0])||q.l[1].gongxian(p[0])||q.l[2].gongxian(p[0])||q.l[3].gongxian(p[0]))
System.out.println("on the quadrilateral");
else System.out.println("in the quadrilateral");
}
else System.out.println("outof the quadrilateral");
}//能构成四边形
else if(t.sjpanduan(q.p)){//构成三角形
double mj=Triangle.mianji(t.p1,t.p2,t.p3);
s1=Triangle.mianji(p[0],t.p1,t.p2)+Triangle.mianji(p[0],t.p2,t.p3)+Triangle.mianji(p[0],t.p3,t.p1);
if(s1==mj) {
if(t.l1.gongxian(p[0])||t.l2.gongxian(p[0])||t.l3.gongxian(p[0]))
System.out.println("on the triangle");
else System.out.println("in the triangle");
}
else System.out.println("outof the triangle");
}//构成三角形
else System.out.println("not a quadrilateral or triangle");
}
}
题目集四 7-3
编写一个银行业务类BankBusiness，具有以下属性和方法：
（1）公有、静态的属性：银行名称bankName，初始值为“中国银行”。
（2）私有属性：账户名name、密码password、账户余额balance。
（3）银行对用户到来的欢迎（welcome）动作（静态、公有方法），显示“中国银行欢迎您的到来！”，其中“中国银行”自动使用bankName的值。
（4）银行对用户离开的提醒（welcomeNext）动作（静态、公有方法），显示“请收好您的证件和物品，欢迎您下次光临！”
（5）带参数的构造方法，完成开户操作。需要账户名name、密码password信息，同时让账户余额为0。
（6）用户的存款（deposit）操作（公有方法，需要密码和交易额信息），密码不对时无法存款且提示“您的密码错误！”；密码正确、完成用户存款操作后，要提示用户的账户余额，例如“您的余额有1000.0元。”。
（7）用户的取款（withdraw）操作（公有方法，需要密码和交易额信息）。密码不对时无法取款且提示“您的密码错误！”；密码正确但余额不足时提示“您的余额不足！”；密码正确且余额充足时扣除交易额并提示用户的账户余额，例如“请取走钞票，您的余额还有500.0元。”。
编写一个测试类Main，在main方法中，先后执行以下操作：
（1）调用BankBusiness类的welcome()方法。
（2）接收键盘输入的用户名、密码信息作为参数，调用BankBusiness类带参数的构造方法，从而创建一个BankBusiness类的对象account。
（3）调用account的存款方法，输入正确的密码，存入若干元。密码及存款金额从键盘输入。
（4）调用account的取款方法，输入错误的密码，试图取款若干元。密码及取款金额从键盘输入。
（5）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额大于余额）。密码及取款金额从键盘输入。
（6）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额小于余额）。密码及取款金额从键盘输入。
（7）调用BankBusiness类的welcomeNext()方法。
输入格式:
输入开户需要的姓名、密码
输入正确密码、存款金额
输入错误密码、取款金额
输入正确密码、大于余额的取款金额
输入正确密码、小于余额的取款金额
输出格式:
中国银行（银行名称）欢迎您的到来！
您的余额有多少元。
您的密码错误！
您的余额不足！
请取走钞票，您的余额还有多少元。
请收好您的证件和物品，欢迎您下次光临！
输入样例:
在这里给出一组输入。请注意，输入与输出是交替的，具体顺序请看测试类中的说明。例如：
张三 123456
123456 1000
654321 2000
123456 2000
123456 500输出样例:
在这里给出相应的输出。请注意，输入与输出是交替的，具体顺序请看测试类中的说明。例如：
中国银行欢迎您的到来！
您的余额有1000.0元。
您的密码错误！
您的余额不足！
请取走钞票，您的余额还有500.0元。
请收好您的证件和物品，欢迎您下次光临！思路:
创建一个银行公司类,属性有银行名字,用户名字,用户密码和余额,相关功能函数如下
class BankBusiness{
String bankName;
String name,password;
double balance;
void welcome(){
System.out.print(this.bankName);
System.out.println("欢迎您的到来！");
}
void kaihu(String str){
String[] n=str.split(" ");
this.name=n[0];
this.password=n[1];
this.balance=0;
}
void cunkuan(String str){
String[] n=str.split(" ");
if(!this.password.equals(n[0])){
System.out.println("您的密码错误");
}
else {
this.balance+=Double.valueOf(n[1]);
System.out.println("您的余额有"+this.balance+"元。");
}
}
void qukuan(String str){
String[] n=str.split(" ");
if(!this.password.equals(n[0])){
System.out.println("您的密码错误！");
}
else {
if(balance<Double.valueOf(n[1])) System.out.println("您的余额不足！");
else {
this.balance-=Double.valueOf(n[1]);
System.out.println("请取走钞票，您的余额还有"+this.balance+"元。");
}
}
}
void welcomeNext(){
System.out.print("请收好您的证件和物品，欢迎您下次光临！");
}
}主函数实现信息的接收,并调用类的方法函数
public class Main{
public static void main(String[] args){
Scanner scan=new Scanner(System.in);
BankBusiness bank=new BankBusiness();
bank.bankName="中国银行";
bank.welcome();
String str=scan.nextLine();
bank.kaihu(str);
str=scan.nextLine();
bank.cunkuan(str);
str=scan.nextLine();
bank.qukuan(str);
str=scan.nextLine();
bank.qukuan(str);
str=scan.nextLine();
bank.qukuan(str);
bank.welcomeNext();
}
}
作业心得:
通过这次大作业,加强了对题目问题的分析能力,很多现实中抽象的数学问题转化成计算机处理会因为算法的不同,引申出一些不易想到的问题,所以在进行算法设计的时候不光要考虑代码复杂情况,更要考虑特殊情况和代码的漏洞
浙公网安备 33010602011771号