第三次blog
第三次BLOG
前言：经过几个月的学习，Java的学习完成了.在此期间，我们学习了新的JavaFX，并加强了聚合和接口知识.PTA的主题越来越我们必须把一个需要更高水平自信的问题放在一起。
（1）第七题：第七题是两个图形卡游戏。第一题是排序，第二个是分组。第一个并不难。你可以先定义一些图形类和地图类，然后对存储的数据进行排序。但是第二个头有点疼。我不知道如何对这些数据进行分组，最终的结果只有82分，并不是所有的测试。经过两个阶段的培训，老师们也意识到我们不能一直忽视这些话题。他开始向我们解释一些问题，给我们代码，告诉我们你的想法，这样我们就可以更好地理解这个主题，并编写自己的代码。
2）第八题：第八题是ATM机的架构.我们需要处理两个银行，一个银联，每个账户对应一张卡，并收到多个不同的ATM号码。在这种情况下，当银行同业拆借超过余额，或账户与可与自动柜员机媲美的银行账户不同时，会发现错误，并在如果金额是正数，则必须获得。如果金额是负数，则为质押。乍一看，这似乎是个问题。但是我是按照老师介绍的电路图创建一个类，分析类之间的关系，这个问题很容易解决。
（3）第九题：第九题是ATM层次结构的改进版，其中包括一家中国农业银行，多个用户和银行间存款。银行间费用需要不同的支付比例，这需要我修改这些类别，并在抽象类和图表中添加一些类别，不同的自动取款机支付不同的佣金。卡不存在。如果指定的ATM机号码不存在，则输出“Sorry,the ATM's id is wrong.”。如果输入银行卡密码失败，输出“对不起，您输入的代码是错误的。如果输入的托收金额超过帐户余额或透支超过指定的透支最高金额，则输出“Sorry,your password is wrong，可以通过一次。最难的是进行银行间交易。
二．设计与分析
①题目集7（7-1）、（7-2）两道题目的递进式设计分析总结
7-1
输入格式:
1.首先，在一行上输入一串数字（1~4，整数），其中，1代表圆形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如： 1 3 4 2 1 3 4 2 1 3 0
2.然后根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。
输出格式:
如果图形数量非法（小于0）或图形属性值非法（数值小于0以及三角形三边不能组成三角形），则输出Wrong Format。
如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。输出内容如下：1.排序前的各图形类型及面积，格式为图形名称
1:面积值1图形名称2:面积值2 …图形名称n:面积值n ，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格；
2.排序后的各图形类型及面积，格式同排序前的输出；
3.所有图形的面积总和，格式为Sum of area:总面积值。
（1）题目中Circle类、Rectangle类、Trapezoid类、Triangle类继承父类Shape类，Card类聚合Shape类，DealCard List类聚合Card类，Card类实现接口Comparable。
（2）在图形类的设计中，体会面向对象设计原则中的“开-闭”原则的实现方法及其作用，思 考假如游戏中再增加一种图形，本次设计是否能实现“开-闭”原则。
（3）考虑类结构如何完善才能使得系统具有较好的可复用性。
题目代码：
import java.util.Scanner;
import java.util.ArrayList;//数组工具类
import java.util.Comparator;//比较接口,通过compare()方法实现元素排序
import java.util.Collections;//集合工具类text
public class Main {
public static Scanner input = new Scanner(System.in);
//在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接使用Main.input.next…即可（避免采坑）
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<Integer>();
int num = input.nextInt();
if(num == 0)
{
System.out.print("The original list:");
System.out.println("\n");
System.out.print("The sorted list:");
System.out.println("\n");
System.out.print("Sum of area:0.00");
}
else{
while(num != 0)
{
if(num < 0 || num > 4)
{
System.out.println("Wrong Format");
System.exit(0);
}
list.add(num);
num = input.nextInt();
}
DealCardList dealCardList = new DealCardList(list);
if(!dealCardList.validate())
{
System.out.println("Wrong Format");
System.exit(0);
}
dealCardList.ShowResult();
input.close();
}
}
}
class Card
{
private Shape shape;
public Shape getShape()
{
return shape;
}
public void setShape(Shape shape)
{
this.shape = shape;
}
Card(){
}
Card(Shape shape)
{
this.shape=shape;
}
}
class DealCardList
{
ArrayList<Card>cardList=new ArrayList<Card>();
DealCardList(){
}
DealCardList(ArrayList<Integer> list) {
ArrayList<Card>Card=new ArrayList<Card>();
for (int i=0; i<list.size();i++) //和作业6-1一样都是循环构建图形法，只不过从主函数移到了类里
{
if(list.get(i)==1)
{
double ridius=Main.input.nextDouble();
Shape circle=new Circle(ridius);
Card card=new Card(circle);
Card.add(card);
}
if(list.get(i)==2)
{
double width=Main.input.nextDouble();
double length=Main.input.nextDouble();
Shape rectangle=new Rectangle(width,length);
Card card=new Card(rectangle);
Card.add(card);
}
if(list.get(i)==3)
{
double sideone=Main.input.nextDouble();
double sidetwo=Main.input.nextDouble();
double sidethree=Main.input.nextDouble();
Shape triangle=new Triangle(sideone,sidetwo,sidethree);
Card card=new Card(triangle);
Card.add(card);
}
if(list.get(i)==4)
{
double sideone=Main.input.nextDouble();
double sidetwo=Main.input.nextDouble();
double height=Main.input.nextDouble();
Shape trapezoid=new Trapezoid(sideone,sidetwo,height);
Card card=new Card(trapezoid);
Card.add(card);
}
if(list.get(i)<0)
{
System.out.println("Wrong Format");
}
if(list.get(i)>4)
{
System.out.println("Wrong Format");
}
}
this.cardList=Card;
}
public boolean validate()
{
boolean h=true;
for(int i=0;i<cardList.size();i++)
{
if(!cardList.get(i).getShape().validate())
h=false;
}
return h;
}
public void cardSort()
{
Collections.sort(cardList,new SortByArea());
for(int j=0;j<cardList.size();j++)
System.out.print(cardList.get(j).getShape().getShapeName()+":"+String.format("%.2f", cardList.get(j).getShape().getArea())+" ");//
System.out.println();
}
public double getAllArea()
{
double sum=0;
for(Card card:cardList)
{
sum=sum+card.getShape().getArea();
}
return sum;
}
public void ShowResult() {
System.out.println("The original list:");
for(int j=0;j<cardList.size();j++)
System.out.print(cardList.get(j).getShape().getShapeName()+":"+String.format("%.2f", cardList.get(j).getShape().getArea())+" ");//
System.out.println();
System.out.println("The sorted list:");
cardSort();
System.out.print("Sum of area:");
System.out.println(String.format("%.2f", getAllArea()));
}
}
abstract class Shape//抽象类
{
private String ShapeName;
public abstract double getArea();//先声明求面积的方法
public abstract boolean validate();//先声明排序的方法
public String getShapeName() {
return ShapeName;
}
public void setShapeName(String shapeName) {
this.ShapeName = shapeName;
}
Shape(){
}
Shape(String shapeName){
this.ShapeName=shapeName;
}
public String toString()
{
return getArea()+"";
}
}
@SuppressWarnings("rawtypes")
class SortByArea implements Comparator{
public int compare(Object a,Object b)
{
Card A=(Card) a;
Card B=(Card) b;
if(A.getShape().getArea()>B.getShape().getArea())
return -1;
else
return 1;
}
}
class Circle extends Shape//圆类（继承图形类）
{
private double radius;
Circle(double radius)
{
this.radius = radius;
this.setShapeName("Circle");
}
@Override
public double getArea()
{
return Math.PI*radius*radius;
}
@Override
public boolean validate()
{
boolean h=false;
if(radius<=0)
h=false;
else
h=true;
return h;
}
}
class Rectangle extends Shape//矩形类（继承图形类）
{
private double width;
private double length;
Rectangle(double width,double length)
{
this.length=length;
this.width=width;
this.setShapeName("Rectangle");
}
@Override
public double getArea()
{
return width*length;
}
@Override
public boolean validate()
{
boolean h=false;
if(width<0||length<0)//zhuyi!
h=false;
else
h=true;
return h;
}
}
class Triangle extends Shape//三角类（继承图形类）
{
private double sideone;
private double sidetwo;
private double sidethree;
Triangle(double sideone,double sidetwo,double sidethree)
{
double Middle;
if(sideone>sidetwo)
{
Middle=sideone;
sideone=sidetwo;
sidetwo=Middle;
}
if(sideone>sidethree)
{
Middle=sideone;
sideone=sidethree;
sidethree=Middle;
}
if(sidetwo>sidethree)
{
Middle=sidetwo;
sidetwo=sidethree;
sidethree=Middle;
}
this.sideone=sideone;
this.sidetwo=sidetwo;
this.sidethree=sidethree;
this.setShapeName("Triangle");
}
@Override
public double getArea()
{
return Math.sqrt((sideone+sidetwo+sidethree)/2*((sideone+sidetwo+sidethree)/2-sideone)*((sideone+sidetwo+sidethree)/2-sidetwo)*((sideone+sidetwo+sidethree)/2-sidethree));
}
@Override
public boolean validate()
{
boolean h;
if(sideone+sidetwo<=sidethree||sideone<=0||sidetwo<=0||sidethree<=0)
h=false;
else
h=true;
return h;
}
}
class Trapezoid extends Shape//三角类（继承图形类）
{
private double sideone;
private double sidetwo;
private double height;
Trapezoid(double sideone,double sidetwo,double height)
{
this.sidetwo=sideone;
this.sideone=sidetwo;
this.height=height;
this.setShapeName("Trapezoid");
}
public double getArea()
{
return (sideone+sidetwo)*height/2;
}
@Override
public boolean validate()
{
boolean h;
if(sideone<=0||sidetwo<=0||height<=0)
h=false;
else
h=true;
return h;
}
}
7-2
输入格式:
在一行上输入一串数字（1~4，整数），其中，1代表圆形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如：1 3 4 2 1 3 4 2 1 3 0
根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。
输出格式:
如果图形数量非法（<=0）或图形属性值非法（数值<0以及三角形三边不能组成三角形），则输出Wrong Format。
如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。输出内容如下：
1.排序前的各图形类型及面积，格式为[图形名称1:面积值1图形名称2:面积值2 …图形名称n:面积值n ]，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格，在结束符“]”之前；
2.输出分组后的图形类型及面积，格式为[圆形分组各图形类型及面积][矩形分组各图形类型及面积][三角形分组各图形类型及面积][梯形分组各图形类型及面积]，各组内格式为图形名称:面积值。按照“Circle、Rectangle、Triangle、 Trapezoid”的顺序依次输出；
3.各组内图形排序后的各图形类型及面积，格式同排序前各组图形的输出；
4.各组中面积之和的最大值输出，格式为The max area:面积值。
题目代码：import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int Choose[] = new int[100];
int numCircle=0;
int numRectangle=0;
int numTriangle=0;
int numTrapezoid=0;
int sumlength=0;
for(int i = 0;;i++) {
int num=sc.nextInt();
if(num==0){//输入0的时候停止输入
break;
}else if(num<0||num>4) {//超出范围非法输入
System.out.println("Wrong Format");
System.exit(0);
}else{
Choose[i]=num;}
//为后面分类图形数组空间做内存大小统计
if(Choose[i]==1) {
numCircle++;
}
if(Choose[i]==2) {
numRectangle++;
}
if(Choose[i]==3) {
numTriangle++;
}
if(Choose[i]==4) {
numTrapezoid++;
}
}
sumlength=numCircle+numRectangle+numTriangle+numTrapezoid;
if(Choose[0]==0) {
System.out.println("Wrong Format");
System.exit(0);
}
//四个数组存分面积，一个存总面积
double Area[] = new double[sumlength];
double circleArea[] = new double[numCircle];
double rectangleArea[] = new double[numRectangle];
double triangleArea[] = new double[numTriangle];
double trapezoidArea[] = new double[numTrapezoid];
//四个参数记录相对应的数组号
int a = 0;
int b = 0;
int c = 0;
int d = 0;
for(int i = 0;i< sumlength; i++) {
if(Choose[i]==0){//数组查到0的时候停止检索
break;}
if(Choose[i]==1){
double radius=sc.nextDouble();
if(radius>0) {
double area= Math.PI*radius*radius;//S=PI*r^2
Area[i] = area;
circleArea[a] = area;
a++;
}else {
System.out.println("Wrong Format");
System.exit(0);
}
}
if(Choose[i]==2){
double length=sc.nextDouble();
double width=sc.nextDouble();
if(length>0&&width>0) {
double area= width*length;//S=L*W
Area[i] = area;
rectangleArea[b] = area;
b++;
}else {
System.out.println("Wrong Format");
System.exit(0);
}
}
if(Choose[i]==3){
double edge1=sc.nextDouble();
double edge2=sc.nextDouble();
double edge3=sc.nextDouble();
if(edge1+edge2<=edge3||edge1+edge3<=edge2||edge2+edge3<=edge1){
System.out.println("Wrong Format");
System.exit(0);
}
if(edge1>0&&edge2>0&&edge3>0) {
double p = (edge1+edge2+edge3)/2;//海伦公式的半周长p
double area = Math.sqrt(p*(p-edge1)*(p-edge2)*(p-edge3));//S=math.sqrt(p*(p-a)*(p-b)*(p-c))
Area[i] = area;
triangleArea[c] = area;
c++;
}else {
System.out.println("Wrong Format");
System.exit(0);
}
}
if(Choose[i]==4){//梯形
double sd=sc.nextDouble();
double xd=sc.nextDouble();
double high=sc.nextDouble();
if(sd>0&&xd>0&&high>0) {
double area= (sd+xd)*high/2;
Area[i] = area;
trapezoidArea[d] = area;
d++;
}else {
System.out.println("Wrong Format");
System.exit(0);
}
}
}//for循环结束
//初始打印
System.out.println("The original list:");
System.out.print("[");
for(int j = 0;j< sumlength;j++) {
if(Choose[j]==0){//数组查到0的时候停止检索
break;}
if(Choose[j]==1) {
System.out.printf("Circle:%.2f ",Area[j]);}
if(Choose[j]==2) {
System.out.printf("Rectangle:%.2f ",Area[j]);}
if(Choose[j]==3) {
System.out.printf("Triangle:%.2f ",Area[j]);}
if(Choose[j]==4) {
System.out.printf("Trapezoid:%.2f ",Area[j]);}
}
System.out.println("]");
//分组打印
System.out.println("The Separated List:");
System.out.print("[");
for(int i = 0;i<numCircle;i++) {
System.out.printf("Circle:%.2f ",circleArea[i]);
}
System.out.print("]");
System.out.print("[");
for(int i = 0;i<numRectangle;i++) {
System.out.printf("Rectangle:%.2f ",rectangleArea[i]);
}
System.out.print("]");
System.out.print("[");
for(int i = 0;i<numTriangle;i++) {
System.out.printf("Triangle:%.2f ",triangleArea[i]);
}
System.out.print("]");
System.out.print("[");
for(int i = 0;i<numTrapezoid;i++) {
System.out.printf("Trapezoid:%.2f ",trapezoidArea[i]);
}
System.out.println("]");
//分组倒序打印
Arrays.sort(circleArea);
Arrays.sort(rectangleArea);
Arrays.sort(triangleArea);
Arrays.sort(trapezoidArea);
System.out.println("The Separated sorted List:");
System.out.print("[");
for(int i = 0;i<numCircle;i++) {
System.out.printf("Circle:%.2f ",circleArea[numCircle-1-i]);
}
System.out.print("]");
System.out.print("[");
for(int i = 0;i<numRectangle;i++) {
System.out.printf("Rectangle:%.2f ",rectangleArea[numRectangle-1-i]);
}
System.out.print("]");
System.out.print("[");
for(int i = 0;i<numTriangle;i++) {
System.out.printf("Triangle:%.2f ",triangleArea[numTriangle-1-i]);
}
System.out.print("]");
System.out.print("[");
for(int i = 0;i<numTrapezoid;i++) {
System.out.printf("Trapezoid:%.2f ",trapezoidArea[numTrapezoid-1-i]);
}
System.out.println("]");
//对各组面积求和
double circle=0;double rectangle=0;double triangle=0;double trapezoid=0;
for(int i = 0;i<numCircle;i++) {
circle+=circleArea[i];
}
for(int i = 0;i<numRectangle;i++) {
rectangle+=rectangleArea[i];
}
for(int i = 0;i<numTriangle;i++) {
triangle+=triangleArea[i];
}
for(int i = 0;i<numTrapezoid;i++) {
trapezoid+=trapezoidArea[i];
}
double result[] = new double[] {circle,rectangle,triangle,trapezoid};
Arrays.sort(result);//选出面积和最大的图形
System.out.printf("The max area:%.2f",result[3]);
sc.close();
}//主类结束
}
7-2主题集和7-1主题集的类结构相似，但7-1函数比较简单，7-2函数深入7-1，7-1只需要计算图的面积，由输入数据组成，并按大小排序，而7-2需要数据组合，将相同的图表分成一组，然后按组对数据进行分类。差异很小。7-1使用array list存储数据，在7-2中，为每个图形创建一个arrayList，然后单独处理数据。
从7-1到7-2，代码所要求的功能从简单到复杂不等，但一般都是根据原始代码进行修改，使其更加多样化.直到那时，只要实现了代码的基本功能，就不难进行进一步的修改。
题目集8,9最终代码：
输入格式:
每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业务操作输入格式如下：
取款功能输入数据格式： 卡号 密码 ATM机编号 金额（由一个或多个空格分隔）
查询余额功能输入数据格式： 卡号
输出格式:
①输入错误处理
如果输入卡号不存在，则输出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.。
②取款业务输出
输出共两行，格式分别为：
业务：取款 [用户姓名]在[银行名称]的[ATM编号]上取款¥[金额
当前余额为¥[金额]
其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。
③查询余额业务输出
业务：查询余额 ¥[金额]
金额保留两位小数。
以下为实验代码：
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
UnionPay unionPay = new UnionPay();
Bank ccb = new Bank("1001","中国建设银行",0.02,0.05);
Bank icbc = new Bank("1002","中国工商银行",0.03,0.05);
Bank agri =new Bank("1003", "中国农业银行",0.04,0.05);
unionPay.addBank(ccb);
unionPay.addBank(icbc);
unionPay.addBank(agri);
ATM aTM1 = new ATM("01",ccb);
ATM aTM2 = new ATM("02",ccb);
ATM aTM3 = new ATM("03",ccb);
ATM aTM4 = new ATM("04",ccb);
ATM aTM5 = new ATM("05",icbc);
ATM aTM6 = new ATM("06",icbc);
ATM aTM7 = new ATM("07",agri);
ATM aTM8 = new ATM("08",agri);
ATM aTM9 = new ATM("09",agri);
ATM aTM10 = new ATM("10",agri);
ATM aTM11 = new ATM("11",agri);
ccb.addATM(aTM1);
ccb.addATM(aTM2);
ccb.addATM(aTM3);
ccb.addATM(aTM4);
icbc.addATM(aTM5);
icbc.addATM(aTM6);
agri.addATM(aTM7);
agri.addATM(aTM8);
agri.addATM(aTM9);
agri.addATM(aTM10);
agri.addATM(aTM11);
User Yangguo = new User("360101200102122324","杨过","13856223254");
User Guojing = new User("360101200012302552","郭靖","13800021124");
User Zhangwuji = new User("360502199805163221","张无忌","13952110011");
User Weixiaobao = new User("360201200513243326","韦小宝","13025996587");
User zhangsanfeng = new User("360201200513243345","张三丰","13025786587");
User linghuchong = new User("360201200513243376","令狐冲","13025996547");
User qiaofeng = new User("360201200513243326","乔峰","13565996587");
User honqigon = new User("360201200532243326","洪七公","13565456587");
Account ccbAcc1 = new Debit("3217000010041315709",10000.00,Yangguo,ccb);
Account ccbAcc2 = new Debit("3217000010041315715",10000.00,Yangguo,ccb);
Account ccbAcc3 = new Debit("3217000010051320007",10000.00,Guojing,ccb);
Account icbcAcc1 = new Debit("3222081502001312389",10000.00,Zhangwuji,icbc);
Account icbcAcc2 = new Debit("3222081502001312390",10000.00,Zhangwuji,icbc);
Account icbcAcc3 = new Debit("3222081502001312399",10000.00,Zhangwuji,icbc);
Account icbcAcc4 = new Debit("3222081502051320785",10000.00,Weixiaobao,icbc);
Account icbcAcc5 = new Debit("3222081502051320786",10000.00,Weixiaobao,icbc);
Account ccbAcc4 = new Credit("3640000010045442002",10000.00,zhangsanfeng,ccb);
Account icbcAcc6 = new Credit("3640000010045441009",10000.00,linghuchong,icbc);
Account agriAcc1 = new Credit("3630000010033431001",10000.00,qiaofeng,agri);
Account agriAcc2 = new Credit("3630000010033431008",10000.00,honqigon,agri);
ccb.addAccount(ccbAcc1);
ccb.addAccount(ccbAcc2);
ccb.addAccount(ccbAcc3);
ccb.addAccount(ccbAcc4);
icbc.addAccount(icbcAcc1);
icbc.addAccount(icbcAcc2);
icbc.addAccount(icbcAcc3);
icbc.addAccount(icbcAcc4);
icbc.addAccount(icbcAcc5);
icbc.addAccount(icbcAcc6);
agri.addAccount(agriAcc1);
agri.addAccount(agriAcc2);
Yangguo.addAccount(ccbAcc1);
Yangguo.addAccount(ccbAcc2);
Guojing.addAccount(ccbAcc3);
Zhangwuji.addAccount(icbcAcc1);
Zhangwuji.addAccount(icbcAcc2);
Zhangwuji.addAccount(icbcAcc3);
Weixiaobao.addAccount(icbcAcc4);
Weixiaobao.addAccount(icbcAcc5);
zhangsanfeng.addAccount(ccbAcc4);
linghuchong.addAccount(icbcAcc6);
qiaofeng.addAccount(agriAcc1);
honqigon.addAccount(agriAcc2);
Card ccbCard1 = new Card("6217000010041315709","88888888",ccbAcc1);//双向指针
Card ccbCard2 = new Card("6217000010041315715","88888888",ccbAcc1);
Card ccbCard3 = new Card("6217000010041315718","88888888",ccbAcc2);
Card ccbCard4 = new Card("6217000010051320007","88888888",ccbAcc3);
Card icbcCard5 = new Card("6222081502001312389","88888888",icbcAcc1);
Card icbcCard6 = new Card("6222081502001312390","88888888",icbcAcc2);
Card icbcCard7 = new Card("6222081502001312399","88888888",icbcAcc3);
Card icbcCard8 = new Card("6222081502001312400","88888888",icbcAcc3);
Card icbcCard9 = new Card("6222081502051320785","88888888",icbcAcc4);
Card icbcCard10 = new Card("6222081502051320786","88888888",icbcAcc5);
Card ccbCard11 =new Card("6640000010045442002", "88888888",ccbAcc4);
Card ccbCard12 = new Card("6640000010045442003","88888888",ccbAcc4);
Card icbcCard13 = new Card("6640000010045441009","88888888",icbcAcc6);
Card agriCard14 =new Card("6630000010033431001","88888888",agriAcc1);
Card agriCard15 =new Card("6630000010033431008","88888888",agriAcc2);
ccbAcc1.addCard(ccbCard1);//账户里面添加卡号
ccbAcc1.addCard(ccbCard2);
ccbAcc2.addCard(ccbCard3);
ccbAcc3.addCard(ccbCard4);
ccbAcc4.addCard(ccbCard11);
ccbAcc4.addCard(ccbCard12);
icbcAcc1.addCard(icbcCard5);
icbcAcc2.addCard(icbcCard6);
icbcAcc3.addCard(icbcCard7);
icbcAcc3.addCard(icbcCard8);
icbcAcc4.addCard(icbcCard9);
icbcAcc5.addCard(icbcCard10);
icbcAcc6.addCard(icbcCard13);
agriAcc1.addCard(agriCard14);
agriAcc2.addCard(agriCard15);
StringBuilder sb = new StringBuilder();
String data;
while(!((data = input.nextLine()).equals("#"))) {
sb.append(data + "\n");
}
String[] dt = sb.toString().split("\n");
for(int i = 0; i < dt.length; i++) {
String[] dataLine = dt[i].toString().split("\\s+");
if(dataLine.length == 1) {
GetBalance gb = new GetBalance(unionPay);//此处unionPay可写可不写,在此处没有起作用
System.out.println("业务：查询余额 "+String.format("¥%.2f", gb.getBalance(dataLine[0])));
}else {
Withdraw wd = new Withdraw(unionPay,dataLine[0],dataLine[1],dataLine[2],Double.parseDouble(dataLine[3]));
wd.withdraw();
}
}
}
}
class Bank {
private String bankNO;//银行编号
private String bankName;//银行名字
private Double rate1=0.00;//跨行利率
private Double rate2 =0.00;//透支手续费
private ArrayList<Account> accountList = new ArrayList<Account>();//一个银行有多个账户
private ArrayList<ATM> ATMList = new ArrayList<ATM>();//一个银行有多个ATM机
public Bank() {
super();
// TODO Auto-generated constructor stub
}
public Bank(String bankNO, String bankName ,Double rate1, Double rate2) {
super();
this.bankNO = bankNO;
this.bankName = bankName;
this.rate1 = rate1;
this.rate2 = rate2;
}
public Double getRate1() {
return rate1;
}
public void setRate1(Double rate1) {
this.rate1 = rate1;
}
public Double getRate2() {
return rate2;
}
public void setRate2(Double rate2) {
this.rate2 = rate2;
}
public String getBankNO() {
return bankNO;
}
public void setBankNO(String bankNO) {
this.bankNO = bankNO;
}
public String getBankName() {
return bankName;
}
public void setBankName(String bankName) {
this.bankName = bankName;
}
public void addAccount(Account account) {//添加账户
this.accountList.add(account);
}
public void removeAccount(Account account) {//消除账户
this.accountList.remove(account);
}
public void addATM(ATM aTM) {//添加ATM机
this.ATMList.add(aTM);
}
public void removeATM(ATM aTM) {//消除ATM机
this.ATMList.remove(aTM);
}
public ArrayList<Account> getAccountList() {
return accountList;
}
public void setAccountList(ArrayList<Account> accountList) {
this.accountList = accountList;
}
public ArrayList<ATM> getATMList() {
return ATMList;
}
public void setATMList(ArrayList<ATM> aTMList) {
ATMList = aTMList;
}
}
class User {
private String ID;//身份证号码
private String name;//名字
private String Phone;//手机号码
ArrayList<Account> list = new ArrayList<Account>();//一个用户有多个账户
public User() {
super();
// TODO Auto-generated constructor stub
}
public User(String iD, String name, String phone) {
super();
ID = iD;
this.name = name;
Phone = phone;
}
public String getID() {
return ID;
}
public void setID(String iD) {
ID = iD;
}
public String getPhone() {
return Phone;
}
public void setPhone(String phone) {
Phone = phone;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void addAccount(Account account) {//添加一个账户
this.list.add(account);
}
public void removeAccount(Account account) {//消除一个账户
this.list.remove(account);
}
}
class Account {
private String accountNO;//账户号码
private double balance = 0;//余额
private User user = null;
private Bank bank = null;
private String accountName = null;//账户类型
// Account account=new Credit();
public String getAccountName() {
return accountName;
}
public void setAccountName(String accountName) {
this.accountName = accountName;
}
private static ArrayList<Card> list = new ArrayList<Card>();//一个账户有多张卡
public Account() {
super();
// TODO Auto-generated constructor stub
}
public Account(Credit credit) {
super();
credit=new Credit();
// TODO Auto-generated constructor stub
}
public Account(String accountNO, double balance, User user, Bank bank) {
super();
this.accountNO = accountNO;
this.balance = balance;
this.user = user;
this.bank = bank;
}
public void addCard(Card card) {//添加卡号
list.add(card);
}
public void removeCard(Card card) {//消除卡号
list.remove(card);
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public String getAccountNO() {
return accountNO;
}
public void setAccountNO(String accountNO) {
this.accountNO = accountNO;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Bank getBank() {
return bank;
}
public void setBank(Bank bank) {
this.bank = bank;
}
public ArrayList<Card> getList() {
return list;
}
public void setList(ArrayList<Card> list) {
Account.list = list;
}
public static Account getAmountbyCardNO(String cardNO) {//通过卡号得到账户
Iterator<Card> cardItr = Account.list.iterator();
Card card = null;
while(cardItr.hasNext()) {
card = cardItr.next();
if(card.getCardNO().equals(cardNO)) {
return card.getAccount();
}
}
return null;
}
}
class Card {
private String cardNO;
private String cardPassword;//卡号密码
private Account account = null;
public Card() {
super();
// TODO Auto-generated constructor stub
}
public Card(String cardNO, String cardPassword, Account account) {
super();
this.cardNO = cardNO;
this.cardPassword = cardPassword;
this.account = account;
}
public String getCardNO() {
return cardNO;
}
public void setCardNO(String cardNO) {
this.cardNO = cardNO;
}
public String getCardPassword() {
return cardPassword;
}
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
public void setCardPassword(String cardPassword) {
this.cardPassword = cardPassword;
}
public boolean checkCard() {
Pattern p = Pattern.compile("\\d{16}+");
Matcher m = p.matcher(this.cardNO);
return m.matches();
}
public boolean checkPassword(String password) {
return this.cardPassword.equals(password);
}
}
class ATM {
private String ATMID;
private Bank bank = null;
public ATM() {
super();
// TODO Auto-generated constructor stub
}
public ATM(String aTMID, Bank bank) {
super();
ATMID = aTMID;
this.bank = bank;
}
public String getATMID() {
return ATMID;
}
public void setATMID(String aTMID) {
ATMID = aTMID;
}
public Bank getBank() {
return bank;
}
public void setBank(Bank bank) {
this.bank = bank;
}
}
class ValidateData {
/**
* 校验卡号是否存在
* @param unionPay
* @param cardNO
* @return
*/
public static Card getCardbyCardNO(UnionPay unionPay,String cardNO) {//判断卡号是否存在并通过卡号找到这张卡
Card card = null;
Iterator<Bank> bankItr = unionPay.getBankList().iterator();
while(bankItr.hasNext()) {
ArrayList<Account> accountList = bankItr.next().getAccountList();
Iterator<Account> accountItr = accountList.iterator();
while(accountItr.hasNext()) {
ArrayList<Card> cardList = accountItr.next().getList();
Iterator<Card> cardItr = cardList.iterator();
while(cardItr.hasNext()) {
card = cardItr.next();
if(card.getCardNO().equals(cardNO)) {
return card;
}
}
}
}
return null;
}
/**
* 校验ATM ID是否存在
* @param unionPay
* @param ATMID
* @return
*/
public static ATM getATMbyATMID(UnionPay unionPay,String ATMID) {//判断存在该ATM机并返回ATM
Iterator<Bank> bankItr = unionPay.getBankList().iterator();
Bank bank = null;
ATM aTM = null;
while(bankItr.hasNext()) {
bank = bankItr.next();
Iterator<ATM> aTMItr = bank.getATMList().iterator();
while(aTMItr.hasNext()) {
aTM = aTMItr.next();
if(aTM.getATMID().equals(ATMID)) {
return aTM;
}
}
}
return null;
}
}
class Withdraw {
private UnionPay unionPay;
private String cardNO;
private String cardPassword;
private String ATMID;
private double amount;
public Withdraw() {
super();
// TODO Auto-generated constructor stub
}
public Withdraw(UnionPay unionPay, String cardNO, String cardPassword, String aTMID, double amount) {
super();
this.unionPay = unionPay;
this.cardNO = cardNO;
this.cardPassword = cardPassword;
ATMID = aTMID;
this.amount = amount;
}
public Withdraw(String cardNO, String cardPassword, String aTMID, double amount) {
super();
this.cardNO = cardNO;
this.cardPassword = cardPassword;
ATMID = aTMID;
this.amount = amount;
}
public void validate() {
/**
* 校验该卡是否存在
*/
Card card = ValidateData.getCardbyCardNO(unionPay, cardNO);
if(card == null) {
System.out.println("Sorry,this card does not exist.");
System.exit(0);
}
/**
* 校验ATM是否存在
*/
ATM aTM = ValidateData.getATMbyATMID(unionPay, ATMID);
if(aTM == null) {
System.out.println("Sorry,the ATM's id is wrong.");
System.exit(0);
}
Account account = Account.getAmountbyCardNO(cardNO);
double balance = account.getBalance();
/**
* 校验卡密码是否正确
*/
if(!card.getCardPassword().equals(cardPassword)) {
System.out.println("Sorry,your password is wrong.");
System.exit(0);
}
}
public void withdraw() {
Credit credit = new Credit();
Debit debit = new Debit();
Account account = new Account(credit);
account = Account.getAmountbyCardNO(cardNO);
double balance = account.getBalance();
double qoite1 = credit.getQoite();
double qoite2 = debit.getQoite();
ATM aTM = ValidateData.getATMbyATMID(unionPay, ATMID);//得到ATM机号
validate();
if(account.getAccountName().equals("借记账号")) {
if (amount > balance + qoite2) {//
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
else if (account.getBank().getBankNO() == aTM.getBank().getBankNO()){
account.setBalance(balance - amount);//取款更新余额操作
}
else if(balance - amount*(1+aTM.getBank().getRate1())>=0) {
account.setBalance(balance - amount*(1+aTM.getBank().getRate1()));
}
else {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
else if(account.getAccountName().equals("贷记账号")) {
if(amount > balance + qoite1) {//超额
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
else {//不超额情况
if(balance<=0) {//如果已经透支且未超过透支额度
account.setBalance(balance-amount-amount*account.getBank().getRate2());
if( account.getBalance() <-50000.00) {//超额
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
else {//还未透支情况
/*
* 未跨行时的情况
*/
if(amount > balance && account.getBank().getBankNO() == aTM.getBank().getBankNO()) {
account.setBalance((balance-amount)*(1+account.getBank().getRate2()));
if( account.getBalance() <-50000.00) {//超额
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
if(amount <= balance && account.getBank().getBankNO() == aTM.getBank().getBankNO()) {
account.setBalance(balance - amount);
if( account.getBalance() <-50000.00) {//超额
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
/*
* 跨行的情况
*/
if(amount > balance && account.getBank().getBankNO() != aTM.getBank().getBankNO()) {
account.setBalance(balance-amount-amount*aTM.getBank().getRate1()-(amount-balance)*account.getBank().getRate2());
if( account.getBalance() <-50000.00) {//超额
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
else if(amount <= balance && account.getBank().getBankNO() != aTM.getBank().getBankNO()){
account.setBalance(balance - amount-amount*aTM.getBank().getRate1());
if( account.getBalance() <-50000.00) {//超额
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
}
}
}
if(amount >= 0) {
showResult(account,1);
}else {
showResult(account,0);
}
}
public void showResult(Account account,int flag) {
ATM aTM = ValidateData.getATMbyATMID(unionPay, ATMID);
String type = "";
if(flag == 1) {
type = "取款";
}else {
type = "存款";
amount *= -1;
}
String userName = account.getUser().getName();
String bankName = aTM.getBank().getBankName();
System.out.println("业务："+type+" " +userName + "在" +
bankName + "的" + ATMID + "号ATM机上" + type + String.format("¥%.2f", amount));
System.out.println("当前余额为" + String.format("¥%.2f", account.getBalance()));
}
}
class UnionPay {
private ArrayList<Bank> bankList = new ArrayList<Bank>();
public UnionPay() {
super();
// TODO Auto-generated constructor stub
}
public UnionPay(ArrayList<Bank> bankList) {
super();
this.bankList = bankList;
}
public ArrayList<Bank> getBankList() {
return bankList;
}
public void setBankList(ArrayList<Bank> bankList) {
this.bankList = bankList;
}
public void addBank(Bank bank) {
this.bankList.add(bank);
}
public void removeBank(Bank bank) {
this.bankList.remove(bank);
}
}
class GetBalance {
private UnionPay unionPay;
public GetBalance() {
super();
// TODO Auto-generated constructor stub
}
public GetBalance(UnionPay unionPay) {
super();
this.unionPay = unionPay;
}
public double getBalance(String cardNO) {
return ValidateData.getCardbyCardNO(unionPay, cardNO).getAccount().getBalance();//调用一个类里面的静态方法时,可以直接使用该类的类名直接调用
}
}
class Debit extends Account{
private Double qoite=0.00;
private String accountName = "借记账号";
public Debit(String accountNO, double balance, User user, Bank bank) {
super(accountNO, balance, user, bank);
// TODO Auto-generated constructor stub
}
public Debit() {
super();
// TODO Auto-generated constructor stub
}
public Double getQoite() {
return qoite;
}
public void setQoite(Double qoite) {
this.qoite = qoite;
}
public String getAccountName() {
return accountName;
}
public void setAccountName(String accountName) {
this.accountName = accountName;
}
}
class Credit extends Account{
private String accountName = "贷记账号";
private Double qoite=50000.00;//借贷余额
public String getAccountName() {
return accountName;
}
public void setAccountName(String accountName) {
this.accountName = accountName;
}
public Double getQoite() {
return qoite;
}
public void setQoite(Double qoite) {
this.qoite = qoite;
}
public Credit(String accountName, Double qoite) {
super();
this.accountName = accountName;
this.qoite = qoite;
}
public Credit() {
super();
// TODO Auto-generated constructor stub
}
public Credit(String accountNO, double balance, User user, Bank bank) {
super(accountNO, balance, user, bank);
// TODO Auto-generated constructor stub
}
}
踩坑心得：
1.编程时不注意字符错误，导致大量编译错误，不够彻底。我们总是忘记输入它或输入它的汉字，导致编译错误
2.创建静态方法时，不要注意到静态方法不能导致非静态方法，从而导致编译错误
不允许直接在类别中调用属性，特别是在打包的情况下。
浙公网安备 33010602011771号