blog第三次作业

一.前言

　　1.三次题目集中所考察的知识点：

　　（1）掌握类的继承、多态性使用方法以及接口的应用

　　2.三次题目集中题量、难度等情况

　　题目集七、八、九的题量都不多，但是题目的难度均大大提高了，不能够轻易解决。

二.设计与分析

①题目集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.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
    //在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
//使用Main.input.next…即可（避免采坑）
    public static Scanner input = new Scanner(System.in);
    public static void main(String[] args){
        ArrayList<Integer> list = new ArrayList<Integer>();
        int num = input.nextInt();
        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 DealCardList{
    ArrayList<Card> List = new ArrayList<Card>();
    DealCardList(){
    }
    DealCardList(ArrayList<Integer> list){
        Scanner in=new Scanner(System.in);
        for(int i=0;i<list.size();i++){
            if(list.get(i)==0){
                break;
            }
        int x=list.get(i);
        switch (x){
        case 1:  
        double r=Main.input.nextDouble();
        Circle circle =new Circle(r);
        circle.setShapeName("Circle:");
        Card card1=new Card(circle);
        List.add(card1);
        break;
        case 2:
        double width=Main.input.nextDouble();
        double length=Main.input.nextDouble();
        Rectangle rectangle =new Rectangle(width,length);
        rectangle.setShapeName("Rectangle:");
        Card card2=new Card(rectangle);
        List.add(card2);
        break;
        case 3:
        double a=Main.input.nextDouble();
        double b=Main.input.nextDouble();
        double c=Main.input.nextDouble();
        Triangle triangle =new Triangle(a,b,c);
        triangle.setShapeName("Triangle:");
        Card card3=new Card(triangle);
        List.add(card3);
        break;
        case 4:
        double l=Main.input.nextDouble();
        double d=Main.input.nextDouble();
        double h=Main.input.nextDouble();
        Trapezoid trapezoid =new Trapezoid(l,d,h);
        trapezoid.setShapeName("Trapezoid:");
        Card card4=new Card(trapezoid);
        List.add(card4);
        break;
        }
    }
    }
    public void showResult(){
        System.out.println("The original list:");
        for (int i=0;i<List.size();i++) {
            System.out.print(List.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",List.get(i).getShape().getArea());
        }
        System.out.println();
        Collections.sort(List);
        System.out.println("The sorted list:");
        for (int i=List.size()-1;i>=0;i--) {
            System.out.print(List.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",List.get(i).getShape().getArea());
        }
        System.out.println();
        System.out.printf("Sum of area:%.2f\n",getAllArea(List));
    }
    public double getAllArea(ArrayList<Card> list) {
        double sum=0;
        for(int i=0;i<list.size();i++){
            sum+=list.get(i).getShape().getArea();
        }
        return sum;
    }
    public boolean validate() {
        for(int i=0;i<List.size();i++) {
        if(List.get(i).getShape().validate()==false)
        return false;
        }
        return true;
    }
}
class Card implements Comparable<Card>{
    Shape shape;
    Card(){
    }
    void setShape(Shape shape) {
        this.shape=shape;
        
    }
    Card(Shape shape){
        this.shape=shape;
    }
    Shape getShape(){
        return shape;
    }
    public int compareTo(Card card) {
        return (int)(shape.getArea()-card.getShape().getArea());
    }
}
class Shape {
    String shapeName;
    Shape() {
    }

    Shape(String shapeName) {
        this.shapeName = shapeName;
    }

    String getShapeName() {
        return shapeName;
    }

    void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }
    double getArea() {
         return 0;
     }
    boolean validate() {
        return false;
    }
}

class Circle extends Shape{
    double radius;
    Circle(){}
    Circle(double radius){
        this.radius = radius;
    }
    public double getArea(){
        double s=Math.PI*radius*radius;
        return s;
    }
    public boolean validate() {
        if(radius<0)
            return false;
        else
            return true;
            
    }
}
class Rectangle extends Shape{
    double length;
    double width;
    Rectangle(){}
    Rectangle(double length,double width){
        this.length = length;
        this.width = width;
    }
    public double getArea(){
        double s=length*width;
        return s;
    }
    public boolean validate() {
        if(length<0||width<0)
            return false;
        else
            return true;
            
    }
}
class Triangle extends Shape{
    double a;
    double b;
    double c;
    Triangle(){}
    Triangle(double a,double b,double c){
        this.a=a;
        this.b=b;
        this.c=c;
    }
     public double getArea(){
            double p=(a+b+c)/2;
            double s=Math.sqrt(p*(p-a)*(p-b)*(p-c));
            return s;
        }
     public boolean validate() {
            if(a>=0&&b>=0&&c>=0&&a+b>c&&b+c>a&&a+c>b)
                return true;
            else
                return false;
                
        }
}
class Trapezoid extends Shape{
    double d;
    double l;
    double h;
    Trapezoid(){}
    Trapezoid(double d,double l,double h){
        this.d=d;
        this.l=l;
        this.h=h;
    }
    public double getArea(){
        double s=(d+l)*h/2;
        return s;
    }
    public boolean validate() {
        if(d<0||l<0||h<0)
            return false;
        else
            return true;
            
    }
}

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.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
    //在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
//使用Main.input.next…即可（避免采坑）
    public static Scanner input = new Scanner(System.in);
    public static void main(String[] args){
        ArrayList<Integer> list = new ArrayList<Integer>();
        int num = input.nextInt();
        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 DealCardList{
    ArrayList<Card> List = new ArrayList<Card>();
    ArrayList<Card> circleList = new ArrayList<Card>();
    ArrayList<Card> rectangleList = new ArrayList<Card>();
    ArrayList<Card> triangleList = new ArrayList<Card>();
    ArrayList<Card> trapezoidList = new ArrayList<Card>();
    DealCardList(){
    }
    DealCardList(ArrayList<Integer> list){
        Scanner in=new Scanner(System.in);
        for(int i=0;i<list.size();i++){
            if(list.get(i)==0){
                break;
            }
        int x=list.get(i);
        switch (x){
        case 1:  
        double r=Main.input.nextDouble();
        Circle circle =new Circle(r);
        circle.setShapeName("Circle:");
        Card card1=new Card(circle);
        List.add(card1);
        circleList.add(card1);
        break;
        case 2:
        double width=Main.input.nextDouble();
        double length=Main.input.nextDouble();
        Rectangle rectangle =new Rectangle(width,length);
        rectangle.setShapeName("Rectangle:");
        Card card2=new Card(rectangle);
        List.add(card2);
        rectangleList.add(card2);
        break;
        case 3:
        double a=Main.input.nextDouble();
        double b=Main.input.nextDouble();
        double c=Main.input.nextDouble();
        Triangle triangle =new Triangle(a,b,c);
        triangle.setShapeName("Triangle:");
        Card card3=new Card(triangle);
        List.add(card3);
        triangleList.add(card3);
        break;
        case 4:
        double l=Main.input.nextDouble();
        double d=Main.input.nextDouble();
        double h=Main.input.nextDouble();
        Trapezoid trapezoid =new Trapezoid(l,d,h);
        trapezoid.setShapeName("Trapezoid:");
        Card card4=new Card(trapezoid);
        List.add(card4);
        trapezoidList.add(card4);
        break;
        }
    }
    }
    public void showResult(){
        System.out.println("The original list:");
        System.out.print("[");
        for (int i=0;i<List.size();i++) {
            System.out.print(List.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",List.get(i).getShape().getArea());
        }
        System.out.print("]");
        System.out.println();
        System.out.println("The Separated List:");
        System.out.print("[");
        for (int i=0;i<circleList.size();i++) {
            System.out.print(circleList.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",circleList.get(i).getShape().getArea());
        }
        System.out.print("][");
        for (int i=0;i<rectangleList.size();i++) {
            System.out.print(rectangleList.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",rectangleList.get(i).getShape().getArea());
        }
        System.out.print("][");
        for (int i=0;i<triangleList.size();i++) {
            System.out.print(triangleList.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",triangleList.get(i).getShape().getArea());
        }
        System.out.print("][");
        for (int i=0;i<trapezoidList.size();i++) {
            System.out.print(trapezoidList.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",trapezoidList.get(i).getShape().getArea());
        }
        System.out.print("]");
        Collections.sort(circleList);
        Collections.sort(rectangleList);
        Collections.sort(triangleList);
        Collections.sort(trapezoidList);
        System.out.println();
        System.out.println("The Separated sorted List:");
        System.out.print("[");
        double[] num=new double[4]; 
        num[0]=getAllArea(circleList);
        num[1]=getAllArea(rectangleList);
        num[2]=getAllArea(triangleList);
        num[3]=getAllArea(trapezoidList);
        for (int i=circleList.size()-1;i>=0;i--) {
            System.out.print(circleList.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",circleList.get(i).getShape().getArea());
        }
        System.out.print("][");
        for (int i=rectangleList.size()-1;i>=0;i--) {
            System.out.print(rectangleList.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",rectangleList.get(i).getShape().getArea());
        }
        System.out.print("][");
        for (int i=triangleList.size()-1;i>=0;i--) {
            System.out.print(triangleList.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",triangleList.get(i).getShape().getArea());
        }
        System.out.print("][");
        for (int i=trapezoidList.size()-1;i>=0;i--) {
            System.out.print(trapezoidList.get(i).getShape().getShapeName());
            System.out.printf("%.2f ",trapezoidList.get(i).getShape().getArea());
        }
        System.out.print("]");
        System.out.println();
        System.out.printf("The max area:%.2f\n",getMaxArea(num));
    }
    public double getAllArea(ArrayList<Card> list) {
        double sum=0;
        for(int i=0;i<list.size();i++){
            sum+=list.get(i).getShape().getArea();
        }
        return sum;
    }
    public double getMaxArea(double a[]) {
        double max=0;
        for(int i=0;i<a.length;i++){
            if(max<a[i])
                max=a[i];
        }
        return max;
    }
    public boolean validate() {
        for(int i=0;i<List.size();i++) {
        if(List.get(i).getShape().validate()==false)
        return false;
        }
        return true;
    }
}
class Card implements Comparable<Card>{
    Shape shape;
    Card(){
    }
    void setShape(Shape shape) {
        this.shape=shape;
        
    }
    Card(Shape shape){
        this.shape=shape;
    }
    Shape getShape(){
        return shape;
    }
    public int compareTo(Card card) {
        return (int)(shape.getArea()-card.getShape().getArea());
    }
}
class Shape {
    String shapeName;
    Shape() {
    }

    Shape(String shapeName) {
        this.shapeName = shapeName;
    }

    String getShapeName() {
        return shapeName;
    }

    void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }
    double getArea() {
         return 0;
     }
    boolean validate() {
        return false;
    }
}

class Circle extends Shape{
    double radius;
    Circle(){}
    Circle(double radius){
        this.radius = radius;
    }
    public double getArea(){
        double s=Math.PI*radius*radius;
        return s;
    }
    public boolean validate() {
        if(radius<0)
            return false;
        else
            return true;
            
    }
}
class Rectangle extends Shape{
    double length;
    double width;
    Rectangle(){}
    Rectangle(double length,double width){
        this.length = length;
        this.width = width;
    }
    public double getArea(){
        double s=length*width;
        return s;
    }
    public boolean validate() {
        if(length<0||width<0)
            return false;
        else
            return true;
            
    }
}
class Triangle extends Shape{
    double a;
    double b;
    double c;
    Triangle(){}
    Triangle(double a,double b,double c){
        this.a=a;
        this.b=b;
        this.c=c;
    }
     public double getArea(){
            double p=(a+b+c)/2;
            double s=Math.sqrt(p*(p-a)*(p-b)*(p-c));
            return s;
        }
     public boolean validate() {
            if(a>=0&&b>=0&&c>=0&&a+b>c&&b+c>a&&a+c>b)
                return true;
            else
                return false;
                
        }
}
class Trapezoid extends Shape{
    double d;
    double l;
    double h;
    Trapezoid(){}
    Trapezoid(double d,double l,double h){
        this.d=d;
        this.l=l;
        this.h=h;
    }
    public double getArea(){
        double s=(d+l)*h/2;
        return s;
    }
    public boolean validate() {
        if(d<0||l<0||h<0)
            return false;
        else
            return true;
            
    }
}

题目集7-2和题目集7-1中的类的设计大致类似，功能也大致相同，只不过7-1中功能较为简单，而7-2的功能在7-1上深化了而已。7-1中只要求计算输入数据组成的图形的面积并进行从小到大的排序，而7-2则要求对输入数据组成的数据进行组合，相同的图形为一组，然后对每个组中的数据进行排序，区别并不是很大，7-1中使用了一个ArrayList储存数据，而7-2中则是将每个图形都创建一个ArrayList进行储存，再分别进行操作。

从7-1到7-2，代码要求实现的功能由简单到复杂，但总体来说，都是在原有代码上进行修改，使代码的功能更加多样，只要实现了代码的基本功能，再做修改就并不困难。

②题目集8和题目集9两道ATM机仿真题目的设计思路分析总结

8-1

输入格式:

每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业务操作输入格式如下：

存款、取款功能输入数据格式： 卡号密码 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编号]上存款¥[金额]

当前余额为¥[金额]

其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。

④查询余额业务输出

¥[金额]

金额保留两位小数。

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","涓浗寤鸿閾惰");
        Bank icbc = new Bank("1002","涓浗宸ュ晢閾惰");
        unionPay.addBank(ccb);
        unionPay.addBank(icbc);
        
        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);
        
        ccb.addATM(aTM1);
        ccb.addATM(aTM2);
        ccb.addATM(aTM3);
        ccb.addATM(aTM4);
        icbc.addATM(aTM5);
        icbc.addATM(aTM6);
        
        User Yangguo = new User("360101200102122324","鏉ㄨ繃","13856223254");
        User Guojing = new User("360101200012302552","閮潠","13800021124");
        User Zhangwuji = new User("360502199805163221","寮犳棤蹇�","13952110011");
        User Weixiaobao = new User("360201200513243326","闊﹀皬瀹�","13025996587");
        
        Account ccbAcc1 = new Account("3217000010041315709",10000.00,Yangguo,ccb);
        Account ccbAcc2 = new Account("3217000010041315715",10000.00,Yangguo,ccb);
        Account ccbAcc3 = new Account("3217000010051320007",10000.00,Guojing,ccb);
        Account icbcAcc1 = new Account("3222081502001312389",10000.00,Zhangwuji,icbc);
        Account icbcAcc2 = new Account("3222081502001312390",10000.00,Zhangwuji,icbc);
        Account icbcAcc3 = new Account("3222081502001312399",10000.00,Zhangwuji,icbc);
        Account icbcAcc4 = new Account("3222081502051320785",10000.00,Weixiaobao,icbc);
        Account icbcAcc5 = new Account("3222081502051320786",10000.00,Weixiaobao,icbc);
        
        ccb.addAccount(ccbAcc1);
        ccb.addAccount(ccbAcc2);
        ccb.addAccount(ccbAcc3);
        icbc.addAccount(icbcAcc1);
        icbc.addAccount(icbcAcc2);
        icbc.addAccount(icbcAcc3);
        icbc.addAccount(icbcAcc4);
        icbc.addAccount(icbcAcc5);
    
        
        Yangguo.addAccount(ccbAcc1);
        Yangguo.addAccount(ccbAcc2);
        Guojing.addAccount(ccbAcc3);
        Zhangwuji.addAccount(icbcAcc1);
        Zhangwuji.addAccount(icbcAcc2);
        Zhangwuji.addAccount(icbcAcc3);
        Weixiaobao.addAccount(icbcAcc4);
        Weixiaobao.addAccount(icbcAcc5);
        
        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);
        
        ccbAcc1.addCard(ccbCard1);
        ccbAcc1.addCard(ccbCard2);
        ccbAcc2.addCard(ccbCard3);
        ccbAcc3.addCard(ccbCard4);
        icbcAcc1.addCard(icbcCard5);
        icbcAcc2.addCard(icbcCard6);
        icbcAcc3.addCard(icbcCard7);
        icbcAcc3.addCard(icbcCard8);
        icbcAcc4.addCard(icbcCard9);
        icbcAcc5.addCard(icbcCard10);
        
        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);
                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 ArrayList<Account> accountList = new ArrayList<Account>();
    private ArrayList<ATM> ATMList = new ArrayList<ATM>();

    public Bank() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Bank(String bankNO, String bankName) {
        super();
        this.bankNO = bankNO;
        this.bankName = bankName;
    }

    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) {
        this.ATMList.add(aTM);
    }
    
    public void removeATM(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 static ArrayList<Card> list = new ArrayList<Card>();

    public Account() {
        super();
        // 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 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 withdraw() {
        /**
         * 鏍￠獙璇ュ崱鏄惁瀛樺湪
         */        
        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);
        }
        
        /**
         * 鏍￠獙鍙栨閲戦鏄惁澶т簬浣欓
         */
        if (amount > balance) {
            System.out.println("Sorry,your account balance is insufficient.");
            System.exit(0);
        }
        
        /**
         * 鏍￠獙鏄惁涓鸿法琛屽彇娆�
         */
        if (account.getBank().getBankNO() != aTM.getBank().getBankNO()) {
            System.out.println("Sorry,cross-bank withdrawal is not supported.");
            System.exit(0);
        }    

        account.setBalance(balance - amount);//鍙栨鏇存柊浣欓鎿嶄綔

        if(amount >= 0) {
            showResult(account,1);
        }else {
            showResult(account,0);
        }
        
    }
    
    public void showResult(Account account,int flag) {
        String type = "";
        if(flag == 1) {
            type = "取款";            
        }else {
            type = "存款";
            amount *= -1;
        }
        String userName = account.getUser().getName();
        String bankName = account.getBank().getBankName();
        System.out.println(userName + "在" +
                bankName + "的" + ATMID + "号ATM机上" + type + String.format("楼%.2f", amount));
                System.out.println("当前余额为" + String.format("楼%.2f", account.getBalance()));
    }
}

class ValidateData {
    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;
    }
    public static ATM getATMbyATMID(UnionPay unionPay,String ATMID) {
        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 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();
    }
}

题目集八我的功能未按照老师的要求完全实现，此为老师的代码。

9-1

输入格式:

每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业务操作输入格式如下：

取款功能输入数据格式： 卡号密码 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 bank1 = new Bank("1001","中国建设银行",0.02);
        Bank bank2 = new Bank("1002","中国工商银行",0.03);
        Bank bank3 = new Bank("1003","中国农业银行",0.04);
        unionPay.addBank(bank1);
        unionPay.addBank(bank2);
        unionPay.addBank(bank3);
        
        ATM aTM1 = new ATM("01",bank1);
        ATM aTM2 = new ATM("02",bank1);
        ATM aTM3 = new ATM("03",bank1);
        ATM aTM4 = new ATM("04",bank1);
        ATM aTM5 = new ATM("05",bank2);
        ATM aTM6 = new ATM("06",bank2);
        ATM aTM7 = new ATM("07",bank3);
        ATM aTM8 = new ATM("08",bank3);
        ATM aTM9 = new ATM("09",bank3);
        ATM aTM10 = new ATM("10",bank3);
        ATM aTM11 = new ATM("11",bank3);
        
        bank1.addATM(aTM1);
        bank1.addATM(aTM2);
        bank1.addATM(aTM3);
        bank1.addATM(aTM4);
        bank2.addATM(aTM5);
        bank2.addATM(aTM6);
        bank3.addATM(aTM7);
        bank3.addATM(aTM8);
        bank3.addATM(aTM9);
        bank3.addATM(aTM10);
        bank3.addATM(aTM11);
        
        User Yangguo = new User("杨过");
        User Guojing = new User("郭靖");
        User Zhangwuji = new User("张无忌");
        User Weixiaobao = new User("韦小宝");
        User Zhangsanfeng = new User("张三丰");
        User Linghuchong = new User("令狐冲");
        User Qiaofeng = new User("乔峰");
        User Hongqigong = new User("洪七公");
         
        Account bank1Acc1 = new Account("3217000010041315709",10000.00,Yangguo,bank1,"1");
        Account bank1Acc2 = new Account("3217000010041315715",10000.00,Yangguo,bank1,"1");
        Account bank1Acc3 = new Account("3217000010051320007",10000.00,Guojing,bank1,"1");
        Account bank2Acc1 = new Account("3222081502001312389",10000.00,Zhangwuji,bank2,"1");
        Account bank2Acc2 = new Account("3222081502001312390",10000.00,Zhangwuji,bank2,"1");
        Account bank2Acc3 = new Account("3222081502001312399",10000.00,Zhangwuji,bank2,"1");
        Account bank2Acc4 = new Account("3222081502051320785",10000.00,Weixiaobao,bank2,"1");
        Account bank2Acc5 = new Account("3222081502051320786",10000.00,Weixiaobao,bank2,"1");
        Account bank1Acc4 = new Account("3640000010045442002",10000.00,Zhangsanfeng,bank1,"0");
        Account bank2Acc6 = new Account("3640000010045441009",10000.00,Linghuchong,bank2,"0");
        Account bank3Acc1 = new Account("3630000010033431001",10000.00,Qiaofeng,bank3,"0");
        Account bank3Acc2 = new Account("3630000010033431008",10000.00,Hongqigong,bank3,"0");
        
        bank1.addAccount(bank1Acc1);
        bank1.addAccount(bank1Acc2);
        bank1.addAccount(bank1Acc3);
        bank2.addAccount(bank2Acc1);
        bank2.addAccount(bank2Acc2);
        bank2.addAccount(bank2Acc3);
        bank2.addAccount(bank2Acc4);
        bank2.addAccount(bank2Acc5);
        bank1.addAccount(bank1Acc4);
        bank2.addAccount(bank2Acc6);
        bank3.addAccount(bank3Acc1);
        bank3.addAccount(bank3Acc2);
    
        
        Yangguo.addAccount(bank1Acc1);
        Yangguo.addAccount(bank1Acc2);
        Guojing.addAccount(bank1Acc3);
        Zhangwuji.addAccount(bank2Acc1);
        Zhangwuji.addAccount(bank2Acc2);
        Zhangwuji.addAccount(bank2Acc3);
        Weixiaobao.addAccount(bank2Acc4);
        Weixiaobao.addAccount(bank2Acc5);
        Zhangsanfeng.addAccount(bank1Acc4);
        Linghuchong.addAccount(bank2Acc6);
        Qiaofeng.addAccount(bank3Acc1);
        Hongqigong.addAccount(bank3Acc2);
        
        Card bank1Card1 = new Card("6217000010041315709","88888888",bank1Acc1);
        Card bank1Card2 = new Card("6217000010041315715","88888888",bank1Acc1);
        Card bank1Card3 = new Card("6217000010041315718","88888888",bank1Acc2);
        Card bank1Card4 = new Card("6217000010051320007","88888888",bank1Acc3);
        Card bank2Card5 = new Card("6222081502001312389","88888888",bank2Acc1);
        Card bank2Card6 = new Card("6222081502001312390","88888888",bank2Acc2);
        Card bank2Card7 = new Card("6222081502001312399","88888888",bank2Acc3);
        Card bank2Card8 = new Card("6222081502001312400","88888888",bank2Acc3);
        Card bank2Card9 = new Card("6222081502051320785","88888888",bank2Acc4);
        Card bank2Card10 = new Card("6222081502051320786","88888888",bank2Acc5);
        Card bank1Card11 = new Card("6640000010045442002","88888888",bank1Acc4);
        Card bank1Card12 = new Card("6640000010045442003","88888888",bank1Acc4);
        Card bank2Card13 = new Card("6640000010045441009","88888888",bank2Acc6);
        Card bank3Card14 = new Card("6630000010033431001","88888888",bank3Acc1);
        Card bank3Card15 = new Card("6630000010033431008","88888888",bank3Acc2);
        
        bank1Acc1.addCard(bank1Card1);
        bank1Acc1.addCard(bank1Card2);
        bank1Acc2.addCard(bank1Card3);
        bank1Acc3.addCard(bank1Card4);
        bank2Acc1.addCard(bank2Card5);
        bank2Acc2.addCard(bank2Card6);
        bank2Acc3.addCard(bank2Card7);
        bank2Acc3.addCard(bank2Card8);
        bank2Acc4.addCard(bank2Card9);
        bank2Acc5.addCard(bank2Card10);
        bank1Acc4.addCard(bank1Card11);
        bank1Acc4.addCard(bank1Card12);
        bank2Acc6.addCard(bank2Card13);
        bank3Acc1.addCard(bank3Card14);
        bank3Acc2.addCard(bank3Card15);
        
        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);
                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 {
    String bankNO;
    String bankName;
    double interest;
    ArrayList<Account> accountList = new ArrayList<Account>();
    ArrayList<ATM> ATMList = new ArrayList<ATM>();

    public Bank() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Bank(String bankNO, String bankName,double interest) {
        super();
        this.bankNO = bankNO;
        this.bankName = bankName;
        this.interest = interest;
    }

    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) {
        this.ATMList.add(aTM);
    }
    
    public void removeATM(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 {
    String name;
    ArrayList<Account> list = new ArrayList<Account>();

    public User() {
        super();
        // TODO Auto-generated constructor stub
    }    

    public User(String name) {
        super();
        this.name = name;
    }
    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 {
    String accountNO;
    String Accounttype;
    double balance = 0;
    User user = null;
    Bank bank = null;
    static ArrayList<Card> list = new ArrayList<Card>();

    public Account() {
        super();
        // TODO Auto-generated constructor stub
    }   

    public Account(String accountNO, double balance, User user, Bank bank,String Accounttype) {
        super();
        this.accountNO = accountNO;
        this.balance = balance;
        this.user = user;
        this.bank = bank;
        this.Accounttype = Accounttype;
    }

    public void addCard(Card card) {
        list.add(card);
    }

    public void removeCard(Card card) {
        list.remove(card);
    }
    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.cardNO.equals(cardNO)) {
                return card.getAccount();
            }
        }
        
        return null;
    }

    public void setBalance(double d) {
        this.balance = d;
        
    }
}

class Card {
    String cardNO;
    String cardPassword;
    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 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 {
    String ATMID;
    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 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 withdraw() {    
        Card card = ValidateData.getCardbyCardNO(unionPay, cardNO);
        if(card == null) {
            System.out.println("Sorry,this card does not exist.");
            System.exit(0);
        }
        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.balance;
        if(!card.getCardPassword().equals(cardPassword)) {
            System.out.println("Sorry,your password is wrong.");
            System.exit(0);
        }
        
        if (amount > balance) {
            if(account.Accounttype=="1") {
            System.out.println("Sorry,your account balance is insufficient.");
            System.exit(0);
            }
            if(account.Accounttype=="0"&&amount>balance+50000) {
                System.out.println("Sorry,your account balance is insufficient.");
                System.exit(0);
            }
        }
        if(account.getBank().getBankName()!=aTM.getBank().getBankName()) {
            if(account.Accounttype=="1"&&(balance-amount - amount*aTM.getBank().interest )<=0) {
                System.out.println("Sorry,your account balance is insufficient.");
                System.exit(0);
            }
            else if(account.Accounttype=="0"&&(balance-amount)<=0) {
                if(balance<=0)
                    account.setBalance(balance - amount - amount*aTM.getBank().interest -amount*0.05);
                else
                    account.setBalance(balance - amount - amount*aTM.getBank().interest + (balance-amount)*0.05);
            }
            else
                account.setBalance(balance - amount - amount*aTM.getBank().interest);
        }
        if(account.getBank().getBankName()==aTM.getBank().getBankName()) {
            if(account.Accounttype=="0"&&(balance-amount)<=0) {
                if(balance<=0)
                    account.setBalance(balance - amount - amount*0.05);
                else
                    account.setBalance(balance - amount + (balance-amount)*0.05);
            }
            else
                account.setBalance(balance - amount);
        }
        if(amount >= 0) {
            showResult(account,aTM,1);
        }else {
            showResult(account,aTM,0);
        }
        
    }
    
    public void showResult(Account account,ATM aTM,int flag) {
        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.balance));
    }
}

class ValidateData {
    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.cardNO.equals(cardNO)) {
                        return card;
                    }
                }
            }
        }
        return null;
    }
    
    public static ATM getATMbyATMID(UnionPay unionPay,String ATMID) {
        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 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().balance;
    }
}

实验9-1与实验8-1类的设计相似，只不过功能实现的更多。

（1）注意本题目中的各实体类之间的关系，尤其是一对多的组合关系。

（2）对实体类的设计要做到单一职责原则，且不能缺少规定的实体类。

（3）在“合成复用原则”及“单一职责原则”基础上，尽量对上次作业的程序进行重构，使之符合 “开-闭”原则。

（3）采坑心得

1.没有注意编程时符号的错误，导致很多次的编译错误，不够细心，总是忘记输入“，”或者将其输成中文符号，导致编译错误；

2.static是创建静态方法，没有注意到静态方法中不能够调用非静态方法，导致编译出错；

3.不能够在一个类中对另一个类中的属性进行直接调用，特别是在封装的情况下。

（4）改进建议

（5）总结

Java是一种面向对象的语言，相比于编程来说，在编写代码前的思考更为重要，考虑如何将代码完善，将Java学习的思维方式更好地运用，才能越走越远。

通过这三次的pta作业，我认识到了一些问题，我对java这门课程的学习还存在很多的问题，在今后的学习中，只会越来越难，如果没有花费足够的到java的学习当中去，因为如果仅靠老师上课所传授的知识，是不可能能够独立完成老师所发布的pta作业的，一定要在课外进行学习，否则只会离老师的进度越来越远，差距越来越大。我明白了，在今后的学习中，不能只靠老师所传授的知识，一定要在课外进行自我学习，才能越走越远

posted @ 2021-06-15 17:23 南久阅读(60) 评论(0) 收藏举报

刷新页面返回顶部

南久

blog第三次作业

一.前言

二.设计与分析

公告