OO第三次大作业——来自小白星球总结

一、前言

 　　第七次题目集：

　　1.题目量为两题：7-1 图形卡片排序游戏，7-2图形卡片分组游戏。

　　2.知识点：（1）继承与多态；（2）使用private进行数据域的封装；（3）ArrayList数组的使用，用以存放不同类型的图形以及数据（4）TreeSet的使用。（5）compareTo()的重写与使用。

　　3.难度：总体难度不是很大。

　　第八次题目集：

　　1.题目量为1题：7-3 ATM机类结构设计（一）。

　　2.知识点：（1）类结构的设计；（2）通过引用变量访问对象，静态变量、方法、数据域封装；（3）方法的重写和重载，对象转化。（4）类的关系的关联，聚集和组合；（5）方法重写与重载，对象转化。

　　3.难度：类结构设计如何才更加合理，难度系数**。

　　第九次题目集：

　　　1.题目量为1题：7-1 ATM机类结构设计（二）

　　　2.知识点：（1）继承与多态；（2）instanceof操作符，protected数据据和方法；（3）object类的equals方法；（4）arraylist类；（5）继承和多态中的调用父类构造方法，构造方法链，调用父类的普通方法；（6）类的关系的关联，聚集和组合。

　　　3.难度：在第八次题目集的基础上新增了借贷卡难度系数***。

二、设计与分析

　　①题目集7（7-1）、（7-2）两道题目的递进式设计分析总结

题目集7-1要求：

1. 作业目标

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

2. 作业要求

2.1 业务背景

（1）卡片大小排序游戏规则

   考虑一款适合于小学生的卡片（Card）排序游戏，其规则为随机发放一些卡片给学生，卡片分为 四种形状：圆形（Circle）、矩形（Rectangle）、三角形（Triangle）及梯形（Trapezoid），并给出各种 卡片的相应参数，要求学生能够迅速求出各卡片的面积大小然后将卡片按照其面积值从大到小进行排 序，同时求出所有卡片的面积之和。

（2）Comparable 接口的应用

   图形类设计可参考作业 6-1 的类层次结构，本次作业要求对卡片排序时使用 Comparable 接口， 即 Card 类需要实现 Comparable 接口中的 CompareTo()方法。

2.2 程序功能需求

（1）实现功能

   本程序仅用于为学生所玩的游戏提供正确答案的功能，即根据学生得到的卡片种类与数量，给出 排序前和排序后的卡片顺序，同时给出所有卡片的面积之和。

（2）输入输出规则

   ①输入规则 首先，在一行上输入一串数字（1~4，整数），其中，1 代表圆形卡片，2 代表矩形卡片，3 代表 三角形卡片，4 代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如： 1 3 4 2 1 3 4 2 1 3 0 然后根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要 输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要 输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。

   ②输出规则  如果图形数量非法（小于 0）或图形属性值非法（数值小于 0 以及三角形三边不能组成三 角形），则输出“Wrong Format”。 2 / 4  如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。输出内容如下：  排序前的各图形类型及面积，格式为“图形名称 1:面积值 1 图形名称 2:面积值 2 …图形名称 n:面积值 n ”，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格；  排序后的各图形类型及面积，格式同排序前的输出；  所有图形的面积总和，格式为“Sum of area:总面积值”。 输出格式见输入输出示例。

题目集7-2要求：

1. 作业目标

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

2. 作业要求

2.1 业务背景

（1）卡片大小排序游戏规则

　　　沿袭作业 7-1，本次作业主要对卡片（Card）进行分组游戏，其规则为随机发放一些卡片给学生， 卡片仍然分为四种形状：圆形（Circle）、矩形（Rectangle）、三角形（Triangle）及梯形（Trapezoid）， 并给出各种卡片的相应参数，要求学生首先根据卡片类型将所有卡片进行分组（一个类型分为一组， 所以最多四组），然后能够对每组内的卡片根据面积值从大到小进行排序，同时求出该组内所有卡片 的面积之和，最后求出每组卡片面积之和中的最大值。

（2）Comparable、Comparator 接口的应用

　　图形类设计可参考作业 7-1 的类层次结构（需要进一步完善），本次作业要求对卡片排序时使用 Comparable 接口或 Comparator 接口。

2.2 程序功能需求

（1）实现功能  对各图形信息进行输入并输出； 输入数据的正确性校验； 对输入的图形按照图形类型进行分组并输出，分组原理如下图所示： 对每组内的图形按照面积值降序排序并输出；  求出每组内图形面积的总和； 求出所有组的面积总和的最大值并输出。

（2）输入输出规则 2 / 5 ①输入规则 首先，在一行上输入一串数字（1~4，整数），其中，1 代表圆形卡片，2 代表矩形卡片，3 代表 三角形卡片，4 代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如： 1 3 4 2 1 3 4 2 1 3 0 然后根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要 输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要 输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。 ②输出规则 如果图形数量非法（<=0）或图形属性值非法（数值<0 以及三角形三边不能组成三角形）， 则输出“Wrong Format”。 如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。输出内容如下： ➢ 排序前的各图形类型及面积，格式为“[图形名称 1:面积值 1 图形名称 2:面积值 2 …图形名称 n:面积值 n ]”，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格， 在结束符“]”之前； ➢ 输出分组后的图形类型及面积，格式为“[圆形分组各图形类型及面积][矩形分组各图形类型 及面积][三角形分组各图形类型及面积][梯形分组各图形类型及面积]”，各组内格式为“图形 名称:面积值”。按照“Circle、Rectangle、Triangle、Trapezoid”的顺序依次输出； ➢ 各组内图形排序后的各图形类型及面积，格式同排序前各组图形的输出； ➢ 各组中面积之和的最大值输出，格式为“The max area:面积值”。 输出格式见输入输出示例。

分析：这两次题目集主要基于图形卡片的多态排序。要求我们掌握类的继承，多态性使用以及接口的引用，要我们对图像进行分类，分为四种形状，分别为：圆形（Circle）、矩形（Rectangle）、三角形（Triangle）及梯形（Trapezoid），并按图片的大小从小到大进行排序和求出面积之和，这题排序时要用comparable接口，Card 类需要实现 Comparable 接口中的 CompareTo()方法，comparable接口定义了compareto方法，用于比较对象，是找出两个相同类型对象中较大者的通用方法，这两个对象必须是可比较的，compareto方法判断这个对象相当于给定对象的顺序，并且但这个对象小于，等于或大于时，分别负整数，零或正整数。从类图上来看，题目集7（7-1）和题目集7（7-2）的类图相差不大，其中Main类、Shape类、Rectangle类、Triangle类、Circle类、Trapezoid类完全一样，类的属性和方法都没有改变，主要差距在于DealCardList类中，不难发现，7-2的DealCardList类中属性更多，方法也多了（这里插一句，接口的变化可以忽略，其实两个题的接口的实现可以不变，当时做完7-1的时候发现Comparable接口是自带的，可以直接使用，无需重新定义，后面7-2改了，同时发现可以利用Collections类中的sort()方法直接对面积的大小进行排序），从这两个题目的递进式设计可以充分体现代码的复用性，以及代码的可拓展性。从类的属性和方法上观察，可以发现每个类都有每个类的特定功能，比如getArea()方法，每个继承Shape类的子类都进行了重写，用以获得各自的面积，体现了设计的“单一职责”原则，一个类/接口只执行一个职责。忽略接口的变化，7-1到7-2的最大区别在于7-2的DealCardList类在7-1的基础上增加了属性和方法，这体现了设计的“开-闭”原则，对扩展开放，对修改关闭

题目集合7-1类图：

 

题目集7-1源码在SourceMonitor中的分析：

题目集合7-2类图：

 

题目集7-2源码在SourceMonitor中的分析图:

 

题目集7-1题目及源码：

7-1 图形卡片排序游戏 (40 分)

掌握类的继承、多态性使用方法以及接口的应用。详见作业指导书 2020-OO第07次作业-1指导书V1.0.pdf

输入格式:

• 首先，在一行上输入一串数字（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. 排序后的各图形类型及面积，格式同排序前的输出；
3. 所有图形的面积总和，格式为Sum of area:总面积值。

输入样例1:

在这里给出一组输入。例如：

1 5 3 2 0

输出样例1:

在这里给出相应的输出。例如：

Wrong Format

输入样例2:

在这里给出一组输入。例如：

4 2 1 3 0
3.2 2.5 0.4 2.3 1.4 5.6 2.3 4.2 3.5

输出样例2:

在这里给出相应的输出。例如：

The original list:
Trapezoid:1.14 Rectangle:3.22 Circle:98.52 Triangle:4.02 
The sorted list:
Circle:98.52 Triangle:4.02 Rectangle:3.22 Trapezoid:1.14 
Sum of area:106.91

输入样例3:

在这里给出一组输入。例如：

4 2 1 3 0
3.2 2.5 0.4 2.3 1.4 5.6 2.3 4.2 8.4

输出样例3:

在这里给出相应的输出。例如：

Wrong Format

//package PTA7;
import java.util.*;
import java.util.TreeSet;
import java.util.ArrayList;

public class Main{
    /*在Main1类中定义一个静态Scanner对象，这样在其他类中如果想要使用该对象进行
     * 输入，则直接使用Main.input.next...即可 */
    public static Scanner input = new Scanner(System.in);

    public static void main(String[] args) {
        ArrayList<Integer> list;
        list = new ArrayList<>();
        int num = input.nextInt();
        while (num != 0) {  //循环一直输入
            //输入非法
            if (num < 0 || num > 4) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            list.add(num);    /*把num存进list数组*/
            num = input.nextInt();
        }
        DealCardList dealCardList = new DealCardList(list);   //把list传进dealCardlist
        if (!dealCardList.validate()) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        dealCardList.showResult();
        input.close();
    }
}
//卡片处理
class DealCardList {
    ArrayList<Card> cardList = new ArrayList<>();
    //无参构造
    public DealCardList() {
    }
    //带参构造
    public DealCardList(ArrayList<Integer> cardnum) {    //list==cardnum ,取数组进行判断
        for (Integer i = 0; i< cardnum.size(); i++) {
            if (cardnum.get(i) == 0) {
                break;
            } else if (cardnum.get(i) == 1) {  //1为圆
                Card c1 = new Card(new Circle(Main.input.nextDouble()));  //如果是圆，则new一个圆类，并输入半径
                c1.getShape().setShapeName("Circle");
                cardList.add(c1);
                //break;
            } else if (cardnum.get(i) == 2) { //2为矩形
                Card c2 = new Card(new Rectangle(Main.input.nextDouble(), Main.input.nextDouble()));
                c2.getShape().setShapeName("Rectangle");
                cardList.add(c2);
                //break;
            } else if (cardnum.get(i) == 3) {  //3为三角形
                Card c3 = new Card(new Triangle(Main.input.nextDouble(), Main.input.nextDouble(), Main.input.nextDouble()));
                c3.getShape().setShapeName("Triangle");
                cardList.add(c3);
                // break;
            } else if (cardnum.get(i) == 4) {  //4为梯形
                Card c4 = new Card(new Trapezoid(Main.input.nextDouble(), Main.input.nextDouble(), Main.input.nextDouble()));
                c4.getShape().setShapeName("Trapezoid");
                cardList.add(c4);
                // break;
            }
        }
    }
    //输入合法性判断
    public boolean validate() {
        boolean b = true;
        for(int i = 0; i < cardList.size() ; i++){
            Card c = cardList.get(i);
            if (!c.getShape().validate()) {
                b = false;
                break;
            }
        }
        return b;
    }
    //卡片排序
    public void cardSort() {
        TreeSet<Card> kp = new TreeSet<>();
        for(int i = 0; i < cardList.size(); i++){
            kp.add(cardList.get(i));
        }
        for (Card a : kp) {
            System.out.print(a.getShape());
        }
    }
    //获取全部面积
    public double getAllArea() {
        double sum = 0;
        for (Card c : cardList) {
            sum = sum + c.getShape().getArea();
        }
        return sum;
    }
    //输出结果
    public void showResult() {
        System.out.println("The original list:");
        for(int i = 0; i<cardList.size() ; i++){
            Card c = cardList.get(i);
            System.out.print(c.getShape());
        }
        System.out.println();
        System.out.println("The sorted list:");
        cardSort();
        System.out.printf("\nSum of area:%.2f\n", getAllArea());
    }
}
//卡片类
class Card implements Comparable<Card>{
    Shape shape;

    //无参构造
    Card() {
    }

    //带参构造
    Card(Shape shape) {
        this.shape = shape;
    }

    //shape getter
    public Shape getShape() {
        return shape;
    }

    //shape setter
    public void setShape(Shape shape) {
        this.shape = shape;
    }
    //compareTo
    public int compareTo(Card c) {
        double value = shape.getArea()-c.getShape().getArea();
        if(value > 0){
            return -1;
        }
        else if(value < 0){
            return 1;
        }
        return 0;
    }
}
//抽象图形类
abstract class Shape{
    private String shapeName;
    //无参构造
    Shape() {
    }

    //带参构造
    Shape(String shapeName) {
        this.shapeName = shapeName;
    }

    //shapeName getter
    public String getShapeName() {
        return shapeName;
    }

    //shapeName setter
    public void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }

    //计算面积
    public double getArea(){
        return 0.0;
    }

    //合法性判断
    public  boolean validate(){
        return true;
    }

    //toString
    public String toString() {
        return  getShapeName()+":"+String.format("%.2f ",getArea());
    }
}
//圆
class Circle extends Shape {
    private double radius;

    //无参构造
    Circle() {
    }

    //带参构造
    Circle(double radius) {
        this.radius = radius;
    }

    //radius getter
    public double getRadius() {
        return radius;
    }

    //radius setter
    public void setRadius(double radius) {
        this.radius = radius;
    }

    //计算面积
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }

    //合法性判断
    @Override
    public boolean validate() {
        return radius > 0;
    }

}
//矩形
class Rectangle extends Shape {
    private double width;
    private double length;

    //无参构造
    Rectangle() {
    }

    //带参构造
    Rectangle(double width, double length) {
        this.width = width;
        this.length = length;
    }

    //width getter
    public double getWidth() {
        return width;
    }

    //width setter
    public void setWidth(double width) {
        this.width = width;
    }

    //length getter
    public double getLength() {
        return length;
    }

    //length setter
    public void setLength(double length) {
        this.length = length;
    }

    //计算面积
    @Override
    public double getArea() {
        return width * length;
    }

    //合法性判断
    @Override
    public boolean validate() {
        return width > 0 && length > 0;
    }
}

//三角形
class Triangle extends Shape {
    private double side1;
    private double side2;
    private double side3;

    //无参构造
    Triangle() {
    }

    //带参构造
    Triangle(double side1, double side2, double side3) {
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }

    //side1 getter
    public double getSide1() {
        return side1;
    }

    //side1 setter
    public void setSide1(double side1) {
        this.side1 = side1;
    }

    //side2 getter
    public double getSide2() {
        return side2;
    }

    //side2 setter
    public void setSide2(double side2) {
        this.side2 = side2;
    }

    //side3 getter
    public double getSide3() {
        return side3;
    }

    //side3 setter
    public void setSide3(double side3) {
        this.side3 = side3;
    }

    //计算面积
    @Override
    public double getArea() {
        double p = (this.side1 + this.side2 + this.side3) / 2.0;
        return Math.sqrt(p * (p - side1) * (p - side2) * (p - side3));
    }

    //合法性判断
    @Override
    public boolean validate() {
        double temp;
        if(side1 > side2){
            temp = side1;
            side1 = side2;
            side2 = temp;
        }
        if(side1 > side3){
            temp = side1;
            side1 = side3;
            side3 = temp;
        }
        if(side2 > side3){
            temp = side2;
            side2 = side3;
            side3 = temp;
        }
        /*
        double[] a = new double[3];
        a[0] = side1;
        a[1] = side2;
        a[2] = side3;
        //使用冒泡排序
        boolean b = true;
        while(b){
            int flag = 0;
            for(int i = 1; i < a.length; i++){
                if(a[i-1]>a[i]){
                    double temp = a[i];
                    a[i] = a[i-1];
                    a[i-1] = temp;
                    flag = 1;
                    if(i==2)
                        b = false;
                }
                if(flag == 1)
                    break;
            }
        }*/
       // return ((a[0] + a[1]) > a[2]) && a[0]> 0 && a[1] > 0 && a[2] > 0;
        return ((side1 + side2) > side3) && side1 >0 && side2 > 0 && side3 > 0;
    }
}

//四边形
class Trapezoid extends Shape {
    private double topSide;
    private double bottomSide;
    private double height;

    //无参构造
    public Trapezoid() {
    }

    //带参构造
    public Trapezoid(double topSide, double bottomSide, double height) {
        this.topSide = topSide;
        this.bottomSide = bottomSide;
        this.height = height;
    }

    //topSide getter
    public double getTopSide() {
        return topSide;
    }

    //topSide setter
    public void setTopSide(double topSide) {
        this.topSide = topSide;
    }

    //bottomSide getter
    public double getBottomSide() {
        return bottomSide;
    }

    //bottomSide setter
    public void setBottomSide(double bottomSide) {
        this.bottomSide = bottomSide;
    }

    //height getter
    public double getHeight() {
        return height;
    }

    // height setter
    public void setHeight(double height) {
        this.height = height;
    }

    //计算面积
    @Override
    public double getArea() {
        return (this.bottomSide + this.topSide) * this.height / 2.0;
    }

    //合法性判断
    @Override
    public boolean validate() {
        return this.topSide > 0 && this.bottomSide > 0 && this.height > 0;
    }
}

题目集7-2题目及源码：

7-2 图形卡片分组游戏 (60 分)

掌握类的继承、多态性使用方法以及接口的应用。 具体需求参考作业指导书。

2021-OO第07次作业-2指导书V1.0.pdf

输入格式:

• 在一行上输入一串数字（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:面积值。

输入样例1:

在这里给出一组输入。例如：

1 5 3 2 0

输出样例1:

在这里给出相应的输出。例如：

Wrong Format

输入样例2:

在这里给出一组输入。例如：

4 2 1 3 0
3.2 2.5 0.4 2.3 1.4 5.6 2.3 4.2 3.5

输出样例2:

在这里给出相应的输出。例如：

The original list:
[Trapezoid:1.14 Rectangle:3.22 Circle:98.52 Triangle:4.02 ]
The Separated List:
[Circle:98.52 ][Rectangle:3.22 ][Triangle:4.02 ][Trapezoid:1.14 ]
The Separated sorted List:
[Circle:98.52 ][Rectangle:3.22 ][Triangle:4.02 ][Trapezoid:1.14 ]
The max area:98.5

输入样例3:

在这里给出一组输入。例如：

2 1 2 1 1 3 3 4 4 1 1 1 2 1 0
2.3 3.5 2.5 4.5 2.1 2.6 8.5 3.2 3.1 3.6 8.5 7.5 9.1245 6.5 3.4 10.2 11.2 11.6 15.4 5.8 2.13 6.2011 2.5 6.4 18.65

import java.util.*;
import java.util.TreeSet;
import java.util.ArrayList;

public class Main{
    /*在Main1类中定义一个静态Scanner对象，这样在其他类中如果想要使用该对象进行
     * 输入，则直接使用Main.input.next...即可 */
    public static Scanner input = new Scanner(System.in);

    public static void main(String[] args) {
        ArrayList<Integer> list;
        list = new ArrayList<>();
        int num = input.nextInt();
        if(num == 0){
            System.out.println("Wrong Format");
            System.exit(0);
        }
        while (num != 0) {  //循环一直输入
            //输入非法
            if (num < 0 || num > 4) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            list.add(num);    /*把num存进list数组*/
            num = input.nextInt();
        }
        DealCardList dealCardList = new DealCardList(list);   //把list传进dealCardlist
        if (!dealCardList.validate()) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        dealCardList.showResult();
        input.close();
    }
}
//卡片处理
class DealCardList {
    ArrayList<Card> cardList = new ArrayList<>();

    //无参构造
    public DealCardList() {
    }

    //带参构造
    public DealCardList(ArrayList<Integer> cardnum) {    //list==cardnum ,取数组进行判断
        for (Integer integer : cardnum) {
            if (integer == 0) {
                break;
            } else if (integer == 1) {  //1为圆
                Card c1 = new Card(new Circle(Main.input.nextDouble()));  //如果是圆，则new一个圆类，并输入半径
                c1.getShape().setShapeName("Circle");
                cardList.add(c1);
            } else if (integer == 2) { //2为矩形
                Card c2 = new Card(new Rectangle(Main.input.nextDouble(), Main.input.nextDouble()));
                c2.getShape().setShapeName("Rectangle");
                cardList.add(c2);
            } else if (integer == 3) {  //3为三角形
                Card c3 = new Card(new Triangle(Main.input.nextDouble(), Main.input.nextDouble(), Main.input.nextDouble()));
                c3.getShape().setShapeName("Triangle");
                cardList.add(c3);
            } else if (integer == 4) {  //4为梯形
                Card c4 = new Card(new Trapezoid(Main.input.nextDouble(), Main.input.nextDouble(), Main.input.nextDouble()));
                c4.getShape().setShapeName("Trapezoid");
                cardList.add(c4);
            }
        }
    }

    //输入合法性判断
    public boolean validate() {
        boolean b = true;
        for (int i = 0; i < cardList.size(); i++) {
            Card c = cardList.get(i);
            if (!c.getShape().validate()) {
                b = false;
                break;
            }
        }
        return b;
    }

    ArrayList<Card> c = new ArrayList<>();//圆
    ArrayList<Card> r = new ArrayList<>(); //矩形
    ArrayList<Card> t1 = new ArrayList<>();//三角形
    ArrayList<Card> t2 = new ArrayList<>();//梯形
    double[] sum = new double[4];

    public void Separated() {
        for (Card a : cardList) {
            switch (a.getShape().getShapeName()) {
                case "Circle":
                    c.add(a);
                    break;
                case "Rectangle":
                    r.add(a);
                    break;
                case "Triangle":
                    t1.add(a);
                    break;
                case "Trapezoid":
                    t2.add(a);
                    break;
            }
        }
    }

    public void spara(ArrayList<Card> list, double[] sum, int i) {
        System.out.print("[");
        sum[i] = 0;
        for (Card a : list) {
            sum[i] = sum[i] + a.getShape().getArea();
            System.out.print(a.getShape());
        }
        System.out.print("]");
    }

    public void spara1(ArrayList<Card> list) {
        TreeSet<Card> kp = new TreeSet<>(list);
        System.out.print("[");
        for (Card a : kp) {
            System.out.print(a.getShape());
        }
        System.out.print("]");
    }

    public double getMax() {
        double max = 0;
        for (int i = 0; i < sum.length; i++) {
            for (int j = 0; j < 4; j++) {
                if (max < sum[j]) {
                    max = sum[j];
                }
            }
        }
        return max;
    }

    public void showResult() {
        Separated();
        System.out.println("The original list:");
        spara(cardList, sum, 0);
        System.out.printf("\nThe Separated List:\n");
        spara(c, sum, 0); //圆
        spara(r, sum, 1); //矩形
        spara(t1, sum, 2); //三角形
        spara(t2, sum, 3); //梯形
        System.out.println("\nThe Separated sorted List:");
        spara1(c);
        spara1(r);
        spara1(t1);
        spara1(t2);
        System.out.printf("\nThe max area:%.2f\n",getMax());
    }
}

//卡片类
class Card implements Comparable<Card>{
    Shape shape;

    //无参构造
    Card() {
    }

    //带参构造
    Card(Shape shape) {
        this.shape = shape;
    }

    //shape getter
    public Shape getShape() {
        return shape;
    }

    //compareTo
    public int compareTo(Card c) {
        double value = shape.getArea()-c.getShape().getArea();
        if(value > 0){
            return -1;
        }
        else if(value < 0){
            return 1;
        }
        return 0;
    }
}
//抽象图形类
abstract class Shape{
    private String shapeName;
    //无参构造
    Shape() {
    }

    //带参构造
    Shape(String shapeName) {
        this.shapeName = shapeName;
    }

    //shapeName getter
    public String getShapeName() {
        return shapeName;
    }

    //shapeName setter
    public void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }

    //计算面积
    public double getArea(){
        return 0.0;
    }

    //合法性判断
    public  boolean validate(){
        return true;
    }

    //toString
    public String toString() {
        return  getShapeName()+":"+String.format("%.2f ",getArea());
    }
}
//圆
class Circle extends Shape {
    private double radius;

    //无参构造
    Circle() {
    }

    //带参构造
    Circle(double radius) {
        this.radius = radius;
    }


    //计算面积
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }

    //合法性判断
    @Override
    public boolean validate() {
        return radius > 0;
    }

}
//矩形
class Rectangle extends Shape {
    private double width;
    private double length;

    //无参构造
    Rectangle() {
    }

    //带参构造
    Rectangle(double width, double length) {
        this.width = width;
        this.length = length;
    }

    //length getter
    public double getLength() {
        return length;
    }

    //length setter
    public void setLength(double length) {
        this.length = length;
    }

    //计算面积
    @Override
    public double getArea() {
        return width * length;
    }

    //合法性判断
    @Override
    public boolean validate() {
        return width > 0 && length > 0;
    }
}

//三角形
class Triangle extends Shape {
    private double side1;
    private double side2;
    private double side3;

    //无参构造
    Triangle() {
    }

    //带参构造
    Triangle(double side1, double side2, double side3) {
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }

    //计算面积
    @Override
    public double getArea() {
        double p = (this.side1 + this.side2 + this.side3) / 2.0;
        return Math.sqrt(p * (p - side1) * (p - side2) * (p - side3));
    }

    //合法性判断
    @Override
    public boolean validate() {
        double temp;
        if(side1 > side2){
            temp = side1;
            side1 = side2;
            side2 = temp;
        }
        if(side1 > side3){
            temp = side1;
            side1 = side3;
            side3 = temp;
        }
        if(side2 > side3){
            temp = side2;
            side2 = side3;
            side3 = temp;
        }
        return ((side1 + side2) > side3) && side1 >0 && side2 > 0 && side3 > 0;
    }
}

//四边形
class Trapezoid extends Shape {
    private double topSide;
    private double bottomSide;
    private double height;

    //无参构造
    public Trapezoid() {
    }

    //带参构造
    public Trapezoid(double topSide, double bottomSide, double height) {
        this.topSide = topSide;
        this.bottomSide = bottomSide;
        this.height = height;
    }


    //计算面积
    @Override
    public double getArea() {
        return (this.bottomSide + this.topSide) * this.height / 2.0;
    }

    //合法性判断
    @Override
    public boolean validate() {
        return this.topSide > 0 && this.bottomSide > 0 && this.height > 0;
    }
}

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

题目集8 ATM机类结构设计一

1.作业目标

   编写一个银行 ATM 机的模拟程序，能够完成用户的存款、取款以及查询余额功能。

2.作业要求

2.1 业务背景

（1）相关概念说明

   中国银联（China UnionPay）：成立于 2002 年 3 月，是经国务院同意，中 国人民银行批准设立的中国银行卡联合组织，总部设于上海。主要负责建设和 运营全国统一的银行卡跨行信息交换网络、提供银行卡跨行信息交换相关的专 业化服务、管理和经营“银联”品牌、制定银行卡跨行交易业务规范和技术标 准。其包含多家银行机构。 银行（Bank）：是依法成立的经营货币信贷业务的金融机构，是商品货币经 济发展到一定阶段的产物。 银行用户（User）：能够在银行办理相应业务的用户。一个银行机构可以拥 有多个银行用户及多个银行账户，一个用户也可以在多个银行机构开立账户。 银行账户（Account）：客户在银行开立的存款账户、贷款账户、往来账户 的总称。一个银行用户可以拥有多个银行账户。 银行卡（Card）：经批准由商业银行(含邮政金融机构) 向社会发行的具有 消费信用、转账结算、存取现金等全部或部分功能的信用支付工具。一个银行 账户可以发行多张银行卡。  ATM（Automated Teller Machine），自动柜员机，因大部分用于取款，又 称自动取款机。它是一种高度精密的机电一体化装置，利用磁性代码卡或智能 卡实现金融交易的自助服务，代替银行柜面人员的工作。可提取现金、查询存 款余额、进行账户之间资金划拨、余额查询等工作。一般 ATM 机隶属于某一银 行机构。

（2）设计要求

   尝试使用面向对象技术对银行用户在 ATM 机上进行相关操作的模拟系统设 计，上述的相关概念均要设计为实体类，业务（控制）类请自行根据实际需要进 行扩充和完善。 注意：为降低难度，本次作业限定银行卡均为借记卡（不能透支），且不允 许跨行办理相关业务（例如在中国建设银行的 ATM 机上对其他银行的账户进行操 作）。

2.2 程序功能需求

  （1）实现功能 基础数据的初始化； 用户存款、取款及查询余额功能。

  （2）初始化数据表 1 银行相关数据 机构名称 银行名称 ATM 机编号 中国银联 中国建设银行 01 02 03 04 中国工商银行 05 06 表 2 用户相关数据 用户姓名 隶属银行 银行账号 初始余额 隶属卡号 杨过 中国建设银行 3217000010041315709 10000.00 6217000010041315709 6217000010041315715 3217000010041315715 10000.00 6217000010041315718 郭靖 中国建设银行 3217000010051320007 10000.00 6217000010051320007 张无忌 中国工商银行 3222081502001312389 10000.00 6222081502001312389 3222081502001312390 10000.00 6222081502001312390 3222081502001312399 10000.00 6222081502001312399 6222081502001312400 韦小宝 中国工商银行 3222081502051320785 10000.00 6222081502051320785 3222081502051320786 10000.00 6222081502051320786 注意：系统的测试用例均采用如上数据，且所有卡号密码默认为“88888888”。

（3）输入输出规则

  1）输入规则 每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业 务操作输入格式如下： ➢ 存款、取款功能输入数据格式 卡号 密码 ATM 机编号 金额（由一个或多个空格分隔） 其中，当金额大于 0 时，代表取款，否则代表存款。 ➢ 查询余额功能输入数据格式 卡号

  2）输出规则 ①输入错误处理  如果输入卡号不存在，则输出“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 编号]上存款¥[金额] 当前余额为¥[金额] 其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。 ④查询余额业务输出 ¥[金额] 金额保留两位小数。

题目集9 类结构设计二

1.作业目标

　　编写一个银行 ATM 机的模拟程序，能够完成用户的取款以及查询余额功能。

2.作业要求

2.1 业务背景

　　（1）相关概念说明 中国银联（China UnionPay）：成立于 2002 年 3 月，是经国务院同意，中 国人民银行批准设立的中国银行卡联合组织，总部设于上海。主要负责建设和 运营全国统一的银行卡跨行信息交换网络、提供银行卡跨行信息交换相关的专 业化服务、管理和经营“银联”品牌、制定银行卡跨行交易业务规范和技术标 准。其包含多家银行机构。 银行（Bank）：是依法成立的经营货币信贷业务的金融机构，是商品货币经 济发展到一定阶段的产物。 银行用户（User）：能够在银行办理相应业务的用户。一个银行机构可以拥 有多个银行用户及多个银行账户，一个用户也可以在多个银行机构开立账户。 银行账户（Account）：客户在银行开立的存款账户、贷款账户、往来账户 的总称。银行账户分为借记账户和贷记账户两种，其中，借记账户不能够透支 取款，而贷记账户可以透支取款（可能需要支付手续费）。一个银行用户可以 拥有多个银行账户。 银行卡（Card）：经批准由商业银行(含邮政金融机构) 向社会发行的具有 消费信用、转账结算、存取现金等全部或部分功能的信用支付工具。根据账户 的不同，银行卡一般分为借记卡（针对借记账户）和信用卡（针对贷记账户） 两类。一个银行账户可以发行多张银行卡。  ATM（Automated Teller Machine），自动柜员机，因大部分用于取款，又 称自动取款机。它是一种高度精密的机电一体化装置，利用磁性代码卡或智能 卡实现金融交易的自助服务，代替银行柜面人员的工作。可提取现金、查询存 款余额、进行账户之间资金划拨、余额查询等工作。一般 ATM 机隶属于某一银行机构。

　　（2）设计要求 尝试使用面向对象技术对银行用户在 ATM 机上进行相关操作的模拟系统设 计，上述的相关概念均要设计为实体类，业务（控制）类请自行根据实际需要进 行扩充和完善。 注意：本次作业中银行卡包含借记卡和信用卡两类，且允许跨行办理相关业 务（例如在中国建设银行的 ATM 机上使用中国工商银行的银行卡进行业务操作）。

2.2 程序功能需求

　　（1）实现功能  基础数据的初始化；  用户取款及查询余额功能。

　　（2）初始化数据 表 1 银行相关数据 机构名称 透支取款手续费 及透支最大限额 银行名称 跨行取款手续费 ATM 机编号 中国银联 取款金额的 5% /50000 元 中国建设银行 取款金额的 2% 01 02 03 04 中国工商银行 取款金额的 3% 05 06 中国农业银行 取款金额的 4% 07 08 09 10 11 表 2 用户相关数据 用户姓名 隶属银行 银行账号 账号种类 隶属卡号 杨过 中国建设银行 3217000010041315709 借记账号 6217000010041315709 6217000010041315715 3217000010041315715 借记账号 6217000010041315718 郭靖 中国建设银行 3217000010051320007 借记账号 6217000010051320007 张无忌 中国工商银行 3222081502001312389 借记账号 6222081502001312389 3222081502001312390 借记账号 6222081502001312390 3222081502001312399 借记账号 6222081502001312399 6222081502001312400 韦小宝 中国工商银行 3222081502051320785 借记账号 6222081502051320785 3222081502051320786 借记账号 6222081502051320786 张三丰 中国建设银行 3640000010045442002 贷记账号 6640000010045442002 6640000010045442003 令狐冲 中国工商银行 3640000010045441009 贷记账号 6640000010045441009 乔峰 中国农业银行 3630000010033431001 贷记账号 6630000010033431001 洪七公 中国农业银行 3630000010033431008 贷记账号 6630000010033431008

　　（3）业务假定

　　　1）系统的测试用例均采用如上数据，且所有卡号密码默认为“88888888”， 初始余额均为 10000 元。

    2）手续费默认均从银行卡所对应的账户中自动扣除。

    3）跨行业务手续费收取比例由 ATM 机隶属银行决定，例如，用户手持中国 工商银行的银行卡在中国建设银行的 ATM 上进行取款操作，则手续费收取比例为 中国建设银行的相应比例，按初始化数据中的规定为取款金额的 2%。

   4）跨行查询余额不收取手续费。 5）透支取款手续费由中国银联统一规定为 5%，最大透支金额均为 50000 元。

 （4）输入输出规则 1）输入规则 每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业 务操作输入格式如下： ➢ 取款功能输入数据格式 卡号 密码 ATM 机编号 金额（由一个或多个空格分隔） ➢ 查询余额功能输入数据格式 卡号 2）输出规则 ①输入错误处理  如果输入卡号不存在，则输出“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 编号]上取款¥[金额] 当前余额为¥[金额] 其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。 ③查询余额业务输出 业务：查询余额 ¥[金额] 金额保留两位小数。

分析：题目集8，银联--银行--账户--卡，依次从上往下聚合，另外ATM与银行绑定，用户与账户绑定。从而实现各类之间的关系。对输入校验时，从银联依次往下搜索卡号、ATM机、余额等信息。在题目集9中，要求在题目集8的基础上增加功能，为增加信用卡类，将账户类写成抽象类，借记账户和贷记账户继承自抽象账户类。

题目集合8类图：

 

 

 

题目集8源码在SourceMonitor中的分析图:

题集8题目及源码：

7-3 ATM机类结构设计（一） (100 分)

设计ATM仿真系统，具体要求参见作业说明。 OO作业8-1题目说明.pdf

输入格式:

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

• 存款、取款功能输入数据格式： 卡号 密码 ATM机编号 金额（由一个或多个空格分隔）， 其中，当金额大于0时，代表取款，否则代表存款。
• 查询余额功能输入数据格式： 卡号

输出格式:

①输入错误处理

• 如果输入卡号不存在，则输出Sorry,this card does not exist.。
• 如果输入ATM机编号不存在，则输出Sorry,the ATM's id is wrong.。
• 如果输入银行卡密码错误，则输出Sorry,your password is wrong.。
• 如果输入取款金额大于账户余额，则输出Sorry,your account balance is insufficient.。
• 如果检测为跨行存取款，则输出Sorry,cross-bank withdrawal is not supported.。

②取款业务输出

输出共两行，格式分别为：

[用户姓名]在[银行名称]的[ATM编号]上取款¥[金额]

当前余额为¥[金额]

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

③存款业务输出

输出共两行，格式分别为：

[用户姓名]在[银行名称]的[ATM编号]上存款¥[金额]

当前余额为¥[金额]

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

④查询余额业务输出

¥[金额]

金额保留两位小数。

输入样例1:

在这里给出一组输入。例如：

6222081502001312390 88888888 06 -500.00
#

输出样例1:

在这里给出相应的输出。例如：

张无忌在中国工商银行的06号ATM机上存款¥500.00
当前余额为¥10500.00

输入样例2:

在这里给出一组输入。例如：

6217000010041315709  88888888 02 3500.00
#

输出样例2:

在这里给出相应的输出。例如：

杨过在中国建设银行的02号ATM机上取款¥3500.00
当前余额为¥6500.00

输入样例3:

在这里给出一组输入。例如：

6217000010041315715
#

输出样例3:

在这里给出相应的输出。例如：

¥10000.00

输入样例4:

在这里给出一组输入。例如：

6222081502001312390 88888888 06 -500.00
6222081502051320786 88888888 06 1200.00
6217000010041315715 88888888 02 1500.00
6217000010041315709  88888888 02 3500.00
6217000010041315715
#

输出样例4:

在这里给出相应的输出。例如：

张无忌在中国工商银行的06号ATM机上存款¥500.00
当前余额为¥10500.00
韦小宝在中国工商银行的06号ATM机上取款¥1200.00
当前余额为¥8800.00
杨过在中国建设银行的02号ATM机上取款¥1500.00
当前余额为¥8500.00
杨过在中国建设银行的02号ATM机上取款¥3500.00
当前余额为¥5000.00
¥5000.00

//package PTA8;
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();  //str用于记录输入的字符
        StringBuilder s = new StringBuilder();  //s用于暂存字符串
        String[] accountAll = new String[]{"6217000010041315709","6217000010041315715","6217000010041315718","6217000010051320007","6222081502001312389","6222081502001312390","6222081502001312399","6222081502001312400","6222081502051320785","6222081502051320786"};
        //输入判断以#结束
        while(!str.equals("#")){
            s.append(str);  //追加字符串在同一个地址空间
            s.append("\n");
            str = input.nextLine();
            // System.out.println(s);
        }
        String data = String.valueOf(s);  //将s中缓存的字符串存到字符串data中
        String[] deal = data.split("\n");

        for(int i = 0; i < deal.length; i++){
            String deal1 = String.valueOf(deal[i]);
            String[] deal2 = deal1.split("\\s+");
            Account account = new Account(deal2[0]);
            if(deal2.length != 1){ //存取款操作
                for(int j = 0; j < deal2.length; j++){
                    ValidateDate validate = new ValidateDate(deal2[2],deal2[0]);
                    if(validate.accountValidateDate()==1 && validate.atmValidateDate()==1){
                        withDraw withdraw = new withDraw(deal2[0],deal2[1],deal2[2],Double.parseDouble(deal2[3]));
                        withdraw.withDrawMate();
                    }
                    break;
                }
            }
            else{ //查询余额
                int index= 20;
                for(int k = 0; k < accountAll.length; k++){
                    if(account.getAccount().equals(accountAll[k]))
                        index = k;
                }
                if(index==0 || index==1 || index==2){  //杨过
                    System.out.printf("¥%.2f\n",account.getBalanceY());
                }
                else if(index==3){  //郭靖
                    System.out.printf("¥%.2f\n",account.getBalanceG());
                }
                else if(index==4 || index==5 || index==6 || index==7){ //张无忌
                    System.out.printf("¥%.2f\n",account.getBalanceZ());
                }
                else if(index==8 || index==9){  //韦小宝
                    System.out.printf("¥%.2f\n",account.getBalanceW());
                }
            }
        }
    }
}
//用户类
class User{
    private String who;
    //private String which;
    String[] countnum = new String[]{"6217000010041315709","6217000010041315715","6217000010041315718","6217000010051320007","6222081502001312389","6222081502001312390","6222081502001312399","6222081502001312400","6222081502051320785","6222081502051320786"};
    //无参构造
    public User(){
    }
    //带参构造
    public User(String who){
        this.who = who;
        // this.which = which;
    }
    //用户名字
    public String getUserName(){
        int index = 0;
        for(int i = 0; i < countnum.length; i++){
            if(countnum[i].equals(who))
                index= i;
        }
        if(index==0 || index==1 || index==2)
            return "杨过";
        else if(index==3)
            return "郭靖";
        else if(index==4 || index==5 || index==6 || index ==7)
            return "张无忌";
        else if(index==8 || index==9)
            return "韦小宝";
        else
            return "0";
    }
    //银行名字
    public String getBankName(){
        int index = 0;
        for(int i = 0; i < countnum.length; i++){
            if(countnum[i].equals(who))
                index= i;
        }
        if(index==0 || index==1 || index==2 || index==3)
            return "中国建设银行";
        else if(index==4 || index==5 || index==6 || index==7 || index==8 || index==9)
            return "中国工商银行";
        else
            return "0";
    }
}
//账户类
class Account{
    private String account;
    static private double balanceY = 10000;  //杨过
    static private double balanceG = 10000;  //郭靖
    static private double balanceZ = 10000;  //张无忌
    static private double balanceW = 10000;  //韦小宝
    //无参构造
    public Account(){
    }
    //带参构造
    public Account(String account){
        this.account = account;
    }
    //account setter
    public void setAccount(String account) {
        this.account = account;
    }
    //account getter
    public String getAccount(){
        return account;
    }
    //BalanceY setter
    public void setBalanceY(double balanceY){
        this.balanceY = balanceY;
    }
    //BalanceY getter
    public double getBalanceY() {
        return balanceY;
    }
    //BalanceG getter
    public double getBalanceG() {
        return balanceG;
    }
    //BalanceG setter
    public void setBalanceG(double balanceG) {
        this.balanceG = balanceG;
    }
    //BalanceZ getter
    public double getBalanceZ() {
        return balanceZ;
    }
    //BalanceZ setter
    public void setBalanceZ(double balanceZ) {
        this.balanceZ = balanceZ;
    }
    //BalanceW setter
    public void setBalanceW(double balanceW) {
        this.balanceW = balanceW;
    }
    //BalanceW getter
    public double getBalanceW() {
        return balanceW;
    }
}
//数据输入合法性检验
class ValidateDate{
    private String atmNum;
    private String accountNum;
    String[] accountAll = new String[]{"6217000010041315709","6217000010041315715","6217000010041315718","6217000010051320007","6222081502001312389","6222081502001312390","6222081502001312399","6222081502001312400","6222081502051320785","6222081502051320786"};
    String[] atmAll = new String[]{"01","02","03","04","05","06"};
    //无参构造
    public ValidateDate(){
    }
    //带参构造
    public ValidateDate(String atmNum, String accountNum){
        this.atmNum = atmNum;
        this.accountNum = accountNum;
    }
    //atmNum getter
    public String getAtmNum() {
        return atmNum;
    }
    //atmNum setter
    public void setAtmNum(String atmNum) {
        this.atmNum = atmNum;
    }
    //accountNum setter
    public void setAccountNum(String accountNum) {
        this.accountNum = accountNum;
    }
    //accountNum getter
    public String getAccountNum() {
        return accountNum;
    }
    //账户输入合法性判断
    public int accountValidateDate(){
        int flag = 0; //标志，用于记录是否匹配
        for (String s : accountAll){
            if(s.equals(accountNum)){
                flag = 1;
                break;
            }
        }
        if(flag==1)
            return 1;
        else{
            System.out.println("Sorry,this card does not exist.");
            return 0;
        }
    }
    //ATM机输入合法性检验
    public int atmValidateDate(){
        int flag = 0; //标志，用于记录是否匹配
        for(String s : atmAll){
            if(s.equals(atmNum)){
                flag = 1;
                break;
            }
        }
        if(flag==1)
            return 1;
        else{
            System.out.println("Sorry,the ATM's id is wrong.");
            return 0;
        }
    }
    //判断跨行转账
    public int mateValidateDate(){
        int flag1 = 0;
        int flag2 = 0;
        /*建设银行*/
        for(int i = 0; i < 4; i++){
            if(accountNum.equals(accountAll[i])){  //确定账户银行
                for(int j = 0; j < 4; j++) {
                    if (atmNum.equals(atmAll[j]))  //确定ATM
                    {
                        flag1 = 1;
                        break;
                    }
                }
            }
        }
        /*工商银行*/
        for(int i = 4; i < accountAll.length; i++){
            if(accountNum.equals(accountAll[i])){//确定银行账户
                for(int j = 4; j < atmAll.length; j++){
                    if (atmNum.equals(atmAll[j]))  //确定ATM
                    {
                        flag2 = 1;
                        break;
                    }
                }
            }
        }
        //非跨行转账
        if(flag1 ==1 || flag2 == 1)
            return 1;
        else{
            System.out.println("Sorry,cross-bank withdrawal is not supported.");
            return 0;
        }
    }
}
//存取款
class withDraw{
    String cardNum; //卡号
    String cardPassword; //卡密码
    String atmNum;  //ATM机号
    double money;  //存取金额
    double balanceY;
    double balanceG;
    double balanceZ;
    double balanceW;
    String[] accountAll = new String[]{"6217000010041315709", "6217000010041315715", "6217000010041315718", "6217000010051320007", "6222081502001312389", "6222081502001312390", "6222081502001312399", "6222081502001312400", "6222081502051320785", "6222081502051320786"};
    //无参构造
    public withDraw(){
    }
    //带参构造
    public withDraw(String cardNum, String cardPassword, String atmNum, double money){
        this.cardNum = cardNum;
        this.cardPassword = cardPassword;
        this.atmNum = atmNum;
        this.money = money;
    }
    //存取款操作
    public void withDrawMate(){

        ValidateDate validate  = new ValidateDate(atmNum, cardNum);
        Account account = new Account(cardNum);
        User user = new User(cardNum);

        int index = 20; //用于记录匹配账户下标
        for(int i = 0; i < accountAll.length; i++){
            if(account.getAccount().equals(accountAll[i])) {
                index = i;
                break;
            }
        }


        //若输入账号合法、ATM机号合法、非跨行取款
        if(validate.mateValidateDate()==1 && validate.atmValidateDate()==1 && validate.accountValidateDate()==1){
            if(cardPassword.equals("88888888")){ //密码合法
                if(10000 - money < 0)  //取款金额不合法
                    System.out.println("Sorry,your account balance is insufficient.");
                else{  //取款金额合法
                    if(money < 0) //如果是存款
                        System.out.println(user.getUserName()+"在"+user.getBankName()+"的"+atmNum+"号ATM机上存款¥"+String.format("%.2f",-money));
                    else  //如果是取款
                        System.out.println(user.getUserName()+"在"+user.getBankName()+"的"+atmNum+"号ATM机上取款¥"+String.format("%.2f",money));

                    if(index==0 || index==1 || index==2){  //杨过
                        account.setBalanceY(account.getBalanceY() - money);
                        System.out.printf("当前余额为¥%.2f\n",account.getBalanceY());
                    }
                    else if(index==3){  //郭靖
                        account.setBalanceG(account.getBalanceG() - money);
                        System.out.printf("当前余额为¥%.2f\n",account.getBalanceG());
                    }
                    else if(index==4 || index==5 || index==6 || index==7){ //张无忌
                        account.setBalanceZ(account.getBalanceZ() - money);
                        System.out.printf("当前余额为¥%.2f\n",account.getBalanceZ());
                    }
                    else if(index==8 || index==9){  //韦小宝
                        account.setBalanceW(account.getBalanceW() - money);
                        System.out.printf("当前余额为¥%.2f\n",account.getBalanceW());
                    }
                }
            }
            else //密码不合法
                System.out.println("Sorry,your password is wrong.");
        }
    }

}

题目集合9类图：

题目集9源码在SourceMonitor中的分析图:

题集9题目及源码：

//package PTA9;
import java.util.*;
public class Main {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        String str = input.nextLine(); //str用于记录输入的字符串
        StringBuilder s = new StringBuilder();  //s用于暂存字符串
        String[] aAll = new String[]{"6217000010041315709","6217000010041315715","6217000010041315718","6217000010051320007","6222081502001312389","6222081502001312390","6222081502001312399","6222081502001312400","6222081502051320785","6222081502051320786","6640000010045442002","6640000010045442003","6640000010045441009","6630000010033431001","6630000010033431008"};
        //输入判断以#结束
        while(!str.equals("#")){
            s.append(str);  //追加字符串在同一个地址空间
            s.append("\n");
            str = input.nextLine();
        }
        String data = String.valueOf(s); //将s中缓存的字符串存到字符串data中
        String[] deal = data.split("\n");
        for (String value : deal) {
            String deal1 = String.valueOf(value);
            String[] deal2 = deal1.split("\\s+");
            Account a = new Account(deal2[0]);
            if (deal2.length != 1) { //存取款操作
                for (int j = 0; j < deal2.length; j++) {
                    ValidateDate validate = new ValidateDate(deal2[2], deal2[0]);
                    if (validate.accountValidateDate() == 1 ) {
                        withDraw withdraw = new withDraw(deal2[0], deal2[1], deal2[2], Double.parseDouble(deal2[3]));
                        withdraw.withDrawMate();
                    }
                    break;
                }
            } else { //查询余额
                int index = 20;
                for (int k = 0; k < aAll.length; k++) {
                    if (a.getAccount().equals(aAll[k]))
                        index = k;
                }
                if (index == 0 || index == 1 || index == 2) {  //杨过
                    System.out.printf("业务：查询余额 ¥%.2f\n", a.getY());
                } else if (index == 3) {  //郭靖
                    System.out.printf("业务：查询余额 ¥%.2f\n", a.getG());
                } else if (index == 4 || index == 5 || index == 6 || index == 7) { //张无忌
                    System.out.printf("业务：查询余额 ¥%.2f\n", a.getZ());
                } else if (index == 8 || index == 9) {  //韦小宝
                    System.out.printf("业务：查询余额 ¥%.2f\n", a.getW());
                }
                else if (index == 10 || index==11){ //张三丰
                    System.out.printf("业务：查询余额 ¥%.2f\n", a.getZS());
                }
                else if ( index == 12){   //令狐冲
                    System.out.printf("业务：查询余额 ¥%.2f\n", a.getL());
                }
                else if (index == 13){  //乔峰
                    System.out.printf("业务：查询余额 ¥%.2f\n", a.getQ());
                }
                else if (index == 14){  //洪七公
                    System.out.printf("业务：查询余额 ¥%.2f\n", a.getH());
                }
            }
        }
    }
}
//用户类
class User{
    private String who;
    private String which;
    String[] countnum = new String[]{"6217000010041315709","6217000010041315715","6217000010041315718","6217000010051320007","6222081502001312389","6222081502001312390","6222081502001312399","6222081502001312400","6222081502051320785","6222081502051320786","6640000010045442002","6640000010045442003","6640000010045441009","6630000010033431001","6630000010033431008"};
    String[] num = new String[]{"01","02","03","04","05","06","07","08","09","10","11"};
    //无参构造
    public User(){
    }
    //带参构造
    public User(String who,String which){
        this.who = who;
         this.which = which;
    }
    //用户名字
    public String getUName(){
        int index = 0;
        for(int i = 0; i < countnum.length; i++){
            if(countnum[i].equals(who))
                index= i;
        }
        if(index==0 || index==1 || index==2) return "杨过";
        else if(index==3) return "郭靖";
        else if(index==4 || index==5 || index==6 || index ==7) return "张无忌";
        else if(index==8 || index==9) return "韦小宝";
        else if(index==10 || index==11) return "张三丰";
        else if(index==12) return "令狐冲";
        else if(index==13) return "乔峰";
        else if(index==14) return "洪七公";
        else return "0";
    }
    //银行名字
    public String getBankName(){
        int index = 0;
        for(int i = 0; i < num.length; i++){
            if(num[i].equals(which))
                index= i;
        }
        if(index==0 || index==1 || index==2 || index==3) return "中国建设银行";
        else if(index==4 || index==5) return "中国工商银行";
        else if(index==6 || index==7 || index==8 || index==9 || index==10) return "中国农业银行";
        else return "0";
    }
}
//账户类
class Account{
    private String account;
    static private double Y = 10000;  //杨过
    static private double G = 10000;  //郭靖
    static private double Z = 10000;  //张无忌
    static private double W = 10000;  //韦小宝
    static private double ZS = 10000; //张三丰
    static private double L = 10000;  //令狐冲
    static private double Q = 10000;  //乔峰
    static private double H = 10000; //洪七公
    String[] atmAll = new String[]{"01","02","03","04","05","06","07","08","09","10","11"};
    //无参构造
    public Account(){
    }
    //带参构造
    public Account(String account){this.account = account;}
    //account getter
    public String getAccount(){return account;}
    //BalanceY setter
    public void setY(double Y){Account.Y = Y;}
    //BalanceY getter
    public double getY() {return Y;}
    //BalanceG getter
    public double getG() {return G;}
    //BalanceG setter
    public void setG(double G) {Account.G = G;}
    //BalanceZ getter
    public  double getZ() {return Z;}
    //BalanceZ setter
    public  void setZ(double Z) {Account.Z = Z;}
    //BalanceW setter
    public  void setW(double W) {Account.W = W;}
    //BalanceW getter
    public  double getW() {return W;}
    //BalanceZS getter
    public  double getZS() {return ZS;}
    //BalanceZS setter
    public void setZS(double ZS) {Account.ZS = ZS;}
    //BalanceL setter
    public void setL(double L) {Account.L = L;}
    //BalanceL getter
    public  double getL() {return L;}
    //BalanceQ setter
    public  void setQ(double Q) {Account.Q = Q;}
    //BalanceQ getter
    public  double getQ() {return Q;}
    //BalanceH getter
    public  double getH() {return H;}
    //BalanceH setter
    public void setH(double H) {Account.H = H;}
    //计算利率
    public double countRate(String atmNum, String accountNum, double balance){
        ValidateDate valadate = new ValidateDate(atmNum,accountNum);
        int index = 20;
        for(int i = 0; i < atmAll.length; i++){
            if(atmNum.equals(atmAll[i])){
                index = i;
                break;
            }
        }
        if(index==0 || index==1 || index==2 || index==3){
            if((valadate.atmkh() == 1)) return 0;  //非跨行
            else return balance*0.02;
        }
        if(index==4 || index==5){
            if((valadate.atmkh() == 1)) return 0;  //非跨行
            else return balance*0.03;
        }
        if(index==6 || index==7 || index==8 || index==9 || index==10){
            if((valadate.atmkh() == 1)) return 0;  //非跨行
            else return balance*0.04;
        }
        else return 0;
    }
}
//数据输入合法性检验
class ValidateDate{
    private String atmNum;
    private String accountNum;
    String[] accountAll = new String[]{"6217000010041315709","6217000010041315715","6217000010041315718","6217000010051320007","6222081502001312389","6222081502001312390","6222081502001312399","6222081502001312400","6222081502051320785","6222081502051320786","6640000010045442002","6640000010045442003","6640000010045441009","6630000010033431001","6630000010033431008"};
    String[] atmAll = new String[]{"01","02","03","04","05","06","07","08","09","10","11"};
    //无参构造
    public ValidateDate(){
    }
    //带参构造
    public ValidateDate(String atmNum, String accountNum){
        this.atmNum = atmNum;
        this.accountNum = accountNum;
    }
    //账户输入合法性判断
    public int accountValidateDate(){
        int flag = 0; //标志，用于记录是否匹配
        for (int i=0;i<accountAll.length;i++){
            if(accountNum.equals(accountAll[i])){
                flag = 1;
                break;
            }
        }
        if(flag==1) return 1;
        else{
            System.out.println("Sorry,this card does not exist.");
            return 0;
        }
    }
    //ATM机输入合法性检验
    public int atm(){
        int flag=0;
        for (int i = 0; i < atmAll.length; i++) {
            if (atmNum.equals(atmAll[i])) {
                flag=1;
                break;
            }
        }
        if(flag==1)
            return 1;
        else
            System.out.println("Sorry,the ATM's id is wrong.");
            return 0;
    }
    //ATM机跨行检验
    public int atmkh() {
        int flag = 0; //标志，用于记录是否匹配
        int index = 20;  //用于记录账户下标
        int index0 = 20; //用于记录atm下标
        for (int i = 0; i < atmAll.length; i++) {
            if (atmNum.equals(atmAll[i])) {
                index0 = i;
                break;
            }
        }
        for(int i = 0; i < accountAll.length; i++){
            if(accountNum.equals(accountAll[i])) {
                index = i;
                break;
            }
        }
        /*判断是否为跨行取款*/
        if(index==0 || index==1 || index==2 || index==3 || index==10 || index==11){
            if(index0==0 || index0==1 || index0==2 || index0==3){
                flag = 1;
            }
        }
        if(index==4 || index==5 || index==6 || index==7 || index==8 || index==9 || index==12){
            if(index0==4 || index0==5) {
                flag = 1;
            }
        }
        if(index==13 || index==14){
            if(index0==6 || index0==7 || index0==8 || index0==9 || index0==10) {
                flag = 1;
            }
        }
        if(flag == 1) return 1;
        else return 0;
    }
}
//存取款
class withDraw{
    String cardNum; //卡号
    String cardPassword; //卡密码
    String atmNum;  //ATM机号
    double money;  //存取金额
    String[] accountAll = new String[]{"6217000010041315709", "6217000010041315715", "6217000010041315718", "6217000010051320007", "6222081502001312389", "6222081502001312390", "6222081502001312399", "6222081502001312400", "6222081502051320785", "6222081502051320786", "6640000010045442002", "6640000010045442003", "6640000010045441009", "6630000010033431001", "6630000010033431008"};
    String[] atmAll = new String[]{"01","02","03","04","05","06","07","08","09","10","11"};
    //无参构造
    public withDraw(){
    }
    //带参构造
    public withDraw(String cardNum, String cardPassword, String atmNum, double money){
        this.cardNum = cardNum;
        this.cardPassword = cardPassword;
        this.atmNum = atmNum;
        this.money = money;
    }
    //存取款操作
    public void withDrawMate() {

        ValidateDate validate = new ValidateDate(atmNum, cardNum);
        Account account = new Account(cardNum);
        User user = new User(cardNum,atmNum);

        int index = 20; //用于记录匹配账户下标
        int index0 = 20;  //用于记录atm下标
        for (int i = 0; i < accountAll.length; i++) {
            if (account.getAccount().equals(accountAll[i])) {
                index = i;
                break;
            }
        }
        for(int i = 0; i < atmAll.length ;i++){
            if(atmNum.equals(atmAll[i])){
                index0 = i;
                break;
            }
        }

        //若输入账号和银行卡号合法
        if (validate.accountValidateDate() == 1 && validate.atm()==1) {
                if(cardPassword.equals("88888888")){
                    //若存款
                    if(money < 0){
                        System.out.println("业务：存款 " + user.getUName() + "在" + user.getBankName() + "的" + atmNum + "号ATM机上存款¥" + String.format("%.2f", -money));
                        if(index==0 || index==1 || index==2) {  System.out.printf("当前余额为¥%.2f\n",(account.getY() - money));account.setY(account.getY() - money);
                        }
                        else if(index==3){System.out.printf("当前余额为¥%.2f\n",(account.getG() - money));account.setG(account.getG() - money);
                        }
                        else if(index==4 || index==5 || index==6 || index==7){System.out.printf("当前余额为¥%.2f\n",(account.getZ() - money));account.setZ(account.getZ() - money);
                        }
                        else if(index==8 || index==9){System.out.printf("当前余额为¥%.2f\n",account.getW() - money);account.setW(account.getW() - money);
                        }
                        else if(index==10 || index==11){System.out.printf("当前余额为¥%.2f\n", account.getZS() - money);account.setZS(account.getZS() - money);
                        }
                        else if(index==12){System.out.printf("当前余额为¥%.2f\n", account.getL() - money);account.setL(account.getL() - money);
                                }
                        else if(index==13){System.out.printf("当前余额为¥%.2f\n", account.getQ() - money);account.setQ(account.getQ() - money);
                        }
                        else if(index==14){System.out.printf("当前余额为¥%.2f\n", account.getH() - money);account.setH(account.getH() - money);
                        }
                    }
                    //取款
                    else{

                        if((index==0|| index==1|| index==2||index==4 || index==5 || index==6||index==7 ||index==8 || index==9)&&(account.getY()-money<=0||account.getG()-money<=0||account.getZ()-money<=0||account.getW()-money<=0)||((index==10||index==11||index==12||index==13||index==14)&&account.getZS()-money<=-50000||account.getL()-money<=-50000||account.getQ()-money<=-50000||account.getH()-money<=-50000)||account.getZS()<=-50000||account.getL()<=-50000||account.getQ()<-50000||account.getH()<=-50000){
                            System.out.println("Sorry,your account balance is insufficient."); return; }

                            System.out.println("业务：取款 " + user.getUName() + "在" + user.getBankName() + "的" + atmNum + "号ATM机上取款¥" + String.format("%.2f", money));

                        //利率
                        double rate = account.countRate(atmNum,cardNum,money);

                        if(index==0 || index==1 || index==2){ //杨过
                            if(account.getY()-money-rate>=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getY() - money - rate);
                                account.setY(account.getY() - money - rate);
                            }
                            else{
                                System.out.println("Sorry,your account balance is insufficient.");
                            }
                        }

                        if(index==3){ //郭靖
                            if(account.getG()-money-rate>=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getG() - money - rate);
                                account.setG(account.getG() - money - rate);
                            }
                            else{
                                System.out.println("Sorry,your account balance is insufficient.");
                            }
                        }

                        if(index==4||index==5||index==6||index==7){ //张无忌
                            if(account.getZ()-money-rate>=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getZ() - money - rate);
                                account.setZ(account.getZ() - money - rate);
                            }
                            else{
                                System.out.println("Sorry,your account balance is insufficient.");
                            }

                        }

                        if(index==8||index==9){ //韦小宝
                            if(account.getW()-money-rate>=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getW() - money - rate);
                                account.setW(account.getW() - money - rate);
                            }
                            else
                                System.out.println("Sorry,your account balance is insufficient.");
                        }

                        if(index==10||index==11){ //张三丰
                            if(account.getZS()-money>=0 && account.getZS()>=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getZS() - money - rate);
                                account.setZS(account.getZS() - money - rate);
                            }
                            else if(account.getZS()-money<=0 && account.getZS()>0){
                                System.out.printf("当前余额为¥%.2f\n", account.getZS()-money-rate-(money-account.getZS())*0.05);
                                account.setZS(account.getZS()-money-rate-(money-account.getZS())*0.05);
                            }
                            else if(account.getZS()<=0&&(account.getZS()-money-rate-money*0.05)>=-50000){
                                System.out.printf("当前余额为¥%.2f\n", account.getZS()-money-rate-money*0.05);
                                account.setZS(account.getZS()-money-rate-money*0.05);
                            }
                            else
                                System.out.println("Sorry,your account balance is insufficient.");

                        }

                        if(index==12){  //令狐冲
                            if(account.getL()>=0&&account.getL()-money>=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getL() - money - rate);
                                account.setL(account.getL() - money - rate);
                            }
                            else if(account.getL()>0 && account.getL()-money<=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getL()-money-rate-(money-account.getL())*0.05);
                                account.setL(account.getL()-money-rate-(money-account.getL())*0.05);
                            }
                            else if(account.getL()<=0&&(account.getL()-money-rate-money*0.05)>=-50000){
                                System.out.printf("当前余额为¥%.2f\n", account.getL()-money-rate-money*0.05);
                                account.setL(account.getL()+money-rate-money*0.05);
                            }
                            else
                                System.out.println("Sorry,your account balance is insufficient.");
                        }

                        if(index==13){  //乔峰
                            if(account.getQ()>=0&&account.getQ()-money>=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getQ() - money - rate);
                                account.setQ(account.getQ() - money - rate);
                            }
                            else if(account.getQ()>0 && account.getQ()-money<=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getQ()-money-rate-(money-account.getQ())*0.05);
                                account.setQ(account.getQ()-money-rate-(money-account.getQ())*0.05);
                            }
                            else if(account.getQ()<=0 && (account.getQ()-money-rate-money*0.05)>=-50000){
                                System.out.printf("当前余额为¥%.2f\n", account.getQ()-money-rate-money*0.05);
                                account.setQ(account.getQ()-money-rate-money*0.05);
                            }
                            else
                                System.out.println("Sorry,your account balance is insufficient.");
                        }

                        if(index==14){  //洪七公
                            if(account.getH()>=0&&account.getH()-money>=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getH() - money - rate);
                                account.setH(account.getH() - money - rate);
                            }
                            else if(account.getH()>0 && account.getH()-money<=0){
                                System.out.printf("当前余额为¥%.2f\n", account.getH()-money-rate-(money-account.getH())*0.05);
                                account.setH(account.getH()-money-rate-(money-account.getH())*0.05);
                            }
                            else if(account.getH()<=0&&(account.getH()-money-rate-money*0.05)>=-50000){
                                System.out.printf("当前余额为¥%.2f\n", account.getH()-money-rate-money*0.05);
                                account.setH(account.getH()-money-rate-money*0.05);
                            }
                            else
                                System.out.println("Sorry,your account balance is insufficient.");
                        }
                    }

                }
                else System.out.println("Sorry,your password is wrong.");
        }
    }
}

三、踩坑心得

（1）由于粗心，类设计不够完善，出现很多细节问题。例如index写成index0，然后智能通过调试慢慢的找错。

//用户名字
    public String getUName(){
        int index = 0;
        for(int i = 0; i < countnum.length; i++){
            if(countnum[i].equals(who))
                index= i;
        }
        if(index==0 || index==1 || index==2) return "杨过";
        else if(index==3) return "郭靖";
        else if(index==4 || index==5 || index==6 || index ==7) return "张无忌";
        else if(index==8 || index==9) return "韦小宝";
        else if(index==10 || index==11) return "张三丰";
        else if(index==12) return "令狐冲";
        else if(index==13) return "乔峰";
        else if(index==14) return "洪七公";
        else return "0";
    }

（2）因为习惯性喜欢写很多注释，所以在第一次提交的时候又因为代码过长而提交不了，然后删除空行和部分注释。

（3）第一次设计类结构时，没有注意到一个用户虽然拥有多张银行卡，但是余额都是归属于一个账户的。

//账户类
class Account{
    private String account;
    static private double balanceY = 10000;  //杨过
    static private double balanceG = 10000;  //郭靖
    static private double balanceZ = 10000;  //张无忌
    static private double balanceW = 10000;  //韦小宝
    //无参构造
    public Account(){
    }
    //带参构造
    public Account(String account){
        this.account = account;
    }
    //account setter
    public void setAccount(String account) {
        this.account = account;
    }
    //account getter
    public String getAccount(){
        return account;
    }
    //BalanceY setter
    public void setBalanceY(double balanceY){
        this.balanceY = balanceY;
    }
    //BalanceY getter
    public double getBalanceY() {
        return balanceY;
    }
    //BalanceG getter
    public double getBalanceG() {
        return balanceG;
    }
    //BalanceG setter
    public void setBalanceG(double balanceG) {
        this.balanceG = balanceG;
    }
    //BalanceZ getter
    public double getBalanceZ() {
        return balanceZ;
    }
    //BalanceZ setter
    public void setBalanceZ(double balanceZ) {
        this.balanceZ = balanceZ;
    }
    //BalanceW setter
    public void setBalanceW(double balanceW) {
        this.balanceW = balanceW;
    }
    //BalanceW getter
    public double getBalanceW() {
        return balanceW;
    }
}

四、改进意见

（1）在银行卡号和ATM机号输入非法问题上，使用循环获得下标在进行账户判断优化了程序。

 

String getUName(){
        int index = 0;
        for(int i = 0; i < countnum.length; i++){
            if(countnum[i].equals(who))
                index= i;
        }
        if(index==0 || index==1 || index==2) return "杨过";
        else if(index==3) return "郭靖";
        else if(index==4 || index==5 || index==6 || index ==7) return "张无忌";
        else if(index==8 || index==9) return "韦小宝";
        else if(index==10 || index==11) return "张三丰";
        else if(index==12) return "令狐冲";
        else if(index==13) return "乔峰";
        else if(index==14) return "洪七公";
        else return "0";
    }
    //银行名字
    public String getBankName(){
        int index = 0;
        for(int i = 0; i < num.length; i++){
            if(num[i].equals(which))
                index= i;
        }
        if(index==0 || index==1 || index==2 || index==3) return "中国建设银行";
        else if(index==4 || index==5) return "中国工商银行";
        else if(index==6 || index==7 || index==8 || index==9 || index==10) return "中国农业银行";
        else return "0";
    }
}

 

（2）跨行检验上也使用下标

//ATM机跨行检验
    public int atmkh() {
        int flag = 0; //标志，用于记录是否匹配
        int index = 20;  //用于记录账户下标
        int index0 = 20; //用于记录atm下标
        for (int i = 0; i < atmAll.length; i++) {
            if (atmNum.equals(atmAll[i])) {
                index0 = i;
                break;
            }
        }
        for(int i = 0; i < accountAll.length; i++){
            if(accountNum.equals(accountAll[i])) {
                index = i;
                break;
            }
        }
        /*判断是否为跨行取款*/
        if(index==0 || index==1 || index==2 || index==3 || index==10 || index==11){
            if(index0==0 || index0==1 || index0==2 || index0==3){
                flag = 1;
            }
        }
        if(index==4 || index==5 || index==6 || index==7 || index==8 || index==9 || index==12){
            if(index0==4 || index0==5) {
                flag = 1;
            }
        }
        if(index==13 || index==14){
            if(index0==6 || index0==7 || index0==8 || index0==9 || index0==10) {
                flag = 1;
            }
        }
        if(flag == 1) return 1;
        else return 0;
    }
}

 

五、总结

　　这是JAVA面对对象数据结构学习的最后一次大作业，不知不觉，我们已经完成了9次题目集，从面对过程到面对对象过程的转变却是艰难的，从单一职责到继承再到多态，从数组到ArrayList到HashSet到HashMap到Tree...学会了一些JAVA自带的数组和类，但是掌握的还不够扎实，也发现还有很多等着我去学习的。从这三次题目集中学会了如何去设计一个类，先思考这个类的属性，作用等，再用封装，继承，多态技术去设计多个需要的类，在设计类之间的关系时，注意他们之间的关系（组合，依赖，关联等），也可以定义抽象类，利用抽象类中可能有抽象方法的特点，实现类型隐藏技术（因为继承的子类实现这个抽象方法时有很多种情况）。也可以利用接口实现多态性，提高程序的拓展性和可维护性。在设计代码的过程中，要学会运用面向对象的思想去设计一个程序，考虑"单一职责"原则、"开放封闭"原则、"Liskov替换原则"原则。希望日后的自己更上一层楼，加油！少年！