1001-----homework------version third

package com.kai.li.message;

import com.kai.li.abc.ATMABC;

/**
  *本类定义所有界面输出内容
  *分为6个内部类
  *依次是主界面，开户界面，查询界面，存款界面，取款界面，退出界面
  */
public class ShowView{
    public static class Main{                            
        public static void display(){
            System.out.println("银行自助终端系统"); 
            System.out.println("****************************");
            System.out.println("0.------开户");
            System.out.println("1.------查询");
            System.out.println("2.------存款");
              System.out.println("3.------取款");
            System.out.println("4.------退出");
             System.out.println("****************************");
        }
        public static void showSelect(){
            System.out.println("请选择你要执行的功能：");
        }
        public static void showReset(){
            System.out.println("您选择的菜单不存在");
            System.out.println("请重新选择：");
            showSelect();
        }
    }
    public static class OpenAccount{                        
        public static void display(){
            System.out.println("****************************");
            System.out.println("您选择的为开户功能");
            showInputName();
        }
        public static void showInputName(){
            System.out.println("请输入您的姓名：");
        }
        public static void showInputId(){
            System.out.println("请输入您的身份证号：");
        }
        public static void showResetId(){
            System.out.println("您输入的身份证号格式不正确，请重新输入");
            showInputId();
        }
        public static void showInputPassword(){
            System.out.println("请输入您的密码：");
        }
        public static void showResetPassword(){
            System.out.println("您输入的密码格式不正确，请重新输入");
            showInputPassword();
        }
        public static void showSuccess(){
            System.out.println("开户成功，谢谢使用！");
        }
    }
    public static class Query{
        public static void display(){
            System.out.println("****************************");
            System.out.println("您选择的为查询功能");
            showQueryCardNumber();
        }
        public static void showQueryCardNumber(){
            System.out.println("请输入您要查询的卡号：");
        }
        public static void showResetCardNumber(){
            System.out.println("您输入的卡号不存在，请重新输入");
            showQueryCardNumber();
        }
        public static void showInputPassword(){
            System.out.println("请输入您的密码：");
        }
        public static void showResetPassword(){
            System.out.println("您输入的密码格式不正确，请重新输入");
            showInputPassword();
        }
        public static void showCardInfo(){
            System.out.println("您查询的账号信息为：");
            System.out.println("****************************");
        }
        public static void showCardMessage(ATMABC atmABC){
            System.out.println(atmABC.card);
            System.out.println("友情提示：您的账户余额为"+atmABC.checkBalance()+"元");
        }
    }
    public static class Deposit{
        public static void display(){
            System.out.println("****************************");
            System.out.println("您选择的为存款功能");
            showDepositCardNumber();
        }
        public static void showDepositCardNumber(){
            System.out.println("请输入您要存款的卡号：");
        }
        public static void showResetCardNumber(){
            System.out.println("您输入的卡号不存在，请重新输入");
            showDepositCardNumber();
        }
        public static void showInputPassword(){
            System.out.println("请输入您的密码：");
        }
        public static void showResetPassword(){
            System.out.println("您输入的密码格式不正确，请重新输入");
            showInputPassword();
        }
        public static void showCardInfo(){
            System.out.println("您要存款的账号信息为：");
            System.out.println("****************************");
        }
        public static void showDepositMoney(){
            System.out.println("请输入您要存款的金额：");
        }
        public static void showError(){
            System.out.println("您输入的金额无效，系统将自动进入主界面");
        }
        public static void showSuccess(){
            System.out.println("存款成功，谢谢使用！");
        }
    }
    public static class Withdrawal{
        public static void display(){
            System.out.println("****************************");
            System.out.println("您选择的为取款功能");
            showWithdrawalCardNumber();
        }
        public static void showWithdrawalCardNumber(){
            System.out.println("请输入您要取款的卡号：");
        }
        public static void showResetCardNumber(){
            System.out.println("您输入的卡号不存在，请重新输入");
            showWithdrawalCardNumber();
        }
        public static void showInputPassword(){
            System.out.println("请输入您的密码：");
        }
        public static void showResetPassword(){
            System.out.println("您输入的密码格式不正确，请重新输入");
            showInputPassword();
        }
        public static void showCardInfo(){
            System.out.println("您要取款的账号信息为：");
            System.out.println("****************************");
        }
        public static void showWithdrawalMoney(){
            System.out.println("请输入您要取款的金额：");
        }
        public static void showError(){
            System.out.println("您输入的金额无效，系统将自动进入主界面");
        }
        public static void showSuccess(){
            System.out.println("取款成功，谢谢使用！");
        }
    }
    public static class Exit{
        public static void exit(){
            System.out.println("系统已成功推出，谢谢使用！");
        }
    }
}

package com.kai.li.myutils;

/**
  *本类为检查用户输入的数据是否合法的类
  *可以检查的内容为：
  *身份证号，密码，卡号，金额
  */
public class Check{
    
    public static boolean checkId(String id){                        //检测输入身份证合法性
        if(id.length()==18 && id.matches("[0-9]+"))
            return true;
        return false;
    }
    public static boolean checkPassword(String password){            //检测输入密码合法性
        if(password.trim().length()==6)
            return true;
        return false;
    }
    public static boolean checkCardNumber(String cardNumber){        //检测输入卡号合法性
        if(cardNumber.length()==8 && cardNumber.matches("[0-9]+"))
            return true;
        return false;
    }
    
    public static boolean checkMoney(String money){                    //检测输入金额合法性
        if(money.matches("^[0-9]+(.[0-9]+)") && Double.parseDouble(money.trim())>=0)
            return true;
        return false;
    }
}

package com.kai.li.myutils;

import java.util.Scanner;

/**
  *用户输入类
  *用来接收用户的各种输入值
  *包括界面选择的数值，姓名，身份证号，密码，金额，银行卡号
  */
public class MyScanner{
    
    @SuppressWarnings("resource")
    public static String getValue(){            //获取用户输入值的通用方法
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        return str;
    }
    public static String getViewNumber(){        //获取用户输入的数值，用于选择需要进入的界面
        return getValue();
    }
    public static String getName(){                //获取用户输入的姓名
        return getValue();
    }
    public static String getId(){                //获取用户输入的身份证号
        return getValue();
    }
    public static String getPassword(){            //获取用户输入的密码
        return getValue();
    }
    public static String getMoney(){            //获取用户输入的金额
        return getValue();
    }
    public static String getCardNumber(){        //获取用户输入的银行卡号
        return getValue();
    }

}

package com.kai.li.myutils;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import com.kai.li.abc.DepositCard;

/**
  *define functions myself
  *@author caw lid
  */
public class MyUtils{

    /*read string from file contents*/
    public static String readFileContents(String filename)throws IOException{    
        File file = new File(filename);
        InputStream in = new FileInputStream(file);
        int i = -1;
        byte[] str = new byte[1024];
        String strs = "";
        while((i = in.read(str)) != -1){
            strs = new String(str,0,i);
        }    
        in.close();
        return strs;
    }
    
    /*write string to a file*/
    public static void writeToFile(String filename,String contents)throws IOException{
        File file = new File(filename);
        if(!file.exists())
            file.createNewFile();
        OutputStream out = new FileOutputStream(file,true);
        String str = contents;
        out.write(str.getBytes());
        out.close();
    }
    
    /*read an object from a textfile*/
    @SuppressWarnings("unchecked")
    public static List<DepositCard> readObject(String filename)throws Exception{
        File file = new File(filename);
        List<DepositCard> listCard = new ArrayList<>();
        if(file.exists()){
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));    
            listCard = (List<DepositCard>)ois.readObject();
            ois.close();
            return listCard;
        }
        return null;
    }
    
    /*write an object to a textfile*/
    public static void writeObject(String filename,List<DepositCard> card)throws IOException{
        File file = new File(filename);
        if(!file.exists())
            file.createNewFile();
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
        oos.writeObject(card);
        oos.close();
    }
    
    /*get a number as String and assign the length*/
    public static String getStringNumber(int length){
        String str = "";
        Random random = new Random();
        for(int i = 0;i < length;i ++){
            int num = random.nextInt(10);
            str +=num; 
        }
        return str;
    }
}

package com.kai.li.model;

import com.kai.li.abc.ATMABC;
import com.kai.li.view.DepositView;
import com.kai.li.view.MainView;
import com.kai.li.view.OpenAccountView;
import com.kai.li.view.QueryView;
import com.kai.li.message.ShowView;
import com.kai.li.view.WithdrawalView;

/**
  *主界面控制器类
  *接收用户输入数值
  *根据用户输入，判断需要启动的相应界面视图
  */
public class MainModel{

    ATMABC atmABC;

    public MainModel(ATMABC atmABC){
        this.atmABC = atmABC;
    }

    /*方法实现区*/
    /*根据用户输入，选择进入相应界面视图*/
    public void selectView(String number){                //传入用户输入的命令参数
        switch(number){                                    //switch接收传入参数
            case "0":
                new OpenAccountView(atmABC);            //选择0时，实例化开户界面对象，进入开户界面
                break;
            case "1":
                new QueryView(atmABC);                    //选择1时，实例化查询界面对象，进入查询界面
                break;
            case "2":
                new DepositView(atmABC);                //选择2时，实例化存款界面对象，进入存款界面
                break;
            case "3":
                new WithdrawalView(atmABC);                //选择3时，实例化取款界面对象，进入取款界面
                break;
            case "4":
                ShowView.Exit.exit();                    //选择4时，显示退出提示信息
                System.exit(1);                            //退出系统
                break;
            default:
                ShowView.Main.showReset();                //输入不合法时，显示输入不正确的提示信息
                new MainView(atmABC);                    //实例化主界面对象，重新启动主界面视图
                break;
        }        
    }
}

package com.kai.li.model;

import static com.kai.li.myutils.MyUtils.readObject;
import static com.kai.li.myutils.MyUtils.writeObject;
import java.io.File;
import java.util.List;
import com.kai.li.abc.DepositCard;
import com.kai.li.view.MainView;
import com.kai.li.abc.ATMABC;
import com.kai.li.message.ShowView.Query;

/**
  *本类为开户控制器类
  *本类功能为保存视图类接收的用户输入数据
  *将数据保存到card变量
  *将card变量添加到abcbank的集合中去
  *给通用模型的方法传递数据让其保存到文件
  */
public class CommonModel{

    /*成员属性定义区*/
    ATMABC atmABC;                                //定义ATM机对象
    String filename;

    /*构造方法区*/
    /*无参构造方法*/
    public CommonModel(ATMABC atmABC){    
        initialize(atmABC);                        //初始化成员变量
        //从文件读取读取农业银行的所有账户信息到ATM机的成员属性
        readInfoFromFile(filename);    
    }

    /*方法实现区*/
    
    /*初始化成员变量*/
    public void initialize(ATMABC atmABC){
        this.atmABC = atmABC;                    //传入ATM机对象赋值
        filename = "d:"+File.separator+"abcdepositcard.txt";
    }
    
    /*开户相关方法区*/
    /*保存姓名到card对象中*/
    public void saveName(String name){            //传递姓名参数
        atmABC.card.setName(name);                //调用card的方法保存姓名
    }
    /*保存身份证号到card对象中*/
    public void saveId(String id){                //传递身份证号参数
        atmABC.card.setId(id);                    //调用card的方法保存身份证号
    }
    /*保存密码到card对象中*/
    public void savePassword(String password){    //传递密码参数
        atmABC.card.setPassword(password);        //调用card的方法保存密码
    }
    /*开户并保存数据到文件*/
    public void openAccount(){
        //调用ATM机方法进行开户
        atmABC.openAccount(atmABC.card.getName(),atmABC.card.getId(),atmABC.card.getPassword());
        //重新初始化用于保存临时储蓄卡账户的变量card
        atmABC.card = new DepositCard();
        //调用自身的方法将数据写入文件    
        saveToFile(filename,atmABC.getListCard());        
    }
    
    /*检查卡号密码，输出账号信息共3个方法*/
    /*检查卡号是否存在*/
    public boolean checkCardNumber(String cardNumber){
        for(DepositCard depositCard:atmABC.getListCard()){
            if(cardNumber.equals(depositCard.getCardNumber())){
                atmABC.card = depositCard;
                return true;
            }
        }
        return false;
    }
    /*检查密码是否正确*/
    public boolean checkPassword(String password){
        if(password.equals(atmABC.card.getPassword()))
            return true;
        return false;
    }
    /*输出账户信息，atm中的card以及card余额单独显示的信息*/
    public void showCardInfo(){
        Query.showCardMessage(this.atmABC);
    }
    
    /*存款，取款方法*/
    /*存款方法*/
    public void deposit(double money){
        for(DepositCard depositCard:atmABC.getBank().getListCard()){
            if(atmABC.card.equals(depositCard)){
                atmABC.deposit(money);
                depositCard = atmABC.card;
                break;
            }
        }
        //调用通用模型类的方法将数据写入文件
        saveToFile(filename,atmABC.getListCard());    
        new MainView(atmABC);
    }
    /*取款方法*/
    public void withdrawal(double money){
        for(DepositCard depositCard:atmABC.getListCard()){
            if(atmABC.card.equals(depositCard)){
                atmABC.withdrawal(money);
                depositCard = atmABC.card;
                break;
            }
        }
        //调用通用模型类的方法将数据写入文件
        saveToFile(filename,atmABC.getListCard());    
        new MainView(atmABC);
    }
    
    /*保存，读取文件数据，共3个方法*/
    /*保存数据到文件，覆盖而不追加*/
    public void saveToFile(String filename,List<DepositCard> listCard){
        try{
            writeObject(filename,listCard);
        }catch(Exception e){
            e.printStackTrace();
        }    
    }
    /*读取文件内容到指定容器listCard*/
    public void readInfoFromFile(String filename){
        try{
            atmABC.getBank().setListCard(readObject(filename));
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

package com.kai.li.client;

import com.kai.li.abc.ATMABC;
import com.kai.li.view.MainView;

/**
  *定义客户端的类
  *本类功能为启动主界面
  */
public class Client{
    public static void main(String[] args){        //main方法，程序入口，实例化一个农业银行的ATM对象，
        ATMABC atmABC = new ATMABC();            //为保证始终一台ATM机，需要进行参数传递
        new MainView(atmABC);                    //启动ATM机的主界面视图                
    }
}

package com.kai.li.view;

import static com.kai.li.myutils.MyScanner.*;
import com.kai.li.abc.ATMABC;
import com.kai.li.message.ShowView;
import com.kai.li.model.MainModel;

/**
  *本类为主界面视图类
  *本类传入主界面控制器对象
  *本类功能为：界面视图的输出，用户输入，根据用户选择调用控制器的方法进入相应界面
  */
public class MainView{

    /*构造方法区*/
    /*无参构造方法*/
    public MainView(ATMABC atmABC){
        this.display()                                            //显示主界面并给出提示
            .selectView(getViewNumber(),new MainModel(atmABC));    //进入用户选择的视图界面    
    }

    /*方法实现区*/
    /*选择视图界面的方法，需要传入两个参数，一个是用户输入的选择命令，一个是主界面控制器对象*/
    public MainView selectView(String number,MainModel mainController){
        mainController.selectView(number);                        //调用主界面控制器对象的视图界面选择方法
        return this;
    }
    /*显示主界面视图的方法*/
    public MainView display(){
        ShowView.Main.display();                                //显示本界面的主视图
        ShowView.Main.showSelect();                                //显示让用户输入命令的提示信息
        return this;
    }
}

package com.kai.li.view;


/*initialize(atmABC);                                //初始化成员属性

display();                                            //显示本界面的主视图并提示用户输入姓名

checkName(getName());                                //根据用户输入的姓名给出相应提示

checkId(getId());                                    //根据用户输入的身份证号给出相应提示
    
checkPassword(getPassword());*/                        //根据用户输入的密码给出相应提示

import static com.kai.li.myutils.MyScanner.*;
import com.kai.li.abc.ATMABC;
import com.kai.li.model.CommonModel;
import com.kai.li.myutils.Check;
import static com.kai.li.message.ShowView.*;

/**
  *本类为开户界面类
  *本类持有一个对象变量，为通用控制器类的实例对象
  *本类通过调用Check类进行数值合法性判断
  *本类功能有四个
  *1 输出界面信息
  *2 接收用户输入的数据
  *3 根据接收数据给出相应提示
  *4 将合法数值传递给控制器类中的方法进行保存
  */
/***
 * 
 * @author Administrator
 *
 */
public class OpenAccountView{

    /*成员属性定义区*/
    CommonModel commonController;                            //定义通用控制器类
    ATMABC atmABC;                                            //定义ATM机对象
    
    /*构造方法区*/
    /*无参构造方法*/
    /***
     * 
     * @param atmABC
     */
    public OpenAccountView(ATMABC atmABC){
            
        this.initialize(atmABC)                                //初始化成员属性
            .display()                                        //显示本界面的主视图并提示用户输入姓名
            .checkName(getName())                            //根据用户输入的姓名给出相应提示
            .checkId(getId())                                //根据用户输入的身份证号给出相应提示
            .checkPassword(getPassword());                    //根据用户输入的密码给出相应提示        
    }        

    /*方法实现区*/
    /*初始化成员变量*/
    public OpenAccountView initialize(ATMABC atmABC){
        commonController = new CommonModel(atmABC);            //初始化开户控制器对象
        this.atmABC = atmABC;                                //传入ATM机对象赋值
        return this;
    }
    /*显示视图*/
    public OpenAccountView display(){
        OpenAccount.display();                                //显示本界面的主视图并提示用户输入姓名
        return this;
    }
    /*根据用户输入姓名给出相应提示*/
    public OpenAccountView checkName(String name){            //接收用户输入姓名参数
        commonController.saveName(name);                    //调用控制器方法保存姓名信息
        OpenAccount.showInputId();                            //提示用户输入身份证号
        return this;
    }
    /*根据用户输入身份证号给出相应提示*/
    public OpenAccountView checkId(String id){                //接收用户输入身份证号
        if(!Check.checkId(id)){                                //检查用户输入的身份证号合法性
            OpenAccount.showResetId();                        //不合法时输出格式不正确的提示信息
            checkId(getId());                                //不合法时递归调用自身，重新验证用户身份证号输入
        }else{
            OpenAccount.showInputPassword();                //合法时提示用户输入密码    
            commonController.saveId(id);                    //合法时调用控制器方法保存用户身份证号            
        }
        return this;
    }
    /*根据用户输入密码给出相应提示*/
    public OpenAccountView checkPassword(String password){    //接收用户输入密码
        if(!Check.checkPassword(password)){                    //检查用户输入密码的合法性
            OpenAccount.showResetPassword();                //不合法时输出格式不正确的提示信息
            checkPassword(getPassword());                    //不合法时递归调用自身，重新验证用户密码输入
        }else{
            OpenAccount.showSuccess();                        //合法时输出开户成功信息的提示
            commonController.savePassword(password);        //合法时调用控制器方法保存用户密码
            commonController.openAccount();                    //合法时通知控制器开户并将数据进行保存
            new MainView(atmABC);                            //合法时实例化主界面对象回到主界面
        }
        return this;
    }
}

package com.kai.li.view;

import static com.kai.li.myutils.MyScanner.*;
import com.kai.li.myutils.Check;
import com.kai.li.abc.ATMABC;
import com.kai.li.message.ShowView;
import com.kai.li.model.CommonModel;

/*****/
public class QueryView{

    ATMABC atmABC;    
    CommonModel commonController;

    public QueryView(ATMABC atmABC){
        
        this.initialize(atmABC)                                  //初始化成员变量
       　　　.display()                                           //显示本界面的主视图并提示用户输入卡号
       　　  .checkCardNumber(getCardNumber())                    //根据用户输入的卡号给出相应提示
        　　 .checkPassword(getPassword());                       //根据用户输入密码给出相应提示
    }

    public QueryView initialize(ATMABC atmABC){
        this.atmABC = atmABC;                                //实例化同一台ATM机对象
        commonController = new CommonModel(atmABC);            //实例化控制器对象
        return this;
    }
    public QueryView display(){
        ShowView.Query.display();                            //显示本界面的主视图并提示用户输入卡号
        return this;
    }
    public QueryView checkCardNumber(String cardNumber){
        if(!Check.checkCardNumber(cardNumber) ||
            !commonController.checkCardNumber(cardNumber)){
            ShowView.Query.showResetCardNumber();
            checkCardNumber(getCardNumber());
        }else{
            ShowView.Query.showInputPassword();
        }
        return this;
    }
    public QueryView checkPassword(String password){
        if(!Check.checkPassword(password) ||
            !commonController.checkPassword(password)){
            ShowView.Query.showResetPassword();
            checkPassword(getPassword());
        }else{
            ShowView.Query.showCardInfo();
            commonController.showCardInfo();
            new MainView(atmABC);
        }
        return this;
    }
}

package com.kai.li.view;

import static com.kai.li.myutils.MyScanner.*;
import com.kai.li.abc.ATMABC;
import com.kai.li.message.ShowView;
import com.kai.li.model.CommonModel;
import com.kai.li.myutils.Check;

/*****/
public class DepositView{

    ATMABC atmABC;
    CommonModel commonController;
    
    public DepositView(ATMABC atmABC){
        
        this.initialize(atmABC)
            .display()
            .checkCardNumber(getCardNumber())            
            .checkPassword(getPassword())
            .checkMoney(getMoney());
    }

    public DepositView initialize(ATMABC atmABC){
        this.atmABC = atmABC;
        commonController = new CommonModel(atmABC);
        return this;
    }
    public DepositView display(){
        ShowView.Deposit.display();
        return this;
    }
    public DepositView checkCardNumber(String cardNumber){
        if(!Check.checkCardNumber(cardNumber) ||
                !commonController.checkCardNumber(cardNumber)){
            ShowView.Deposit.showResetCardNumber();
            checkCardNumber(getCardNumber());
        }else{
            ShowView.Deposit.showInputPassword();
        }
        return this;
    }
    public DepositView checkPassword(String password){
        if(!Check.checkPassword(password) ||
                !commonController.checkPassword(password)){
            ShowView.Deposit.showResetPassword();
            checkPassword(getPassword());
        }else{
            ShowView.Deposit.showCardInfo();
            commonController.showCardInfo();
            ShowView.Deposit.showDepositMoney();
        }
        return this;
    }
    public DepositView checkMoney(String money){
        if(!Check.checkMoney(money)){
            ShowView.Deposit.showError();
            checkMoney(getMoney());
        }else{
            ShowView.Deposit.showSuccess();
            commonController.deposit(Double.parseDouble(money.trim()));
            new MainView(atmABC);
        }
        return this;
    }
}

package com.kai.li.view;

import com.kai.li.myutils.Check;
import static com.kai.li.myutils.MyScanner.*;
import com.kai.li.abc.ATMABC;
import com.kai.li.message.ShowView;
import com.kai.li.model.CommonModel;

/****/
public class WithdrawalView{
    
    ATMABC atmABC;
    CommonModel commonController;
    
    public WithdrawalView(ATMABC atmABC){
        
        this.initialize(atmABC)
            .display()
            .checkCardNumber(getCardNumber())            
            .checkPassword(getPassword())
            .checkMoney(getMoney());
    }
    
    public WithdrawalView initialize(ATMABC atmABC){
        this.atmABC = atmABC;
        commonController = new CommonModel(atmABC);
        return this;
    }
    public WithdrawalView display(){
        ShowView.Withdrawal.display();
        return this;
    }
    public WithdrawalView checkCardNumber(String cardNumber){
        if(!Check.checkCardNumber(cardNumber) ||
            !commonController.checkCardNumber(cardNumber)){
            ShowView.Withdrawal.showResetCardNumber();
            checkCardNumber(getCardNumber());
        }else{
            ShowView.Withdrawal.showInputPassword();
        }
        return this;
    }
    public WithdrawalView checkPassword(String password){
        if(!Check.checkPassword(password) ||
            !commonController.checkPassword(password)){
            ShowView.Withdrawal.showResetPassword();
            checkPassword(getPassword());
        }else{
            ShowView.Withdrawal.showCardInfo();
            commonController.showCardInfo();
            ShowView.Withdrawal.showWithdrawalMoney();
        }
        return this;
    }
    public WithdrawalView checkMoney(String money){
        if(!Check.checkMoney(money)){
            ShowView.Withdrawal.showError();
            checkMoney(getMoney());
        }else{
            ShowView.Withdrawal.showSuccess();
            commonController.withdrawal(Double.parseDouble(money.trim()));
            new MainView(atmABC);
        }
        return this;
    }
}

package com.kai.li.unionpay;

import com.kai.li.abc.DepositCard;

/**
  *定义ATM机的抽象类
  *该类持有储蓄卡对象
  *调用储蓄卡对象的方法实现了自身的查询余额，存款，取款方法
  *该类定义了自己的抽象方法---开户
  */
public abstract class AATM{
    
    public DepositCard card;

    /*定义抽象方法---开户，具体实现由子类完成*/
    //抽象方法：定义开户功能
    public abstract boolean openAccount(String name,String id,String password);

    /*调用银行卡的查询余额方法，实现ATM机自身的查询余额方法*/
    public double checkBalance(){                    //方法：实现查询余额功能
        return card.getBalance();                    //调用card对象的查询余额方法
    } 

    /*调用银行卡的存款方法，实现ATM机自身的存款方法*/
    public boolean deposit(double money){            //方法：实现存款功能
        return card.deposit(money);                    //调用card对象的存款方法
        
    }
    
    /*调用银行卡的取款方法，实现ATM机自身的取款方法*/
    public boolean withdrawal(double money){        //方法：实现取款功能
        return card.withdrawal(money);                //调用card对象的取款方法
    }
}

package com.kai.li.unionpay;

/**
  *这是一个枚举类
  *该枚举类定义了四大行
  *需使用构造方法给四大行指定具体名称
  */
public enum EBank{

    /*通过构造方法定义四大行的枚举常量*/
    ABC("农业银行"),ICBC("工商银行"),CCB("建设银行"),BOC("中国银行");
    
    /*构造方法，可设置枚举常量的name属性*/
    private EBank(String name){                //构造方法：初始化name的值
        this.setName(name);
    }
    
    /*定义私有属性name，用来标识枚举常量*/
    private String name;                    //属性：通过构造方法完成赋值

    /*setter方法*/
    public void setName(String name){        //方法：可设置name属性的值
        this.name = name;
    }

    /*getter方法*/
    public String getName(){                //方法：可获取name属性的值
        return this.name;
    }
    
}

package com.kai.li.unionpay;

/**
  *定义银行卡接口
  *该接口包含三个抽象方法
  *1 查询余额
  *2 存款
  *3 取款
  *@author 
  *@version second
  */
public interface ICard{
    
    /*查询余额的抽象方法，该方法应当返回余额的具体数值*/
    double checkBalance();
    
    /*存款的抽象方法，该方法应当返回一个布尔值，成功为true,失败为false*/
    boolean deposit(double money);

    /*取款的抽象方法，该方法应当返回一个布尔值，成功为true,失败为false*/    
    boolean withdrawal(double money);

}

package com.kai.li.abc;

import com.kai.li.unionpay.EBank;
import com.kai.li.unionpay.AATM;
import static com.kai.li.myutils.MyUtils.getStringNumber;

import java.util.List;

/**
  *ATM机的实现类
  *本类为农业银行的ATM机类
  *本类继承自父类的方法有三个
  *三个方法是：查询余额，存款，取款
  *本类实现父类的抽象方法有一个
  *实现的抽象方法是：开户
  *本类成员属性有：银行类型
  *成员属性银行类型使用枚举类赋值
  */
public class ATMABC extends AATM{
    
    /**成员变量定义区**/
    private EBank type;                                //成员属性：定义发卡行名称
    private BankABC bank;                            //成员属性：定义农业银行对象

    /**构造方法定义区**/
    /*无参构造方法*/
    public ATMABC(){
        this.card = new DepositCard();                //初始化：父类继承过来的储蓄卡对象
        this.type = EBank.ABC;                        //初始化：枚举类给发卡行名称赋值
        this.bank = BankABC.getBankABC();            //初始化：单例模式初始化银行对象
    }

    /**Override方法区**/
    @Override
    /*重写父类抽象方法实现开户功能*/
    public boolean openAccount(String name,String id,String password){
        card = new DepositCard(name,id,password);    //根据传入参数实例化储蓄卡对象
        card.setType(this.type);                    //给储蓄卡对象设置发卡行
        card.setCardNumber(getStringNumber(8));     //给储蓄卡对象随机生成8位数卡号
        for(DepositCard card:bank.getListCard()){    //循环遍历农业银行所有的已开户账户
            if(this.card.equals(card))                //判断新生成储蓄卡对象是否在农业银行账户集合中存在
                return false;                        //如果存在，返回false
        }
        bank.getListCard().add(card);                //如果不存在，则将新开户账户加入到农业银行账户集合
        return true;                                //并且返回true
    }
    
    /*getter方法区*/
    public BankABC getBank(){                        //获取农业银行的对象
        return bank;
    }
    public EBank getType(){                            //获取ATM机的银行类型属性
        return type;
    }
    public List<DepositCard> getListCard(){            //获取农业银行账户集合
        return bank.getListCard();
    }
}

package com.kai.li.abc;

import java.util.List;
import java.util.ArrayList;
import com.kai.li.unionpay.EBank;

/**
  *定义农业银行的类
  *该类构造方法私有，使用单例模式定义
  *属性包括银行类型，银行名称，银行卡列表
  *其中银行类型以枚举定义，银行名称使用枚举类的name属性赋值
  *银行卡使用集合list保存
  *本类不设置setter方法
  */
public class BankABC{

    /**
       *变量定义区
      *定义了自身实例变量bank并设置为私有静态常量
      *@see type 定义了枚举类型的变量type，用来保存银行类型
      *@see name 定义了变量name，用来保存该类型银行的名称
      *@see listCard 定义了变量集合listCard，用来保存开户的银行卡
      */
    private static final BankABC bank = new BankABC();    //定义自身对象的唯一实例
    
    private EBank type;                                    //定义银行类型
    private String name;                                //定义银行名称
    private List<DepositCard> listCard;                    //定义保存银行卡账户集合

    public void setListCard(List<DepositCard> listCard) {
        this.listCard = listCard;
    }

    /*私有化的构造方法*/
    private BankABC(){
        type = EBank.ABC;                                //使用枚举类型初始化银行类型
        name = type.getName();                            //使用枚举类型的属性初始化银行名称
        listCard = new ArrayList<DepositCard>();        //使用List接口的实现类ArrayList初始化银行卡账户集合
    }

    /*getter方法区*/
    public static BankABC getBankABC(){                    //定义静态工厂方法取得自身实例
        return bank;
    }
    public EBank getEBank(){                            //获取私有属性银行类型的值
        return type;
    }
    public String getName(){                            //获取私有属性银行名称的值
        return name;
    }
    public List<DepositCard> getListCard(){                //获取私有属性银行卡账户集合的值
        return listCard;
    }
}

package com.kai.li.abc;

import java.io.Serializable;
import com.kai.li.unionpay.EBank;
import com.kai.li.unionpay.ICard;

/**
  *储蓄卡类
  *该类继承自ICard接口
  *该类拥有属性银行类型，姓名，身份证号，卡号，密码，余额
  *该类实现接口中的三个方法，查询余额，存款，取款
  *银行卡类型将由ATM机所属银行设置
  */
public class DepositCard implements ICard,Serializable{
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;//软件提示加的，等下查查什么意思
    /*变量定义区*/
    private EBank type;                            //变量：定义发卡行
    private String name;                        //变量：定义储蓄卡持有人姓名
    private String id;                            //变量：定义身份证号
    private String cardNumber;                    //变量：定义卡号
    private String password;                    //变量：定义密码
    private double balance;                        //变量：定义余额

    /*构造方法区*/
    public DepositCard(){                        //构造方法：无参构造方法
        this.type = null;                        //初始化：给发卡行赋值null
        this.cardNumber = null;                    //初始化：给卡号赋值null
        this.balance = 0.0;                        //初始化：给余额赋值0.0元
    }
    public DepositCard(String name,String id,String password){    //构造方法：三个参数的构造方法
        this();                                //调用：调用本类无参构造方法初始化成员变量
        this.name = name;                    //初始化：将构造方法接收的参数给name赋值
        this.id = id;                        //初始化：将构造方法接收的参数给id赋值
        this.password = password;            //初始化：将构造方法接收的参数给password赋值
    }

    /*setter方法区*/
    public void setType(EBank type){                //setter：设置发卡行
        this.type = type;
    }
    public void setName(String name){                //setter：设置姓名            
        this.name = name;                    
    }    
    public void setId(String id){                    //setter：设置身份证号
        this.id = id;
    }
    public void setCardNumber(String cardNumber){    //setter：设置卡号
        this.cardNumber = cardNumber;
    }
    public void setPassword(String password){        //setter：设置密码
        this.password = password;
    }
    public void setBalance(double balance){            //setter：设置余额
        this.balance = balance;
    }

    /*getter方法区*/
    public EBank getType(){                        //getter：获取发卡行
        return type;    
    }
    public String getName(){                    //getter：获取持卡人姓名
        return name;
    }
    public String getId(){                        //getter：获取身份证号
        return id;
    }
    public String getCardNumber(){                //getter：获取卡号
        return cardNumber;
    }
    public String getPassword(){                //getter：获取密码
        return password;
    }
    public double getBalance(){                    //getter：获取余额
        return balance;
    }

    /*重写方法区*/
    @Override
    public double checkBalance(){                //Override：查询余额
        return this.getBalance();                //return：调用getter方法返回成员属性balance
    }
    @Override
    public boolean deposit(double money){        //Override：存款
        this.balance += money;                    //赋值：将传入的money参数与balance相加后赋值
        return true;                            //return：存款成功返回true;
    }
    @Override
    public boolean withdrawal(double money){            //Override：取款
        if(money>this.balance)                    //判断传入的money是否合法
            return false;                        //return：不合法返回false
        this.balance -= money;                    //赋值：将传入的money参数与balance预算后赋值
        return true;                            //return：取款成功返回true            
    }
    @Override
    public String toString(){                    //Override：储蓄卡信息输出
        return "发卡行：" + getType() + "

"        
            + "姓名：" + getName() + "

"
            + "身份证号：" + getId() + "

"
            + "银行卡号：" + getCardNumber() + "

"
            + "密码："  + getPassword() + "

"
            + "余额：" + getBalance();
    }
}