题目集7~9的总结性Blog

一丶前言

老师布置了PTA第七次到第九次作业，在写这些题目得时候，让我受益匪浅，我发现Java有很多使用技巧和操作的方便，特色十分明显。第七次和第九次题目集一共只有四道题目，但是每一道题都十分有难度，需要我们细细去理解。第九次作业较第八次作业而言，题目的难度增加了一些，从第七次作业中，我学到了很多知识，例如继承、多态的应用，还有复习了之前所学方法，让我收获很多加深了印象。对于这几次大作业而言，题目难度不大，但是很考验基础，题目是让我们掌握ArrayList泛型的应用方法、，单一职责的应用，多态性及其使用方法，每一道题都有其意义，都让我收获匪浅。

二丶设计与分析

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

对于第七次PTA作业，题目集有两道题目，都不是很有难度，属于基础题型，我认为这俩道题目很具有分析价值的，都考察了我们选择语句与思维逻辑能力。

题目：

我们先按照题目要求，写出相对应的父类和子类

class Trapezoid extends Shape{
private double topSide;
private double bottomSide;
private double height;
Trapezoid(){}
Trapezoid(double a,double b,double c){
this.topSide=a;
this.bottomSide=b;
height=c;
}
public double getArea() {
return (topSide+bottomSide)*height/2;
}

@Override
public boolean validate() {
return topSide>0&&height>0&&bottomSide>0;
}
}
class Circle extends Shape {
private double radius;
public Circle() {
}
public Circle(double radius) {
this.radius = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
@Override
public double getArea() {
return Math.PI*radius*radius;
}
@Override
public boolean validate() {
return this.radius>0;
}
}
class Rectangle extends Shape {
private double width, height;
public Rectangle() {
}
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
@Override
public double getArea() {
return height * width;
}
@Override
public boolean validate() {
return width > 0 && height > 0;
}
}
class Triangle extends Shape{
private double side1;
private double side2;
private double side3;
Triangle(){

}
Triangle(double a,double b,double c){
this.side1=a;
this.side2=b;
this.side3=c;
}
public double getArea(){
double p=(side1+side2+side3)/2;
return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
}
public boolean validate(){
if(side1>0&&side2>0&&side3>0){
if(side1+side2>side3&&side1+side3>side2&&side2+side3>side1){
return true;
}
return false;
}
return false;
}
}
abstract class Shape {
private String shapeName;
public Shape() {
}

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

public String getShapeName() {
return shapeName;
}

public void setShapeName(String shapeName) {
this.shapeName = shapeName;
}
public abstract double getArea();
public abstract boolean validate();
public String toString() {
return getShapeName()+":"+String.format("%.2f ",getArea());
}
}

紧接着，使用 Comparable 接口，即 Card 类需要实现 Comparable 接口中的 CompareTo()方法。

class Card implements Comparable<Card> {
    private Shape shape;
    Card(){}
    Card(Shape shape){
        this.shape=shape;
    }

    public Shape getShape() {
        return shape;
    }
    public void setShape(Shape shape) {
        this.shape = shape;
    }
    public int compareTo(Card card){
        return -(int)(shape.getArea()-card.getShape().getArea());
    }
}

然后我们在进行选择图形等操作。

class DealCardList {
    ArrayList<Card> cardlist= new ArrayList<Card>();
    DealCardList(){}
    DealCardList(ArrayList<Integer> card){
        Scanner in=new Scanner(System.in);
        for(int i = 0 ;i<card.size();i++){
            if(card.get(i)==0){
                break;
            }
            int n=card.get(i);
            switch (n){
                case 1:
                    Card a1=new Card();

                    a1.setShape(new Circle(Main.input.nextDouble()));
                    a1.getShape().setShapeName("Circle");
                    cardlist.add(a1);
                    break;
                case 2:
                    Card a2=new Card();

                    a2.setShape(new Rectangle(Main.input.nextDouble(),Main.input.nextDouble()));
                    a2.getShape().setShapeName("Rectangle");
                    cardlist.add(a2);
                    break;

                case 3:
                    Card a3=new Card();

                    a3.setShape(new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
                    a3.getShape().setShapeName("Triangle");
                    cardlist.add(a3);
                    break;
                case 4:
                    Card a4=new Card();

                    a4.setShape(new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
                    a4.getShape().setShapeName("Trapezoid");
                    cardlist.add(a4);
                    break;
            }
        }
    }
    public boolean validate(){
        for(int i=0;i<cardlist.size();i++){
            if(!cardlist.get(i).getShape().validate()){
                return false;
            }
        }
        return true;
    }
    public double getAllArea(){
        double sum=0;
        for (int i=0;i<cardlist.size();i++) {
            sum+=cardlist.get(i).getShape().getArea();
        }
        return sum;
    }

    public void showResult(){
        System.out.println("The original list:");
        for (int i=0;i<cardlist.size();i++) {
            System.out.print(cardlist.get(i).getShape());
        }
        System.out.println();
        System.out.println("The sorted list:");
        Collections.sort(cardlist);
        for (int i=0;i<cardlist.size();i++) {
            System.out.print(cardlist.get(i).getShape());
        }
        System.out.println();
        System.out.printf("Sum of area:%.2f\n",getAllArea());
    }
}

紧接着，我们来看（7-2）作业的题目，首先，看到这个题目我就意识到这两个题应该是属于同一种写法，所以我们只需要对（7-1）进行修改，那么下一道题就会少很多问题。

在这个题目中，主要是需要满足题目要求，使用指点方法来进行写码，并且将题目要求的方法功能实现.

这道题目与（7-1）最大不同就是需要我们将每个图形进行分组，在算出它们的面积，进行排序

并将每个分组的最大面积求出来，然后拿出来再次进行排序。

class DealCardList {
    ArrayList<Card> cardlist= new ArrayList<Card>();
    ArrayList<Card> circle1= new ArrayList<Card>();
    ArrayList<Card> rectangle1= new ArrayList<Card>();
    ArrayList<Card> triangle1= new ArrayList<Card>();
    ArrayList<Card> trapeaoid1= new ArrayList<Card>();
    ArrayList su=new ArrayList();
    DealCardList(ArrayList<Integer> card){
        Scanner in=new Scanner(System.in);
        for(int i = 0 ;i<card.size();i++){
            if(card.get(i)==0){
                break;
            }
            int n=card.get(i);
            switch (n){
                case 1:
                    Card a1=new Card();

                    a1.setShape(new Circle(Main.input.nextDouble()));
                    a1.getShape().setShapeName("Circle");
                    cardlist.add(a1);
                    circle1.add(a1);
                    break;
                case 2:
                    Card a2=new Card();

                    a2.setShape(new Rectangle(Main.input.nextDouble(),Main.input.nextDouble()));
                    a2.getShape().setShapeName("Rectangle");
                    cardlist.add(a2);
                    rectangle1.add(a2);
                    break;

                case 3:
                    Card a3=new Card();

                    a3.setShape(new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
                    a3.getShape().setShapeName("Triangle");
                    cardlist.add(a3);
                    triangle1.add(a3);
                    break;
                case 4:
                    Card a4=new Card();

                    a4.setShape(new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
                    a4.getShape().setShapeName("Trapezoid");
                    cardlist.add(a4);
                    trapeaoid1.add(a4);
                    break;
            }
        }
    }
    public boolean validate(){
        for(int i=0;i<cardlist.size();i++){
            if(!cardlist.get(i).getShape().validate()){
                return false;
            }
        }
        return true;
    }
    public void showResult(){
        System.out.println("The original list:");
        for (int i=0;i<cardlist.size();i++) {
            if(i==0){
                System.out.print("[");
            }
            System.out.print(cardlist.get(i).getShape());
            if(i==cardlist.size()-1){
                System.out.print("]");
            }
        }
        System.out.println();
        System.out.println("The Separated List:");
        double sum=0;
        double sum1=0;
        double sum2=0;
        double sum3=0;
        for(int j=0;j<circle1.size();j++){
            if(j==0){
                System.out.print("[");
            }
            System.out.print(circle1.get(j).getShape());
            sum+=circle1.get(j).getShape().getArea();
            su.add(sum);
            if(j==circle1.size()-1){
                System.out.print("]");
            }
        }
        if(circle1.size()==0){
            System.out.print("[]");
        }
        for(int j=0;j<rectangle1.size();j++){
            if(j==0){
                System.out.print("[");
            }
            System.out.print(rectangle1.get(j).getShape());
            sum1+=rectangle1.get(j).getShape().getArea();
            su.add(sum1);
            if(j==rectangle1.size()-1){
                System.out.print("]");
            }
        }
        if(rectangle1.size()==0){
            System.out.print("[]");
        }
        for(int j=0;j<triangle1.size();j++){
            if(j==0){
                System.out.print("[");
            }
            System.out.print(triangle1.get(j).getShape());
            sum2+=triangle1.get(j).getShape().getArea();
            su.add(sum2);
            if(j==triangle1.size()-1){
                System.out.print("]");
            }
        }
        if(triangle1.size()==0){
            System.out.print("[]");
        }
        for(int j=0;j<trapeaoid1.size();j++){
            if(j==0){
                System.out.print("[");
            }
            System.out.print(trapeaoid1.get(j).getShape());

            sum3+=trapeaoid1.get(j).getShape().getArea();
            su.add(sum3);
            if(j==trapeaoid1.size()-1){
                System.out.print("]");
            }
        }
        if(trapeaoid1.size()==0){
            System.out.print("[]");
        }
        System.out.println();
        System.out.println("The Separated sorted List:");
        Collections.sort(su);
        Collections.sort(cardlist);
        Collections.sort(circle1);
        Collections.sort(rectangle1);
        Collections.sort(triangle1);
        Collections.sort(trapeaoid1);

        for(int j=0;j<circle1.size();j++){
            if(j==0){
                System.out.print("[");
            }
            System.out.print(circle1.get(j).getShape());
            if(j==circle1.size()-1){
                System.out.print("]");
            }
        }
        if(circle1.size()==0){
            System.out.print("[]");
        }
        for(int j=0;j<rectangle1.size();j++){
            if(j==0){
                System.out.print("[");
            }
            System.out.print(rectangle1.get(j).getShape());
            if(j==rectangle1.size()-1){
                System.out.print("]");
            }
        }
        if(rectangle1.size()==0){
            System.out.print("[]");
        }
        for(int j=0;j<triangle1.size();j++){
            if(j==0){
                System.out.print("[");
            }
            System.out.print(triangle1.get(j).getShape());
            if(j==triangle1.size()-1){
                System.out.print("]");
            }
        }
        if(triangle1.size()==0){
            System.out.print("[]");
        }
        for(int j=0;j<trapeaoid1.size();j++){
            if(j==0){
                System.out.print("[");
            }
            System.out.print(trapeaoid1.get(j).getShape());
            if(j==trapeaoid1.size()-1){
                System.out.print("]");
            }
        }
        if(trapeaoid1.size()==0){
            System.out.print("[]");
        }
        System.out.println();
        System.out.printf("The max area:%.2f\n",su.get(su.size()-1));
    }
}

父类和子类：

class Card implements Comparable<Card> {
    private Shape shape;
    Card(){}
    Card(Shape shape){
        this.shape=shape;
    }

    public Shape getShape() {
        return shape;
    }
    public void setShape(Shape shape) {
        this.shape = shape;
    }
    public int compareTo(Card card){
        return -(int)(shape.getArea()-card.getShape().getArea());
    }
}
class Trapezoid extends Shape{
    private double topSide;
    private double bottomSide;
    private double height;
    Trapezoid(){}
    Trapezoid(double a,double b,double c){
        this.topSide=a;
        this.bottomSide=b;
        height=c;
    }
    public double getArea() {
        return (topSide+bottomSide)*height/2;
    }

    @Override
    public boolean validate() {
        return topSide>0&&height>0&&bottomSide>0;
    }
}
class Circle extends Shape {
    private double radius;
    public Circle() {
    }
    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI*radius*radius;
    }
    @Override
    public boolean validate() {
        return this.radius>0;
    }
}
 class Rectangle extends Shape {
    private double width, height;
    public Rectangle() {
    }
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }


    @Override
    public double getArea() {
        return height * width;
    }
    @Override
    public boolean validate() {
        return width > 0 && height > 0;
    }
}
class Triangle extends Shape{
    private double side1;
    private double side2;
    private  double side3;
    Triangle(){

    }
    Triangle(double a,double b,double c){
        this.side1=a;
        this.side2=b;
        this.side3=c;
    }
    public double getArea(){
        double p=(side1+side2+side3)/2;
        return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
    }
    public boolean validate(){
        if(side1>0&&side2>0&&side3>0){
            if(side1+side2>side3&&side1+side3>side2&&side2+side3>side1){
                return true;
            }
            return false;
        }
        return false;
    }
}
abstract class Shape {
    private String shapeName;
    public Shape() {
    }

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

    public String getShapeName() {
        return shapeName;
    }

    public void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }
    public abstract double getArea();
    public abstract boolean validate();
    public String toString() {
        return getShapeName()+":"+String.format("%.2f ",getArea());
    }
}

ok，对比两道题目，我了解了类结构如何完善才能使得系统具有较好的可复用性。通过此例，进一步深入理解面向对象设计原则中的“单一职责”原则和“开-闭”原则。

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

第八次大作业是关于模拟银行ATM机的编程题目

首先我们来看看题目

看到这个题目，丝毫不用慌张，我们就按照我们对题目的理解，开始设计

首先是关于银行ATM机的几个类我们需要清楚明晰，有哪些类，如何设计等

按照题目的要求，我们要求设计银联类，银行类，银行用户类，银行卡类，ATM机类等，尝试使用面向对象技术对银行用户在 ATM 机上进行相关操作的模拟系统设计，上述的相关概念均要设计为实体类，业务（控制）类请自行根据实际需要进行扩充和完善。

ok，开始写代码：

class Bank {
    private String bankNO;
    private String bankName;
    private ArrayList<Account> accountList = new ArrayList<Account>();
    private ArrayList<ATM> ATMList = new ArrayList<ATM>();

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

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

    public String getBankNO() {
        return bankNO;
    }

    public void setBankNO(String bankNO) {
        this.bankNO = bankNO;
    }

    public String getBankName() {
        return bankName;
    }

    public void setBankName(String bankName) {
        this.bankName = bankName;
    }

    public void addAccount(Account account) {
        this.accountList.add(account);
    }

    public void removeAccount(Account account) {
        this.accountList.remove(account);
    }
    
    public void addATM(ATM aTM) {
        this.ATMList.add(aTM);
    }
    
    public void removeATM(ATM aTM) {
        this.ATMList.remove(aTM);
    }

    public ArrayList<Account> getAccountList() {
        return accountList;
    }

    public void setAccountList(ArrayList<Account> accountList) {
        this.accountList = accountList;
    }

    public ArrayList<ATM> getATMList() {
        return ATMList;
    }

    public void setATMList(ArrayList<ATM> aTMList) {
        ATMList = aTMList;
    }
}

class User {
    private String ID;
    private String name;
    private String Phone;
    ArrayList<Account> list = new ArrayList<Account>();

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

    public User(String iD, String name, String phone) {
        super();
        ID = iD;
        this.name = name;
        Phone = phone;
    }

    public String getID() {
        return ID;
    }

    public void setID(String iD) {
        ID = iD;
    }

    public String getPhone() {
        return Phone;
    }

    public void setPhone(String phone) {
        Phone = phone;
    }    

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void addAccount(Account account) {
        this.list.add(account);
    }

    public void removeAccount(Account account) {
        this.list.remove(account);
    }
}

class Account {
    private String accountNO;
    private double balance = 0;
    private User user = null;
    private Bank bank = null;
    private static ArrayList<Card> list = new ArrayList<Card>();

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

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

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

    public void removeCard(Card card) {
        list.remove(card);
    }

    public double getBalance() {
        return balance;
    }

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

    public String getAccountNO() {
        return accountNO;
    }

    public void setAccountNO(String accountNO) {
        this.accountNO = accountNO;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Bank getBank() {
        return bank;
    }

    public void setBank(Bank bank) {
        this.bank = bank;
    }

    public ArrayList<Card> getList() {
        return list;
    }

    public void setList(ArrayList<Card> list) {
        Account.list = list;
    }
    
    public static Account getAmountbyCardNO(String cardNO) {
        Iterator<Card> cardItr = Account.list.iterator();
        Card card = null;
        
        while(cardItr.hasNext()) {
            card = cardItr.next();
            if(card.getCardNO().equals(cardNO)) {
                return card.getAccount();
            }
        }
        
        return null;
    }
}

class Card {
    private String cardNO;
    private String cardPassword;
    private Account account = null;

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

    public Card(String cardNO, String cardPassword, Account account) {
        super();
        this.cardNO = cardNO;
        this.cardPassword = cardPassword;
        this.account = account;
    }

    public String getCardNO() {
        return cardNO;
    }

    public void setCardNO(String cardNO) {
        this.cardNO = cardNO;
    }

    public String getCardPassword() {
        return cardPassword;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    public void setCardPassword(String cardPassword) {
        this.cardPassword = cardPassword;
    }

    public boolean checkCard() {
        Pattern p = Pattern.compile("\\d{16}+");
        Matcher m = p.matcher(this.cardNO);
        return m.matches();
    }

    public boolean checkPassword(String password) {
        return this.cardPassword.equals(password);
    }    
}

class ATM {
    private String ATMID;
    private Bank bank = null;

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

    public ATM(String aTMID, Bank bank) {
        super();
        ATMID = aTMID;
        this.bank = bank;
    }

    public String getATMID() {
        return ATMID;
    }

    public void setATMID(String aTMID) {
        ATMID = aTMID;
    }

    public Bank getBank() {
        return bank;
    }

    public void setBank(Bank bank) {
        this.bank = bank;
    }
}

将每个类的属性和方法完善后，我们在进行数据处理

class Withdraw {
    private UnionPay unionPay;
    private String cardNO;
    private String cardPassword;
    private String ATMID;
    private double amount;

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

    public Withdraw(UnionPay unionPay, String cardNO, String cardPassword, String aTMID, double amount) {
        super();
        this.unionPay = unionPay;
        this.cardNO = cardNO;
        this.cardPassword = cardPassword;
        ATMID = aTMID;
        this.amount = amount;
    }
    
    public Withdraw(String cardNO, String cardPassword, String aTMID, double amount) {
        super();
        this.cardNO = cardNO;
        this.cardPassword = cardPassword;
        ATMID = aTMID;
        this.amount = amount;
    }


    public void withdraw() {
        /**
         * 校验该卡是否存在
         */        
        Card card = ValidateData.getCardbyCardNO(unionPay, cardNO);
        if(card == null) {
            System.out.println("Sorry,this card does not exist.");
            System.exit(0);
        }
        
        /**
         * 校验ATM是否存在
         */
        ATM aTM = ValidateData.getATMbyATMID(unionPay, ATMID);
        if(aTM == null) {
            System.out.println("Sorry,the ATM's id is wrong.");
            System.exit(0);
        }
        
        Account account = Account.getAmountbyCardNO(cardNO);
        double balance = account.getBalance();
        
        /**
         * 校验卡密码是否正确
         */
        if(!card.getCardPassword().equals(cardPassword)) {
            System.out.println("Sorry,your password is wrong.");
            System.exit(0);
        }
        
        /**
         * 校验取款金额是否大于余额
         */
        if (amount > balance) {
            System.out.println("Sorry,your account balance is insufficient.");
            System.exit(0);
        }
        
        /**
         * 校验是否为跨行取款
         */
        if (account.getBank().getBankNO() != aTM.getBank().getBankNO()) {
            System.out.println("Sorry,cross-bank withdrawal is not supported.");
            System.exit(0);
        }    

        account.setBalance(balance - amount);//取款更新余额操作

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

class ValidateData {
    /**
     * 校验卡号是否存在
     * @param unionPay
     * @param cardNO
     * @return
     */
    public static Card getCardbyCardNO(UnionPay unionPay,String cardNO) {
        Card card = null;
        Iterator<Bank> bankItr = unionPay.getBankList().iterator();
        
        while(bankItr.hasNext()) {
            ArrayList<Account> accountList = bankItr.next().getAccountList();
            Iterator<Account> accountItr = accountList.iterator();
            while(accountItr.hasNext()) {
                ArrayList<Card> cardList = accountItr.next().getList();
                Iterator<Card> cardItr = cardList.iterator();
                while(cardItr.hasNext()) {
                    card = cardItr.next();
                    if(card.getCardNO().equals(cardNO)) {
                        return card;
                    }
                }
            }
        }
        return null;
    }
    
    /**
     * 校验ATM ID是否存在
     * @param unionPay
     * @param ATMID
     * @return
     */
    public static ATM getATMbyATMID(UnionPay unionPay,String ATMID) {
        Iterator<Bank> bankItr = unionPay.getBankList().iterator();
        Bank bank = null;
        ATM aTM = null;
        
        while(bankItr.hasNext()) {
            bank = bankItr.next();
            Iterator<ATM> aTMItr = bank.getATMList().iterator();    
            
            while(aTMItr.hasNext()) {
                aTM = aTMItr.next();
                if(aTM.getATMID().equals(ATMID)) {
                    return aTM;
                }
            }            
        }        
        return null;    
    }
}

class UnionPay {
    private ArrayList<Bank> bankList = new ArrayList<Bank>();

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

    public UnionPay(ArrayList<Bank> bankList) {
        super();
        this.bankList = bankList;
    }

    public ArrayList<Bank> getBankList() {
        return bankList;
    }

    public void setBankList(ArrayList<Bank> bankList) {
        this.bankList = bankList;
    }
    
    public void addBank(Bank bank) {
        this.bankList.add(bank);
    }
    
    public void removeBank(Bank bank) {
        this.bankList.remove(bank);
    }    
}

class GetBalance {
    private UnionPay unionPay;
    
    public GetBalance() {
        super();
        // TODO Auto-generated constructor stub
    }

    public GetBalance(UnionPay unionPay) {
        super();
        this.unionPay = unionPay;
    }

    public double getBalance(String cardNO) {
        return ValidateData.getCardbyCardNO(unionPay, cardNO).getAccount().getBalance();
    }
}

ok，最后我们可以存入题目所提供的用户信息

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        
        UnionPay unionPay = new UnionPay();       
        
        Bank ccb = new Bank("1001","中国建设银行");
        Bank icbc = new Bank("1002","中国工商银行");
        unionPay.addBank(ccb);
        unionPay.addBank(icbc);
        
        ATM aTM1 = new ATM("01",ccb);
        ATM aTM2 = new ATM("02",ccb);
        ATM aTM3 = new ATM("03",ccb);
        ATM aTM4 = new ATM("04",ccb);
        ATM aTM5 = new ATM("05",icbc);
        ATM aTM6 = new ATM("06",icbc);
        
        ccb.addATM(aTM1);
        ccb.addATM(aTM2);
        ccb.addATM(aTM3);
        ccb.addATM(aTM4);
        icbc.addATM(aTM5);
        icbc.addATM(aTM6);
        
        User Yangguo = new User("360101200102122324","杨过","13856223254");
        User Guojing = new User("360101200012302552","郭靖","13800021124");
        User Zhangwuji = new User("360502199805163221","张无忌","13952110011");
        User Weixiaobao = new User("360201200513243326","韦小宝","13025996587");
        
        Account ccbAcc1 = new Account("3217000010041315709",10000.00,Yangguo,ccb);
        Account ccbAcc2 = new Account("3217000010041315715",10000.00,Yangguo,ccb);
        Account ccbAcc3 = new Account("3217000010051320007",10000.00,Guojing,ccb);
        Account icbcAcc1 = new Account("3222081502001312389",10000.00,Zhangwuji,icbc);
        Account icbcAcc2 = new Account("3222081502001312390",10000.00,Zhangwuji,icbc);
        Account icbcAcc3 = new Account("3222081502001312399",10000.00,Zhangwuji,icbc);
        Account icbcAcc4 = new Account("3222081502051320785",10000.00,Weixiaobao,icbc);
        Account icbcAcc5 = new Account("3222081502051320786",10000.00,Weixiaobao,icbc);
        
        ccb.addAccount(ccbAcc1);
        ccb.addAccount(ccbAcc2);
        ccb.addAccount(ccbAcc3);
        icbc.addAccount(icbcAcc1);
        icbc.addAccount(icbcAcc2);
        icbc.addAccount(icbcAcc3);
        icbc.addAccount(icbcAcc4);
        icbc.addAccount(icbcAcc5);
    
        
        Yangguo.addAccount(ccbAcc1);
        Yangguo.addAccount(ccbAcc2);
        Guojing.addAccount(ccbAcc3);
        Zhangwuji.addAccount(icbcAcc1);
        Zhangwuji.addAccount(icbcAcc2);
        Zhangwuji.addAccount(icbcAcc3);
        Weixiaobao.addAccount(icbcAcc4);
        Weixiaobao.addAccount(icbcAcc5);
        
        Card ccbCard1 = new Card("6217000010041315709","88888888",ccbAcc1);
        Card ccbCard2 = new Card("6217000010041315715","88888888",ccbAcc1);
        Card ccbCard3 = new Card("6217000010041315718","88888888",ccbAcc2);
        Card ccbCard4 = new Card("6217000010051320007","88888888",ccbAcc3);
        Card icbcCard5 = new Card("6222081502001312389","88888888",icbcAcc1);
        Card icbcCard6 = new Card("6222081502001312390","88888888",icbcAcc2);
        Card icbcCard7 = new Card("6222081502001312399","88888888",icbcAcc3);
        Card icbcCard8 = new Card("6222081502001312400","88888888",icbcAcc3);
        Card icbcCard9 = new Card("6222081502051320785","88888888",icbcAcc4);
        Card icbcCard10 = new Card("6222081502051320786","88888888",icbcAcc5);
        
        ccbAcc1.addCard(ccbCard1);
        ccbAcc1.addCard(ccbCard2);
        ccbAcc2.addCard(ccbCard3);
        ccbAcc3.addCard(ccbCard4);
        icbcAcc1.addCard(icbcCard5);
        icbcAcc2.addCard(icbcCard6);
        icbcAcc3.addCard(icbcCard7);
        icbcAcc3.addCard(icbcCard8);
        icbcAcc4.addCard(icbcCard9);
        icbcAcc5.addCard(icbcCard10);
        
        StringBuilder sb = new StringBuilder();
        
        String data;
        
        while(!((data = input.nextLine()).equals("#"))) {
            sb.append(data + "\n");
        }        
        
        String[] dt = sb.toString().split("\n");
        for(int i = 0; i < dt.length; i++) {
            String[] dataLine = dt[i].toString().split("\\s+");
            
            if(dataLine.length == 1) {
                GetBalance gb = new GetBalance(unionPay);
                System.out.println(String.format("¥%.2f", gb.getBalance(dataLine[0])));
            }else {
                Withdraw wd = new Withdraw(unionPay,dataLine[0],dataLine[1],dataLine[2],Double.parseDouble(dataLine[3]));
                wd.withdraw();
            }
        }       
    }
}

ok，这样就基本完成了题目要求。当然我们要注意一点就是输入时，我们使用的之前所学的正则表达式呢部分。拆分和匹配的过程也在代码中。

紧接着，我们来看题目集九也就是最后一道题目，这道题目与第八次题目类型是一样的，都是对模拟ATM机的操作。

我们来看看题目

对于第九次作业，我认为就是对第八次ATM机进行部分调整得到的，首先，我们了解到这次的作业是将银行账户分为借记账户和贷记账户两种，其中，借记账户不能够透支取款，而贷记账户可以透支取款（可能需要支付手续费）。一个银行用户可以拥有多个银行账户。根据账户的不同，银行卡一般分为借记卡（针对借记账户）和信用卡（针对贷记账户）两类

尝试使用面向对象技术对银行用户在 ATM 机上进行相关操作的模拟系统设计，上述的相关概念均要设计为实体类，业务（控制）类请自行根据实际需要进行扩充和完善。

题目储存人物信息的类与作业八类似：

class InitData {

    public InitData() {
        // TODO Auto-generated constructor stub
    }

    public static UnionPay initData() {
        UnionPay unionPay = new UnionPay();

        Bank ccb = new Bank("1001", "中国建设银行", 0.02);
        Bank icbc = new Bank("1002", "中国工商银行", 0.03);
        Bank abc = new Bank("1003", "中国农业银行", 0.04);// new
        unionPay.addBank(ccb);
        unionPay.addBank(icbc);
        unionPay.addBank(abc);// new

        ATM aTM1 = new ATM("01", ccb);
        ATM aTM2 = new ATM("02", ccb);
        ATM aTM3 = new ATM("03", ccb);
        ATM aTM4 = new ATM("04", ccb);
        ATM aTM5 = new ATM("05", icbc);
        ATM aTM6 = new ATM("06", icbc);
        ATM aTM7 = new ATM("07", abc);// new
        ATM aTM8 = new ATM("08", abc);// new
        ATM aTM9 = new ATM("09", abc);// new
        ATM aTM10 = new ATM("10", abc);// new
        ATM aTM11 = new ATM("11", abc);// new

        ccb.addATM(aTM1);
        ccb.addATM(aTM2);
        ccb.addATM(aTM3);
        ccb.addATM(aTM4);
        icbc.addATM(aTM5);
        icbc.addATM(aTM6);
        abc.addATM(aTM7);// new
        abc.addATM(aTM8);// new
        abc.addATM(aTM9);// new
        abc.addATM(aTM10);// new
        abc.addATM(aTM11);// new

        User Yangguo = new User("360101200102122324", "杨过", "13856223254");
        User Guojing = new User("360101200012302552", "郭靖", "13800021124");
        User Zhangwuji = new User("360502199805163221", "张无忌", "13952110011");
        User Weixiaobao = new User("360201200513243326", "韦小宝", "13025996587");
        User Zhangsanfeng = new User("360102199713459810", "张三丰", "13677871290");// new
        User Linghuchong = new User("360503190299878473", "令狐冲", "13609899238");// new
        User Qiaofeng = new User("360607194313666711", "乔峰", "13677871290");// new
        User Hongqigong = new User("363220987809872234", "洪七公", "13609009454");// new

        AbstractAccount ccbAcc1 = new DebitAccount("3217000010041315709", 10000.00, Yangguo, ccb, 0, 0);
        AbstractAccount ccbAcc2 = new DebitAccount("3217000010041315715", 10000.00, Yangguo, ccb, 0, 0);
        AbstractAccount ccbAcc3 = new DebitAccount("3217000010051320007", 10000.00, Guojing, ccb, 0, 0);
        AbstractAccount ccbAcc4 = new CreditAccount("3640000010045442002", 10000.00, Zhangsanfeng, ccb, 0.05, 50000.00);// new

        AbstractAccount icbcAcc1 = new DebitAccount("3222081502001312389", 10000.00, Zhangwuji, icbc, 0, 0);
        AbstractAccount icbcAcc2 = new DebitAccount("3222081502001312390", 10000.00, Zhangwuji, icbc, 0, 0);
        AbstractAccount icbcAcc3 = new DebitAccount("3222081502001312399", 10000.00, Zhangwuji, icbc, 0, 0);
        AbstractAccount icbcAcc4 = new DebitAccount("3222081502051320785", 10000.00, Weixiaobao, icbc, 0, 0);
        AbstractAccount icbcAcc5 = new DebitAccount("3222081502051320786", 10000.00, Weixiaobao, icbc, 0, 0);
        AbstractAccount icbcAcc6 =
            new CreditAccount("3640000010045441009", 10000.00, Linghuchong, icbc, 0.05, 50000.00);// new

        AbstractAccount abcAcc1 = new CreditAccount("3630000010033431001", 10000.00, Qiaofeng, abc, 0.05, 50000.00);// new
        AbstractAccount abcAcc2 = new CreditAccount("3630000010033431008", 10000.00, Hongqigong, abc, 0.05, 50000.00);// new

        ccb.addAccount(ccbAcc1);
        ccb.addAccount(ccbAcc2);
        ccb.addAccount(ccbAcc3);
        ccb.addAccount(ccbAcc4);// new

        icbc.addAccount(icbcAcc1);
        icbc.addAccount(icbcAcc2);
        icbc.addAccount(icbcAcc3);
        icbc.addAccount(icbcAcc4);
        icbc.addAccount(icbcAcc5);
        icbc.addAccount(icbcAcc6);// new

        abc.addAccount(abcAcc1);// new
        abc.addAccount(abcAcc2);// new

        Yangguo.addAccount(ccbAcc1);
        Yangguo.addAccount(ccbAcc2);
        Guojing.addAccount(ccbAcc3);
        Zhangsanfeng.addAccount(ccbAcc4);// new

        Zhangwuji.addAccount(icbcAcc1);
        Zhangwuji.addAccount(icbcAcc2);
        Zhangwuji.addAccount(icbcAcc3);
        Weixiaobao.addAccount(icbcAcc4);
        Weixiaobao.addAccount(icbcAcc5);
        Linghuchong.addAccount(icbcAcc6);// new

        Qiaofeng.addAccount(abcAcc1);// new
        Hongqigong.addAccount(abcAcc2);// new

        Card ccbCard1 = new Card("6217000010041315709", "88888888", ccbAcc1);
        Card ccbCard2 = new Card("6217000010041315715", "88888888", ccbAcc1);
        Card ccbCard3 = new Card("6217000010041315718", "88888888", ccbAcc2);
        Card ccbCard4 = new Card("6217000010051320007", "88888888", ccbAcc3);

        Card icbcCard5 = new Card("6222081502001312389", "88888888", icbcAcc1);
        Card icbcCard6 = new Card("6222081502001312390", "88888888", icbcAcc2);
        Card icbcCard7 = new Card("6222081502001312399", "88888888", icbcAcc3);
        Card icbcCard8 = new Card("6222081502001312400", "88888888", icbcAcc3);
        Card icbcCard9 = new Card("6222081502051320785", "88888888", icbcAcc4);
        Card icbcCard10 = new Card("6222081502051320786", "88888888", icbcAcc5);

        Card ccbCard11 = new Card("6640000010045442002", "88888888", ccbAcc4);// new
        Card ccbCard12 = new Card("6640000010045442003", "88888888", ccbAcc4);// new

        Card icbcCard13 = new Card("6640000010045441009", "88888888", icbcAcc6);// new

        Card abcCard14 = new Card("6630000010033431001", "88888888", abcAcc1);// new
        Card abcCard15 = new Card("6630000010033431008", "88888888", abcAcc2);// new

        ccbAcc1.addCard(ccbCard1);
        ccbAcc1.addCard(ccbCard2);
        ccbAcc2.addCard(ccbCard3);
        ccbAcc3.addCard(ccbCard4);
        ccbAcc4.addCard(ccbCard11);// new
        ccbAcc4.addCard(ccbCard12);// new

        icbcAcc1.addCard(icbcCard5);
        icbcAcc2.addCard(icbcCard6);
        icbcAcc3.addCard(icbcCard7);
        icbcAcc3.addCard(icbcCard8);
        icbcAcc4.addCard(icbcCard9);
        icbcAcc5.addCard(icbcCard10);
        icbcAcc6.addCard(icbcCard13);// new

        abcAcc1.addCard(abcCard14);// new
        abcAcc2.addCard(abcCard15);// new

        return unionPay;
    }
}

然后我们在设计其他类，

class UnionPay {
    private ArrayList<Bank> bankList = new ArrayList<Bank>();// 银联包含的银行列表

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

    public UnionPay(ArrayList<Bank> bankList) {
        super();
        this.bankList = bankList;
    }

    public ArrayList<Bank> getBankList() {
        return bankList;
    }

    public void setBankList(ArrayList<Bank> bankList) {
        this.bankList = bankList;
    }

    public void addBank(Bank bank) {
        this.bankList.add(bank);
    }

    public void removeBank(Bank bank) {
        this.bankList.remove(bank);
    }
}

/**
 * 用户类
 * 
 * @author Administrator
 * @date
 */
class User {
    private String ID;// 身份证号
    private String name;// 姓名
    private String Phone;// 电话号码
    ArrayList<AbstractAccount> list = new ArrayList<AbstractAccount>();// 该用户拥有的账户列表（注意，账户可能隶属于不同银行

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

    public User(String iD, String name, String phone) {
        super();
        ID = iD;
        this.name = name;
        Phone = phone;
    }

    public String getID() {
        return ID;
    }

    public void setID(String iD) {
        ID = iD;
    }

    public String getPhone() {
        return Phone;
    }

    public void setPhone(String phone) {
        Phone = phone;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void addAccount(AbstractAccount ccbAcc1) {
        this.list.add(ccbAcc1);
    }

    public void removeAccount(DebitAccount account) {
        this.list.remove(account);
    }
}

class Bank {
    private String bankNO;// 银行编号
    private String bankName;// 银行名称
    private double commission;// 跨行业务收取的手续费
    // 银行拥有的账户列表
    private ArrayList<AbstractAccount> accountList = new ArrayList<AbstractAccount>();
    // 银行拥有的ATM机列表
    private ArrayList<ATM> ATMList = new ArrayList<ATM>();

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

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

    public String getBankNO() {
        return bankNO;
    }

    public void setBankNO(String bankNO) {
        this.bankNO = bankNO;
    }

    public String getBankName() {
        return bankName;
    }

    public void setBankName(String bankName) {
        this.bankName = bankName;
    }

    public double getCommission() {
        return commission;
    }

    public void setCommission(double commission) {
        this.commission = commission;
    }

    public void addAccount(AbstractAccount account) {
        this.accountList.add(account);
    }

    public void removeAccount(AbstractAccount account) {
        this.accountList.remove(account);
    }

    public void addATM(ATM aTM) {
        this.ATMList.add(aTM);
    }

    public void removeATM(ATM aTM) {
        this.ATMList.remove(aTM);
    }

    public ArrayList<AbstractAccount> getAccountList() {
        return accountList;
    }

    public void setAccountList(ArrayList<AbstractAccount> accountList) {
        this.accountList = accountList;
    }

    public ArrayList<ATM> getATMList() {
        return ATMList;
    }

    public void setATMList(ArrayList<ATM> aTMList) {
        ATMList = aTMList;
    }
}

/**
 * 银行卡类，大家思考下该类与账户类的关系，例如用户的余额为什么不是设置在Card类中
 * 
 * @author Administrator
 * @date
 */
class Card {
    private String cardNO;// 卡号
    private String cardPassword;// 密码
    private AbstractAccount account = null;// 该卡所属账号

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

    public Card(String cardNO, String cardPassword, AbstractAccount account) {
        super();
        this.cardNO = cardNO;
        this.cardPassword = cardPassword;
        this.account = account;
    }

    public String getCardNO() {
        return cardNO;
    }

    public void setCardNO(String cardNO) {
        this.cardNO = cardNO;
    }

    public String getCardPassword() {
        return cardPassword;
    }

    public AbstractAccount getAccount() {
        return account;
    }

    public void setAccount(AbstractAccount account) {
        this.account = account;
    }

    public void setCardPassword(String cardPassword) {
        this.cardPassword = cardPassword;
    }

    public boolean checkCard() {
        Pattern p = Pattern.compile("\\d{16}+");
        Matcher m = p.matcher(this.cardNO);
        return m.matches();
    }

    public boolean checkPassword(String password) {
        return this.cardPassword.equals(password);
    }

}

与第八题主要差距在于关于本次作业中银行卡包含借记卡和信用卡两类，且允许跨行办理相关业务（例如在中国建设银行的 ATM 机上使用中国工商银行的银行卡进行业务操作）。

class Withdraw {
    // 以下属性为取款需要输入的信息
    private UnionPay unionPay;// 银联，一切业务操作的入口
    private String cardNO;// 卡号
    private String cardPassword;// 密码
    private String ATMID;// ATM编号
    private double amount;// 取款金额

    // 根据卡号获取卡对象
    private Card card = null;
    // 根据ATM编号获取ATM对象
    private ATM aTM = null;
    // 根据卡号获取对应账号
    private AbstractAccount account = null;
    // 根据ATM或ATM所属银行对象
    private Bank bank = null;

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

    /**
     * 
     * @param unionPay
     * @param cardNO
     * @param cardPassword
     * @param aTMID
     * @param amount
     */
    public Withdraw(UnionPay unionPay, String cardNO, String cardPassword, String aTMID, double amount) {
        super();
        this.unionPay = unionPay;
        this.cardNO = cardNO;
        this.cardPassword = cardPassword;
        ATMID = aTMID;
        this.amount = amount;
    }

    /**
     * 求跨行业务手续费
     * 
     * @return
     */
    public double getCrossBankCommission(double amount) {
        return amount * bank.getCommission();
    }

    /**
     * 求透支取款手续费
     * 
     * @param amount
     * @return
     */
    public double getOverdrawCommission(double amount) {
        return amount * account.getRatio();
    }

    /**
     * 校验是否为跨行取款
     */
    public boolean isCrossBank() {
        if (account.getBank().getBankNO() != aTM.getBank().getBankNO()) {
            return true;
        }
        return false;
    }

    /**
     * 判断是否为信用卡
     * 
     * @return
     */
    public boolean isCreditAccount() {
        if (account instanceof CreditAccount) {
            return true;
        }
        return false;
    }

    /**
     * 校验输入的数据是否正确 注意：该方法不支持开闭原则，大家可以思考如何设计才能针对各种银行卡均能够实现开闭原则
     * 
     * @return
     */
    public boolean checkData() {

        // 获取银行卡对象
        card = ATMUtil.getCardbyCardNO(unionPay, cardNO);

        // 银行卡不存在（卡号错误）
        if (card == null) {
            System.out.println("Sorry,this card does not exist.");
            return false;
        }

        // 获取ATM机对象
        aTM = ATMUtil.getATMbyATMID(unionPay, ATMID);

        // ATM机不存在（ATM ID错误）
        if (aTM == null) {
            System.out.println("Sorry,the ATM's id is wrong.");
            return false;
        }

        // 获取ATM机所隶属银行对象
        bank = aTM.getBank();

        // 用户密码错误
        if (!card.getCardPassword().equals(cardPassword)) {
            System.out.println("Sorry,your password is wrong.");
            return false;
        }

        // 根据卡号获取用户账号
        account = ATMUtil.getAccountbyCardNO(cardNO);

        // 如果为借记卡
        if (!isCreditAccount()) {
            double commission = 0;

            // 如果为跨行业务，则收取跨行费用
            if (this.isCrossBank()) {
                commission += this.getCrossBankCommission(amount);
            }
            // 取款超出余额
            if (amount + commission > account.getBalance()) {
                System.out.println("Sorry,your account balance is insufficient.");
                return false;
            }
        }

        // 如果为信用卡
        if (isCreditAccount()) {
            double commission = 0; // 手续费总额
            double overdrawAmount = 0; // 透支金额
            double balance = 0; // 当前卡上余额

            balance = account.getBalance(); // 获取当前卡余额

            // 有余额，则透支金额为取款金额与余额的差值
            if (balance >= 0) {
                overdrawAmount = amount - account.getBalance();
            } else {// 余额为负值（已经透支），则透支金额为取款金额
                overdrawAmount = amount;
            }

            // 收取跨行业务费用
            if (this.isCrossBank()) {
                commission += this.getCrossBankCommission(amount);
            }
            // 收取透支费用
            if (overdrawAmount > 0) {
                commission += this.getOverdrawCommission(overdrawAmount);
            }

            // 如果取款金额与手续费金额之和大于卡片余额与可透支最大金额之和，无法取款
            if (commission + amount > account.getBalance() + account.getOverdrawAmount()) {
                System.out.println("Sorry,your account balance is insufficient.");
                return false;
            }
        }

        return true;
    }

    /**
     * 该方法支持开闭原则
     */
    public void withdraw() {
        double commission = 0;
        double overdrawAmount = 0;
        double balance = 0;

        balance = account.getBalance();

        if (balance >= 0) {
            overdrawAmount = amount - account.getBalance();
        } else {
            overdrawAmount = amount;
        }

        // 收取跨行费用
        if (this.isCrossBank()) {
            commission += this.getCrossBankCommission(amount);
        }
        // 收取透支费用
        if (overdrawAmount > 0) {
            commission += this.getOverdrawCommission(overdrawAmount);
        }

        if (commission + amount > balance + account.getOverdrawAmount()) {
            System.out.println("Sorry,your account balance is insufficient.");
            System.exit(0);
        }

        this.account.setBalance(balance - amount - commission);
        showResult(this.account);
    }

    /**
     * 显示
     * 
     * @param account
     */
    public void showResult(AbstractAccount account) {
        String userName = account.getUser().getName();
        String bankName = aTM.getBank().getBankName();
        System.out
            .println("业务：取款 " + userName + "在" + bankName + "的" + ATMID + "号ATM机上取款" + String.format("¥%.2f", amount));

        System.out.println("当前余额为" + String.format("¥%.2f", account.getBalance()));
    }
}

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

        UnionPay unionPay = InitData.initData();// 初始化程序数据

        StringBuilder sb = new StringBuilder();// 用于接收输入数据

        String data;

        // 解析输入各行数据
        while (!((data = input.nextLine()).equals("#"))) {
            sb.append(data + "\n");
        }

        String[] dt = sb.toString().split("\n");
        for (int i = 0; i < dt.length; i++) {
            String[] dataLine = dt[i].toString().split("\\s+");

            if (dataLine.length == 1) {// 查询余额功能
                GetBalance gb = new GetBalance(unionPay);
                System.out.println("业务：查询余额 " + String.format("¥%.2f", gb.getBalance(dataLine[0])));
            } else {// 取款功能
                Withdraw wd =
                    new Withdraw(unionPay, dataLine[0], dataLine[1], dataLine[2], Double.parseDouble(dataLine[3]));
                if (wd.checkData()) {
                    wd.withdraw();
                } else {
                    System.exit(0);
                }
            }
        }
    }
}

本题重点考察继承、多态及抽象类的应用提示：所谓的借记卡与信用卡的说法实际是针对用户的账户类型。

充分理解后，我们就能够完成这道题目。

三丶踩坑心得

（1）第七次作业PTA的作业中，主要是要考虑到继承和多态的应用，以及ArraryLIst泛型的应用，以及Comparable接口的使用。

class Card implements Comparable<Card> {
private Shape shape;
Card(){}
Card(Shape shape){
this.shape=shape;
}

public Shape getShape() {
return shape;
}
public void setShape(Shape shape) {
this.shape = shape;
}
public int compareTo(Card card){
return -(int)(shape.getArea()-card.getShape().getArea());
}
}

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

public String getShapeName() {
return shapeName;
}

当然，第七次作业中第二道题目也是要考虑到上面的要求，然后考虑面向对象设计的“单一职责原则”，思考该程序是否能够符合“开-闭”原则，要注意两道题目的Comparable接口的使用。

class DealCardList {
ArrayList<Card> cardlist= new ArrayList<Card>();
ArrayList<Card> circle1= new ArrayList<Card>();
ArrayList<Card> rectangle1= new ArrayList<Card>();
ArrayList<Card> triangle1= new ArrayList<Card>();
ArrayList<Card> trapeaoid1= new ArrayList<Card>();
ArrayList su=new ArrayList();
DealCardList(ArrayList<Integer> card){
Scanner in=new Scanner(System.in);
for(int i = 0 ;i<card.size();i++){
if(card.get(i)==0){
break;
}
int n=card.get(i);
switch (n){
case 1:
Card a1=new Card();

a1.setShape(new Circle(Main.input.nextDouble()));
a1.getShape().setShapeName("Circle");
cardlist.add(a1);
circle1.add(a1);
break;
case 2:
Card a2=new Card();

a2.setShape(new Rectangle(Main.input.nextDouble(),Main.input.nextDouble()));
a2.getShape().setShapeName("Rectangle");
cardlist.add(a2);
rectangle1.add(a2);
break;

case 3:
Card a3=new Card();

a3.setShape(new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
a3.getShape().setShapeName("Triangle");
cardlist.add(a3);
triangle1.add(a3);
break;
case 4:
Card a4=new Card();

a4.setShape(new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
a4.getShape().setShapeName("Trapezoid");
cardlist.add(a4);
trapeaoid1.add(a4);
break;
}
}
}
public boolean validate(){
for(int i=0;i<cardlist.size();i++){
if(!cardlist.get(i).getShape().validate()){
return false;
}
}
return true;
}
public void showResult(){
System.out.println("The original list:");
for (int i=0;i<cardlist.size();i++) {
if(i==0){
System.out.print("[");
}
System.out.print(cardlist.get(i).getShape());
if(i==cardlist.size()-1){
System.out.print("]");
}
}
System.out.println();
System.out.println("The Separated List:");
double sum=0;
double sum1=0;
double sum2=0;
double sum3=0;
for(int j=0;j<circle1.size();j++){
if(j==0){
System.out.print("[");
}
System.out.print(circle1.get(j).getShape());
sum+=circle1.get(j).getShape().getArea();
su.add(sum);
if(j==circle1.size()-1){
System.out.print("]");
}
}
if(circle1.size()==0){
System.out.print("[]");
}
for(int j=0;j<rectangle1.size();j++){
if(j==0){
System.out.print("[");
}
System.out.print(rectangle1.get(j).getShape());
sum1+=rectangle1.get(j).getShape().getArea();
su.add(sum1);
if(j==rectangle1.size()-1){
System.out.print("]");
}
}
if(rectangle1.size()==0){
System.out.print("[]");
}
for(int j=0;j<triangle1.size();j++){
if(j==0){
System.out.print("[");
}
System.out.print(triangle1.get(j).getShape());
sum2+=triangle1.get(j).getShape().getArea();
su.add(sum2);
if(j==triangle1.size()-1){
System.out.print("]");
}
}
if(triangle1.size()==0){
System.out.print("[]");
}
for(int j=0;j<trapeaoid1.size();j++){
if(j==0){
System.out.print("[");
}
System.out.print(trapeaoid1.get(j).getShape());

sum3+=trapeaoid1.get(j).getShape().getArea();
su.add(sum3);
if(j==trapeaoid1.size()-1){
System.out.print("]");
}
}
if(trapeaoid1.size()==0){
System.out.print("[]");
}
System.out.println();
System.out.println("The Separated sorted List:");
Collections.sort(su);
Collections.sort(cardlist);
Collections.sort(circle1);
Collections.sort(rectangle1);
Collections.sort(triangle1);
Collections.sort(trapeaoid1);

for(int j=0;j<circle1.size();j++){
if(j==0){
System.out.print("[");
}
System.out.print(circle1.get(j).getShape());
if(j==circle1.size()-1){
System.out.print("]");
}
}
if(circle1.size()==0){
System.out.print("[]");
}
for(int j=0;j<rectangle1.size();j++){
if(j==0){
System.out.print("[");
}
System.out.print(rectangle1.get(j).getShape());
if(j==rectangle1.size()-1){
System.out.print("]");
}
}
if(rectangle1.size()==0){
System.out.print("[]");
}
for(int j=0;j<triangle1.size();j++){
if(j==0){
System.out.print("[");
}
System.out.print(triangle1.get(j).getShape());
if(j==triangle1.size()-1){
System.out.print("]");
}
}
if(triangle1.size()==0){
System.out.print("[]");
}
for(int j=0;j<trapeaoid1.size();j++){
if(j==0){
System.out.print("[");
}
System.out.print(trapeaoid1.get(j).getShape());
if(j==trapeaoid1.size()-1){
System.out.print("]");
}
}
if(trapeaoid1.size()==0){
System.out.print("[]");
}
System.out.println();
System.out.printf("The max area:%.2f\n",su.get(su.size()-1));
}
}

（2）第八次作业和第九次作业ATM类型的题目是很有难度的

答案的测试点的数据，我都带进去将每一个点都通过才行。

这道题目要注意的是最后的输入保留两位小数

if(flag1==true&&flag2==true&&flag3==true&&flag4==true){
if(money1>0) {
double qian=list.get(p).getAccount().get(io).getMoney()-money1;
list.get(p).getAccount().get(io).setMoney(qian);
System.out.println(list.get(p).getName() + "在" + list.get(p).getAccount().get(io).getBank() + "的" + bank1 + "号ATM机上取款¥"+String.format("%.2f", money1));
System.out.println("当前余额为¥"+String.format("%.2f", qian));
}
if(money1<0) {
double qian1=list.get(p).getAccount().get(io).getMoney()-money1;
list.get(p).getAccount().get(io).setMoney(qian1);
System.out.println(list.get(p).getName() + "在" + list.get(p).getAccount().get(io).getBank() + "的" + bank1 + "号ATM机上存款¥"+String.format("%.2f", -money1));
System.out.println("当前余额为¥"+String.format("%.2f", qian1));
}
}

其他细节就在于个个类的设计，在上面这道题目中，代码已经很详细了。

第九次PTA作业较第八次作业复杂了一点

需要注意的坑有很多，首先我们要理解类与对象的关系，对象是类的一个实例，对象之间在现实生活和编程中都有关系。有时很难理解或实现这些关系。这些关系有时很容易混合：组合、聚合和关联。

依赖关系，是类与类之间的联接。依赖关系表示一个类依赖于另一个类的定义。使用关系。一般情况下，依赖关系在Java语言中体现为局域变量、方法的形参，或者对静态方法的调用。

关联关系，是类与类之间的联接，它使一个类知道另一个类的属性和方法。拥有关系。关联可以是双向的，也可以是单向的。在Java语言中，关联关系一般使用成员变量来实现。

聚合关系，是关联关系的一种，是强的关联关系。聚合是整体和个体之间的关系。例如，汽车类与引擎类、轮胎类，以及其它的零件类之间的关系便整体和个体的关系。与关联关系一样，聚合关系也是通过实例变量实现的。但是关联关系所涉及的两个类是处在同一层次上的，而在聚合关系中，两个类是处在不平等层次上的，一个代表整体，另一个代表部分。

组合关系，是关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分对象的生命周期，组合关系是不能共享的。代表整体的对象需要负责保持部分对象和存活，在一些情况下将负责代表部分的对象湮灭掉。代表整体的对象可以将代表部分的对象传递给另一个对象，由后者负责此对象的生命周期。换言之，代表部分的对象在每一个时刻只能与一个对象发生组合关系，由后者排他地负责生命周期。部分和整体的生命周期一样。

我们要将这种概念知识牢记于心。

四丶改进建议

我认为第七次作业中，可以适当提升难度系数。

第八次作业中，我认为我写的代码不够严谨，以及复用性不是呢么充分。

第九次作业中，应该按照老师的具体要求去完成，自己写的还是有些差错的。

五丶总结

学习了解了继承、多态的应用、ArrayList泛型的应用方法、Comparable接口及泛型的应用；单一职责原则的应用、开-闭原则的应用，掌握了数据的输入与输出；同时学习编写结构清晰、逻辑正确、功能完善的java代码。对课堂模式的看法与建议：课堂采取的是线上线下相结合的模式。线上需通过mooc自学相关Java内容，老师根据题目的完成情况讲产生的学各种知识，这种课堂模式非常具有创新性，大大增强了课堂效率。当然我也了解到代码的编写过程一定要严谨，数据的处理也是十分重要的，一定要去测试代码，测试代码输入的合理性，这也是题目涉及到的非法输入的测试点。很多东西需要自学，这样也养成了自学的习惯和学会翻阅资料等。做题只靠老师讲的知识远远不够，需要我们自己去查找资料。

posted @ 2021-06-14 12:52 gddd 阅读(88) 评论(0) 收藏举报

刷新页面返回顶部

gddd