题目集 7-9总结

前言：

题目集七：

主要需要知道两个知识点：

（1）ArrayList 动态数组的运用，到后面的题目我们会发现这个东西有多香

（2）Compareable 和Compareto 这两个接口的区别和排序规则

题目集八、九：

我觉得与之前题目不同区别的就是老师没给我们类图，想都别想肯定是锻炼我们面向对象的思想来解题，并且后面会添加条件，看看我们代码的质量高不高。题目集九就是添加了借记卡，然后看看我们的代码质量了。

设计与分析：

题目集七 7-1 图形卡片排序游戏：

掌握类的继承、多态性使用方法以及接口的应用。详见作业指导书 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图形名称2:面积值2 …图形名称n:面积值n，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格；
排序后的各图形类型及面积，格式同排序前的输出；
所有图形的面积总和，格式为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



结尾无空行

1.ArrayList 动态数组里面可以存储什么呢？跟普通的数组有什么区别呢？到底哪里好用呢？

ArrayList存储的其实是对象，不管是int 型，String型，还是我们自定义的类。

而它与普通的数组的区别就在于我们不需要设置数组的大小，可以任意添加删除。如果你删除ArrayList的一个中间元素是，它后面的数会自动的往前移动一个位置，就不需要特判什么的了。

2.Compareable和Compareto的区别

（1）Comparebale

class Card implements Comparable<Card>{
    Shape shape;
    Card(){
        
    }
    Card(Shape shape){
        this.shape=shape;
    }
    public Shape getShape() {
        return shape;
    }
    public void setShape(Shape shape) {
        this.shape = shape;
    }
    @Override
    public int compareTo(Card o) {    //返回int类型，大于0为正序，小于0为逆序
        // TODO Auto-generated method stub
        if(this.getShape().getArea() > o.getShape().getArea())
        return -1;
        else if(this.getShape().getArea() < o.getShape().getArea())
            return 1;
        return 0;
    }
}

View Code

调用这个 Collection.sort(cardList);来进行排序

cardList 是一个动态数组里面存储的是Card类型的对象，Card实现compareable这个接口，继承一个方法，而这方法通过返回一个int值来规定cardList里面对象的顺序，显而易见我们通过面积大小来规定的，其实具体的规则我自己的理解是，return 1 就改变两个对象的位置。

（2）Comparetor

这个在上次的博客提到过，如果想看的可以去上次的博客翻看。

心得：

心得就是秒了，无坑。

源代码：

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) {
        // TODO Auto-generated method stub
        
        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> cardList = new ArrayList<>();
    DealCardList() {
        
    }
    DealCardList(ArrayList<Integer> list){
        for(int i:list) {
            switch(i) {
            case 1: 
            Card card = new Card(new Circle(Main.input.nextDouble()));
            card.getShape().setShapeName("Circle");
            cardList.add(card);
            break;
            case 2:
            Card card1 = new Card(new Rectangle(Main.input.nextDouble(),Main.input.nextDouble()));
            card1.getShape().setShapeName("Rectangle");
            cardList.add(card1);
            break;
            case 3:
            Card card2 = new Card(new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
            card2.getShape().setShapeName("Triangle");
            cardList.add(card2);
            break;
            case 4:
            Card card3 = new Card(new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
            card3.getShape().setShapeName("Trapezoid");
            cardList.add(card3);
            break;
            }
        }
    }
    boolean validate() {
        for(Card i: cardList) {
            if(i.getShape().validate() == false) {
                return false;
            }
        }
        return true;
    }
    void cardSort() {
        Collections.sort(cardList);
    }
    double getAllArea() {
        double sum=0;
        for(Card i : cardList) {
            sum = sum + i.getShape().getArea();
        }
        return sum;
    }
    void showResult() {
        System.out.println("The original list:");
        for(Card i: cardList) {
          System.out.print(i.getShape().getShapeName()+":" + String.format("%.2f", i.getShape().getArea()) + " ");        
        }
        System.out.println();
        System.out.println("The sorted list:");
        cardSort();
        for(Card i: cardList) {
              System.out.print(i.getShape().getShapeName()+":" + String.format("%.2f", i.getShape().getArea()) + " ");        
            }
        System.out.println();
        System.out.print("Sum of area:" + String.format("%.2f", getAllArea()));
    }
}
class Card implements Comparable<Card>{
    Shape shape;
    Card(){
        
    }
    Card(Shape shape){
        this.shape=shape;
    }
    public Shape getShape() {
        return shape;
    }
    public void setShape(Shape shape) {
        this.shape = shape;
    }
    @Override
    public int compareTo(Card o) {    //返回int类型，大于0为正序，小于0为逆序
        // TODO Auto-generated method stub
        if(this.getShape().getArea() > o.getShape().getArea())
        return -1;
        else if(this.getShape().getArea() < o.getShape().getArea())
            return 1;
        return 0;
    }
}
class  Shape{
    private String shapeName;
    Shape(){
        
    }
     Shape(String shapeName){
         this.shapeName=shapeName;
     }
    public String getShapeName() {
        return shapeName;
    }
    public void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }
     double getArea() {
        return 0.0;
    }
    
 
       boolean validate() {
        return false;
           
       }

    
     public String toString() {
        return shapeName;
     }
}
class Circle extends  Shape{
    private double radius;
    Circle(){
        
    }
    Circle(double radius){
        this.radius=radius;
    }
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    double getArea() {
        return Math.PI*radius*radius;
    }
    boolean validate() {
        if(radius <= 0)
            return false;
        return true;
    }
}
class Rectangle extends Shape{
    private double width;
    private double length;
    Rectangle(){
        
    }
    Rectangle(double width,double length){
        this.width=width;
        this.length=length;
    }
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    double getArea() {
        return width*length;
    }
    boolean validate() {
        if(width <= 0 || length <= 0)
            return false;
        return true;
    }
}
class Triangle extends Shape{
    private double side1;
    private double side2;
    private double side3;
    Triangle(double side1,double side2,double side3){
        this.side1=side1;
        this.side2=side2;
        this.side3=side3;
    }
    public boolean validate() {
        if(side1 <=0 || side2<=0 || side3 <= 0)
            return false;
         if(side1 < side2+side3 && side2<side1+side3  && side3<side2+side1){
            return true;
        }
        else {
            return false;
        }
    }
    public double getArea() {
        double p;
        p=0.5*(side1+side2+side3);
        return Math.pow(p*(p-side1)*(p-side2)*(p-side3), 0.5);
    }
}
class Trapezoid extends Shape{
    private double topSide;
    private double bottonSide;
    private double height;
    Trapezoid(){
        
    }
    Trapezoid(double topSide,double bottonSide,double height){
        this.topSide=topSide;
        this.bottonSide=bottonSide;
        this.height=height;
    }
    double getArea() {
        return ((topSide+bottonSide)/2.0)*height;
    }

    boolean validate() {
        if(height <=0 || topSide <= 0 || bottonSide <= 0)
            return false;
        return true;
    }
    
}

View Code

题目集7 7-2 图形卡片分组游戏

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

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图形名称2:面积值2 …图形名称n:面积值n ]，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格，在结束符“]”之前；
输出分组后的图形类型及面积，格式为[圆形分组各图形类型及面积][矩形分组各图形类型及面积][三角形分组各图形类型及面积][梯形分组各图形类型及面积]，各组内格式为图形名称:面积值。按照“Circle、Rectangle、Triangle、Trapezoid”的顺序依次输出；
各组内图形排序后的各图形类型及面积，格式同排序前各组图形的输出；
各组中面积之和的最大值输出，格式为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.52结尾无空行

输入样例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结尾无空行

输出样例3:

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

The original list:
[Rectangle:8.05 Circle:19.63 Rectangle:9.45 Circle:21.24 Circle:226.98 Triangle:4.65 Triangle:29.80 Trapezoid:50.49 Trapezoid:175.56 Circle:105.68 Circle:14.25 Circle:120.81 Rectangle:16.00 Circle:1092.72 ]
The Separated List:
[Circle:19.63 Circle:21.24 Circle:226.98 Circle:105.68 Circle:14.25 Circle:120.81 Circle:1092.72 ][Rectangle:8.05 Rectangle:9.45 Rectangle:16.00 ][Triangle:4.65 Triangle:29.80 ][Trapezoid:50.49 Trapezoid:175.56 ]
The Separated sorted List:
[Circle:1092.72 Circle:226.98 Circle:120.81 Circle:105.68 Circle:21.24 Circle:19.63 Circle:14.25 ][Rectangle:16.00 Rectangle:9.45 Rectangle:8.05 ][Triangle:29.80 Triangle:4.65 ][Trapezoid:175.56 Trapezoid:50.49 ]
The max area:1601.31结尾无空行

输入样例4:

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

1 1 3 0
6.5 12.54 3.6 5.3 6.4结尾无空行

输出样例4:

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

The original list:
[Circle:132.73 Circle:494.02 Triangle:9.54 ]
The Separated List:
[Circle:132.73 Circle:494.02 ][][Triangle:9.54 ][]
The Separated sorted List:
[Circle:494.02 Circle:132.73 ][][Triangle:9.54 ][]
The max area:626.75结尾无空行

心得：

有些哥们（比如ygx（狗头））写的时候发现自己提交pta的代码长度超限，可能是前面设计的不太行，然后输出的话，没有用写在一个方法里面（如果想要输出就调用这个方法），减少代码的复用率，可以明显减少自己的代码长度。

源代码：

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) {
        // TODO Auto-generated method stub
        
        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()) || list.size() == 0){
        System.out.println("Wrong Format");
        System.exit(0);
        }
        dealCardList.showOriginal_list();
        dealCardList.showSeparated_list();
        dealCardList.showSeparated_sortlist();
        dealCardList.showMax_Area();
        input.close();
        }
    }

class DealCardList{

    ArrayList<Card> cardList = new ArrayList<>();
    ArrayList<Card> card1 = new ArrayList<>();
    ArrayList<Card> card2 = new ArrayList<>();
    ArrayList<Card> card3 = new ArrayList<>();
    ArrayList<Card> card4 = new ArrayList<>();
    DealCardList() {
        
    }
    DealCardList(ArrayList<Integer> list){
        for(int i:list) {
            switch(i) {
            case 1: 
            Card card = new Card(new Circle(Main.input.nextDouble()));
            card.getShape().setShapeName("Circle");
            cardList.add(card);
            break;
            case 2:
            Card card1 = new Card(new Rectangle(Main.input.nextDouble(),Main.input.nextDouble()));
            card1.getShape().setShapeName("Rectangle");
            cardList.add(card1);
            break;
            case 3:
            Card card2 = new Card(new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
            card2.getShape().setShapeName("Triangle");
            cardList.add(card2);
            break;
            case 4:
            Card card3 = new Card(new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
            card3.getShape().setShapeName("Trapezoid");
            cardList.add(card3);
            break;
            }
        }
    }
    boolean validate() {
        for(Card i: cardList) {
            if(i.getShape().validate() == false) {
                return false;
            }
        }
        return true;
    }
    void cardSort(ArrayList<Card> cardList) {
        Collections.sort(cardList);
    }
    double getAllArea() {
        double sum=0;
        for(Card i : cardList) {
            sum = sum + i.getShape().getArea();
        }
        return sum;
    }
    
    void showOriginal_list() {
        System.out.println("The original list:");
        System.out.print("[");
        for(Card i: cardList) {
          System.out.print(i.getShape().getShapeName()+":" + String.format("%.2f", i.getShape().getArea()) + " ");        
        }
        System.out.print("]");
        System.out.println();
    }
    void showSeparated_list() {
        int j=0;
        for(Card i : cardList) {
            switch(i.getShape().getShapeName()) {
            case "Circle":
                card1.add(i);
                break;
            case "Rectangle":
                card2.add(i);
                break;
            case "Triangle":
                card3.add(i);
                break;
            case "Trapezoid":
                card4.add(i);
                break;
            }
        }
        System.out.println("The Separated List:");
        System.out.print("[");
        for(j=0;j<card1.size();j++) {
            System.out.print(card1.get(j).getShape().getShapeName() +":" + String.format("%.2f", card1.get(j).getShape().getArea()) + " ");
        }
        System.out.print("]");
        System.out.print("[");
        for(j=0;j<card2.size();j++) {
            System.out.print(card2.get(j).getShape().getShapeName() +":" + String.format("%.2f", card2.get(j).getShape().getArea()) + " ");
        }
        System.out.print("]");
        System.out.print("[");
        for(j=0;j<card3.size();j++) {
            System.out.print(card3.get(j).getShape().getShapeName() +":" + String.format("%.2f", card3.get(j).getShape().getArea()) + " ");
        }
        System.out.print("]");
        System.out.print("[");
        for(j=0;j<card4.size();j++) {
            System.out.print(card4.get(j).getShape().getShapeName() +":" + String.format("%.2f", card4.get(j).getShape().getArea()) + " ");
        }
        System.out.print("]");
        System.out.println();
    }
    void showSeparated_sortlist() {
        cardSort(card1);
        cardSort(card2);
        cardSort(card3);
        cardSort(card4);
        System.out.println("The Separated sorted List:");
        System.out.print("[");
        for(Card i:card1) {
            System.out.print(i.getShape().getShapeName() + ":" + String.format("%.2f", i.getShape().getArea())+ " ");
        }
        System.out.print("]");
        System.out.print("[");
        for(Card i:card2) {
            System.out.print(i.getShape().getShapeName() + ":" + String.format("%.2f", i.getShape().getArea()) + " ");
        }
        System.out.print("]");
        System.out.print("[");
        for(Card i:card3) {
            System.out.print(i.getShape().getShapeName() + ":" + String.format("%.2f", i.getShape().getArea())+ " ");
        }
        System.out.print("]");
        System.out.print("[");
        for(Card i:card4) {
            System.out.print(i.getShape().getShapeName() + ":" + String.format("%.2f", i.getShape().getArea())+ " ");
        }
        System.out.print("]");
        System.out.println();
    }
    void showMax_Area() {
        double max=0;
        double max1=0;
        double max2=0;
        double max3=0;
        double max4=0;
        for(Card i:card1) {
                max1 = max1+i.getShape().getArea();
        }
        max = max1;
        for(Card i:card2) {
        
                max2 = max2+i.getShape().getArea();
        }
        if(max < max2)
            max = max2;
        for(Card i:card3) {
            
                max3 = max3+i.getShape().getArea();
            
        }
        if(max < max3)
            max = max3;
        for(Card i:card4) {
            
                max4 =max4+ i.getShape().getArea();
            
        }
        if(max < max4)
            max = max4;
        System.out.print("The max area:" + String.format("%.2f", max));
    }
    
}
class Card implements Comparable<Card>{
    Shape shape;
    Card(){
        
    }
    Card(Shape shape){
        this.shape=shape;
    }
    public Shape getShape() {
        return shape;
    }
    public void setShape(Shape shape) {
        this.shape = shape;
    }
    @Override
    public int compareTo(Card o) {    //返回int类型，大于0为正序，小于0为逆序
        // TODO Auto-generated method stub
        if(this.getShape().getArea() > o.getShape().getArea())
        return -1;
        else if(this.getShape().getArea() < o.getShape().getArea())
            return 1;
        return 0;
    }
}
class  Shape{
    private String shapeName;
    Shape(){
        
    }
     Shape(String shapeName){
         this.shapeName=shapeName;
     }
    public String getShapeName() {
        return shapeName;
    }
    public void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }
     double getArea() {
        return 0.0;
    }
    
 
       boolean validate() {
        return false;
           
       }

    
     public String toString() {
        return shapeName;
     }
}
class Circle extends  Shape{
    private double radius;
    Circle(){
        
    }
    Circle(double radius){
        this.radius=radius;
    }
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    double getArea() {
        return Math.PI*radius*radius;
    }
    boolean validate() {
        if(radius <= 0)
            return false;
        return true;
    }
}
class Rectangle extends Shape{
    private double width;
    private double length;
    Rectangle(){
        
    }
    Rectangle(double width,double length){
        this.width=width;
        this.length=length;
    }
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    double getArea() {
        return width*length;
    }
    boolean validate() {
        if(width <= 0 || length <= 0)
            return false;
        return true;
    }
}
class Triangle extends Shape{
    private double side1;
    private double side2;
    private double side3;
    Triangle(double side1,double side2,double side3){
        this.side1=side1;
        this.side2=side2;
        this.side3=side3;
    }
    public boolean validate() {
        if(side1 <=0 || side2<=0 || side3 <= 0)
            return false;
         if(side1 < side2+side3 && side2<side1+side3  && side3<side2+side1){
            return true;
        }
        else {
            return false;
        }
    }
    public double getArea() {
        double p;
        p=0.5*(side1+side2+side3);
        return Math.pow(p*(p-side1)*(p-side2)*(p-side3), 0.5);
    }
}
class Trapezoid extends Shape{
    private double topSide;
    private double bottonSide;
    private double height;
    Trapezoid(){
        
    }
    Trapezoid(double topSide,double bottonSide,double height){
        this.topSide=topSide;
        this.bottonSide=bottonSide;
        this.height=height;
    }
    double getArea() {
        return ((topSide+bottonSide)/2.0)*height;
    }

    boolean validate() {
        if(height <=0 || topSide <= 0 || bottonSide <= 0)
            return false;
        return true;
    }
    
}

View Code

题目集八 7-3 ATM机类结构的设计

设计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结尾无空行

心得：

通过题目我们不难发现，这道题是从卡号开始的，所以非常不建议从用户的角度为底层去构建你的代码，我是从账户类为底层的，构建函数为：

User a;
    String accountid;
    double balance;
    ArrayList <Card> card1 = new ArrayList<>();
    Bank bank;
    Account(){
        
    }
    Account(User a , String accoutid,double balance,ArrayList <Card> card1,Bank bank){
        this.a=a;
        this.accountid=accountid;
        this.balance=balance;
        this.card1=card1;
        this.bank=bank;
    }

View Code

这道题比较难设计，因为一个人可以有多个账户，一个账户可以有多张卡，到底该怎么来让一个账户有多张卡呢，这里就需要用到动态数组了，声明两个动态数组分别为Card类型和账户类型。

以下是杨过信息的初始化

//杨过信息的初始化
         DebitCard  card1= new DebitCard("借记账号","6217000010041315709","88888888");
         DebitCard card2 = new DebitCard("借记账号","6217000010041315715","88888888");
        ArrayList <Card> cardList1 = new ArrayList<>();
        cardList1.add(card1);
        cardList1.add(card2);   
        Account accout1 = new Account(a1,"3217000010041315709",10000,cardList1,bank1);
        DebitCard card3 = new DebitCard("借记账号","6217000010041315718","88888888");
        ArrayList <Card> cardList2 = new ArrayList<>();
        cardList2.add(card3);
        Account accout2 = new Account(a1,"3217000010041315715",10000,cardList2,bank1);

View Code

类图：

源代码：

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        User a1 = new User("杨过");
        User a2 = new User("郭靖");
        User a3 = new User("张无忌");
        User a4 = new User("韦小宝");
        ArrayList <ATM> ATMList1 = new ArrayList<>();
        ATM atm1 = new ATM("01");
        ATM atm2 = new ATM("02");
        ATM atm3 = new ATM("03");
        ATM atm4 = new ATM("04");
        ATMList1.add(atm1);
        ATMList1.add(atm2);
        ATMList1.add(atm3);
        ATMList1.add(atm4);
        Bank bank1  = new Bank("中国建设银行",ATMList1);
        ArrayList <ATM> ATMList2 = new ArrayList<>();
        ATM atm5 = new ATM("05");
        ATM atm6 = new ATM("06");
        ATMList2.add(atm5);
        ATMList2.add(atm6);
        Bank bank2 = new Bank("中国工商银行",ATMList2);
        
        //杨过信息的初始化
        Card card1  = new Card("6217000010041315709","88888888");
        Card card2 = new Card("6217000010041315715","88888888");
        ArrayList <Card> cardList1 = new ArrayList<>();
        cardList1.add(card1);
        cardList1.add(card2);   
        Account accout1 = new Account(a1,"3217000010041315709",10000,cardList1,bank1);
        Card card3 = new Card("6217000010041315718","88888888");
        ArrayList <Card> cardList2 = new ArrayList<>();
        cardList2.add(card3);
        Account accout2 = new Account(a1,"3217000010041315715",10000,cardList2,bank1);
        
        //郭靖信息的初始化
        Card card4  = new Card("6217000010051320007","88888888");
        ArrayList <Card> cardList3 = new ArrayList<>();
        cardList3.add(card4);
        Account accout3 = new Account(a2,"3217000010051320007",10000,cardList3,bank1);
        
        //张无忌信息的初始化
        Card card5  = new Card("6222081502001312389","88888888");
        ArrayList <Card> cardList4 = new ArrayList<>();
        cardList4.add(card5);
        Account accout4 = new Account(a3,"3222081502001312389",10000,cardList4,bank2);
        
        Card card6  = new Card("6222081502001312390","88888888");
        ArrayList <Card> cardList5 = new ArrayList<>();
        cardList5.add(card6);
        Account accout5 = new Account(a3,"3222081502001312390",10000,cardList5,bank2);
        
        Card card7  = new Card("6222081502001312399","88888888");
        Card card8  = new Card("6222081502001312400","88888888");
        ArrayList <Card> cardList6 = new ArrayList<>();
        cardList6.add(card7);
        cardList6.add(card8);
        Account accout6 = new Account(a3,"3222081502001312399",10000,cardList6,bank2);
        
        //韦小宝信息的初始化
        Card card9 = new Card("6222081502051320785","88888888");
        ArrayList <Card> cardList7 = new ArrayList<>();
        cardList7.add(card9);
        Account accout7 = new Account(a4,"3222081502051320785",10000,cardList7,bank2);
        
        Card card10 = new Card("6222081502051320786","88888888");
        ArrayList <Card> cardList8 = new ArrayList<>();
        cardList8.add(card10);
        Account accout8 = new Account(a4,"3222081502051320786",10000,cardList8,bank2);
        
        ArrayList <Account> accountList = new ArrayList<>();
        accountList.add(accout1);
        accountList.add(accout2);
        accountList.add(accout3);
        accountList.add(accout4);
        accountList.add(accout5);
        accountList.add(accout6);
        accountList.add(accout7);
        accountList.add(accout8);
       Scanner in = new Scanner (System.in);
      ArrayList<String> m = new ArrayList<>();  //记录每一条信息
       String n = in.nextLine();
       ATM ATM1 = new ATM();
      int count = -1;
      int countcard = -1;
       int i=0;
       while(n.equals("#") == false) {
           m.add(n);
           i++;
           n = in.nextLine();
       }
       for(String j: m) {

          String[] x  = j.split("\\s+");
          if(x.length==1) {  // 长度为一则为查询功能
              count  = finddex(x[0],accountList);
              if(count == -1) {
                  System.out.println("Sorry,this card does not exist.");
                  System.exit(0);
              }
              else {
                  ATM1.Inquire(accountList.get(count));
              }
          }
          else {
              count  = finddex(x[0],accountList);
              if(count == -1) {
                  System.out.println("Sorry,this card does not exist.");
                  System.exit(0);
              }
              countcard = accountList.get(count).find_cardid(x[0]);
              if(accountList.get(count).getCard1().get(countcard).check_password(x[1]) == false) {
                  System.out.println("Sorry,your password is wrong.");
                  System.exit(0);
              }
              if(accountList.get(count).getBank().check_ATMid(x[2]) == false) {
                  System.out.println("Sorry,the ATM's id is wrong.");
                  System.exit(0);
              }
              if(accountList.get(count).getBank().check_ATM(x[2]) == false) {
                  System.out.println("Sorry,cross-bank withdrawal is not supported.");
                  System.exit(0);
              }
              double money = Double.parseDouble(x[3]);
              if(money > 0 && ATM1.check_balance(accountList.get(count), money) == false) {
                  System.out.println("Sorry,your account balance is insufficient.");
                  System.exit(0);
              }
              if(money < 0 ) {
                  ATM1.Withdrawal(accountList.get(count), money);
                  System.out.println(accountList.get(count).getA().getName()+"在"+ accountList.get(count).getBank().getBankname()+"的"+ x[2] +"号ATM机上存款¥" + String.format("%.2f", Math.abs(money))); 
                  System.out.println("当前余额为¥" + String.format("%.2f", accountList.get(count).getBalance()) );
              }
              else {
                  ATM1.Withdrawal(accountList.get(count), money);
                  System.out.println(accountList.get(count).getA().getName()+"在"+ accountList.get(count).getBank().getBankname()+"的"+ x[2] +"号ATM机上取款¥" + String.format("%.2f", money)); 
                  System.out.println("当前余额为¥" + String.format("%.2f", accountList.get(count).getBalance()) );
              }
             
          }
        
       }
    }
    public static int finddex(String x, ArrayList <Account> accountlist) {  //找寻卡号在哪个银行账号上，如果找到了返回数组的下标，如果没有找到则返回-1
        int count=-1;
        for(Account i: accountlist) {
            count++;
            if(i.check_cardid(x) == true) {
                return count;
            }
        }
        return -1;
    }
}
class User{
  private String name;
  User(){
      
  }
  User(String name){
      this.name=name;
  }
public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}
}
class Account{
    User a;
    String accountid;
    double balance;
    ArrayList <Card> card1 = new ArrayList<>();
    Bank bank;
    Account(){
        
    }
    Account(User a , String accoutid,double balance,ArrayList <Card> card1,Bank bank){
        this.a=a;
        this.accountid=accountid;
        this.balance=balance;
        this.card1=card1;
        this.bank=bank;
    }
    
      boolean check_cardid(String cardid) {   //检验卡号的正确性
            for(Card i : card1) {
                if(cardid.equals(i.getCardid())) {
                    return true;
                }
            }
            return false;
        }
      int find_cardid(String cardid) {
          int count = -1;
            for(Card i : card1) {
                count++;
                if(cardid.equals(i.getCardid())) {
                    return count;
                }
            }
            return 0;
      }
    public User getA() {
        return a;
    }

    public void setA(User a) {
        this.a = a;
    }

    public String getAccountid() {
        return accountid;
    }

    public void setAccountid(String accountid) {
        this.accountid = accountid;
    }

    public double getBalance() {
        return balance;
    }

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

    public ArrayList<Card> getCard1() {
        return card1;
    }

    public void setCard1(ArrayList<Card> card1) {
        this.card1 = card1;
    }

    public Bank getBank() {
        return bank;
    }

    public void setBank(Bank bank) {
        this.bank = bank;
    }
    
}
class Card{
private    String cardid;
   private String password;
   Card(){
       
   }
   Card(String cardid,String password){
       this.cardid=cardid;
       this.password=password;
   }
boolean check_password(String PassWord) { //检查卡号密码是否正确
    if(PassWord.equals(password)) {
        return true;
    }
    return false;
}
public String getCardid() {
    return cardid;
}
public void setCardid(String cardid) {
    this.cardid = cardid;
}
public String getPassword() {
    return password;
}
public void setPassword(String password) {
    this.password = password;
}
    
}
class Bank{
private    String bankname;
private    ArrayList<ATM> atm = new ArrayList<>();
private String[] ID = {"01","02","03","04","05","06"};
Bank(){
    
}
    Bank(String bankname,ArrayList<ATM> atm){
        this.bankname=bankname;
        this.atm=atm;
    }
    boolean check_ATMid(String ATMid) {   //检验ATM编号是否存在
        for(int i=0; i<ID.length;i++) {
            if(ATMid.equals(ID[i])) {
                return true;
            }
        }
        return false;
    }
    boolean check_ATM(String ATMid) {   //检验是否跨行存取存款
        for(ATM i : atm) {
            if(ATMid.equals(i.getATMid())) {
                return true;
            }
            
        }
        return false;
    }
    public String getBankname() {
        return bankname;
    }
    public void setBankname(String bankname) {
        this.bankname = bankname;
    }
    public ArrayList<ATM> getAtm() {
        return atm;
    }
    public void setAtm(ArrayList<ATM> atm) {
        this.atm = atm;
    }
    
}
class ATM{
 private String ATMid;
    ATM(){
        
    }
    ATM(String ATMid){
    this.ATMid=ATMid;
    }
    public String getATMid() {
        return ATMid;
    }
    public void setATMid(String aTMid) {
        ATMid = aTMid;
    }
    boolean check_balance(Account a,double b) {
        if(a.getBalance() - b <0) {
            return false;
        }
        return true;
    }

    void Withdrawal(Account a,double b) {
        a.setBalance(a.getBalance()-b);
    }
    void Inquire(Account a) {
        System.out.println("¥"+String.format("%.2f", a.getBalance()));
    }
}

View Code

题目集九 7-1 ATM机类结构设计（二）

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

输入格式:

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

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

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

③查询余额业务输出

业务：查询余额 ¥[金额]

金额保留两位小数。

输入样例1:

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

6222081502001312390 88888888 06 500.00
#结尾无空行

输出样例1:

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

业务：取款 张无忌在中国工商银行的06号ATM机上取款¥500.00
当前余额为¥9500.00结尾无空行

输入样例2:

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

6217000010041315709  88888888 06 3500.00
#结尾无空行

输出样例2:

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

业务：取款 杨过在中国工商银行的06号ATM机上取款¥3500.00
当前余额为¥6395.00结尾无空行

输入样例3:

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

6217000010041315715
#结尾无空行

输出样例3:

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

业务：查询余额 ¥10000.00



结尾无空行

输入样例4:

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

6222081502001312390 88888888 01 500.00
6222081502051320786 88888888 06 1200.00
6217000010041315715 88888888 02 1500.00
6217000010041315709  88888888 02 3500.00
6217000010041315715
#结尾无空行

输出样例4:

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

业务：取款 张无忌在中国建设银行的01号ATM机上取款¥500.00
当前余额为¥9490.00
业务：取款 韦小宝在中国工商银行的06号ATM机上取款¥1200.00
当前余额为¥8800.00
业务：取款 杨过在中国建设银行的02号ATM机上取款¥1500.00
当前余额为¥8500.00
业务：取款 杨过在中国建设银行的02号ATM机上取款¥3500.00
当前余额为¥5000.00
业务：查询余额 ¥5000.00结尾无空行

输入样例5:

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

6640000010045442002 88888888 09 3000
6640000010045442002 88888888 06 8000
6640000010045442003 88888888 01 10000
6640000010045442002
#结尾无空行

输出样例5:

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

业务：取款 张三丰在中国农业银行的09号ATM机上取款¥3000.00
当前余额为¥6880.00
业务：取款 张三丰在中国工商银行的06号ATM机上取款¥8000.00
当前余额为¥-1416.00
业务：取款 张三丰在中国建设银行的01号ATM机上取款¥10000.00
当前余额为¥-11916.00
业务：查询余额 ¥-11916.00结尾无空行

心得：

这道题坑的地方还是蛮多的，讲讲我做这道题时我觉得比较坑的地方：

1.判断它的余额是否够

我用的方法是

boolean check_balance(Account a,double b,int i,int lever)

第一个参数传取钱的账户

第二个参数是这个账户的第几张卡

第三个参数是你取钱要收的手续费等级，等级0则不需要手续费，等级1则收取2%的手续费，等级2则收取3%的手续费，等级4则收取4%的手续费，判断这个我用了一个函数

代码

（1）如果是借记卡，那么你取的钱加上你的手续费不能超过你的余额才行，很多人会忽略这个小细节，以下是部分代码细节：

代码

（2）如果是贷记卡，它有两种手续费，如果是跨行的手续费，你取多少钱就算多少的手续费不管它是否透支。透支的手续费，要看你取的时候余额是不是为0，当余额为负的你还在取钱才算手续费，有些人会想我跨行的手续费算不算透支的呢？根据题目它是没有算的。

代码

2.取钱的时候的细节

1.判断现在余额是否大于0

（1）如果大于0，那么余额减去你要取的钱是否大于0

①如果大于0，又是跨行则加上手续费即可

②如果小于0，余额减去取款的那部分取款需要收取透支的手续费，如果是跨行取款则加上全部取款乘上跨行的手续费比例

（2）如果小于0

①如果是跨行取款，总手续费公式为 b*（x+y）

②如果不是跨行取款，总手续费公式为 b*y

( x为跨行的手续费比例，y为透支手续费比例)

类图：

源代码：

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        User a1 = new User("杨过");
        User a2 = new User("郭靖");
        User a3 = new User("张无忌");
        User a4 = new User("韦小宝");
        User a5 = new User("张三丰");
        User a6 = new User("令狐冲");
        User a7 = new User("乔峰");
        User a8 = new User("洪七公");
        
        ArrayList <ATM> ATMList1 = new ArrayList<>();
        ATM atm1 = new ATM("01");
        ATM atm2 = new ATM("02");
        ATM atm3 = new ATM("03");
        ATM atm4 = new ATM("04");
        ATMList1.add(atm1);
        ATMList1.add(atm2);
        ATMList1.add(atm3);
        ATMList1.add(atm4);
        Bank bank1  = new Bank("中国建设银行",ATMList1);
        
        ArrayList <ATM> ATMList2 = new ArrayList<>();
        ATM atm5 = new ATM("05");
        ATM atm6 = new ATM("06");
        ATMList2.add(atm5);
        ATMList2.add(atm6);
        Bank bank2 = new Bank("中国工商银行",ATMList2);
        
         ArrayList <ATM> ATMList3 = new ArrayList<>();
         ATM atm7 = new ATM("07");
         ATM atm8 = new ATM("08");
         ATM atm9 = new ATM("09");
         ATM atm10 = new ATM("10");
         ATM atm11 = new ATM("11");
         ATMList3.add(atm7);
         ATMList3.add(atm8);
         ATMList3.add(atm9);
         ATMList3.add(atm10);
         ATMList3.add(atm11);
         Bank bank3 = new Bank("中国农业银行",ATMList3);
        //杨过信息的初始化
         DebitCard  card1= new DebitCard("借记账号","6217000010041315709","88888888");
         DebitCard card2 = new DebitCard("借记账号","6217000010041315715","88888888");
        ArrayList <Card> cardList1 = new ArrayList<>();
        cardList1.add(card1);
        cardList1.add(card2);   
        Account accout1 = new Account(a1,"3217000010041315709",10000,cardList1,bank1);
        DebitCard card3 = new DebitCard("借记账号","6217000010041315718","88888888");
        ArrayList <Card> cardList2 = new ArrayList<>();
        cardList2.add(card3);
        Account accout2 = new Account(a1,"3217000010041315715",10000,cardList2,bank1);
        
        //郭靖信息的初始化
        DebitCard card4  = new DebitCard("借记账号","6217000010051320007","88888888");
        ArrayList <Card> cardList3 = new ArrayList<>();
        cardList3.add(card4);
        Account accout3 = new Account(a2,"3217000010051320007",10000,cardList3,bank1);
        
        //张无忌信息的初始化
        DebitCard card5  = new DebitCard("借记账号","6222081502001312389","88888888");
        ArrayList <Card> cardList4 = new ArrayList<>();
        cardList4.add(card5);
        Account accout4 = new Account(a3,"3222081502001312389",10000,cardList4,bank2);
        
        DebitCard card6  = new DebitCard("借记账号","6222081502001312390","88888888");
        ArrayList <Card> cardList5 = new ArrayList<>();
        cardList5.add(card6);
        Account accout5 = new Account(a3,"3222081502001312390",10000,cardList5,bank2);
        
        DebitCard card7  = new DebitCard("借记账号","6222081502001312399","88888888");
  DebitCard card8  = new DebitCard("借记账号","6222081502001312400","88888888");
        ArrayList <Card> cardList6 = new ArrayList<>();
        cardList6.add(card7);
        cardList6.add(card8);
        Account accout6 = new Account(a3,"3222081502001312399",10000,cardList6,bank2);
        
        //韦小宝信息的初始化
        DebitCard card9 = new DebitCard("借记账号","6222081502051320785","88888888");
        ArrayList <Card> cardList7 = new ArrayList<>();
        cardList7.add(card9);
        Account accout7 = new Account(a4,"3222081502051320785",10000,cardList7,bank2);
        
        DebitCard card10 = new DebitCard("借记账号","6222081502051320786","88888888");
        ArrayList <Card> cardList8 = new ArrayList<>();
        cardList8.add(card10);
        Account accout8 = new Account(a4,"3222081502051320786",10000,cardList8,bank2);
        
        //张三丰的信息初始化
        FreightCard card11 = new FreightCard("贷记账号","6640000010045442002","88888888");
        FreightCard card12 = new FreightCard("贷记账号","6640000010045442003","88888888");
        
        ArrayList<Card> cardList9 = new ArrayList<>();
        cardList9.add(card11);
        cardList9.add(card12);
        Account account9 = new Account(a5,"3640000010045442002",10000,cardList9,bank1);
        
        //令狐冲的信息初始化
        FreightCard card13 = new FreightCard("贷记账号","6640000010045441009","88888888");
        ArrayList<Card> cardList10 = new ArrayList<>();
        cardList10.add(card13);
        Account account10 = new Account(a6,"3640000010045441009",10000,cardList10,bank2);
        
        //乔峰的信息初始化
        FreightCard card14 = new FreightCard("贷记账号","6630000010033431001","88888888");
        ArrayList<Card> cardList11 = new ArrayList<>();
        cardList11.add(card14);
        Account account11 = new Account(a7,"3630000010033431001",10000,cardList11,bank3);
        
        //洪七公的信息初始化
        FreightCard card15 = new FreightCard("贷记账号","6630000010033431008","88888888");
        ArrayList<Card> cardList12 = new ArrayList<>();
        cardList12.add(card15);
        Account account12 = new Account(a8,"3630000010033431008",10000,cardList12,bank3);
        ArrayList <Account> accountList = new ArrayList<>();
        accountList.add(accout1);
        accountList.add(accout2);
        accountList.add(accout3);
        accountList.add(accout4);
        accountList.add(accout5);
        accountList.add(accout6);
        accountList.add(accout7);
        accountList.add(accout8);
        accountList.add(account9);
        accountList.add(account10);
        accountList.add(account11);
        accountList.add(account12);
       Scanner in = new Scanner (System.in);
      ArrayList<String> m = new ArrayList<>();  //记录每一条信息
       String n = in.nextLine();
       ATM ATM1 = new ATM();
      int count = -1;
      int countcard = -1;
       int i=0;
       String d="";
       while(n.equals("#") == false) {
           m.add(n);
           i++;
           n = in.nextLine();
       }
       for(String j: m) {

          String[] x  = j.split("\\s+");
          if(x.length==1) {  // 长度为一则为查询功能
              count  = finddex(x[0],accountList);
              if(count == -1) {
                  System.out.println("Sorry,this card does not exist.");
                  System.exit(0);
              }
              else {
                  System.out.print("业务：查询余额 ");
                  ATM1.Inquire(accountList.get(count));
              }
          }
          else {
              count  = finddex(x[0],accountList); //找到账户的下标
              countcard = accountList.get(count).find_cardid(x[0]); //找到是哪张卡
              int y = findproportion(accountList,x[2],count);//找到跨行取款的金额比例
              if(count == -1) {
                  System.out.println("Sorry,this card does not exist.");
                  System.exit(0);
              }
             
              if(accountList.get(count).getCard1().get(countcard).check_password(x[1]) == false) {
                  System.out.println("Sorry,your password is wrong.");
                  System.exit(0);
              }
              if(accountList.get(count).getBank().check_ATMid(x[2]) == -1) {
                  System.out.println("Sorry,the ATM's id is wrong.");
                  System.exit(0);
              }
              double money = Double.parseDouble(x[3]);
              if(ATM1.check_balance(accountList.get(count), money,countcard,y) == false) {
                  System.out.println("Sorry,your account balance is insufficient.");
                  System.exit(0);
              }
            
              if(y == 0)
             d =accountList.get(count).getBank().getBankname();
              else if(y==1) {
                  d="中国建设银行";
              }
              else if(y==2) {
                  d="中国工商银行";
              }
              else {
                  d="中国农业银行";
              }
                  ATM1.Withdrawal(accountList.get(count), money,y);
                  System.out.println("业务：取款 "+accountList.get(count).getA().getName()+"在"+ d+"的"+ x[2] +"号ATM机上取款¥" + String.format("%.2f", money)); 
                  System.out.print("当前余额为");
                 ATM1.Inquire(accountList.get(count));
              
             
          }
        
       }
    }
    public static int findproportion(ArrayList<Account> accountlist,String ATMid,int count) {
        if(accountlist.get(count).getBank().check_ATM(ATMid) == true) {
            return 0;
        }
        else {
            int i=accountlist.get(count).getBank().check_ATMid(ATMid);
            if(i<4)
                return 1;
            else if(i<6)
            return 2;
            else
                return 3;
        }
    }
    public static int finddex(String x, ArrayList <Account> accountlist) {  //找寻卡号在哪个银行账号上，如果找到了返回数组的下标，如果没有找到则返回-1
        int count=-1;
        for(Account i: accountlist) {
            count++;
            if(i.check_cardid(x) == true) {
                return count;
            }
        }
        return -1;
    }
    
}
class User{
  private String name;
  User(){
      
  }
  User(String name){
      this.name=name;
  }
public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}
}
class Account{
    User a;
    String accountid;
    double balance;
    ArrayList <Card> card1 = new ArrayList<>();
    Bank bank;
    Account(){
        
    }
    Account(User a , String accoutid,double balance,ArrayList <Card> card1,Bank bank){
        this.a=a;
        this.accountid=accountid;
        this.balance=balance;
        this.card1=card1;
        this.bank=bank;
    }
    
      boolean check_cardid(String cardid) {   //检验卡号的正确性
            for(Card i : card1) {
                if(cardid.equals(i.getCardid())) {
                    return true;
                }
            }
            return false;
        }
      int find_cardid(String cardid) {
          int count = -1;
            for(Card i : card1) {
                count++;
                if(cardid.equals(i.getCardid())) {
                    return count;
                }
            }
            return 0;
      }
    public User getA() {
        return a;
    }

    public void setA(User a) {
        this.a = a;
    }

    public String getAccountid() {
        return accountid;
    }

    public void setAccountid(String accountid) {
        this.accountid = accountid;
    }

    public double getBalance() {
        return balance;
    }

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

    public ArrayList<Card> getCard1() {
        return card1;
    }

    public void setCard1(ArrayList<Card> card1) {
        this.card1 = card1;
    }

    public Bank getBank() {
        return bank;
    }

    public void setBank(Bank bank) {
        this.bank = bank;
    }
    
}
abstract class Card{
public String type;
public    String cardid;
  public String password;
   Card(){
       
   }
   Card(String type,String cardid,String password){
         this.type=type;
       this.cardid=cardid;
       this.password=password;
   }
public String getType() {
    return type;
}

public void setType(String type) {
    this.type = type;
}

public String getCardid() {
    return cardid;
}

public void setCardid(String cardid) {
    this.cardid = cardid;
}

public String getPassword() {
    return password;
}

public void setPassword(String password) {
    this.password = password;
}

   abstract boolean  check_password(String PassWord);
}
class DebitCard extends Card{

     DebitCard (){
         
     }
     DebitCard(String type,String cardid,String password){
         this.type=type;
         this.cardid=cardid;
         this.password=password;
     }
    @Override
    boolean check_password(String PassWord) {
        // TODO Auto-generated method stub
        if(password.equals(PassWord) == true)
            return true;
        return false;
    }
    
}
class FreightCard extends Card{
     
      FreightCard (){
             
         }
      FreightCard(String type,String cardid,String password){
             this.type=type;
             this.cardid=cardid;
             this.password=password;
         }
    @Override
    boolean check_password(String PassWord) {
        // TODO Auto-generated method stub
        if(password.equals(PassWord) == true)
            return true;
        return false;
    }
    
}

class Bank{
private    String bankname;
private    ArrayList<ATM> atm = new ArrayList<>();
private String[] ID = {"01","02","03","04","05","06","07","08","09","10","11"};
Bank(){
    
}
    Bank(String bankname,ArrayList<ATM> atm){
        this.bankname=bankname;
        this.atm=atm;
    }
    int  check_ATMid(String ATMid) {   //检验ATM编号是否存在
        int count=-1;
        for(int i=0; i<ID.length;i++) {
            count++;
            if(ATMid.equals(ID[i])) {
                return count;
            }
        }
        return -1;
    }
    boolean check_ATM(String ATMid) {   //检验是否跨行存取存款
        for(ATM i : atm) {
            if(ATMid.equals(i.getATMid())) {
                return true;
            }
        }
        return false;
    }
    public String getBankname() {
        return bankname;
    }
    public void setBankname(String bankname) {
        this.bankname = bankname;
    }
    public ArrayList<ATM> getAtm() {
        return atm;
    }
    public void setAtm(ArrayList<ATM> atm) {
        this.atm = atm;
    }
    
}
class ATM{
 private String ATMid;
    ATM(){
        
    }
    ATM(String ATMid){
    this.ATMid=ATMid;
    }
    public String getATMid() {
        return ATMid;
    }
    public void setATMid(String aTMid) {
        ATMid = aTMid;
    }
    boolean check_balance(Account a,double b,int i,int lever) {
             if(a.getCard1().get(i).getType().equals("借记账号")) {
                 if(lever == 0) {
                     if(a.getBalance()-b <0) {
                         return false;
                     }
                 }
                 else if(lever == 1) {
                     if(a.getBalance()-b-b*0.02<0)
                         return false;
                 }
                 else if(lever == 2) {
                     if(a.getBalance()-b-b*0.03 <0)
                         return false;
                 }
                 else {
                     if(a.getBalance()-b-b*0.04<0)
                         return false;
                 }
                 return true;
             }
             else if(a.getCard1().get(i).getType().equals("贷记账号")) {
                 if(a.getBalance()-b > 0) {
                     return true;
                 }
                 double c = a.getBalance()-b;
                 if(lever == 0) {
                     if(a.getBalance()>=0)
                     {
                            if(a.getBalance()-b+c*0.05 < -50000) {
                                return false;
                              }
                     }
                     else {
                         if(a.getBalance()-b-b*0.05 < -50000)
                             return false;
                     }
                 }
                 else if(lever == 1) {
                     if(a.getBalance() >= 0)
                     {
                         if(a.getBalance()-b-b*0.02+c*0.05<-50000)
                             return false;
                     }
                     else {
                         if(a.getBalance()-b-b*0.07 < -50000)
                             return false;
                     }
                 }
                 else if(lever == 2) {
                     if(a.getBalance() >= 0)
                     {
                         if(a.getBalance()-b-b*0.03+c*0.05<-50000)
                             return false;
                     }
                     else {
                         if(a.getBalance()-b-b*0.08 < -50000)
                             return false;
                     }
                 }
                 else {
                     if(a.getBalance() >= 0)
                     {
                         if(a.getBalance()-b-b*0.04+c*0.05<-50000)
                             return false;
                     }
                     else {
                         if(a.getBalance()-b-b*0.09 < -50000)
                             return false;
                     }
                 }
                 return true;
             }
              return false;
    }
    void Withdrawal(Account a,double b,int i) {
        if(i == 0) {
            if(a.getBalance()>0) {
                if(a.getBalance()-b>=0)
                a.setBalance(a.getBalance()-b);
                else {
                    double c = a.getBalance()-b;
                    a.setBalance(a.getBalance()-b+c*0.05);
                }
            }
            else {
                double c = b*0.05;
                a.setBalance(a.getBalance()-b-c);
            }
        }
    else  if(i==1) {
            if(a.getBalance()>0) {
                if(a.getBalance()-b >= 0) {
                    a.setBalance(a.getBalance()-(b+b*0.02));
              }
              else {
                  double c = a.getBalance()-b;
                  a.setBalance(a.getBalance()-b+c*0.05-b*0.02);
              }
            }
            else {
                double c = b*0.05;
                a.setBalance(a.getBalance()-b-b*0.02-c);
            }
        }
        else if (i == 2) {
            if(a.getBalance()>0) {
                if(a.getBalance()-b >= 0)
                    a.setBalance(a.getBalance()-(b+b*0.03));
                    else {
                        double c = a.getBalance()-b;
                        a.setBalance(a.getBalance()+c*0.05-b*0.03-b);
                    }
            }
            else {
                double c = b*0.05;
                a.setBalance(a.getBalance()-b-b*0.03-c);
            }
        }
        else {
            if(a.getBalance()>0) {
                if(a.getBalance()-b >= 0) {
                    a.setBalance(a.getBalance()-(b+b*0.04));
                 }
              else {
                 double c = a.getBalance()-b;
                a.setBalance(a.getBalance()+c*0.05-b-b*0.04);
                }
                 }
            else {
                double c = b*0.05;
                a.setBalance(a.getBalance()-b-b*0.04-c);
            }
            }
        
        }
    
    void Inquire(Account a) {
        System.out.println("¥"+String.format("%.2f", a.getBalance()));
    }
}

View Code

总结：

通过这学期对java的初学，感受最深的就是，用户需求的改变，我自己写的代码能不能适应他的需要。而不是他说一个需求我就要重新再写一边我的代码。通过这三次的大作业我们也能很好的体会到，如果题目增加一点要求，我们的代码是否能只在原代码的基础上修改，就能满足题目的要求，老师大概也行就是想培养我们这样的能力吧。

posted @ 2021-12-18 17:37 aimer1 阅读(55) 评论(0) 收藏举报

刷新页面返回顶部

二刺螈下不了地狱

题目集 7-9总结

前言：

题目集七：

主要需要知道两个知识点：

题目集八、九：

设计与分析：

题目集七 7-1 图形卡片排序游戏：

输入格式:

输出格式:

输入样例1:

输出样例1:

输入样例2:

输出样例2:

输入样例3:

输出样例3:

1.ArrayList 动态数组里面可以存储什么呢？跟普通的数组有什么区别呢？到底哪里好用呢？

2.Compareable和Compareto的区别

（1）Comparebale

（2）Comparetor

心得：

源代码：

题目集7 7-2 图形卡片分组游戏

输入格式:

输出格式:

输入样例1:

输出样例1:

输入样例2:

输出样例2:

输入样例3:

输出样例3:

输入样例4:

输出样例4:

心得：

源代码：

题目集八 7-3 ATM机类结构的设计

输入格式:

输出格式:

输入样例1:

输出样例1:

输入样例2:

输出样例2:

输入样例3:

输出样例3:

输入样例4:

输出样例4:

心得：

类图：

源代码：

题目集九 7-1 ATM机类结构设计（二）

输入格式:

输出格式:

输入样例1:

输出样例1:

输入样例2:

输出样例2:

输入样例3:

输出样例3:

输入样例4:

输出样例4:

输入样例5:

输出样例5:

心得：

1.判断它的余额是否够

2.取钱的时候的细节

类图：

源代码：

总结：

公告