OOP题目集4~6总结

前言：

　　这次的题目集难度较以往而言提升了很多，突然提升的难度难免会造成些许的不适应。但是题目虽然有难度，同样的收获也与难度成正比增长。而这次题目集总结主要以三道大题来进行分析。

 

 

第四次作业：

　　题目7-1 菜单计价程序-3：

需求分析：

　　设计菜单点单计价程序，根据输入的信息，计算并输出相应的价格。菜单记录所有菜品，每个菜品包括菜名、单价属性，由输入决定。订单包括桌号信息、点菜信息属性。菜品会有规定时间折扣，折扣通过点菜时间判断。在点菜时还可以通过delete删除之前的点菜记录。只能在营业时间之内点餐。

题目分析：

　　应设置四个类，菜品类Dish，包含菜名和单价属性，包括getPrice计算不同份额的价格的方法；菜单类Menu，包含菜品列表，包含添加菜品和查找菜品的方法；点菜记录类Record，包含点菜序号，菜品，份额，包含计价方法；点单类Order， 包含点菜记录，包含计价，包含增减查三种方法。设置一个DealData类来处理数据。

我的代码：

package DISH;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Scanner;

class Dish {

    public  String name;//菜品名称
    public  int unit_price; //单价

    public Dish() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public Dish(String name, int unit_price) {
        super();
        this.name = name;
        this.unit_price = unit_price;
    }

    public String getName() {
        return name;
    }

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

    public int getUnit_price() {
        return unit_price;
    }

    public void setUnit_price(int unit_price) {
        this.unit_price = unit_price;
    }

    public int getPrice(int portion) { // 不同份额的价格转化
        switch(portion) {
        case 1:
            unit_price *= 1;
            break;
        case 2:
            unit_price *= 1.5;
            break;
        case 3:
            unit_price *= 2;
            break;
        }
        return (int)unit_price;
    }
}

class Menu {

    public  ArrayList<Dish> dishs = new ArrayList<Dish>();//菜品数组，保存所有菜品信息
    
    public Dish searchDish(String dishName){
        Dish dish = null;
        for(Dish t:dishs) {
            if(dishName.equals(t.getName())) {
                dish = t;
            }
        }
        if(dish == null) {
            System.out.println(dishName +"does not exist");
        }
        return dish;
    }

    public void addDish(String dishName,int unit_price){
        Dish t = new Dish();
        t.setName(dishName);
        t.setUnit_price(unit_price);
        dishs.add(t);
    }

    
}

class Record {

    public int orderNum; //序号
    public  Dish d = new Dish(); //菜品
    public  int portion; //份额
    public  int num; // 份数
    
    public Record() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public Record(int orderNum, Dish d, int portion, int num) {
        super();
        this.orderNum = orderNum;
        this.d = d;
        this.portion = portion;
        this.num = num;
    }

    public int getOrderNum() {
        return orderNum;
    }

    public void setOrderNum(int orderNum) {
        this.orderNum = orderNum;
    }

    public Dish getDish() {
        return d;
    }

    public void setDish(Dish d) {
        this.d = d;
    }

    public int getPortion() {
        return portion;
    }

    public void setPortion(int portion) {
        this.portion = portion;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public int getPrice(){
        return d.getPrice(portion) * num;
    }
}

class Order {

    public static int differenceMoney; // 要删除菜品的价钱
    public static int errorDeleteTime; //删除错误的次数
    public ArrayList<Record> records = new ArrayList<Record>();

    public int getTotalPrice(){
        int sum = 0;
        for(Record r:records) {
            sum += r.getPrice();
        }
        return sum;
    }
    
    public int getDifferenceMoney() {
        return differenceMoney;
    }
    
    public void setDifferenceMoney(int differenceMoney) {
        this.differenceMoney = differenceMoney;
    }

    public Record addARecord(int orderNum, String dishName, int portion, int num, Menu menu) {
        Dish dish = menu.searchDish(dishName);
        if (dish == null) {
            System.out.println(dishName + " does not exist");
            return null;
        }
        Record r = new Record();
        r.setOrderNum(orderNum);
        r.setDish(dish);
        r.setPortion(portion);
        r.setNum(num);
        records.add(r);
        return r;
    }

    public void delARecordByOrderNum(int orderNum) { // 根据序号删除一条记录
        for(int i = 0; i < records.size(); i++) {
            if(records.get(i).getOrderNum() == orderNum) {
                differenceMoney += records.get(i).getPrice();
                return;
            }
        }
        System.out.println("delete error;"); // 序号不存在
    }
    
    public Record findRecordByNum(int orderNum) { // 根据序号查找
        for(Record record : records) {
            if (record.getOrderNum() == orderNum) {
                return record;
            }
        }
        return null;
    }

}



class DealData {
    StringBuilder sb = new StringBuilder();

    public DealData() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public DealData(StringBuilder sb) {
        super();
        this.sb = sb;
    }

    public void setSb(StringBuilder sb) {
        this.sb = sb;
    }
    
    public void dealData() {
        Scanner input = new Scanner(System.in);
        ArrayList<String> outPut = new ArrayList<String>();
        String allInput = "";
        allInput = input.nextLine();
        if(allInput.equals("exit")) {
            System.exit(0);
        }
        while(!allInput.equals("end")) {
            sb.append(allInput);
            sb.append("\n");
            allInput = input.nextLine();
            
        }
        sb.append("end");
        Menu menu = new Menu();
        double discount = 1.0;
        int i = 0;
        String[] lines = sb.toString().split("\\s+");
        while (!lines[i].equals("end")) {
            if (lines[i].startsWith("table")) {
                String[] parts = lines[i].split(" ");
                int tableNum = Integer.parseInt(parts[1]);
                System.out.println("table " + tableNum + ": ");
                String date = parts[2];
                LocalDate currentDate = LocalDate.of(Integer.parseInt(parts[2].split("/")[0]), Integer.parseInt(parts[2].split("/")[1]),
                        Integer.parseInt(parts[2].split("/")[2]));
                String week = String.valueOf(currentDate.getDayOfWeek());
                String time = parts[3];
                Order order = new Order();
                int totalPrice = 0;
                boolean isDiscount = false;
                boolean outTime = false;
                while (true){
                    lines[i] = input.nextLine();
                    if (lines[i].contains("end")) {
                        break;
                    }
                    if (lines[i].startsWith("table")) {
                        break;
                    } else if (lines[i].contains("delete")) {
                        int deleteNum = Integer.parseInt(lines[i].split("\\s+")[0]);
                        order.delARecordByOrderNum(deleteNum);
                    } else {
                        String[] parts2 = lines[i].split("\\s+");
                        if (parts2.length > 2 && parts2.length <= 4) {
                            int orderNum = Integer.parseInt(parts2[0]);
                            String dishName = parts2[1];
                            int portion = Integer.parseInt(parts2[2]);
                            int num = Integer.parseInt(parts2[3]);
                            Record record = order.addARecord(orderNum, dishName, portion, num, menu);
                            if (record != null) {
                                totalPrice += record.getPrice();
                                System.out.println(record.orderNum + " " + record.d.name + " " + record.getPrice());
                            }
                        }
                        else if (parts2.length > 4) {
                            int dNUm = Integer.parseInt(parts2[0]);
                            int orderNum = Integer.parseInt(parts2[1]);
                            String dishName = parts2[2];
                            int portion = Integer.parseInt(parts2[3]);
                            int num = Integer.parseInt(parts2[4]);
                            Record record = order.addARecord(orderNum, dishName, portion, num, menu);
                            if (record != null) {
                                totalPrice += record.getPrice();
                                System.out.println(record.orderNum + " table " + tableNum + " pay for table " + dNUm  + " " + record.getPrice());
                            }
                        }
                    }
                }
                int hour = Integer.parseInt(time.split("/")[0]);
                int minute = Integer.parseInt(time.split("/")[1]);
                if ( week.equals("SATURDAY") || week.equals("SUNDAY")) {
                    if ( (hour > 9 && hour <= 21) || (hour == 9 && minute >= 30) ) {
                        isDiscount = true;
                        discount = 1.0;
                        outTime = false;
                    } else {
                        outTime = true;
                    }
                } else {
                    if ( hour > 10 && hour < 14 || (hour == 10 && minute >= 30) || (hour == 14 && minute <= 30)) {
                        isDiscount = true;
                        discount = 0.6;
                    }
                    else if ( (hour >= 17 && hour < 20) ||(hour == 20 && minute <= 30) ) {
                        isDiscount = true;
                        discount = 0.8;
                    } else {
                        outTime = true;
                    }
                }
                if (isDiscount) {
                    totalPrice = (int)((totalPrice- Order.differenceMoney) * discount + 0.5);
                }
                if(outTime) {
                    outPut.add("table " + String.valueOf(tableNum) + " out of opening hours");
                } else {
                    outPut.add("table " + String.valueOf(tableNum) + ": " + totalPrice);
                }
            } else {
                String[] parts = lines[i].split(" ");
                if(parts.length == 2) {
                String dishName = parts[0];
                int unit_price = Integer.parseInt(parts[1]);
                menu.addDish(dishName, unit_price);
                }

            }
            i++;
        }
        for (i = 0; i <outPut.size();i++) {
            System.out.println(outPut.get(i));
        }
    }
}


public class Main {
    public static void main(String[] args) {
        
        DealData d = new DealData();
        d.dealData();
        
    }
}

 

sourceMonitor：

 

可以看出不是很好，太复杂了，因为判断和循环嵌套太多。

 

类图：

 

 

第六次作业：

　　题目7-4 ATM机类结构设计（一）：

需求分析：

　　编写一个银行 ATM 机的模拟程序，能够完成用户的存款、取款以及查询余额功能。相关概念分别有：中国银联（China UnionPay）、银行（Bank）、银行用户（User）、银行账户（Account）、银行卡（Card）、ATM（Automated Teller Machine）。其中，中国银联包含多家银行机构，银行则有银行名称属性。银行用户则持有银行账户，银行账户包含银行卡（可多张）、账户余额属性，且隶属于某家银行，为某人所持有。银行卡包含银行卡号、银行卡密码属性。ATM机比较复杂，可提取现金、查询存款余额、余额查询等工作，并且隶属于某一银行机构。

题目分析：

　　设计要求：尝试使用面向对象技术对银行用户在 ATM 机上进行相关操作的模拟系统设 计，上述的相关概念均要设计为实体类，业务（控制）类请自行根据实际需要进 行扩充和完善。本次作业限定银行卡均为借记卡（不能透支），且不允许跨行办理相关业务（例如在中国建设银行的 ATM 机上对其他银行的账户进行操作）。所以根据题目要求，我设置了ChinaUnionPay类，Bank类（继承ChinaUnionPay类），ATM类，User类，Account类和Card类六个主要的实体类。在数据处理方面设置AllInfo类进行几个人的数据初始化，用CheckData类来分割和检查数据（这里没做好，没有实现单一职责），用Controller类来主控数据。

我的代码：

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

class ChinaUnionPay {
    private ArrayList<Bank> bank = new ArrayList<Bank>();

    public ChinaUnionPay() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public ChinaUnionPay(ArrayList<Bank> bank) {
        super();
        this.bank = bank;
    }

    public ArrayList<Bank> getBank() {
        return bank;
    }

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

/**
 * 银行有名字
 * 银行可以有很多账户
 * 银行可以有很多用户
 * 银行可以有很多ATM机
 * @author 龚良堃
 *
 */

class Bank extends ChinaUnionPay{

    protected String bankName;
    protected ArrayList<ATM> atm;

    public Bank() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public Bank(String bankName, ArrayList<ATM> atm) {
        super();
        this.bankName = bankName;
        this.atm = atm;
    }

    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;
    }

    public void Name(String atmNum) {
        if(atmNum.matches("[0][1-4]")) {
            this.bankName = "中国建设银行";
        }
        if(atmNum.matches("[0][5-6]")) {
            this.bankName = "中国工商银行";
        }
    }
}

class ATM {

    private String atmNum;

    public ATM() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public ATM(String atmNum) {
        super();
        this.atmNum = atmNum;

    }

    public String getAtmNum() {
        return atmNum;
    }

    public void setAtmNum(String atmNum) {
        this.atmNum = atmNum;
    }

    public boolean isLegalATM() {
        if(this.atmNum.matches("[0][1-6]"))
            return true;
        return false;
    }

}

/**
 * 用户应该有名字
 * 用户应该有账户
 * 用户可以有多个账户 (数组对象)
 * @author 龚良堃
 *
 */

class User {

    protected String name;
    protected ArrayList<Account> accounts;
    //    private Card[] cards;

    public User() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public User(String name, ArrayList<Account> accounts) {
        super();
        this.name = name;
        this.accounts = accounts;
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(ArrayList<Account> accounts) {
        this.accounts = accounts;
    }
}

/**
 * 账户里有银行卡
 * 一个账户可以有多张银行卡 (数组对象)
 * 银行卡的钱是账户共享的
 * 所以应该把关于钱的属性放账户里
 * @author 龚良堃
 *
 */

class Account {

    private ArrayList<Card> cards;
    private Bank bank;
    private double allMoney = 10000.00;

    public Account() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public Account(ArrayList<Card> cards, Bank bank) {
        super();
        this.cards = cards;
        this.bank = bank;
    }

    public ArrayList<Card> getCards() {
        return cards;
    }

    public void setCards(ArrayList<Card> cards) {
        this.cards = cards;
    }

    public Bank getBank() {
        return bank;
    }

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

    public double getAllMoney() {
        return allMoney;
    }

    public void setAllMoney(double allMoney) {
        this.allMoney = allMoney;
    }

    public void changeValue(double changeValue) {
        if(canTakeMoney(changeValue)) {
            this.allMoney -= changeValue;
        }
    }

    public boolean canTakeMoney(double takeValue) {
        if(takeValue > this.allMoney) {
            return false;
        }
        return true;
    }

    public boolean isCardExist(String cardID) {
        for(int i = 0; i < cards.size(); i++) {
            for(int j = 0; j < getCards().size(); j++) { // 存疑
                if (cards.get(i).getCardID().equals(cardID)) {
                    return true;
                }
            }
        }
        return false;
    }

    public boolean isRightPassword(String password) {
        if(password.matches("88888888")) {
            return true;
        }
        return false;
    }
}

/** 
 * 我认为卡里的属性应该有:
 * 卡号 cardID
 * 卡密 password
 * 卡内余额 allMoney (初始10000.00) (错误的)
 * 要取走的金额 takeMoney (初始0.00) (错误的)
 * 要存入的金额 addMoney (初始0.00) (错误的)
 * @author 龚良堃
 *
 */
class Card {

    private String cardID;
    private String password;

    public Card() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public Card(String cardID, String password) {
        super();
        this.cardID = cardID;
        this.password = password;
    }

    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;
    }

    public boolean isMyCard(String cardID) {
        if(this.cardID.matches(cardID)) {
            return true;
        }
        return false;
    }

    public boolean isRightPassword(String password) {
        if(password.matches("88888888")) {
            return true;
        }
        return false;
    }
}

class AllInfo {

    public AllInfo() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public ArrayList<User> info() {
        ArrayList<ATM> atmNum01 = new ArrayList<ATM>(); // 建行ATM
        ATM atm01 = new ATM("01");
        ATM atm02 = new ATM("02");
        ATM atm03 = new ATM("03");
        ATM atm04 = new ATM("04");
        atmNum01.add(atm01);
        atmNum01.add(atm02);
        atmNum01.add(atm03);
        atmNum01.add(atm04);

        ArrayList<ATM> atmNum02 = new ArrayList<ATM>(); // 工行ATM
        ATM atm05 = new ATM("05");
        ATM atm06 = new ATM("06");
        atmNum02.add(atm05);
        atmNum02.add(atm06);

        Bank bank01 = new Bank("中国建设银行", atmNum01); // 两个银行的初始化
        Bank bank02 = new Bank("中国工商银行", atmNum02);

        ArrayList<Card> cards01 = new ArrayList<Card>(); // 杨过一个账户的卡
        Card card01 = new Card("6217000010041315709","88888888"); // 杨过的卡
        Card card02 = new Card("6217000010041315715","88888888");
        cards01.add(card01);
        cards01.add(card02);
        ArrayList<Card> cards02 = new ArrayList<Card>(); // 杨过一个账户的卡
        Card card03 = new Card("6217000010041315718","88888888");
        cards02.add(card03);
        ArrayList<Card> cards03 = new ArrayList<Card>(); // 郭靖账户的卡
        Card card04 = new Card("6217000010051320007", "8888888");
        cards03.add(card04);
        ArrayList<Card> cards04 = new ArrayList<Card>(); // 张无忌一个账户的卡
        Card card05 = new Card("6222081502001312389","88888888");
        cards04.add(card05);
        ArrayList<Card> cards05 = new ArrayList<Card>(); // 张无忌一个账户的卡
        Card card06 = new Card("6222081502001312390","88888888");
        cards05.add(card06);
        ArrayList<Card> cards06 = new ArrayList<Card>(); // 张无忌一个账户的卡
        Card card07 = new Card("6222081502001312399","88888888");
        Card card08 = new Card("6222081502001312400","88888888");
        cards06.add(card07);
        cards06.add(card08);
        ArrayList<Card> cards07 = new ArrayList<Card>(); // 韦小宝一个账户的卡
        Card card09 = new Card("6222081502051320785","88888888");
        cards07.add(card09);
        ArrayList<Card> cards08 = new ArrayList<Card>(); // 韦小宝一个账户的卡
        Card card10 = new Card("6222081502051320786","88888888");
        cards08.add(card10);

        ArrayList<Account> accounts01 = new ArrayList<Account>(); // 杨过的账户
        Account account01 = new Account(cards01, bank01); // 杨过的建行账户一卡
        Account account02 = new Account(cards02, bank01); // 杨过的建行账户二卡
        accounts01.add(account01);
        accounts01.add(account02);
        ArrayList<Account> accounts02 = new ArrayList<Account>(); // 郭靖的账户
        Account account03 = new Account(cards03, bank01); // 郭靖的建行账户一卡
        accounts02.add(account03);
        ArrayList<Account> accounts03 = new ArrayList<Account>(); // 张无忌的账户
        Account account04 = new Account(cards04, bank02); // 张无忌的建行账户一卡
        Account account05 = new Account(cards05, bank02); // 张无忌的建行账户二卡
        Account account06 = new Account(cards06, bank02); // 张无忌的建行账户三卡
        accounts03.add(account04);
        accounts03.add(account05);
        accounts03.add(account06);
        ArrayList<Account> accounts04 = new ArrayList<Account>(); // 韦小宝的账户
        Account account07 = new Account(cards07, bank02);
        Account account08 = new Account(cards08, bank02);
        accounts04.add(account07);
        accounts04.add(account08);

        ArrayList<User> users = new ArrayList<User>();
        User user01 = new User("杨过", accounts01); // 初始化杨过的信息
        users.add(user01);
        User user02 = new User("郭靖", accounts02); // 初始化郭靖
        users.add(user02);
        User user03 = new User("张无忌", accounts03); // 初始化张无忌
        users.add(user03);
        User user04 = new User("韦小宝", accounts04); // 初始化韦小宝
        users.add(user04);
        
        return users;
    }
}

class CheckData {

    private String data; // 一行的数据


    public CheckData() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public CheckData(String data) {
        super();
        this.data = data;
    }

    public void setData(String data) {
        this.data = data;
    }

    public String[] getSplitedData() { // 将一行的数据经过分割后返回
        String[] datas = data.split("\\s+");
        if(datas.length >= 1) { // 如果长度正确则返回分割后的数组, 否则返回空
            return datas;
        }
        return null;
    }

    public boolean isLegalInput() {
        if(getSplitedData() == null) {
            return false;
        }
        return true;
    }
}

class Controller {

    StringBuilder sb = new StringBuilder();
    protected AllInfo allInfo = new AllInfo();
    protected View view = new View();


    public Controller() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public Controller(StringBuilder sb) {
        super();
        this.sb = sb;
    }

    public StringBuilder getSb() {
        return sb;
    }

    public void setSb(StringBuilder sb) {
        this.sb = sb;
    }

    public void in() {
        Scanner in = new Scanner(System.in);
        String allInput = "";
        allInput = in.nextLine();
        if(allInput.equals("#")) {
            System.exit(0);
        }
        while(!allInput.equals("#")) {
            sb.append(allInput);
            sb.append("\n");
            allInput = in.nextLine();

        }
    }

    public void play() {
        ArrayList<User> users = allInfo.info();
        in();
        String[] datas = sb.toString().split("\n"); // 输入数据分行分割

        int i = 0;
            for(i = 0; i < datas.length; i ++) {
                CheckData checkData = new CheckData(datas[i]);
                String[] d = checkData.getSplitedData(); // 一条数据的分割

                if(d.length > 1) {
                    ATM atm = new ATM(d[2]);
                    ArrayList<ATM> atmd = new ArrayList<ATM>();
                    Bank bankd = new Bank("name", atmd);
                    bankd.Name(d[2]);
                    int usersNum = 0;
                    int accountsNum = 0;
                    double money = 0.0;
                    if(d.length == 4) {
                        money = Double.parseDouble(d[3]);
                    }
                    boolean flag = false;
                    for(int j = 0; j < users.size(); j ++) {
                        for(int k = 0; k < users.get(j).accounts.size(); k ++) {
                            if(users.get(j).accounts.get(k).isCardExist(d[0])) {
                                usersNum = j;
                                accountsNum = k;
                                flag = true;
                            }
                        }
                    }
                    if(flag == true) { // 卡号存在
                        if(users.get(usersNum).accounts.get(accountsNum).isRightPassword(d[1])) { // 密码正确
                            if(atm.isLegalATM()) { // ATM正确
                                if(users.get(usersNum).accounts.get(accountsNum).getBank().getBankName().equals(bankd.getBankName())) {    // 对应银行正确
                                    if(users.get(usersNum).accounts.get(accountsNum).canTakeMoney(money)) { // 能够取钱
                                        users.get(usersNum).accounts.get(accountsNum).changeValue(money);
                                        if(money > 0) {
                                            view.rightTakeOutput(users.get(usersNum).getName(),
                                                    users.get(usersNum).accounts.get(accountsNum).getBank().getBankName(),
                                                    d[2], money);
                                            view.showBalance(users.get(usersNum).accounts.get(accountsNum).getAllMoney());
                                        } else {
                                            view.rightAddOutput(users.get(usersNum).getName(),
                                                    users.get(usersNum).accounts.get(accountsNum).getBank().getBankName(),
                                                    d[2], 0-money);
                                            view.showBalance(users.get(usersNum).accounts.get(accountsNum).getAllMoney());
                                        }
                                    } else {
                                        view.balanceWrong();
                                    }
                                } else {
                                    view.crossBankWrong();
                                }
                            } else {
                                view.ATMWrong();
                            }
                        } else {
                            view.passwordWrong();
                        }
                    } else {
                        view.cardWrong();
                    }
                } else if(d.length == 1){ // 查询余额
                    boolean flag = false;
                    int usersNum = 0;
                    int accountsNum = 0;
                    for(int j = 0; j < users.size(); j ++) {
                        for(int k = 0; k < users.get(j).accounts.size(); k ++) {
                            if(users.get(j).accounts.get(k).isCardExist(d[0])) {
                                usersNum = j;
                                accountsNum = k;
                                flag = true;
                            }
                        }
                    }
                    if(flag) {
                        view.onlyShowBalance(users.get(usersNum).accounts.get(accountsNum).getAllMoney());
                    } else {
                        view.cardWrong();
                    }
                }
            }
    }
}

class View {

    public View() {
        super();
        // TODO 自动生成的构造函数存根
    }

    // 错误输出汇总
    public void cardWrong() {
        System.out.println("Sorry,this card does not exist.");        
    }

    public void ATMWrong() {
        System.out.println("Sorry,the ATM's id is wrong.");
    }

    public void passwordWrong() {
        System.out.println("Sorry,your password is wrong.");
    }

    public void balanceWrong() {
        System.out.println("Sorry,your account balance is insufficient.");
    }

    public void crossBankWrong() {
        System.out.println("Sorry,cross-bank withdrawal is not supported.");
    }

    // 正确输出
    public void rightTakeOutput(String userName, String bankName, String atmNum, double takeMoney) { // 取钱的输出
        System.out.print(userName + "在" + bankName + "的" + atmNum + "号ATM机上取款¥");
        System.out.printf("%.2f", takeMoney);
        System.out.println();
    }

    public void rightAddOutput(String userName, String bankName, String atmNum, double addMoney) { // 存钱的输出
        System.out.print(userName + "在" + bankName + "的" + atmNum + "号ATM机上存款¥");
        System.out.printf("%.2f", addMoney);
        System.out.println();

    }

    public void showBalance(double allMoney) {
        System.out.printf("当前余额为¥%.2f", allMoney);
        System.out.println();
    }

    public void onlyShowBalance(double allMoney) {
        System.out.printf("¥%.2f", allMoney);
        System.out.println();
    }
}

public class Main {

    public static void main(String[] args) {

        Controller co = new Controller();
        co.play();
    }
}

 

　　其实这次的代码我自认为不是很满意，因为太复杂了。复杂的体现在于其中的AllInfo类里添加所有人的信息，以及Controller类里的play方法种的if判断，非常长且判断层数太多。先放上类图和sourceMonitor吧：

 

sourceMonitor：

这是最复杂的Controllor类的图，可以看出复杂度和深度很高。

 

类图：

 相应输出：

 

　　题目7-5 ATM机类结构设计（二）：

需求分析：

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

　　1.银行账户：客户在银行开立的存款账户、贷款账户、往来账户 的总称。银行账户分为借记账户和贷记账户两种，其中，借记账户不能够透支取款，而贷记账户可以透支取款（可能需要支付手续费）。一个银行用户可以拥有多个银行账户。

　　2.银行卡（Card）：经批准由商业银行(含邮政金融机构) 向社会发行的具有消费信用、转账结算、存取现金等全部或部分功能的信用支付工具。根据账户 的不同，银行卡一般分为借记卡（针对借记账户）和信用卡（针对贷记账户） 两类。一个银行账户可以发行多张银行卡。

　　3.允许跨行办理相关业务务（例如在中国建设银行的 ATM 机上使用中国工商银行的银行卡进行业务操作）。

题目分析：

　　这题在上题基础上改变了很多需求，要求可以跨行操作业务，但要收取手续费，手续费根据银行不同而设立不同手续费；要求新增信用卡类；要求账户新增贷记账户且可以透支取款。

我的代码：

import java.util.*;

import java.util.ArrayList;



class ChinaUnionPay {
    private ArrayList<Bank> bank = new ArrayList<Bank>();

    public ChinaUnionPay() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public ChinaUnionPay(ArrayList<Bank> bank) {
        super();
        this.bank = bank;
    }

    public ArrayList<Bank> getBank() {
        return bank;
    }

    public void setBank(ArrayList<Bank> bank) {
        this.bank = bank;
    }
    
    // 暂时放这
    public boolean isCrossBank(String bankName1, String bankName2) {
        if(bankName1.matches(bankName2)) {
            return true;
        }
        return false;
    }

}

class Bank {
    
    private String bankName;
    private ArrayList<ATM> atms = new ArrayList<ATM>();
    private double premium; // 手续费
    
    public Bank() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public Bank(String bankName, ArrayList<ATM> atms, double premium) {
        super();
        this.bankName = bankName;
        this.atms = atms;
        this.premium = premium;
    }

    public String getBankName() {
        return bankName;
    }

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

    public ArrayList<ATM> getAtms() {
        return atms;
    }

    public void setAtms(ArrayList<ATM> atms) {
        this.atms = atms;
    }

    
    public double getPremium() {
        return premium;
    }
    

    public void setPremium(double premium) {
        this.premium = premium;
    }
    
}

class ATM {
    
    private String atmNum;

    public ATM() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public ATM(String atmNum) {
        super();
        this.atmNum = atmNum;
    }

    public String getAtmNum() {
        return atmNum;
    }

    public void setAtmNum(String atmNum) {
        this.atmNum = atmNum;
    }
    
    public boolean isRightNum(String atmNum) { // 判断是否存在当前编号的ATM机
        if(atmNum.matches("([0][1-9])|([1][0-1])")) {
            return true;
        }
        return false;
    }
}

class User {
    
    private String name;
    private ArrayList<Account> accounts = new ArrayList<Account>();
    
    public User() {
        super();
        // TODO 自动生成的构造函数存根
    }
    
    public User(String name, ArrayList<Account> accounts) {
        super();
        this.name = name;
        this.accounts = accounts;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public ArrayList<Account> getAccounts() {
        return accounts;
    }
    
    public void setAccounts(ArrayList<Account> accounts) {
        this.accounts = accounts;
    }
}

class CreditUser {
    
    private String name;
    private ArrayList<CreditAccount> accounts = new ArrayList<CreditAccount>();
    
    public CreditUser() {
        super();
        // TODO 自动生成的构造函数存根
    }
    
    public CreditUser(String name, ArrayList<CreditAccount> accounts) {
        super();
        this.name = name;
        this.accounts = accounts;
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<CreditAccount> getAccounts() {
        return accounts;
    }

    public void setAccounts(ArrayList<CreditAccount> accounts) {
        this.accounts = accounts;
    }
    
    
    
}

class Account {
    
    private Bank bank;
    private ArrayList<Card> cards = new ArrayList<Card>();
    private double money = 10000.00;
    
    public Account() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public Account(ArrayList<Card> cards, Bank bank) {
        super();
        this.bank = bank;
        this.cards = cards;
    }

    public Bank getBank() {
        return bank;
    }

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

    public ArrayList<Card> getCards() {
        return cards;
    }

    public void setCards(ArrayList<Card> cards) {
        this.cards = cards;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
    
    public void changeMoney(double cMoney) {
        this.money -= cMoney;
    }
    
}

class CreditAccount {
    
    private Bank bank;
    private ArrayList<Card> cards = new ArrayList<Card>();
    private double money = 50000.00;
    
    public CreditAccount() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public CreditAccount(ArrayList<Card> cards, Bank bank) {
        super();
        this.bank = bank;
        this.cards = cards;
    }

    public Bank getBank() {
        return bank;
    }

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

    public ArrayList<Card> getCards() {
        return cards;
    }

    public void setCards(ArrayList<Card> cards) {
        this.cards = cards;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
    
}

class Card {
    
    private String cardID;
    private String password = "88888888";
    
    public Card() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public Card(String cardID, String password) {
        super();
        this.cardID = cardID;
        this.password = password;
    }

    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 AllUsers {
    
    public ArrayList<User> info() {
        ArrayList<ATM> atmNum01 = new ArrayList<ATM>(); // 建行ATM
        ATM atm01 = new ATM("01");
        ATM atm02 = new ATM("02");
        ATM atm03 = new ATM("03");
        ATM atm04 = new ATM("04");
        atmNum01.add(atm01);
        atmNum01.add(atm02);
        atmNum01.add(atm03);
        atmNum01.add(atm04);

        ArrayList<ATM> atmNum02 = new ArrayList<ATM>(); // 工行ATM
        ATM atm05 = new ATM("05");
        ATM atm06 = new ATM("06");
        atmNum02.add(atm05);
        atmNum02.add(atm06);
        
        ArrayList<ATM> atmNum03 = new ArrayList<ATM>(); // 农行ATM
        ATM atm07 = new ATM("07");
        ATM atm08 = new ATM("08");
        ATM atm09 = new ATM("09");
        ATM atm10 = new ATM("10");
        ATM atm11 = new ATM("11");
        atmNum03.add(atm07);
        atmNum03.add(atm08);
        atmNum03.add(atm09);
        atmNum03.add(atm10);
        atmNum03.add(atm11);
        
        Bank bank01 = new Bank("中国建设银行", atmNum01, 0.02); // 两个银行的初始化
        Bank bank02 = new Bank("中国工商银行", atmNum02, 0.03);
        Bank bank03 = new Bank("中国农商银行", atmNum03, 0.04);
        
        ArrayList<Card> cards01 = new ArrayList<Card>(); // 杨过一个账户的卡
        Card card01 = new Card("6217000010041315709","88888888"); // 杨过的卡
        Card card02 = new Card("6217000010041315715","88888888");
        cards01.add(card01);
        cards01.add(card02);
        
        ArrayList<Card> cards02 = new ArrayList<Card>(); // 杨过一个账户的卡
        Card card03 = new Card("6217000010041315718","88888888");
        cards02.add(card03);
        
        ArrayList<Card> cards03 = new ArrayList<Card>(); // 郭靖账户的卡
        Card card04 = new Card("6217000010051320007", "8888888");
        cards03.add(card04);
        
        ArrayList<Card> cards04 = new ArrayList<Card>(); // 张无忌一个账户的卡
        Card card05 = new Card("6222081502001312389","88888888");
        cards04.add(card05);
        
        ArrayList<Card> cards05 = new ArrayList<Card>(); // 张无忌一个账户的卡
        Card card06 = new Card("6222081502001312390","88888888");
        cards05.add(card06);
        
        ArrayList<Card> cards06 = new ArrayList<Card>(); // 张无忌一个账户的卡
        Card card07 = new Card("6222081502001312399","88888888");
        Card card08 = new Card("6222081502001312400","88888888");
        cards06.add(card07);
        cards06.add(card08);
        
        ArrayList<Card> cards07 = new ArrayList<Card>(); // 韦小宝一个账户的卡
        Card card09 = new Card("6222081502051320785","88888888");
        cards07.add(card09);
        
        ArrayList<Card> cards08 = new ArrayList<Card>(); // 韦小宝一个账户的卡
        Card card10 = new Card("6222081502051320786","88888888");
        cards08.add(card10);
                
        ArrayList<Account> accounts01 = new ArrayList<Account>(); // 杨过的账户
        Account account01 = new Account(cards01, bank01); // 杨过的建行账户一卡
        Account account02 = new Account(cards02, bank01); // 杨过的建行账户二卡
        accounts01.add(account01);
        accounts01.add(account02);
        
        ArrayList<Account> accounts02 = new ArrayList<Account>(); // 郭靖的账户
        Account account03 = new Account(cards03, bank01); // 郭靖的建行账户一卡
        accounts02.add(account03);
        
        ArrayList<Account> accounts03 = new ArrayList<Account>(); // 张无忌的账户
        Account account04 = new Account(cards04, bank02); // 张无忌的建行账户一卡
        Account account05 = new Account(cards05, bank02); // 张无忌的建行账户二卡
        Account account06 = new Account(cards06, bank02); // 张无忌的建行账户三卡
        accounts03.add(account04);
        accounts03.add(account05);
        accounts03.add(account06);
        
        ArrayList<Account> accounts04 = new ArrayList<Account>(); // 韦小宝的账户
        Account account07 = new Account(cards07, bank02);
        Account account08 = new Account(cards08, bank02);
        accounts04.add(account07);
        accounts04.add(account08);
        
        ArrayList<User> users = new ArrayList<User>();
        User user01 = new User("杨过", accounts01); // 初始化杨过的信息
        users.add(user01);
        User user02 = new User("郭靖", accounts02); // 初始化郭靖
        users.add(user02);
        User user03 = new User("张无忌", accounts03); // 初始化张无忌
        users.add(user03);
        User user04 = new User("韦小宝", accounts04); // 初始化韦小宝
        users.add(user04);
        
        return users;
    }
    
    public ArrayList<CreditUser> info1(){
        
        
        ArrayList<ATM> atmNum01 = new ArrayList<ATM>(); // 建行ATM
        ATM atm01 = new ATM("01");
        ATM atm02 = new ATM("02");
        ATM atm03 = new ATM("03");
        ATM atm04 = new ATM("04");
        atmNum01.add(atm01);
        atmNum01.add(atm02);
        atmNum01.add(atm03);
        atmNum01.add(atm04);

        ArrayList<ATM> atmNum02 = new ArrayList<ATM>(); // 工行ATM
        ATM atm05 = new ATM("05");
        ATM atm06 = new ATM("06");
        atmNum02.add(atm05);
        atmNum02.add(atm06);
        
        ArrayList<ATM> atmNum03 = new ArrayList<ATM>(); // 农行ATM
        ATM atm07 = new ATM("07");
        ATM atm08 = new ATM("08");
        ATM atm09 = new ATM("09");
        ATM atm10 = new ATM("10");
        ATM atm11 = new ATM("11");
        atmNum03.add(atm07);
        atmNum03.add(atm08);
        atmNum03.add(atm09);
        atmNum03.add(atm10);
        atmNum03.add(atm11);
        
        Bank bank01 = new Bank("中国建设银行", atmNum01, 0.02); // 两个银行的初始化
        Bank bank02 = new Bank("中国工商银行", atmNum02, 0.03);
        Bank bank03 = new Bank("中国农商银行", atmNum03, 0.04);

        ArrayList<Card> cards09 = new ArrayList<Card>(); // 张三丰的卡们
        Card card11 = new Card("6640000010045442002", "88888888");
        Card card12 = new Card("6640000010045442003", "88888888");
        cards09.add(card11);
        cards09.add(card12);
        
        ArrayList<Card> cards10 = new ArrayList<Card>(); // 令狐冲的卡
        Card card13 = new Card("6640000010045441009", "88888888");
        
        ArrayList<Card> cards11 = new ArrayList<Card>();
        Card card14 = new Card("6630000010033431001", "88888888");
        cards11.add(card14);
        
        ArrayList<Card> cards12 = new ArrayList<Card>();
        Card card15 = new Card("6630000010033431008", "88888888");
        cards12.add(card15);
        
        
        ArrayList<CreditAccount> accounts05 = new ArrayList<CreditAccount>(); // 张三丰
        CreditAccount account09 = new CreditAccount(cards09, bank01);
        accounts05.add(account09);
        
        ArrayList<CreditAccount> accounts06 = new ArrayList<CreditAccount>(); // 令狐冲
        CreditAccount account10 = new CreditAccount(cards10, bank02);
        accounts06.add(account10);
        
        ArrayList<CreditAccount> accounts07 = new ArrayList<CreditAccount>(); // 乔峰
        CreditAccount account11 = new CreditAccount(cards11, bank03);
        accounts07.add(account11);
        
        ArrayList<CreditAccount> accounts08 = new ArrayList<CreditAccount>(); // 洪七公
        CreditAccount account12 = new CreditAccount(cards12, bank03);
        accounts08.add(account12);
        
        ArrayList<CreditUser> users = new ArrayList<CreditUser>();
        CreditUser user05 = new CreditUser("张三丰", accounts05);
        CreditUser user06 = new CreditUser("令狐冲", accounts06);
        CreditUser user07 = new CreditUser("乔峰", accounts07);
        CreditUser user08 = new CreditUser("洪七公", accounts08);
        users.add(user05);
        users.add(user06);
        users.add(user07);
        users.add(user08);
        
        return users;

    }
}

class Check1 { // 检查借记账户输入的正确性
    User users = new User();
    private String cardID;
    private String password;
    private String atmNum;
    private double balance;
    View v = new View();

    
    public Check1() {
        super();
        // TODO 自动生成的构造函数存根
    }
    
    public Check1(User users, String cardID, String password, String atmNum, double balance) {
        super();
        this.users = users;
        this.cardID = cardID;
        this.password = password;
        this.atmNum = atmNum;
        this.balance = balance;
    }
    
    public boolean check() {
        int flag = 0;
        int i = 0;
        int userNum = 0;
        int j = 0;
        int accoNum = 0;
        int k = 0;
        int cardNum = 0;
        
        for(i = 0; j < users.getAccounts().size(); j ++){
            for(j = 0; j < users.getAccounts().get(i).getCards().size(); j ++) {
                if (cardID.equals(users.getAccounts().get(i).getCards().get(j).getCardID())){
                    flag=1;
                    userNum = i; // 定位
                    accoNum = j;
                    break;
                }
            }

        }

        if(flag == 1) { // 检查密码
            if(password.equals(users.getAccounts().get(accoNum).getCards().get(cardNum).getPassword())) {
                flag = 2;
            } else {
                v.passwordWrong();
                return false;
            }
        } else {
            v.cardWrong();
            return false;
        }
        
        if(flag == 2) { // 检查ATM
            if(atmNum.matches("([0][1-9])|([1][0-1])")) {
                flag = 3;
            }
        }
        
        if(flag == 3) {
            flag = 4;
        } else {
            v.ATMWrong();
            return false;
        }
        
        if(flag == 4) { // 检查是否可取钱
            if(balance > users.getAccounts().get(accoNum).getMoney()) {
                return false;
            } else {
                return true;
            }
        } else {
            v.balanceWrong();
            return false;
        }
    }
    
    public int crossWhitchBank(int bankNum, String atmNum) {
        if (bankNum == 0&& atmNum.matches("0[1-4]")) {
            return 1; // 建行
            
        } else if (bankNum == 1 && atmNum.matches("[0][56]")) {
            return 2; // 工行
            
        } else if (bankNum == 2 && atmNum.matches("([0][789])|([1][01])")) {
            return 3; // 农行
            
        } else {
            return 0; // 非跨银行
        }
    }
    
    
}

class View {
    public View() {
        super();
        // TODO 自动生成的构造函数存根
    }

    // 错误输出汇总
    public void cardWrong() {
        System.out.println("Sorry,this card does not exist.");        
    }
    
    public void ATMWrong() {
        System.out.println("Sorry,the ATM's id is wrong.");
    }
    
    public void passwordWrong() {
        System.out.println("Sorry,your password is wrong.");
    }
    
    public void balanceWrong() {
        System.out.println("Sorry,your account balance is insufficient.");
    }
    
    // 正确输出
    public void rightTakeOutput(String userName, String bankName, String atmNum, double takeMoney) { // 取钱的输出
        System.out.print(userName + "在" + bankName + "的" + atmNum + "号ATM机上取款¥");
        System.out.printf("%.2f", takeMoney);
        System.out.println();
    }
    
    public void rightAddOutput(String userName, String bankName, String atmNum, double addMoney) { // 存钱的输出
        System.out.print(userName + "在" + bankName + "的" + atmNum + "号ATM机上存款¥");
        System.out.printf("%.2f", addMoney);
        System.out.println();

    }
    
    public void showBalance(double allMoney) {
        System.out.printf("当前余额为¥%.2f", allMoney);
        System.out.println();
    }
    
    public void onlyShowBalance(double allMoney) {
        System.out.printf("¥%.2f", allMoney);
        System.out.println();
    }
}

class DealData {
    StringBuilder sb = new StringBuilder();
    AllUsers all = new AllUsers();
    
    public DealData() {
        super();
        // TODO 自动生成的构造函数存根
    }

    public DealData(StringBuilder sb) {
        super();
        this.sb = sb;
    }

    public StringBuilder getSb() {
        return sb;
    }

    public void setSb(StringBuilder sb) {
        this.sb = sb;
    }
    
    public void input() {
        Scanner in = new Scanner(System.in);
        String allInput = "";
        allInput = in.nextLine();
        while(!allInput.equals("#")) {
            sb.append(allInput);
            sb.append("\n");
            allInput = in.nextLine();
            
        }
    }
    
    public String[] lines() {
        input();
        String[] lines = sb.toString().split("\n"); // 输入数据分行分割
        return lines;
    }
    
    public String[] datas(String line) {
        String[] datas = line.split("\\s+");
        if(datas.length >= 1) { // 如果长度正确则返回分割后的数组, 否则返回空
            return datas;            
        }
        return null;
    }
    
    public void play() {
        ArrayList<User> users = all.info();
        View v = new View();
        input();
        String[] lines = lines();
        
        for(int i = 0; i < lines.length; i ++) {
            String[] datas = datas(lines[i]);
            if(datas.length == 4) {
                double money = Double.parseDouble(datas[3]);
                for(int j = 0; j < users.size(); j ++) {
                    for(int k = 0; k < users.get(j).getAccounts().size(); k ++) {
                        Check1 check = new Check1(users.get(j), datas[0], datas[1], datas[2], money);
                        check.check();
                        if(check.check()) {
                            if(check.crossWhitchBank(k, datas[3]) == 0) { // 非跨行
                                        users.get(i).getAccounts().get(j).changeMoney(money);
                                        if(money > 0) {
                                            v.rightTakeOutput(users.get(i).getName(),
                                                    users.get(i).getAccounts().get(j).getBank().getBankName(),
                                                    datas[2], money);
                                            v.showBalance(users.get(i).getAccounts().get(j).getMoney());
                                        } else {
                                            v.rightAddOutput(users.get(i).getName(),
                                                    users.get(i).getAccounts().get(j).getBank().getBankName(),
                                                    datas[2], 0-money);
                                            v.showBalance(users.get(i).getAccounts().get(j).getMoney());
                            v.rightTakeOutput(users.get(j).getName(), users.get(j).getAccounts().get(k).getBank().getBankName(), datas[2], money);
                                        }                        
                            }
                        }
                    }
                }
            }
        }
}



public class Main {

    public static void main(String[] args) {
        DealData d = new DealData();
        d.play();
    }
}
}

　　这题一直在修改，到现在也还有点问题，不能保证正确。前前后后重新写了三次，我觉得自己写的太复杂了，不能完全掌握这题。先放上类图和sourceMonitor：

 

sourceMonitor：

 

类图：

 

总结：

　　这三次的题目集做的并不是很好，与其他人相比有很大差距。记忆犹新的是第六次作业7-5 在结束的前一秒上交的，但是是不完整的。当时如果再有半个小时就可以写完，这是时间安排上的问题，由于上周没有飞机仪表项目的检查，而我却把时间更多地放在了飞机仪表项目上，导致时间上没有安排好，这是我吸取的教训之一。另外就是在写代码之前一定要先设计好、想清楚，而且设计好之后尽量不要更改，按照设计的来。在两题ATM机的题目里，我重写的次数是六次，这是对时间的最大程度的浪费，在写代码时发现这个属性放这会更好，比如money我一开始放在了Card类里，但这是不对的。因为一个账户里可以有很多张卡，但一个账户里的钱是所有卡通用的。这也与我的常识认知有关，我习惯性地认为钱是在银行卡里的，所以不假思索地将money放在了Card里。经过讨论和仔细读题我才最终确定我错了。另一个就是Bank类，我一直在修改Bank类里的属性，首先ATM是有的，但是Account和User我不知道要不要或者说有无必要放入Bank类里，这里也是一直在修改的地方。这种修改导致的牵一发而动全身最终带来的结果是重写。现在想来还有后怕，我因为这种问题浪费了很多时间，也最终导致我没有写完，这真是非常要命的，无论是对心理还是生理。会出现这些问题也说明我的能力不足，对面向对象的设计不到位。警钟长鸣，我会吸取这惨痛的教训，放到未来。