1001-----homework------version second

最新推荐文章于 2024-10-30 18:07:32 发布

alexliu6711

最新推荐文章于 2024-10-30 18:07:32 发布

阅读量131

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/kaililikai/p/5936331.html

版权

 1 package com.kai.li.abc;
 2 
 3 import com.kai.li.unionpay.EBank;
 4 import com.kai.li.unionpay.AATM;
 5 import static com.kai.li.myutils.MyUtils.getStringNumber;
 6 
 7 /**
 8   *ATM机的实现类
 9   *本类为农业银行的ATM机类
10   *本类继承自父类的方法有三个
11   *三个方法是：查询余额，存款，取款
12   *本类实现父类的抽象方法有一个
13   *实现的抽象方法是：开户
14   *本类成员属性有：银行类型
15   *成员属性银行类型使用枚举类赋值
16   */
17 public class ATMABC extends AATM{
18     
19     /**成员变量定义区**/
20     private EBank type;                            //成员属性：定义发卡行名称
21     private BankABC bank;                        //成员属性：定义农业银行对象
22 
23     /**构造方法定义区**/
24     /*无参构造方法*/
25     public ATMABC(){
26         this.card = new DepositCard();            //初始化：父类继承过来的储蓄卡对象
27         this.type = EBank.ABC;                    //初始化：枚举类给发卡行名称赋值
28         this.bank = BankABC.getBankABC();        //初始化：单例模式初始化银行对象
29     }
30 
31     /**Override方法区**/
32     @Override
33     /*重写父类抽象方法实现开户功能*/
34     public boolean openAccount(String name,String id,String password){
35         card = new DepositCard(name,id,password);    //根据传入参数实例化储蓄卡对象
36         card.setType(this.type);                    //给储蓄卡对象设置发卡行
37         card.setCardNumber(getStringNumber(8));     //给储蓄卡对象随机生成8位数卡号
38         for(DepositCard card:bank.getListCard()){    //循环遍历农业银行所有的已开户账户
39             if(this.card.equals(card))                //判断新生成储蓄卡对象是否在农业银行账户集合中存在
40                 return false;                        //如果存在，返回false
41         }
42         bank.getListCard().add(card);                //如果不存在，则将新开户账户加入到农业银行账户集合
43         return true;                                //并且返回true
44         
45     }
46     
47     /*getter方法区*/
48     public BankABC getBank(){                        //获取农业银行的单例对象
49         return bank;
50     }
51     public EBank getType(){                            //获取ATM机的银行类型属性
52         return type;
53     }
54 }

 1 package com.kai.li.abc;
 2 
 3 import java.util.List;
 4 import java.util.ArrayList;
 5 import com.kai.li.unionpay.EBank;
 6 
 7 /**
 8   *定义农业银行的类
 9   *该类构造方法私有，使用单例模式定义
10   *属性包括银行类型，银行名称，银行卡列表
11   *其中银行类型以枚举定义，银行名称使用枚举类的name属性赋值
12   *银行卡使用集合list保存
13   *本类不设置setter方法
14   */
15 public class BankABC{
16 
17     /**
18        *变量定义区
19       *定义了自身实例变量bank并设置为私有静态常量
20       *@see type 定义了枚举类型的变量type，用来保存银行类型
21       *@see name 定义了变量name，用来保存该类型银行的名称
22       *@see listCard 定义了变量集合listCard，用来保存开户的银行卡
23       */
24     private static final BankABC bank = new BankABC();    //定义自身对象的唯一实例
25     
26     private EBank type;                    //定义银行类型
27     private String name;                    //定义银行名称
28     private List<DepositCard> listCard;            //定义保存银行卡账户集合
29 
30     /*私有化的构造方法*/
31     private BankABC(){
32         type = EBank.ABC;                //使用枚举类型初始化银行类型
33         name = type.getName();                //使用枚举类型的属性初始化银行名称
34         listCard = new ArrayList<DepositCard>();    //使用List接口的实现类ArrayList初始化银行卡账户集合
35     }
36 
37     /*getter方法区*/
38     public static BankABC getBankABC(){            //定义静态工厂方法取得自身实例
39         return bank;
40     }
41     public EBank getEBank(){                //获取私有属性银行类型的值
42         return type;
43     }
44     public String getName(){                //获取私有属性银行名称的值
45         return name;
46     }
47     public List<DepositCard> getListCard(){            //获取私有属性银行卡账户集合的值
48         return listCard;
49     }
50 }

  1 package com.kai.li.abc;
  2 
  3 import java.io.Serializable;
  4 import com.kai.li.unionpay.EBank;
  5 import com.kai.li.unionpay.ICard;
  6 
  7 /**
  8   *储蓄卡类
  9   *该类继承自ICard接口
 10   *该类拥有属性银行类型，姓名，身份证号，卡号，密码，余额
 11   *该类实现接口中的三个方法，查询余额，存款，取款
 12   *银行卡类型将由ATM机所属银行设置
 13   */
 14 public class DepositCard implements ICard,Serializable{
 15     
 16     /**
 17      * 
 18      */
 19     private static final long serialVersionUID = 1L;//软件提示加的，等下查查什么意思
 20     /*变量定义区*/
 21     private EBank type;                        //变量：定义发卡行
 22     private String name;                        //变量：定义储蓄卡持有人姓名
 23     private String id;                        //变量：定义身份证号
 24     private String cardNumber;                    //变量：定义卡号
 25     private String password;                    //变量：定义密码
 26     private double balance;                        //变量：定义余额
 27 
 28     /*构造方法区*/
 29     public DepositCard(){                        //构造方法：无参构造方法
 30         this.type = null;                    //初始化：给发卡行赋值null
 31         this.cardNumber = null;                    //初始化：给卡号赋值null
 32         this.balance = 0.0;                    //初始化：给余额赋值0.0元
 33     }
 34     public DepositCard(String name,String id,String password){    //构造方法：三个参数的构造方法
 35         this();                            //调用：调用本类无参构造方法初始化成员变量
 36         this.name = name;                    //初始化：将构造方法接收的参数给name赋值
 37         this.id = id;                        //初始化：将构造方法接收的参数给id赋值
 38         this.password = password;                //初始化：将构造方法接收的参数给password赋值
 39     }
 40 
 41     /*setter方法区*/
 42     public void setType(EBank type){                //setter：设置发卡行
 43         this.type = type;
 44     }
 45     public void setName(String name){                //setter：设置姓名            
 46         this.name = name;                    
 47     }    
 48     public void setId(String id){                    //setter：设置身份证号
 49         this.id = id;
 50     }
 51     public void setCardNumber(String cardNumber){            //setter：设置卡号
 52         this.cardNumber = cardNumber;
 53     }
 54     public void setPassword(String password){            //setter：设置密码
 55         this.password = password;
 56     }
 57     public void setBalance(double balance){                //setter：设置余额
 58         this.balance = balance;
 59     }
 60 
 61     /*getter方法区*/
 62     public EBank getType(){                        //getter：获取发卡行
 63         return type;    
 64     }
 65     public String getName(){                    //getter：获取持卡人姓名
 66         return name;
 67     }
 68     public String getId(){                        //getter：获取身份证号
 69         return id;
 70     }
 71     public String getCardNumber(){                    //getter：获取卡号
 72         return cardNumber;
 73     }
 74     public String getPassword(){                    //getter：获取密码
 75         return password;
 76     }
 77     public double getBalance(){                    //getter：获取余额
 78         return balance;
 79     }
 80 
 81     /*重写方法区*/
 82     @Override
 83     public double checkBalance(){                    //Override：查询余额
 84         return this.getBalance();                //return：调用getter方法返回成员属性balance
 85     }
 86     @Override
 87     public boolean deposit(double money){                //Override：存款
 88         this.balance += money;                    //赋值：将传入的money参数与balance相加后赋值
 89         return true;                        //return：存款成功返回true;
 90     }
 91     @Override
 92     public boolean withdrawal(double money){            //Override：取款
 93         if(money>this.balance)                    //判断传入的money是否合法
 94             return false;                    //return：不合法返回false
 95         this.balance -= money;                    //赋值：将传入的money参数与balance预算后赋值
 96         return true;                        //return：取款成功返回true            
 97     }
 98     @Override
 99     public String toString(){                    //Override：储蓄卡信息输出
100         return "发卡行：" + getType() + "\n\r"        
101             + "姓名：" + getName() + "\n\r"
102             + "身份证号：" + getId() + "\n\r"
103             + "银行卡号：" + getCardNumber() + "\n\r"
104             + "密码："  + getPassword() + "\n\r"
105             + "余额：" + getBalance();
106     }
107 }

 1 package com.kai.li.unionpay;
 2 
 3 import com.kai.li.abc.DepositCard;
 4 
 5 /**
 6   *定义ATM机的抽象类
 7   *该类持有储蓄卡对象
 8   *调用储蓄卡对象的方法实现了自身的查询余额，存款，取款方法
 9   *该类定义了自己的抽象方法---开户
10   */
11 public abstract class AATM{
12     
13     public DepositCard card;
14 
15     /*定义抽象方法---开户，具体实现由子类完成*/
16     //抽象方法：定义开户功能
17     public abstract boolean openAccount(String name,String id,String password);
18 
19     /*调用银行卡的查询余额方法，实现ATM机自身的查询余额方法*/
20     public double checkBalance(){                    //方法：实现查询余额功能
21         return card.getBalance();                //调用card对象的查询余额方法
22     } 
23 
24     /*调用银行卡的存款方法，实现ATM机自身的存款方法*/
25     public boolean deposit(double money){                //方法：实现存款功能
26         return card.deposit(money);                //调用card对象的存款方法
27         
28     }
29     
30     /*调用银行卡的取款方法，实现ATM机自身的取款方法*/
31     public boolean withdrawal(double money){            //方法：实现取款功能
32         return card.withdrawal(money);                //调用card对象的取款方法
33     }
34 }

 1 package com.kai.li.unionpay;
 2 
 3 /**
 4   *这是一个枚举类
 5   *该枚举类定义了四大行
 6   *需使用构造方法给四大行指定具体名称
 7   */
 8 public enum EBank{
 9 
10     /*通过构造方法定义四大行的枚举常量*/
11     ABC("农业银行"),ICBC("工商银行"),CCB("建设银行"),BOC("中国银行");
12     
13     /*构造方法，可设置枚举常量的name属性*/
14     private EBank(String name){                //构造方法：初始化name的值
15         this.setName(name);
16     }
17     
18     /*定义私有属性name，用来标识枚举常量*/
19     private String name;                    //属性：通过构造方法完成赋值
20 
21     /*setter方法*/
22     public void setName(String name){            //方法：可设置name属性的值
23         this.name = name;
24     }
25 
26     /*getter方法*/
27     public String getName(){                //方法：可获取name属性的值
28         return this.name;
29     }
30     
31 }

 1 package com.kai.li.unionpay;
 2 
 3 /**
 4   *定义银行卡接口
 5   *该接口包含三个抽象方法
 6   *1 查询余额
 7   *2 存款
 8   *3 取款
 9   *@author 
10   *@version second
11   */
12 public interface ICard{
13     
14     /*查询余额的抽象方法，该方法应当返回余额的具体数值*/
15     double checkBalance();
16     
17     /*存款的抽象方法，该方法应当返回一个布尔值，成功为true,失败为false*/
18     boolean deposit(double money);
19 
20     /*取款的抽象方法，该方法应当返回一个布尔值，成功为true,失败为false*/    
21     boolean withdrawal(double money);
22 
23 }

 1 package com.kai.li.myutils;
 2 
 3 import java.util.Random;
 4 import java.io.File;
 5 import java.io.InputStream;
 6 import java.io.OutputStream;
 7 import java.io.FileInputStream;
 8 import java.io.FileOutputStream;
 9 import java.io.ObjectOutputStream;
10 import java.io.ObjectInputStream;
11 import java.io.IOException;
12 
13 /**
14   *define functions myself
15   *@author caw lid
16   */
17 public class MyUtils{
18 
19     /*read file contents*/
20     public static String readFileContents(String filename)throws IOException{    
21         File file = new File(filename);
22         InputStream in = new FileInputStream(file);
23         int i = -1;
24         byte[] str = new byte[1024];
25         String strs = "";
26         while((i = in.read(str)) != -1){
27             strs = new String(str,0,i);
28         }    
29         in.close();
30         return strs;
31     }
32     
33     /*write string to a file*/
34     public static void writeToFile(String filename,String contents)throws IOException{
35         File file = new File(filename);
36         if(!file.exists())
37             file.createNewFile();
38         OutputStream out = new FileOutputStream(file,true);
39         String str = contents;
40         out.write(str.getBytes());
41         out.close();
42     }
43 
44     /*read an object from a textfile*/
45     @SuppressWarnings("unchecked")
46     public static <T> void readObject(String filename,T t)throws Exception{
47         File file = new File(filename);
48         ObjectInputStream ois;
49         InputStream in = new FileInputStream(file);
50         ois = new ObjectInputStream(in);
51         t = (T)ois.readObject();
52         System.out.println(t);;
53         ois.close();
54     }
55     
56     /*write an object to a textfile*/
57     public static void writeObject(String filename,Object object)throws IOException{
58         File file = new File(filename);
59         if(!file.exists())
60             file.createNewFile();
61         ObjectOutputStream oos;
62         OutputStream out = new FileOutputStream(file);
63         oos = new ObjectOutputStream(out);
64         oos.writeObject(object);
65         oos.close();
66     }
67     public static void writeObjectT(String filename,Object object)throws IOException{
68         File file = new File(filename);
69         if(!file.exists())
70             file.createNewFile();
71         ObjectOutputStream oos;
72         OutputStream out = new FileOutputStream(file,true);
73         oos = new ObjectOutputStream(out);
74         oos.writeObject(object);
75         oos.close();
76     }
77     
78     /*get a number as String and assign the length*/
79     public static String getStringNumber(int length){
80         String str = "";
81         Random random = new Random();
82         for(int i = 0;i < length;i ++){
83             int num = random.nextInt(10);
84             str +=num; 
85         }
86         return str;
87     }
88 }

 1 package com.kai.li.text;
 2 
 3 import com.kai.li.abc.ATMABC;
 4 
 5 /**
 6   *定义客户端的类
 7   *本类功能为启动主界面
 8   */
 9 public class Client{
10     public static void main(String[] args){        //main方法，程序入口
11 
12         //实例化一个农业银行的ATM对象，为保证始终一台ATM机，需要进行参数传递
13         ATMABC atmABC = new ATMABC();
14         new MainView(atmABC);        //启动ATM机的主界面视图                
15     }
16 }

 1 package com.kai.li.text;
 2 
 3 /**
 4   *本类为检查用户输入的数据是否合法的类
 5   *可以检查的内容为：
 6   *身份证号，密码，卡号，金额
 7   */
 8 public class Check{
 9     
10     public static boolean checkId(String id){                        //检测输入身份证合法性
11         if(id.length()==18 && id.matches("[0-9]+"))
12             return true;
13         return false;
14     }
15     public static boolean checkPassword(String password){            //检测输入密码合法性
16         if(password.trim().length()==6)
17             return true;
18         return false;
19     }
20     public static boolean checkCardNumber(String cardNumber){        //检测输入卡号合法性
21         if(cardNumber.length()==8 && cardNumber.matches("[0-9]+"))
22             return true;
23         return false;
24     }
25     
26     public static boolean checkMoney(String money){                    //检测输入金额合法性
27         if(money.matches("^[0-9]+(.[0-9]+)") && Double.parseDouble(money.trim())>=0)
28             return true;
29         return false;
30     }
31 }

  1 package com.kai.li.text;
  2 
  3 import java.io.File;
  4 import java.util.List;
  5 import com.kai.li.abc.DepositCard;
  6 import com.kai.li.abc.ATMABC;
  7 
  8 /**
  9   *本类为开户控制器类
 10   *本类功能为保存视图类接收的用户输入数据
 11   *将数据保存到card变量
 12   *将card变量添加到abcbank的集合中去
 13   *给通用模型的方法传递数据让其保存到文件
 14   */
 15 public class CommonController{
 16 
 17     /*成员属性定义区*/
 18     CommonModel commonModel;                    //定义通用模型类
 19     ATMABC atmABC;                                //定义ATM机对象
 20 
 21     /*构造方法区*/
 22     /*无参构造方法*/
 23     public CommonController(ATMABC atmABC){
 24         
 25         commonModel = new CommonModel(atmABC);    //实例化通用模型类
 26         this.atmABC = atmABC;                    //传入ATM机对象赋值
 27         readInfoFromFile();                        //从文件读取读取农业银行的所有账户信息到ATM机的持有属性
 28         for(DepositCard depositCard:atmABC.getBank().getListCard()){
 29             System.out.println(depositCard);
 30             System.out.println("测试");
 31         }
 32     }
 33 
 34     /*方法实现区*/
 35     /*保存姓名到card对象中*/
 36     public void saveName(String name){            //传递姓名参数
 37         atmABC.card.setName(name);                //调用card的方法保存姓名
 38     }
 39     /*保存身份证号到card对象中*/
 40     public void saveId(String id){                //传递身份证号参数
 41         atmABC.card.setId(id);                    //调用card的方法保存身份证号
 42     }
 43     /*保存密码到card对象中*/
 44     public void savePassword(String password){    //传递密码参数
 45         atmABC.card.setPassword(password);        //调用card的方法保存密码
 46     }
 47 
 48     /*开户并保存数据到文件*/
 49     public void openAccount(){
 50         //调用ATM机方法进行开户
 51         atmABC.openAccount(atmABC.card.getName(),atmABC.card.getId(),atmABC.card.getPassword());    
 52         //调用自身的方法将数据写入文件    
 53         saveToFile("d:"+File.separator+"abcdepositcard.txt",atmABC.getBank().getListCard());        
 54     }
 55     /*调用通用模型的方法实现自身将数据保存到文件*/
 56     public void saveToFile(String filename,List<DepositCard> listCard){
 57         commonModel.saveInfo(filename,listCard);
 58     }
 59     public void saveToFileT(String filename,List<DepositCard> listCard){
 60         commonModel.saveInfoT(filename,listCard);
 61     }
 62     /*调用通用模型的方法将农业银行的用户信息从文件中读出到指定容器*/
 63     public void readInfoFromFile(){
 64         commonModel.readInfo("d:"+File.separator+"abcdepositcard.txt",atmABC.getBank().getListCard());
 65     }
 66     
 67     /*检查卡号是否存在*/
 68     public boolean checkCardNumber(String cardNumber){
 69         readInfoFromFile();
 70         for(DepositCard depositCard:atmABC.getBank().getListCard()){
 71             if(cardNumber.equals(depositCard.getCardNumber())){
 72                 atmABC.card = depositCard;
 73                 return true;
 74             }
 75         }
 76         return false;
 77     }
 78     /*检查密码是否正确*/
 79     public boolean checkPassword(String password){
 80         if(password.equals(atmABC.card.getPassword()))
 81             return true;
 82         return false;
 83     }
 84     /*输出账户信息*/
 85     public void showCardInfo(){
 86         System.out.println(atmABC.card);
 87         System.out.println("友情提示：您的账户余额为"+atmABC.checkBalance()+"元");
 88     }
 89     /*存款方法*/
 90     public void deposit(double money){
 91         for(DepositCard depositCard:atmABC.getBank().getListCard()){
 92             if(atmABC.card.equals(depositCard)){
 93                 atmABC.deposit(money);
 94                 depositCard = atmABC.card;
 95                 break;
 96             }
 97         }
 98         //调用通用模型类的方法将数据写入文件
 99         commonModel.saveInfo("d:"+File.separator+"abcdepositcard.txt",atmABC.getBank().getListCard());    
100         new MainView(atmABC);
101     }
102     /*取款方法*/
103     public void withdrawal(double money){
104         for(DepositCard depositCard:atmABC.getBank().getListCard()){
105             if(atmABC.card.equals(depositCard)){
106                 atmABC.withdrawal(money);
107                 depositCard = atmABC.card;
108                 break;
109             }
110         }
111         //调用通用模型类的方法将数据写入文件
112         commonModel.saveInfo("d:"+File.separator+"abcdepositcard.txt",atmABC.getBank().getListCard());    
113         new MainView(atmABC);
114     }
115 }

 1 package com.kai.li.text;
 2 
 3 import static com.kai.li.myutils.MyUtils.*;
 4 import java.util.List;
 5 import com.kai.li.abc.DepositCard;
 6 import com.kai.li.abc.ATMABC;
 7 
 8 /**
 9   *本类为通用模型类
10   *本类功能为接收合法数值保存到对象变量中
11   *并将对象变量保存到文件
12   */
13 public class CommonModel{
14 
15     ATMABC atmABC;
16     public CommonModel(ATMABC atmABC){
17         this.atmABC = atmABC;
18      }
19     
20     /*保存数据到文件，覆盖而不追加*/
21     public void saveInfo(String filename,List<DepositCard> listCard){
22         try{
23             writeObject(filename,listCard);
24         }catch(Exception e){
25             e.printStackTrace();
26         }    
27     }
28     /*保存数据到文件，追加内容*/
29     public void saveInfoT(String filename,List<DepositCard> listCard){
30         try{
31             writeObjectT(filename,listCard);
32         }catch(Exception e){
33             e.printStackTrace();
34         }    
35     }
36     /*读取文件内容到指定容器*/
37     public void readInfo(String filename,List<DepositCard> listCard){
38         try{
39             readObject(filename,listCard);
40         }catch(Exception e){
41             e.printStackTrace();
42         }
43     }
44 }

 1 package com.kai.li.text;
 2 
 3 import static com.kai.li.text.Check.*;
 4 import static com.kai.li.text.MyScanner.*;
 5 import com.kai.li.abc.ATMABC;
 6 
 7 /*****/
 8 public class DepositView{
 9 
10     ATMABC atmABC;
11     CommonController commonController;
12     public DepositView(ATMABC atmABC){
13         this.atmABC = atmABC;
14         commonController = new CommonController(atmABC);
15         
16         ShowView.Deposit.display();
17             
18         checkCardNumber(getCardNumber());            //根据用户输入的卡号给出相应提示
19         checkPassword(getPassword());
20         checkMoney(getMoney());
21     }
22 
23     public void checkCardNumber(String cardNumber){
24         if(!Check.checkCardNumber(cardNumber) ||
25             !commonController.checkCardNumber(cardNumber)){
26             ShowView.Deposit.showResetCardNumber();
27             checkCardNumber(getCardNumber());
28         }else{
29             ShowView.Deposit.showInputPassword();
30         }
31     }
32     public void checkPassword(String password){
33         if(!Check.checkPassword(password) ||
34             !commonController.checkPassword(password)){
35             ShowView.Deposit.showResetPassword();
36             checkPassword(getPassword());
37         }else{
38             ShowView.Deposit.showCardInfo();
39             commonController.showCardInfo();
40             ShowView.Deposit.showDepositMoney();
41         }
42     }
43     public void checkMoeny(String money){
44         if(!Check.checkMoney(money)){
45             ShowView.Deposit.showError();
46             checkMoeny(getMoney());
47         }else{
48             ShowView.Deposit.showSuccess();
49             commonController.deposit(Double.parseDouble(money.trim()));
50             new MainView(atmABC);
51         }
52     }
53 }

 1 package com.kai.li.text;
 2 
 3 import com.kai.li.abc.ATMABC;
 4 
 5 /**
 6   *主界面控制器类
 7   *接收用户输入数值
 8   *根据用户输入，判断需要启动的相应界面视图
 9   */
10 public class MainController{
11 
12     ATMABC atmABC;
13 
14     public MainController(ATMABC atmABC){
15         this.atmABC = atmABC;
16     }
17 
18     /*方法实现区*/
19     /*根据用户输入，选择进入相应界面视图*/
20     public void selectView(String number){                //传入用户输入的命令参数
21         switch(number){                        //switch接收传入参数
22             case "0":
23                 new OpenAccountView(atmABC);        //选择0时，实例化开户界面对象，进入开户界面
24                 break;
25             case "1":
26                 new QueryView(atmABC);            //选择1时，实例化查询界面对象，进入查询界面
27                 break;
28             case "2":
29                 new DepositView(atmABC);        //选择2时，实例化存款界面对象，进入存款界面
30                 break;
31             case "3":
32                 new WithdrawalView(atmABC);        //选择3时，实例化取款界面对象，进入取款界面
33                 break;
34             case "4":
35                 ShowView.Exit.exit();            //选择4时，显示退出提示信息
36                 System.exit(1);                //退出系统
37                 break;
38             default:
39                 ShowView.Main.showReset();        //输入不合法时，显示输入不正确的提示信息
40                 new MainView(atmABC);            //实例化主界面对象，重新启动主界面视图
41                 break;
42         }        
43     }
44 }

 1 package com.kai.li.text;
 2 
 3 import static com.kai.li.text.MyScanner.*;
 4 import com.kai.li.abc.ATMABC;
 5 
 6 /**
 7   *本类为主界面视图类
 8   *本类传入主界面控制器对象
 9   *本类功能为：界面视图的输出，用户输入，根据用户选择调用控制器的方法进入相应界面
10   */
11 public class MainView{
12 
13     /*构造方法区*/
14     /*无参构造方法*/
15     public MainView(ATMABC atmABC){
16 
17         ShowView.Main.display();                //显示本界面的主视图
18         ShowView.Main.showSelect();                //显示让用户输入命令的提示信息
19         
20         //进入用户选择的视图界面    
21         selectView(getViewNumber(),new MainController(atmABC));    
22     }
23 
24     /*方法实现区*/
25     /*选择视图界面的方法，需要传入两个参数，一个是用户输入的选择命令，一个是主界面控制器对象*/
26     public void selectView(String number,MainController mainController){
27         mainController.selectView(number);            //调用主界面控制器对象的视图界面选择方法
28     }
29 }

 1 package com.kai.li.text;
 2 
 3 import java.util.Scanner;
 4 
 5 /**
 6   *用户输入类
 7   *用来接收用户的各种输入值
 8   *包括界面选择的数值，姓名，身份证号，密码，金额，银行卡号
 9   */
10 public class MyScanner{
11 
12     public static String getViewNumber(){        //获取用户输入的数值，用于选择需要进入的界面
13         Scanner scanner = new Scanner(System.in);
14         String str = scanner.nextLine();
15         return str;
16     }
17     public static String getName(){                //获取用户输入的姓名
18         Scanner scanner = new Scanner(System.in);
19         String str = scanner.nextLine();
20         return str;
21     }
22     public static String getId(){                //获取用户输入的身份证号
23         Scanner scanner = new Scanner(System.in);
24         String str = scanner.nextLine();
25         return str;
26     }
27     public static String getPassword(){            //获取用户输入的密码
28         Scanner scanner = new Scanner(System.in);
29         String str = scanner.nextLine();
30         return str;
31     }
32     public static String getMoney(){            //获取用户输入的金额
33         Scanner scanner = new Scanner(System.in);
34         String str = scanner.nextLine();
35         return str;
36     }
37     public static String getCardNumber(){        //获取用户输入的银行卡号
38         Scanner scanner = new Scanner(System.in);
39         String str = scanner.nextLine();
40         return str;
41     }
42 
43 }

 1 package com.kai.li.text;
 2 
 3 import static com.kai.li.text.MyScanner.*;
 4 import com.kai.li.abc.ATMABC;
 5 
 6 /**
 7   *本类为开户界面类
 8   *本类持有一个对象变量，为通用控制器类的实例对象
 9   *本类通过调用Check类进行数值合法性判断
10   *本类功能有四个
11   *1 输出界面信息
12   *2 接收用户输入的数据
13   *3 根据接收数据给出相应提示
14   *4 将合法数值传递给控制器类中的方法进行保存
15   */
16 public class OpenAccountView{
17 
18     /*成员属性定义区*/
19     CommonController commonController;                        //定义通用控制器类
20     ATMABC atmABC;                                            //定义ATM机对象
21     
22     /*构造方法区*/
23     /*无参构造方法*/
24     public OpenAccountView(ATMABC atmABC){
25 
26         commonController = new CommonController(atmABC);    //初始化开户控制器对象
27 
28         this.atmABC = atmABC;                                //传入ATM机对象赋值
29     
30         ShowView.OpenAccount.display();                        //显示本界面的主视图并提示用户输入姓名
31 
32         checkName(getName());                                //根据用户输入的姓名给出相应提示
33         
34         checkId(getId());                                    //根据用户输入的身份证号给出相应提示
35             
36         checkPassword(getPassword());                        //根据用户输入的密码给出相应提示
37                                 
38     }        
39     
40     /*方法实现区*/
41     /*根据用户输入姓名给出相应提示*/
42     public void checkName(String name){                        //接收用户输入姓名参数
43         commonController.saveName(name);                    //调用控制器方法保存姓名信息
44         ShowView.OpenAccount.showInputId();                    //提示用户输入身份证号
45     }
46     /*根据用户输入身份证号给出相应提示*/
47     public void checkId(String id){                            //接收用户输入身份证号
48         if(!Check.checkId(id)){                                //检查用户输入的身份证号合法性
49             ShowView.OpenAccount.showResetId();                //不合法时输出格式不正确的提示信息
50             checkId(getId());                                //不合法时递归调用自身，重新验证用户身份证号输入
51         }else{
52             ShowView.OpenAccount.showInputPassword();        //合法时提示用户输入密码    
53             commonController.saveId(id);                    //合法时调用控制器方法保存用户身份证号            
54         }    
55     }
56     /*根据用户输入密码给出相应提示*/
57     public void checkPassword(String password){                //接收用户输入密码
58         if(!Check.checkPassword(password)){                    //检查用户输入密码的合法性
59             ShowView.OpenAccount.showResetPassword();        //不合法时输出格式不正确的提示信息
60             checkPassword(getPassword());                    //不合法时递归调用自身，重新验证用户密码输入
61         }else{
62             ShowView.OpenAccount.showSuccess();                //合法时输出开户成功信息的提示
63             commonController.savePassword(password);        //合法时调用控制器方法保存用户密码
64             commonController.openAccount();                    //合法时通知控制器开户并将数据进行保存
65             new MainView(atmABC);                            //合法时实例化主界面对象回到主界面
66         }
67     }
68 }

 1 package com.kai.li.text;
 2 
 3 import static com.kai.li.text.MyScanner.*;
 4 import com.kai.li.text.Check;
 5 import com.kai.li.abc.ATMABC;
 6 
 7 /*****/
 8 public class QueryView{
 9 
10     ATMABC atmABC;    
11     CommonController commonController;
12 
13     public QueryView(ATMABC atmABC){
14         this.atmABC = atmABC;                    //实例化同一台ATM机对象
15         commonController = new CommonController(atmABC);    //实例化控制器对象
16         ShowView.Query.display();                //显示本界面的主视图并提示用户输入卡号
17         checkCardNumber(getCardNumber());            //根据用户输入的卡号给出相应提示
18         checkPassword(getPassword());                //根据用户输入密码给出相应提示
19     }
20 
21     public void checkCardNumber(String cardNumber){
22         if(!Check.checkCardNumber(cardNumber) ||
23             !commonController.checkCardNumber(cardNumber)){
24             ShowView.Query.showResetCardNumber();
25             checkCardNumber(getCardNumber());
26         }else{
27             ShowView.Query.showInputPassword();
28         }
29     }
30     public void checkPassword(String password){
31         if(!Check.checkPassword(password) ||
32             !commonController.checkPassword(password)){
33             ShowView.Query.showResetPassword();
34             checkPassword(getPassword());
35         }else{
36             ShowView.Query.showCardInfo();
37             commonController.showCardInfo();
38             new MainView(atmABC);
39         }
40     }
41 }

  1 package com.kai.li.text;
  2 
  3 /**
  4   *本类定义所有界面输出内容
  5   *分为6个内部类
  6   *依次是主界面，开户界面，查询界面，存款界面，取款界面，退出界面
  7   */
  8 public class ShowView{
  9     public static class Main{                            
 10         public static void display(){
 11             System.out.println("银行自助终端系统"); 
 12             System.out.println("****************************");
 13             System.out.println("0.------开户");
 14             System.out.println("1.------查询");
 15             System.out.println("2.------存款");
 16               System.out.println("3.------取款");
 17             System.out.println("4.------退出");
 18              System.out.println("****************************");
 19         }
 20         public static void showSelect(){
 21             System.out.println("请选择你要执行的功能：");
 22         }
 23         public static void showReset(){
 24             System.out.println("您选择的菜单不存在");
 25             System.out.println("请重新选择：");
 26             showSelect();
 27         }
 28     }
 29     public static class OpenAccount{                        
 30         public static void display(){
 31             System.out.println("****************************");
 32             System.out.println("您选择的为开户功能");
 33             showInputName();
 34         }
 35         public static void showInputName(){
 36             System.out.println("请输入您的姓名：");
 37         }
 38         public static void showInputId(){
 39             System.out.println("请输入您的身份证号：");
 40         }
 41         public static void showResetId(){
 42             System.out.println("您输入的身份证号格式不正确，请重新输入");
 43             showInputId();
 44         }
 45         public static void showInputPassword(){
 46             System.out.println("请输入您的密码：");
 47         }
 48         public static void showResetPassword(){
 49             System.out.println("您输入的密码格式不正确，请重新输入");
 50             showInputPassword();
 51         }
 52         public static void showSuccess(){
 53             System.out.println("开户成功，谢谢使用！");
 54         }
 55     }
 56     public static class Query{
 57         public static void display(){
 58             System.out.println("****************************");
 59             System.out.println("您选择的为查询功能");
 60             showQueryCardNumber();
 61         }
 62         public static void showQueryCardNumber(){
 63             System.out.println("请输入您要查询的卡号：");
 64         }
 65         public static void showResetCardNumber(){
 66             System.out.println("您输入的卡号不存在，请重新输入");
 67             showQueryCardNumber();
 68         }
 69         public static void showInputPassword(){
 70             System.out.println("请输入您的密码：");
 71         }
 72         public static void showResetPassword(){
 73             System.out.println("您输入的密码格式不正确，请重新输入");
 74             showInputPassword();
 75         }
 76         public static void showCardInfo(){
 77             System.out.println("您查询的账号信息为：");
 78             System.out.println("****************************");
 79         }
 80     }
 81     public static class Deposit{
 82         public static void display(){
 83             System.out.println("****************************");
 84             System.out.println("您选择的为存款功能");
 85             showDepositCardNumber();
 86         }
 87         public static void showDepositCardNumber(){
 88             System.out.println("请输入您要存款的卡号：");
 89         }
 90         public static void showResetCardNumber(){
 91             System.out.println("您输入的卡号不存在，请重新输入");
 92             showDepositCardNumber();
 93         }
 94         public static void showInputPassword(){
 95             System.out.println("请输入您的密码：");
 96         }
 97         public static void showResetPassword(){
 98             System.out.println("您输入的密码格式不正确，请重新输入");
 99             showInputPassword();
100         }
101         public static void showCardInfo(){
102             System.out.println("您要存款的账号信息为：");
103             System.out.println("****************************");
104         }
105         public static void showDepositMoney(){
106             System.out.println("请输入您要存款的金额：");
107         }
108         public static void showError(){
109             System.out.println("您输入的金额无效，系统将自动进入主界面");
110         }
111         public static void showSuccess(){
112             System.out.println("存款成功，谢谢使用！");
113         }
114     }
115     public static class Withdrawal{
116         public static void display(){
117             System.out.println("****************************");
118             System.out.println("您选择的为取款功能");
119         }
120         public static void showWithdrawalCardNumber(){
121             System.out.println("请输入您要取款的卡号：");
122         }
123         public static void showResetCardNumber(){
124             System.out.println("您输入的卡号不存在，请重新输入");
125             showWithdrawalCardNumber();
126         }
127         public static void showInputPassword(){
128             System.out.println("请输入您的密码：");
129         }
130         public static void showResetPassword(){
131             System.out.println("您输入的密码格式不正确，请重新输入");
132             showInputPassword();
133         }
134         public static void showCardInfo(){
135             System.out.println("您要取款的账号信息为：");
136             System.out.println("****************************");
137         }
138         public static void showWithdrawalMoney(){
139             System.out.println("请输入您要取款的金额：");
140         }
141         public static void showError(){
142             System.out.println("您输入的金额无效，系统将自动进入主界面");
143         }
144         public static void showSuccess(){
145             System.out.println("取款成功，谢谢使用！");
146         }
147     }
148     public static class Exit{
149         public static void exit(){
150             System.out.println("系统已成功推出，谢谢使用！");
151         }
152     }
153 }

 1 package com.kai.li.text;
 2 
 3 import static com.kai.li.text.Check.*;
 4 import static com.kai.li.text.MyScanner.*;
 5 import com.kai.li.abc.ATMABC;
 6 
 7 /****/
 8 public class WithdrawalView{
 9     
10     ATMABC atmABC;
11     CommonController commonController;
12     public WithdrawalView(ATMABC atmABC){
13         this.atmABC = atmABC;
14         commonController = new CommonController(atmABC);
15         
16         ShowView.Withdrawal.display();
17             
18         checkCardNumber(getCardNumber());            //根据用户输入的卡号给出相应提示
19         checkPassword(getPassword());
20         checkMoney(getMoney());
21 
22     }
23 
24     public void checkCardNumber(String cardNumber){
25         if(!Check.checkCardNumber(cardNumber) ||
26             !commonController.checkCardNumber(cardNumber)){
27             ShowView.Withdrawal.showResetCardNumber();
28             checkCardNumber(getCardNumber());
29         }else{
30             ShowView.Withdrawal.showInputPassword();
31         }
32     }
33     public void checkPassword(String password){
34         if(!Check.checkPassword(password) ||
35             !commonController.checkPassword(password)){
36             ShowView.Withdrawal.showResetPassword();
37             checkPassword(getPassword());
38         }else{
39             ShowView.Withdrawal.showCardInfo();
40             commonController.showCardInfo();
41             ShowView.Withdrawal.showWithdrawalMoney();
42         }
43     }
44     public void checkMoeny(String money){
45         if(!Check.checkMoney(money)){
46             ShowView.Withdrawal.showError();
47             checkMoeny(getMoney());
48         }else{
49             ShowView.Deposit.showSuccess();
50             commonController.withdrawal(Double.parseDouble(money.trim()));
51             new MainView(atmABC);
52         }
53     }
54 }