第三次Blog

一、前言

知识点：这三次作业主要考察的是我们对于接口、继承、组合的掌握，同时考察了我们对于题目给出的需求，要如何去面向对象地设计类。这三次作业，可以看成两次作业，日期和存款的第二个题目都只是在第一个题目上增加需求，所以这就考验我们要如何去设计类能够便于我们进行代码的后期维护。

题量：这三次作业的题量算是相当少了，三次作业四个题目，确实不算多。

难度：日期问题的难度一般，因为已经给出了类图，所以第一题就按照类图来就很容易了。第二次也只是在第一题的基础上增加需求，增加几个函数也很容易解决；存款问题的难度较大，首先要自己设计合理便于后期维护的类图，就考验我们面向对象的思想，要自己独立设计解决一个问题，是有一定难度的。

 

二、设计与分析

题目集七 

 

 

 

 

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

import java.util.*;

public class Main {
    public static Scanner input=new Scanner(System.in);
    public static void main(String[] args) {
        
    
        ArrayList<Integer> list = new ArrayList<Integer>();
        
        int num=input.nextInt();
        
        while(num!=0) {
            if(num<0||num>4) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            list.add(num);
            num=input.nextInt();
        }
        
        DealCardList dealCardList =new DealCardList(list);
        
        if(!dealCardList.validate()) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        
        dealCardList.showResult();
        
    }
}


abstract class Shape{
    private String shapeName;
    
    public String getShapeName() {
        return this.shapeName;
    }
    
    public void setShapeName(String shapeName) {
        this.shapeName=shapeName;
    }
    
    abstract public double getArea();
    abstract public boolean validate();
    abstract public String toString();
    
}


//圆
class Circle extends Shape{
    private double radius;
    
    public Circle(double radius){
        this.radius=radius;
    }
    
    public double getRadius() {
        return this.radius;
    }
    
    public void setRadius(double radius) {
        this.radius=radius;
    }
    
    @Override
    public double getArea() {
        // TODO Auto-generated method stub
        return Math.PI*this.radius*this.radius;
    }

    @Override
    public boolean validate() {
        // TODO Auto-generated method stub
        if(this.radius<0)
            return false;
        else
            return true;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "Circle:"+String.format("%.2f",this.getArea())+" ";
    }
    
}

//矩形
class Rectangle extends Shape{
    private double width;
    private double length;
    
    public Rectangle(double width2, double length2) {
        // TODO Auto-generated constructor stub
        this.length=length2;
        this.width=width2;
    }

    public double getWidth() {
        return this.width;
    }
    
    public void setWidth(double width) {
        this.width=width;
    }
    
    public double getlength() {
        return this.length;
    }
    
    public void setLength(double length) {
        this.length=length;
    }
    
    @Override
    public double getArea() {
        // TODO Auto-generated method stub
        return this.length*this.width;
    }

    @Override
    public boolean validate() {
        // TODO Auto-generated method stub
        if(this.width>=0&&this.length>=0)
            return true;
        else
            return false;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "Rectangle:"+String.format("%.2f",this.getArea())+" ";
    }
    
}

//三角形
class Triangle extends Shape{
    private double side1;
    private double side2;
    private double side3;
    
    public Triangle(double s1, double s2, double s3) {
        // TODO Auto-generated constructor stub
        this.side1=s1;
        this.side2=s2;
        this.side3=s3;
    }

    @Override
    public double getArea() {
        // TODO Auto-generated method stub
         double p=(side1+side2+side3)/2;
            double s=Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
            return s;
    }

    @Override
    public boolean validate() {
        // TODO Auto-generated method stub
        if(side1+side2<=side3||side1+side3<=side2||side2+side3<=side1)
            return false;
        else if(side1-side2>=side3||side1-side3>=side2||side2-side3>=side1)
            return false;
        else 
            return true;

    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "Triangle:"+String.format("%.2f",this.getArea())+" ";
    }
    
}

//梯形
class Trapezoid extends Shape{
    private double topSide;
    private double bottomSide;
    private double height;
    
    public Trapezoid(double tops, double bottoms, double h) {
        // TODO Auto-generated constructor stub
        this.bottomSide=bottoms;
        this.height=h;
        this.topSide=tops;
    }

    @Override
    public double getArea() {
        // TODO Auto-generated method stub
        return (this.topSide+this.bottomSide)*this.height/2;
    }

    @Override
    public boolean validate() {
        // TODO Auto-generated method stub
        if(topSide>=0&&bottomSide>=0&&height>=0)
            return true;
        else
            return false;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "Trapezoid:"+String.format("%.2f",this.getArea())+" ";
    }
    
}

class Card implements Comparable{
    private Shape shape;
    
    public Card(Shape shape) {
        this.shape=shape;
    }
    
    public Shape getShape() {
        return this.shape;
    }
    
    public void setShape(Shape shape) {
        this.shape=shape;
    }
    
    @Override
    public int compareTo(Card card) {
        // TODO Auto-generated method stub
         if(this.shape.getArea()>card.shape.getArea())//从大到小
              return 1;
        else if(this.shape.getArea()<card.shape.getArea())//从小到大
              return -1;
        else
              return 0;
    }
    
}

class DealCardList{
    
    ArrayList<Card> cardList=new ArrayList<Card>();
    
    public DealCardList(ArrayList<Integer> list) {
        // TODO Auto-generated constructor stub
        for(int i=0;i<list.size();i++) {
            int j=list.get(i);
            
            switch(j) {
            case 1:{
                double radius=Main.input.nextDouble();
                Circle c=new Circle(radius);
                this.cardList.add(i,new Card(c));
                break;
            }
            case 2:{
                double width=Main.input.nextDouble();
                double length=Main.input.nextDouble();
                Rectangle rec=new Rectangle(width,length);
                this.cardList.add(i, new Card(rec));
                break;
            }
            case 3:{
                double s1=Main.input.nextDouble();
                double s2=Main.input.nextDouble();
                double s3=Main.input.nextDouble();
                Triangle tri=new Triangle(s1,s2,s3);
                this.cardList.add(i, new Card(tri));
                break;
            }
            case 4:
                double tops=Main.input.nextDouble();
                double bottoms=Main.input.nextDouble();
                double h=Main.input.nextDouble();
                Trapezoid tra=new Trapezoid(tops,bottoms,h);
                this.cardList.add(i, new Card(tra));
                break;
            }
            
        }
        
    }

    public boolean validate() {
        for(Card c:cardList) {
            if(!c.getShape().validate())
                return false;
        }
        return true;
    }
    
    public void cardSort() {
        int i,j;
        for(i=0;i<cardList.size();i++) {
            for(j=0;j<cardList.size()-1;j++) {
                Card card1=cardList.get(j);
                Card card2=cardList.get(j+1);
                if(card1.compareTo(card2)!=1) {
                    cardList.set(j, card2);
                    cardList.set(j+1, card1);
                }
            }
        }
    }
    
    public String getAllArea() {
        double sum=0;
        for(Card c:cardList)
            sum=sum+c.getShape().getArea();
        return String.format("%.2f",sum);
    }
    
    public void showResult() {
        
        System.out.println("The original list:");
        for(Card c:cardList)
            System.out.print(c.getShape().toString());
        System.out.println("");
        
        System.out.println("The sorted list:");
        this.cardSort();
        for(Card c:cardList)
            System.out.print(c.getShape().toString());
        System.out.println("");
        
        System.out.println("Sum of area:"+this.getAllArea());
    }
}

interface Comparable{
    abstract public int compareTo(Card card);
}

 

SourceMonitor：

 

思路：

　　按照题目给出的类图进行编码就好，主函数也给了代码，没什么好说的。

踩坑心得：

　　对于这道题目，一开始按照类图写完代码后，一直显示数组越界，后来发现是 ArrayList.set 和 ArrayList.add 这两个搞混了，ArrayList.set 必须要动态数组不为空，当动态数组为空时，就无法set 会报错数组越界，数组为空时只能使用 ArrayList.add 对动态数组添加数据。然后还有一个特别傻x的问题，就是我一开始给构造方法的时候，忘记写构造方法的方法体了，导致构造方法一直是空的，所以一直无法输出，导致错误。

改进建议：

　　对于这道题目没有什么改进建议，按照题目给出的类图写代码就好，但是在编码的过程的时候要特别注意一些小细节，因为一些小错误导致我后面找bug的时候花费了一些时间，所谓细节决定成败，不要忽视任何一个小地方。

 

 

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

import java.util.*;

public class Main {
    public static Scanner input=new Scanner(System.in);
    public static void main(String[] args) {
        
    
        ArrayList<Integer> list = new ArrayList<Integer>();
        
        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=input.nextInt();
        }
        
        DealCardList dealCardList =new DealCardList(list);
        
        if(!dealCardList.validate()) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        
        dealCardList.showResult();
        
    }
}


abstract class Shape{
    private String shapeName;
    
    public String getShapeName() {
        return this.shapeName;
    }
    
    public void setShapeName(String shapeName) {
        this.shapeName=shapeName;
    }
    
    abstract public double getArea();
    abstract public boolean validate();
    abstract public String toString();
    
}


//圆
class Circle extends Shape{
    private double radius;
    
    public Circle(double radius){
        this.radius=radius;
    }
    
    public double getRadius() {
        return this.radius;
    }
    
    public void setRadius(double radius) {
        this.radius=radius;
    }
    
    @Override
    public double getArea() {
        // TODO Auto-generated method stub
        return Math.PI*this.radius*this.radius;
    }

    @Override
    public boolean validate() {
        // TODO Auto-generated method stub
        if(this.radius<0)
            return false;
        else
            return true;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "Circle:"+String.format("%.2f",this.getArea())+" ";
    }
    public String getShapeName() {
        return "Circle";
    }
}

//矩形
class Rectangle extends Shape{
    private double width;
    private double length;
    
    public Rectangle(double width2, double length2) {
        // TODO Auto-generated constructor stub
        this.length=length2;
        this.width=width2;
    }

    public double getWidth() {
        return this.width;
    }
    
    public void setWidth(double width) {
        this.width=width;
    }
    
    public double getlength() {
        return this.length;
    }
    
    public void setLength(double length) {
        this.length=length;
    }
    
    @Override
    public double getArea() {
        // TODO Auto-generated method stub
        return this.length*this.width;
    }

    @Override
    public boolean validate() {
        // TODO Auto-generated method stub
        if(this.width>=0&&this.length>=0)
            return true;
        else
            return false;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "Rectangle:"+String.format("%.2f",this.getArea())+" ";
    }
    public String getShapeName() {
        return "Rectangle";
    }
}

//三角形
class Triangle extends Shape{
    private double side1;
    private double side2;
    private double side3;
    
    public Triangle(double s1, double s2, double s3) {
        // TODO Auto-generated constructor stub
        this.side1=s1;
        this.side2=s2;
        this.side3=s3;
    }

    @Override
    public double getArea() {
        // TODO Auto-generated method stub
         double p=(side1+side2+side3)/2;
            double s=Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
            return s;
    }

    @Override
    public boolean validate() {
        // TODO Auto-generated method stub
        if(side1+side2<=side3||side1+side3<=side2||side2+side3<=side1)
            return false;
        else if(side1-side2>=side3||side1-side3>=side2||side2-side3>=side1)
            return false;
        else 
            return true;

    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "Triangle:"+String.format("%.2f",this.getArea())+" ";
    }
    public String getShapeName() {
        return "Triangle";
    }
}

//梯形
class Trapezoid extends Shape{
    private double topSide;
    private double bottomSide;
    private double height;
    
    public Trapezoid(double tops, double bottoms, double h) {
        // TODO Auto-generated constructor stub
        this.bottomSide=bottoms;
        this.height=h;
        this.topSide=tops;
    }

    @Override
    public double getArea() {
        // TODO Auto-generated method stub
        return (this.topSide+this.bottomSide)*this.height/2;
    }

    @Override
    public boolean validate() {
        // TODO Auto-generated method stub
        if(topSide>=0&&bottomSide>=0&&height>=0)
            return true;
        else
            return false;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "Trapezoid:"+String.format("%.2f",this.getArea())+" ";
    }
    public String getShapeName() {
        return "Trapezoid";
    }
}

class Card implements Comparable{
    private Shape shape;
    
    public Card(Shape shape) {
        this.shape=shape;
    }
    
    public Shape getShape() {
        return this.shape;
    }
    
    public void setShape(Shape shape) {
        this.shape=shape;
    }
    
    @Override
    public int compareTo(Card card) {
        // TODO Auto-generated method stub
         if(this.shape.getArea()>card.shape.getArea())//从大到小
              return 1;
        else if(this.shape.getArea()<card.shape.getArea())//从小到大
              return -1;
        else
              return 0;
    }
    
}

class DealCardList extends Group{
    
    ArrayList<Card> cardList=new ArrayList<Card>();
    
    public DealCardList(ArrayList<Integer> list) {
        // TODO Auto-generated constructor stub
        for(int i=0;i<list.size();i++) {
            int j=list.get(i);
            
            switch(j) {
            case 1:{
                double radius=Main.input.nextDouble();
                Circle c=new Circle(radius);
                this.cardList.add(i,new Card(c));
                break;
            }
            case 2:{
                double width=Main.input.nextDouble();
                double length=Main.input.nextDouble();
                Rectangle rec=new Rectangle(width,length);
                this.cardList.add(i, new Card(rec));
                break;
            }
            case 3:{
                double s1=Main.input.nextDouble();
                double s2=Main.input.nextDouble();
                double s3=Main.input.nextDouble();
                Triangle tri=new Triangle(s1,s2,s3);
                this.cardList.add(i, new Card(tri));
                break;
            }
            case 4:
                double tops=Main.input.nextDouble();
                double bottoms=Main.input.nextDouble();
                double h=Main.input.nextDouble();
                Trapezoid tra=new Trapezoid(tops,bottoms,h);
                this.cardList.add(i, new Card(tra));
                break;
            }
            
        }
        
    }

    public boolean validate() {
        for(Card c:cardList) {
            if(!c.getShape().validate())
                return false;
        }
        return true;
    }
    
    public void cardSort() {
        int i,j;
        for(i=0;i<cardList.size();i++) {
            for(j=0;j<cardList.size()-1;j++) {
                Card card1=cardList.get(j);
                Card card2=cardList.get(j+1);
                if(card1.compareTo(card2)!=1) {
                    cardList.set(j, card2);
                    cardList.set(j+1, card1);
                }
            }
        }
    }
    
    public String getAllArea() {
        double sum=0;
        for(Card c:cardList)
            sum=sum+c.getShape().getArea();
        return String.format("%.2f",sum);
    }
    
    public void showResult() {
        
        System.out.println("The original list:");
        System.out.print("[");
        for(Card c:cardList)
            System.out.print(c.getShape().toString());
        System.out.print("]");
        System.out.println("");
        
        
        System.out.println("The Separated List:");
        this.groupby();
        System.out.print("[");
        for(Shape c:this.cir)
            System.out.print(c.toString());
        System.out.print("]");
        
        System.out.print("[");
        for(Shape c:this.rec)
            System.out.print(c.toString());
        System.out.print("]");
        
        System.out.print("[");
        for(Shape c:this.tra)
            System.out.print(c.toString());
        System.out.print("]");
        
        System.out.print("[");
        for(Shape c:this.tri)
            System.out.print(c.toString());
        System.out.print("]");
        System.out.println("");
        
        System.out.println("The Separated sorted List:");
        this.cardSort();
        this.cir.clear();
        this.rec.clear();
        this.tra.clear();
        this.tri.clear();
        this.groupby();
        System.out.print("[");
        for(Shape c:this.cir)
            System.out.print(c.toString());
        System.out.print("]");
        
        System.out.print("[");
        for(Shape c:this.rec)
            System.out.print(c.toString());
        System.out.print("]");
        
        System.out.print("[");
        for(Shape c:this.tra)
            System.out.print(c.toString());
        System.out.print("]");
        
        System.out.print("[");
        for(Shape c:this.tri)
            System.out.print(c.toString());
        System.out.print("]");
        System.out.println("");
        
        System.out.println("The max area:"+this.getMax());
        
        /*
        System.out.println("The sorted list:");
        this.cardSort();
        for(Card c:cardList)
            System.out.print(c.getShape().toString());
        System.out.println("");
        
        System.out.println("Sum of area:"+this.getAllArea());
        */
    }

    @Override
    public void groupby() {
        // TODO Auto-generated method stub

        for(int i=0;i<this.cardList.size();i++) {
            String s=this.cardList.get(i).getShape().getShapeName();
            if(s.equals("Circle")) {
                this.cir.add(this.cardList.get(i).getShape());
            }
            if(s.equals("Rectangle")) {
                this.rec.add(this.cardList.get(i).getShape());
            }
            if(s.equals("Triangle")) {
                this.tra.add(this.cardList.get(i).getShape());
            }
            if(s.equals("Trapezoid")) {
                this.tri.add(this.cardList.get(i).getShape());
            }
        }
    }

    @Override
    public String getMax() {
        // TODO Auto-generated method stub
        double sum1=0,sum2=0,sum3=0,sum4=0;
        for(Shape a1:this.cir)
            sum1=a1.getArea()+sum1;
        for(Shape a2:this.rec)
            sum2=a2.getArea()+sum2;
        for(Shape a3:this.tra)
            sum3=a3.getArea()+sum3;
        for(Shape a4:this.tri)
            sum4=a4.getArea()+sum4;
        
        double max=0;
        double[] sum= {sum1,sum2,sum3,sum4};
        for(int i=0;i<4;i++) {
            if(max<sum[i])
                max=sum[i];
        }
        
        return String.format("%.2f",max);
    }
}

interface Comparable{
    abstract public int compareTo(Card card);
}

abstract class Group{
    public ArrayList<Shape> cir=new ArrayList<Shape>();
    public ArrayList<Shape> rec=new ArrayList<Shape>();
    public ArrayList<Shape> tri=new ArrayList<Shape>();
    public ArrayList<Shape> tra=new ArrayList<Shape>();
    abstract public void groupby();
    abstract public String getMax();
}

 

SourceMonitor：

 

 

思路：

　　这道题目就主要是在第一个题目的基础上进行输出的格式修改，一开始我是在DealCardList类中增加一些存按照图形分类的动态数组，便于后面按照图形形状进行分类输出，后来觉得太麻烦了就创建了一个专门用来分组的抽象父类让DealCardList类继承，分类的动态数组中的排序可以让排序函数将所有图形面积排序好，然后再按照图形形状进行分类就好。

踩坑心得：

　　这道题目的难点我觉得就是分类和 "[" "]"这两个括号，特别要注意的是，在使用动态数组输出的时候要注意，在每个不同输出的种类之前清空一下数组，这样就避免，以前使用过这个数组，然后会输出很多多余的数据，然后就是要注意"[" "]"这两个括号的位置。

改进建议：

　　我觉得我创建的这个用来分组的abstract class Group抽象父类，他不应该是一个父类，应该是一个接口，因为这个类就是为了给DealCardList类增加功能而已，他不太符合父类和子类的定义，所以将这个父类改成接口更好。

 

题目集八、九

 

 

 

 

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

略（错误代码我就不放上来了）

SourceMonitor：

 

思路 ：

　　一开始我就觉得要有Bank，Account，User，Card，Check这几个类，然后利用父类和子类继承来实现功能。

踩坑心得：

　　这次的错误真的是相当离谱，导致我一运行我的代码，整个eclipse就卡住不能动，运行超时，实在太离谱了，我的代码整个就是循环嵌套循环，整个复杂度就非常高，最后实在是无法解决，eclipse也卡住不能动，感觉就是写了一个病毒代码一样，其他人运行我的代码也是eclipse卡住不能动。

改进建议：

　　因为我为每个用户都建立了一个类，他们都继承User父类，也为每一个银行建立了一个类，他们都继承Bank父类，就导致类非常多，然后他们又与Check进行组合，这样就导致耦合度很高，后期改代码的时候改到崩溃，这些子类可以整合到一个动态数组里面，然后再主函数中进行添加。

 

7-1 ATM机类结构设计（二） (100 分) 源码：

 

 

import java.util.ArrayList;

import java.util.Scanner;

/******************************主类****************************************************/

public class Main {
    
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);

/******************************银行初始化**********************************************/
        //建设银行
        ArrayList<String> l1=new ArrayList<String>();
        l1.add("01");
        l1.add("02");
        l1.add("03");
        l1.add("04");
        Bank CCB=new Bank("中国建设银行",l1,0.02,0.05);
        
        //工商
        ArrayList<String> l2=new ArrayList<String>();
        l2.add("05");
        l2.add("06");
        Bank ICBC=new Bank("中国工商银行",l2,0.03,0.05);
        
        //农业
        ArrayList<String> l3=new ArrayList<String>();
        l3.add("07");
        l3.add("08");
        l3.add("09");
        l3.add("10");
        l3.add("11");
        Bank ABC=new Bank("中国农业银行",l3,0.04,0.05);
        
/******************************用户初始化**********************************************/

        //杨过
        //账户1的卡号
        ArrayList<Card> y1=new ArrayList<Card>();
        y1.add(new Card("6217000010041315709","88888888"));
        y1.add(new Card("6217000010041315715","88888888"));
        
        //账户2的卡号
        ArrayList<Card> y2=new ArrayList<Card>();
        y2.add(new Card("6217000010041315718","88888888"));
        
        //杨过账户
        ArrayList<Account> a1=new ArrayList<Account>();
        a1.add(new Account("3217000010041315709",y1,1,10000));
        a1.add(new Account("3217000010041315715 ",y2,1,10000));
        
        User yg=new User("杨过",CCB,a1);
        
        
        
        //郭靖
        //账户1卡号
        ArrayList<Card> g=new ArrayList<Card>();
        g.add(new Card("6217000010051320007","88888888"));
        
        //郭靖账户
        ArrayList<Account> a2=new ArrayList<Account>();
        a2.add(new Account(" 3217000010051320007",g,1,10000));
        
        User gj=new User("郭靖",CCB,a2);
        
        //张无忌
        //账户1卡号
        ArrayList<Card> z1=new ArrayList<Card>();
        z1.add(new Card("6222081502001312389","88888888"));
        
        //账户2卡号
        ArrayList<Card> z2=new ArrayList<Card>();
        z2.add(new Card("6222081502001312390","88888888"));
        
        //账户3卡号
        ArrayList<Card> z3=new ArrayList<Card>();
        z3.add(new Card("6222081502001312399","88888888"));
        z3.add(new Card("6222081502001312400","88888888"));
        
        //账户
        ArrayList<Account> a3=new ArrayList<Account>();
        a3.add(new Account("3222081502001312389",z1,1,10000));
        a3.add(new Account("3222081502001312390",z2,1,10000));
        a3.add(new Account("3222081502001312399",z3,1,10000));
        
        User zwj=new User("张无忌",ICBC,a3);
        
        //韦小宝
        //账户1
        ArrayList<Card> w1=new ArrayList<Card>();
        w1.add(new Card("6222081502051320785","88888888"));
        
        //账户2
        ArrayList<Card> w2=new ArrayList<Card>();
        w2.add(new Card("6222081502051320786","88888888"));
        
        //账户
        ArrayList<Account> a4=new ArrayList<Account>();
        a4.add(new Account("3222081502051320785",w1,1,10000));
        a4.add(new Account("3222081502051320786",w2,1,10000));
        
        User wxb=new User("韦小宝",ICBC,a4);
        
        //张三丰
        //账户1
        ArrayList<Card> z=new ArrayList<Card>();
        z.add(new Card("6640000010045442002","88888888"));
        z.add(new Card("6640000010045442003","88888888"));
        
        //账户
        ArrayList<Account> a5=new ArrayList<Account>();
        a5.add(new Account("3640000010045442002",z,2,10000));
        
        User zsf=new User("张三丰",CCB,a5);
        
        //令狐冲
        //账户1
        ArrayList<Card> l=new ArrayList<Card>();
        l.add(new Card("6640000010045441009","88888888"));
        
        //账户
        ArrayList<Account> a6=new ArrayList<Account>();
        a6.add(new Account("3640000010045441009",l,2,10000));
        
        User lhc=new User("令狐冲",ICBC,a6);
        
        //乔峰
        //账户1卡号
        ArrayList<Card> q=new ArrayList<Card>();
        q.add(new Card("6630000010033431001","88888888"));
        
        //账户
        ArrayList<Account> a7=new ArrayList<Account>();
        a7.add(new Account("3630000010033431001",q,2,10000));
        
        User qf=new User("乔峰",ABC,a7);
        
        //洪七公
        //账户1卡号
        ArrayList<Card> h=new ArrayList<Card>();
        h.add(new Card("6630000010033431008","88888888"));
        
        //账户
        ArrayList<Account> a8=new ArrayList<Account>();
        a8.add(new Account("3630000010033431008",h,2,10000));
        
        User hqg=new User("洪七公",ABC,a8);
        
        
        
/******************************检查初始化**********************************************/
    
        ArrayList<User> user=new ArrayList<User>();
        user.add(yg);
        user.add(gj);
        user.add(zwj);
        user.add(wxb);
        user.add(zsf);
        user.add(lhc);
        user.add(qf);
        user.add(hqg);
        Check check=new Check(user);
        
/******************************输入**************************************************/
        String s=input.nextLine();
        
        while(!s.equals("#")) {
            String[] b=s.split("\\s+");
            
            if(b.length==1&&check.cardnumCheck(b[0])) {
                User u=check.getHold();
                for(Account a:u.account) {
                    for(Card c:a.cardList) {
                        if(c.cardnum.equals(b[0]))
                            System.out.println("业务：查询余额 ¥"+String.format("%.2f",a.money));
                    }
                }
                }
            else {
                if(!check.cardnumCheck(b[0]))
                    System.out.println("Sorry,this card does not exist.");
                else if(!check.passwordCheck(b[1]))
                    System.out.println("Sorry,your password is wrong.");
                else if(!check.atmCheck(b[2]))
                    System.out.println("Sorry,the ATM's id is wrong.");
                else if(!check.withdrawalCheck(b[0],b[2],Double.parseDouble(b[3])))
                        System.out.println("Sorry,your account balance is insufficient.");
                else {
                    
                    String bank=null;
                    for(User u:check.user) {
                        for(String a:u.bank.atmList) {
                            if(a.equals(b[2])) 
                                bank=u.bank.name;
                        }
                    }
                    System.out.println("业务：取款 "+check.hold.name+"在"+bank+"的"+b[2]+"号ATM机上取款¥"+String.format("%.2f",Double.parseDouble(b[3])));
                    User u=check.getHold();
                    for(Account a:u.account) {
                        for(Card c:a.cardList) {
                            if(c.cardnum.equals(b[0])) {
                                double m=Double.parseDouble(b[3]);                                    
                                    a.money=a.money-m-check.fee;
                                System.out.println("当前余额为¥"+String.format("%.2f",a.money));
                                }
                    
                    
                    }
                }
            }
        
        }
            s=input.nextLine();
        }
            
            
    }
}

/******************************银行类**********************************************/

class Bank{
    
    String name;
    ArrayList<String> atmList;
    double cross;
    double overdraft;
    
    public Bank(String string, ArrayList<String> l1, double d, double e) {
        // TODO Auto-generated constructor stub
        this.name=string;
        this.atmList=l1;
        this.cross=d;
        this.overdraft=e;;
    }
    
}

/******************************账户类**********************************************/
class Account{
    
    String account;
    ArrayList<Card> cardList;
    double money;
    int type;
    
    public Account(String string, ArrayList<Card> c1, int i,double m) {
        // TODO Auto-generated constructor stub
        this.account=string;
        this.cardList=c1;
        this.type=i;
        this.money=m;
    }

}

/******************************卡类*************************************************/

class Card{
    
    String password;
    String cardnum;
    
    
    public Card(String string, String string2) {
        // TODO Auto-generated constructor stub
        this.cardnum=string;
        this.password=string2;
    }
}

/******************************用户类**********************************************/

class User{
    
    String name;
    Bank bank;
    ArrayList<Account> account;
    
    public User(String s,Bank cCB, ArrayList<Account> a1) {
        // TODO Auto-generated constructor stub
        this.name=s;
        this.account=a1;
        this.bank=cCB;
    }
}

/******************************检查类**********************************************/

class Check{
    
    ArrayList<User> user;
    User hold=new User(null, null, null);//持卡人
    public static double fee=0;
    
    public Check(ArrayList<User> user2) {
        // TODO Auto-generated constructor stub
        this.user=user2;
    }

    //检查卡号是否存在
    public boolean cardnumCheck(String s) {
        for(User u:this.user) {
            for(Account a:u.account) {
                for(Card c:a.cardList) {
                    if(c.cardnum.equals(s)) {
                        this.hold=u;
                        return true;
                    }
                }
            }
        }
        return false;
    }
    
    //返回输入的卡号的用户
    public User getHold() {
        return this.hold;
    }
    
    //检查ATM机是否存在
    public boolean atmCheck(String s) {
        for(User u:this.user) {
            for(String atm:u.bank.atmList) {
                if(atm.equals(s))
                    return true;
            }
        }
        return false;
    }
    
    //检查银行卡密码是否正确
    public boolean passwordCheck(String s) {
        if(s.equals("88888888"))
            return true;
        else 
            return false;
    }
    
    //检查是否跨行取款
    public boolean atmCrossCheck(String s) {
        //与持卡人所在的银行的atm机做比较
        for(String atm:this.hold.bank.atmList) {
            if(atm.equals(s))
                return true;
        }
        return false;
    }
    
    //检查取款金额大于账户余额或者透支金额超过规定最大透支金额
    public boolean withdrawalCheck(String card,String atm,double m) {
        
        fee=0;
        
        //是否跨行取款
        if(this.atmCrossCheck(atm)) {
            fee=0;
        }
        else {
            for(User u:this.user) {
                for(String a:u.bank.atmList) {
                    if(a.equals(atm))
                        fee=m*u.bank.cross;
                }
            }
        }
        
        //是否是贷记卡
        if(this.hold.account.get(0).type==1) {//借记卡
            for(Account a:this.hold.account) {
                for(Card c:a.cardList) {
                    if(c.cardnum.equals(card)) {
                        if(a.money>=(m+fee))
                            return true;
                    }
                }
            }
        }
        else{//贷记卡
            for(Account a:this.hold.account) {
                for(Card c:a.cardList) {
                    if(c.cardnum.equals(card)) {
                        if(a.money>=(m+fee)) {
                            return true;
                        }
                        else if((a.money+50000)>=(m+(m-a.money)*this.hold.bank.overdraft+fee)) {
                            if(a.money>=0)
                                fee=(m-a.money)*0.05+fee;
                            else
                                fee=m*0.05+fee;
                            return true;
                        }
                        else 
                            return false;
                            
                        }
                    }
                }
            }
        
        return false;
    }
    
    //获得atm机所在银行
    public Bank getBank(String atm) {
        for(User u:this.user) {
            for(String a:u.bank.atmList) {
                if(a.equals(atm)) {
                    return u.bank;
                }
                    
            }
        }
        return this.hold.bank;
    }
    
    
}

 

SourceMonitor：

 

 

 

思路 ：

　这次我吸收了上次eclipse卡住的教训，首先就去CSDN学习了一下别人怎么设计的类，自己设计的实在太复杂了，后面我只保留了我上一个题目的父类，再在父类里面添加动态数组，在主函数中进行类的构造，这样也方面后续代码的维护，类也没那么多，简化了自己的代码。

踩坑心得：

　这次踩坑的就是一开始题目没理解清楚，以为是一个账户中的每一个卡都有10000元，完成代码后才发现是一个账户总共这么多，还好自己设计的类便于维护，并不需要修改太多，编码前一定要先了解清楚需求，否则怎么做都是错的。还有一个就是输出的问题找了好久，一个保留两位小数的，又是细节问题，自己是实在是太粗心了，还有各种输出错误找了好久唉，细节！细节！细节！

改进建议：

　　我感觉主函数还是太复杂了，嵌套循环太多了，但是又没有什么好的解决方法，CSDN学习一些别人的方法看看

 

总结

　　通过这几次实验，面向对象的思想已经根植在我心里了但是我对于类的设计还是不够，还需要多学习其他大佬的设计方法。然后对于继承、接口和组合能够得心应手了，这几次作业收获特别大，动态数组真的是我的最爱，真的特别方便好用，希望以后能够多学习更多的java方法，然后在设计方面能更上一层楼。