1001-----homework------version first

 

 

 

 1 package com.kai.li.atm;
 2 
 3 /**
 4   *客户端
 5   *@author kaili
 6   */
 7 public class Client{
 8     public static void main(String[] args){
 9         new MainView();           //启动主界面
10     }
11 }

 1 package com.kai.li.atm;
 2 
 3 import java.io.IOException;
 4 import com.kai.li.myutils.MyUtils;
 5 
 6 /**
 7   *主界面
 8   */
 9 public class MainView{
10     
11     private MainController mainController;            //定义主界面控制变量
12 
13     /*构造函数初始化主界面*/
14     MainView(){
15         mainController = new MainController();        //初始化主界面控制器
16         display();                    //显示主界面视图
17         selectView();                    //根据用户输入，启动相应视图界面
18     }
19 
20     /*显示主界面*/
21     public void display(){
22         try{
23             System.out.println(mainController.getFileContents());
24         }catch(Exception e){
25             e.printStackTrace();
26         }
27     }
28 
29     /*根据用户输入，启动相应视图界面*/
30     public void selectView(){
31         mainController.selectView(MyUtils.scanner());
32     }
33 
34 }

 1 package com.kai.li.atm;
 2 
 3 /**
 4   *主界面控制器
 5   *根据用户输入进入子界面
 6   **/
 7 
 8 public class MainController{
 9 
10     /*定义主界面数据模型变量*/
11     private MainModel mainModel;
12     
13     /*构造方法初始化主界面数据模型对象*/
14     MainController(){
15         this.mainModel = new MainModel();
16     }
17 
18     /*根据用户输入进入相应子界面*/
19     public void selectView(String str){
20         switch(str){
21             case "0":
22                 new CreatAccountView();        //启动注册账户界面视图
23                 break;
24             case "1":
25                 new SearchView();        //启动查询账户界面视图
26                 break;
27             case "2":
28                 new DepositView();        //启动存款界面视图
29                 break;
30             case "3":
31                 new WithdrawalView();        //启动提款界面视图
32                 break;
33             case "4":
34                 exit();                //退出应用程序
35                 break;
36             default:
37                 showMessageAndNew();        //默认提示信息并重新启动主界面视图
38         }
39     }
40 
41     /*获取保存在文件中的数据内容*/
42     public String getFileContents()throws Exception{
43             return mainModel.getFileContents();
44     }
45     
46     /*退出系统的方法定义*/
47     public void exit(){
48         System.out.println("您已经安全退出ATM系统。谢谢使用！");
49         System.exit(1);
50     }
51     /*信息提示并重新启动主界面视图*/
52     public void showMessageAndNew(){
53         System.out.println("\n\r你选择的菜单不存在！");
54         System.out.println("请重新选择：");
55         new MainView();
56     }
57 }

 1 package com.kai.li.atm;
 2 
 3 import java.io.IOException;
 4 import com.kai.li.myutils.MyUtils;
 5 
 6 
 7 /**
 8   *主界面数据模型类
 9   */
10 public class MainModel{
11     
12     /*获取保存在文件中的数据*/
13     public String getFileContents()throws IOException{
14         return MyUtils.readFileContents("d:/mainview.txt");    
15     }
16     
17 }

  1 package com.kai.li.atm;
  2 
  3 import static com.kai.li.myutils.MyUtils.scanner;
  4 import com.kai.li.unionpay.ICard;
  5 import com.kai.li.abc.Card;
  6 
  7 /**
  8   *开户视图类
  9   */
 10 public class CreatAccountView{
 11 
 12     /**
 13       *变量定义
 14       */
 15     private CreatAccountController creatAccountController;       //定义开户控制变量
 16     private Card card;                          //定义银行卡变量
 17 
 18     /**
 19       *构造方法完成界面功能
 20       *信息提示与接收用户输入
 21       */
 22     CreatAccountView(){
 23 
 24         this.creatAccountController = new CreatAccountController();    //初始化账户控制器
 25         display();                            //显示开户界面
 26 
 27         showMessageName();                        //提示输入姓名信息
 28         String name = getName();                    //获得用户输入姓名信息
 29 
 30         showMessageId();                        //提示输入身份证信息
 31         String id = getId();                        //获得用户输入的身份证信息
 32         checkId(id);                            //根据用户输入身份信息的合法性完成相应功能
 33 
 34         showMessagePassword();                        //提示输入密码信息
 35         String password = getPassword();                //获得用户输入的密码信息
 36         checkPassword(password);                    //根据用户输入密码的合法性完成相应功能
 37 
 38         card = new Card(name,id,password);                //根据用户输入信息生成银行卡账户
 39 
 40         saveInfo();                            //保存银行卡信息到文件
 41 
 42         showMessageSuccess();                        //显示开户成功的提示信息
 43 
 44         new MainView();                            //返回主界面
 45 
 46     }
 47 
 48     /*从文件获得数据并显示在界面*/
 49     public void display(){
 50         try{
 51             //将从文件获得的数据显示在界面视图中
 52             System.out.println(creatAccountController.getFileContents());    
 53         }catch(Exception e){
 54             e.printStackTrace();
 55         }
 56     }
 57 
 58     /*保存用户信息到文件*/
 59     public void saveInfo(){
 60         creatAccountController.saveInfo(card);                //通过Card类传递数据保存到硬盘中的文件
 61     }
 62     
 63     /*接收用户输入姓名，身份证，密码信息*/
 64     public String getName(){                        //获取用户输入的姓名
 65         return scanner();
 66     }
 67     public String getId(){                            //获取用户输入的身份证号
 68         return scanner();
 69     }
 70     public String getPassword(){                        //获取用户输入的密码
 71         return scanner();
 72     }
 73     
 74     /*显示提示性信息*/
 75     public void showMessageName(){
 76         System.out.println("请输入你的姓名：");                //提示姓名输入
 77     }
 78     public void showMessageId(){
 79         System.out.println("请输入你的身份证号：");            //提示身份证号输入
 80     }
 81     public void showMessagePassword(){
 82         System.out.println("请输入你的密码：");                //提示密码输入
 83     }
 84     public void showMessageSuccess(){
 85         System.out.println("开户成功，谢谢使用！");            //开户成功的提示信息
 86     }
 87 
 88     /*身份证信息检查*/
 89     public void checkId(String id){
 90         while(!creatAccountController.checkId(id)){        
 91             System.out.println("身份证格式无效，请重新输入：");
 92             id = getId();
 93         }
 94     }
 95     /*密码信息检查*/
 96     public void checkPassword(String password){
 97         while(!creatAccountController.checkPassword(password)){
 98             System.out.println("密码格式无效，请重新输入：");
 99             password = getPassword();
100         }    
101     }
102 
103 }

 1 package com.kai.li.atm;
 2 
 3 import java.io.IOException;
 4 import com.kai.li.abc.Card;
 5 import java.util.regex.Matcher;
 6 
 7 /**
 8   *开户控制器
 9   */
10 public class CreatAccountController{
11     
12     /*定义开户模型*/
13     private CreatAccountModel creatAccountModel;
14 
15     /*构造方法*/
16     CreatAccountController(){
17         this.creatAccountModel = new CreatAccountModel();
18     }
19     
20     /*从文件获取数据*/
21     public String getFileContents()throws IOException{
22         return creatAccountModel.getFileContents();
23     }
24 
25     /*检查身份证信息合法性*/
26     public boolean checkId(String id){
27         if(id.length()==18&&id.matches("[0-9]+"))
28             return true;
29         else 
30             return false;
31     }
32 
33     /*检查密码信息合法性*/
34     public boolean checkPassword(String password){
35         if(password.length()==6&&password.matches("[0-9]+"))
36             return true;
37         else 
38             return false;
39     }
40     
41     /*保存用户开户信息*/
42     public void saveInfo(Card card){
43         if(card != null)
44             creatAccountModel.saveInfo(card);
45     }
46 }

 1 package com.kai.li.atm;
 2 
 3 import java.io.IOException;
 4 import com.kai.li.myutils.MyUtils;
 5 import com.kai.li.abc.Card;
 6 
 7 /**
 8   *开户数据模型类
 9   */
10 public class CreatAccountModel{
11 
12     /*获取文件中的数据*/
13     public String getFileContents()throws IOException{
14         return MyUtils.readFileContents("d:/creataccountview.txt");
15     }
16 
17     /*将用户输入的数据保存到硬盘中的文件中*/
18     public void saveInfo(Card card){
19         try{
20             MyUtils.writeToFile("d:/card.txt",card);
21         }catch(Exception e){
22             e.printStackTrace();
23             
24         }
25     }
26     
27 }

 1 package com.kai.li.atm;
 2 
 3 import static com.kai.li.myutils.MyUtils.scanner;
 4 
 5 /**
 6   *查询视图界面类
 7   */
 8 public class SearchView{
 9 
10     /*定义查询控制器变量*/
11     private SearchController searchController;
12 
13     /*构造方法完成用户输入及视图展现*/
14     public SearchView(){
15 
16         searchController = new SearchController();    //实例化查询控制器    
17 
18         showMessageIndex();        //显示提示信息
19     
20         showMessageCardnumber();        //提示用户输入卡号
21         String cardnumber = getCardnumber();    //获取用户输入的卡号
22         checkCardnumber(cardnumber);        //根据卡号输入的合法性执行相应功能
23 
24         showMessagePassword();            //提示用户输入密码
25         String password = getPassword();    //获取用户输入的密码
26         checkPassword(password);        //根据密码输入的合法性执行相应功能
27     }
28 
29     /*界面信息提示的相关方法*/
30     public void showMessageIndex(){                //提示本视图界面功能信息
31         System.out.println("****************");        
32         System.out.println("你选择的为查询功能");
33     }
34     public void showMessageCardnumber(){            //提示用户输入卡号
35         System.out.println("请输入您要查询的卡号：");
36     }
37     public void showMessagePassword(){            //提示用户输入密码
38         System.out.println("请输入您的密码：");
39     }
40     public void showMessageEnd(){                //输出成功查询后的相关信息
41         System.out.println();
42         System.out.println("你查询的账号信息为：");
43         System.out.println("*****************************");
44         System.out.println(searchController.searchModel.card);
45     }
46 
47     /*数值合法性检查的相关方法*/
48     public void checkCardnumber(String cardnumber){            //检测卡号是否存在    
49         while(!searchController.checkCardnumber(cardnumber)){
50             System.out.println("您查询的账户不存在！请重新输入：");
51             cardnumber = getCardnumber();
52         }
53     }
54     public void checkPassword(String password){            //检测密码是否正确
55         int i = 1;
56         while(!searchController.checkPassword(password) && i<3){    //循环判断密码是否正确
57             System.out.println("您的密码不正确！请重新输入：");
58             i++;
59             password = getPassword();
60         }
61         if(i == 3)
62             new MainView();        //如果3次输入错误，则返回主界面
63         showMessageEnd();    //查询成功后的提示信息
64         new MainView();        //启动主界面
65     }
66     
67     /*获取用户输入的相关方法*/
68     public String getCardnumber(){        //获取用户输入的卡号
69         return scanner();
70     }
71     public String getPassword(){        //获取用户输入的密码
72         return scanner();
73     }
74 
75 }

 1 package com.kai.li.atm;
 2 
 3 
 4 /**
 5   *查询账户的控制器类
 6   */
 7 public class SearchController{
 8     
 9     /*定义查询功能的数据模型变量*/
10     SearchModel searchModel;
11 
12     /*构造方法实例化数据模型类并获取账户信息*/
13     public SearchController(){
14 
15         this.searchModel = new SearchModel();
16         
17         setCard();
18     }
19 
20     /*检测卡号是否存在*/
21     public boolean checkCardnumber(String cardnumber){
22         if(!cardnumber.equals(searchModel.card.getCardnumber().trim()))
23             return false;
24         return true;
25     }
26 
27     /*检测密码是否正确*/
28     public boolean checkPassword(String password){
29         if(!password.equals(searchModel.card.getPassword().trim()))
30             return false;
31         return true;
32     }
33 
34     /*获取账户信息并保存在card对象中*/
35     public void setCard(){
36         try{
37             searchModel.setCard();
38         }catch(Exception e){
39             e.printStackTrace();
40         }
41 
42     }
43 }

 1 package com.kai.li.atm;
 2 
 3 import static com.kai.li.myutils.MyUtils.readFileContents;
 4 import com.kai.li.abc.Card;
 5 import java.util.List;
 6 import java.util.ArrayList;
 7 
 8 /**
 9   *查询功能的数据模型类
10   *没有去实现一个文件中保存多个账户的情况
11   *写入文件的构造方法需要改成true，以追加文本
12   *可以在Card的toString方法中添加字符“账户：”进行分割
13   *分割后其余步骤同下
14   */
15 public class SearchModel{
16 
17     /*定义储蓄卡的变量及列表变量*/
18     Card card = new Card();
19     List<String[]> list = new ArrayList<>();
20     
21     /*从硬盘文件中读取数据*/
22     public String[] getCardInfo()throws Exception{
23         return readFileContents("d:/card.txt").split("\n");
24     }
25        
26     /*将读取到的数据转换成card对象的属性*/
27     public void setCard()throws Exception{    
28         String[] strs = getCardInfo();        //定义临时变量保存按行分割后的字符数组
29         for(String str:strs){            //遍历数组并按：分割后保存进列表
30             list.add(str.split("："));
31         }
32         for(String[] str:list){            //遍历列表，根据数组下标给card对象赋值
33             switch(str[0]){
34                 case "姓名":
35                         card.setName(str[1]);    //给card对象的name属性赋值
36                         continue;
37                 case "身份证":
38                         card.setId(str[1]);    //给card对象的id属性赋值
39                         continue;
40                 case "卡号":
41                         card.setCardnumber(str[1]);    //给card对象的cardnumber属性赋值
42                         continue;
43                 case "密码":
44                         card.setPassword(str[1]);    //给card对象的password属性赋值
45                         continue;
46                 case "余额":
47                         card.setBalance(str[1]);    //给card对象的balance属性赋值
48                         continue;
49             }
50         }
51     }
52     
53 }

  1 package com.kai.li.atm;
  2 
  3 import static com.kai.li.myutils.MyUtils.scanner;
  4 
  5 /**
  6   *存款的试图界面
  7   *本类主要完成视图输出以及用户输入的功能
  8   */
  9 public class DepositView{
 10 
 11     /*定义控制器变量*/
 12     DepositController depositController;
 13 
 14     /*构造方法*/
 15     public DepositView(){
 16 
 17         depositController = new DepositController();        //实例化控制器变量
 18 
 19         showMessageIndex();                    //界面信息提示
 20         String cardnumber = getCardnumber();            //获取用户输入卡号
 21         checkCardnumber(cardnumber);                //根据用户输入卡号合法性给出相应界面信息
 22         
 23         showMessagePassword();                    //界面信息提示，提示用户输入密码
 24         String password = getPassword();            //获取用户输入密码
 25         checkPassword(password);                //根据用户输入密码合法性给出相应界面信息
 26 
 27         showMessageDeposit();                    //界面信息提示，输出用户账户信息
 28         showMessageCardInfo();                    //输出用户的账户具体信息
 29 
 30         showMessageMoney();                    //界面信息提示，提示用户输入存款金额
 31         String money = getMoney();                //获取用户输入存款金额
 32         checkMoney(money);                    //根据用户输入金额合法性给出相应界面信息
 33 
 34     }
 35 
 36     /*获取用户输入*/
 37     public String getCardnumber(){                    //获取用户卡号
 38         return scanner();
 39     }
 40     public String getPassword(){                    //获取用户密码
 41         return scanner();
 42     }
 43     public String getMoney(){                    //获取用户存款金额
 44         return scanner();
 45     }
 46 
 47     /*根据用户输入数据合法性展示界面提示*/
 48     public void checkCardnumber(String cardnumber){            //根据用户输入卡号合法性给出相应界面信息
 49         while(!depositController.checkCardnumber(cardnumber)){
 50             showMessageCardnumber();
 51             cardnumber = getCardnumber();
 52         }
 53     }    
 54     public void checkPassword(String password){            //根据用户输入密码合法性给出相应界面信息
 55         while(!depositController.checkPassword(password)){
 56             showMessageResetPassword();
 57             password = getPassword();
 58         }
 59     }    
 60     public void checkMoney(String money){                //根据用户输入存款金额合法性给出相应界面信息
 61         while(!depositController.checkMoney(money)){
 62             showMessageExit();
 63             new MainView();
 64         }
 65         deposit(money);                    //调用控制器的存款方法
 66         showMessageEnd();                //显示存款成功的信息
 67         new MainView();                    //返回主界面
 68     }
 69 
 70 
 71     /*界面视图内容输出*/
 72     public void showMessageIndex(){                    //本功能界面信息提示
 73         System.out.println("****************");        
 74         System.out.println("你选择的为存款功能");
 75         System.out.println("请输入你要存入的卡号：");
 76     }
 77     public void showMessageCardnumber(){                //提示卡号不存在，需重新输入
 78         System.out.println("您输入的卡号不存在");
 79         System.out.println("请重新输入卡号：");
 80     }
 81     public void showMessagePassword(){                //提示输入密码
 82         System.out.println("请输入密码：");
 83     }
 84     public void showMessageResetPassword(){                //提示密码不正确，需重新输入
 85         System.out.println("您输入的密码不正确");
 86         System.out.println("请重新输入密码：");
 87     }
 88     public void showMessageDeposit(){                //提示将显示账户信息
 89         System.out.println("您要存款的账户信息为");
 90         System.out.println("****************");            
 91     }
 92     public void showMessageMoney(){                    //提示输入存款金额
 93         System.out.println("请输入您要存款的金额");        
 94     }
 95     public void showMessageExit(){                    //提示金额无效
 96         System.out.println("您输入的金额无效，系统将回到主界面！");        
 97     }
 98     public void showMessageEnd(){                    //提示存款成功
 99         System.out.println("存款成功，谢谢使用！");        
100     }
101     public void showMessageCardInfo(){                //输出账户信息
102         System.out.println(depositController.depositModel.card);
103     }
104 
105     /*将合法的存款金额写入card对象并保存到文件*/
106     public void deposit(String money){                        //存入相应金额并保存到文件
107         depositController.deposit(money);                //调用控制器的存钱方法
108     }
109 }

 1 package com.kai.li.atm;
 2 
 3 import java.util.regex.Matcher;
 4 
 5 /**
 6   *存款控制器
 7   */
 8 public class DepositController{
 9 
10     /*定义存款模型变量*/
11     DepositModel depositModel;
12 
13     /*构造方法*/
14     public DepositController(){
15 
16         depositModel = new DepositModel();    //实例化模型对象
17                 
18         setCard();                //从文件获取账户信息并保存在card对象
19     
20     }
21 
22     /*从文件获取账户信息并保存在card对象*/
23     public void setCard(){
24         try{
25             depositModel.setCard();
26         }catch(Exception e){
27             e.printStackTrace();
28         }
29     }
30 
31     /*检测获取到的用户数据的合法性*/
32     public boolean checkCardnumber(String cardnumber){        //检测卡号是否存在
33         if(!cardnumber.equals(depositModel.card.getCardnumber().trim()))
34             return false;                    //不存在返回false
35         return true;                        //存在返回true
36     }
37     public boolean checkPassword(String password){            //检测密码是否正确
38         if(!password.equals(depositModel.card.getPassword().trim()))
39             return false;                    //不正确返回false
40         return true;                        //正确返回true
41     }
42     public boolean checkMoney(String money){            //检测存款金额是否合法
43         if(money.matches("[0-9]+")&&Double.parseDouble(money.trim())>0)
44             return true;                    //是整数并且>0返回true
45         return false;                        //其他返回false
46     }
47 
48     /*存款的方法*/
49     public void deposit(String money){
50         String depositMoney = (Double.parseDouble(money.trim())
51             + Double.parseDouble(depositModel.card.getBalance().trim()))
52             + "";
53         depositModel.card.setBalance(depositMoney);
54         depositModel.saveInfo();
55     }
56 }

 1 package com.kai.li.atm;
 2 
 3 import com.kai.li.myutils.MyUtils;
 4 
 5 
 6 public class DepositModel extends SearchModel{
 7 
 8     
 9 
10     /*将用户输入的数据保存到硬盘中的文件中*/
11     public void saveInfo(){
12         try{
13             MyUtils.writeToFile("d:/card.txt",card);
14         }catch(Exception e){
15             e.printStackTrace();
16             
17         }
18     }
19 
20 }

  1 package com.kai.li.atm;
  2 
  3 import static com.kai.li.myutils.MyUtils.scanner;
  4 
  5 /**
  6   *取款视图界面
  7   */
  8 public class WithdrawalView{
  9 
 10     /*定义控制器变量*/
 11     WithdrawalController withdrawalController;        //定义控制器变量
 12     
 13     /*构造方法*/
 14     public WithdrawalView(){
 15         
 16         withdrawalController = new WithdrawalController();    //初始化控制器对象
 17 
 18         showMessageWithdrawal();                //显示界面视图信息
 19         String cardnumber = getCardnumber();            //获取用户输入的卡号
 20         checkCardnumber(cardnumber);                //检测卡号是否存在并输并给出相关提示信息
 21 
 22         showMessagePassword();                    //提示用户输入密码
 23         String password = getPassword();            //获取用户输入密码
 24         checkPassword(password);                //检测密码是否正确并给出相关提示信息
 25 
 26         showMessageCardInfo();                    //输出账户信息
 27         showMessageMoney();                    //提示用户输入取款金额
 28         String money = getMoney();                //获取用户输入金额
 29         checkMoney(money);                    //检测金额合法性并给出相关提示信息
 30         
 31     }
 32 
 33     /*获取用户输入*/
 34     public String getCardnumber(){                    //获取用户输入卡号
 35         return scanner();
 36     }
 37     public String getPassword(){                    //获取用户输入密码
 38         return scanner();
 39     }
 40     public String getMoney(){                    //获取用户输入金额
 41         return scanner();
 42     }
 43 
 44     /*根据用户输入合法性做出信息提示*/
 45     public void checkCardnumber(String cardnumber){            //卡号是否存在及提示信息
 46         while(!withdrawalController.checkCardnumber(cardnumber)){
 47             showMessageReset();
 48             cardnumber = getCardnumber();
 49         }
 50     }
 51     public void checkPassword(String password){            //密码是否正确及提示信息
 52         while(!withdrawalController.checkPassword(password)){
 53             showMessagePassword();
 54             password = getPassword();
 55         }
 56     }    
 57     public void checkMoney(String money){                //存款金额无效及提示信息
 58         while(!withdrawalController.checkMoney(money)){
 59             showMessageToMainView();
 60             new MainView();
 61         }
 62         withdrawal(money);
 63         showMessageSuccess();
 64         new MainView();
 65     }
 66 
 67     /*视图界面提示信息*/
 68     public void showMessageWithdrawal(){                //提示取款功能，提示输入卡号
 69         System.out.println("****************");        
 70         System.out.println("您选择的为取款功能");
 71         System.out.println("请输入你要取款的卡号：");
 72     }
 73     public void showMessageReset(){                    //提示用户卡号不存在，需重新输入卡号
 74         System.out.println("您输入的卡号不存在，请重新输入");
 75         System.out.println("请输入你要取款的卡号：");
 76     }
 77     public void showMessagePassword(){                    //提示用户输入密码
 78         System.out.println("请您输入密码：");
 79     }
 80     public void showMessageResetPassword(){                    //提示用户密码输入错误，需重新输入
 81         System.out.println("您输入的密码不正确，请重新输入");
 82         System.out.println("请您输入密码：");
 83     }
 84     public void showMessageCardInfo(){                    //提示将输出账户信息并输出
 85         System.out.println("您要取款的账号信息为");
 86         System.out.println("****************");        
 87         showCardInfo();
 88     }
 89     public void showMessageMoney(){                        //提示用户输入取款金额
 90         System.out.println("请输入您要取款的金额：");
 91     }
 92     public void showMessageToMainView(){                    //提示用户输入的取款金额无效
 93         System.out.println("您输入的金额无效，系统将自动跳转到主界面！");
 94     }
 95     public void showMessageSuccess(){                    //提示用户取款成功
 96         System.out.println("取款成功，谢谢使用！");
 97     }
 98 
 99     /*输出用户信息*/
100     public void showCardInfo(){                        //将当前card的信息输出
101         System.out.println(withdrawalController.withdrawalModel.card);
102     }
103 
104     /*取款并将数据保存到文件*/
105     public void withdrawal(String money){                    //调用控制器取款方法并保存数据到文件
106         withdrawalController.withdrawal(money);
107     }
108 
109 }

 1 package com.kai.li.atm;
 2 
 3 import java.util.regex.Matcher;
 4 
 5 /**
 6   *取款控制器
 7   */
 8 public class WithdrawalController{
 9 
10     /*定义取款模型变量*/
11     WithdrawalModel withdrawalModel;
12 
13     /*构造方法*/
14     public WithdrawalController(){
15 
16         withdrawalModel = new WithdrawalModel();    //实例化模型对象
17                 
18         setCard();                    //从文件获取账户信息并保存在card对象
19     
20     }
21 
22     /*从文件获取账户信息并保存在card对象*/
23     public void setCard(){
24         try{
25             withdrawalModel.setCard();
26         }catch(Exception e){
27             e.printStackTrace();
28         }
29     }
30 
31     /*检测获取到的用户数据的合法性*/
32     public boolean checkCardnumber(String cardnumber){        //检测卡号是否存在
33         if(!cardnumber.equals(withdrawalModel.card.getCardnumber().trim()))
34             return false;                    //不存在返回false
35         return true;                        //存在返回true
36     }
37     public boolean checkPassword(String password){            //检测密码是否正确
38         if(!password.equals(withdrawalModel.card.getPassword().trim()))
39             return false;                    //不正确返回false
40         return true;                        //正确返回true
41     }
42     public boolean checkMoney(String money){            //检测取款金额是否合法
43         if(money.matches("[0-9]+")&&Double.parseDouble(money.trim())>0
44             &&Double.parseDouble(money.trim())<=
45                 Double.parseDouble(withdrawalModel.card.getBalance().trim()))
46             return true;                    //是整数并且>0并且<=余额返回true
47         return false;                        //其他返回false
48     }
49 
50     /*取款的方法*/
51     public void withdrawal(String money){
52         String withdrawalMoney = (Double.parseDouble(withdrawalModel.card.getBalance().trim())
53             - Double.parseDouble(money.trim()))
54             + "";
55         withdrawalModel.card.setBalance(withdrawalMoney);
56         withdrawalModel.saveInfo();
57     }
58 }

1 package com.kai.li.atm;
2 
3 /**
4   *模型类
5   */
6 public class WithdrawalModel extends DepositModel{
7 
8 }

 1 package com.kai.li.abc;
 2 
 3 import java.util.Random;
 4 
 5 /**
 6   *用于传递数据的中间类
 7   */
 8 public class Card{
 9 
10     /*定义私有属性*/
11     private String name;
12     private String id;
13     private String cardnumber;
14     private String password;
15     private String balance;
16 
17     /*无参构造方法*/
18     public Card(){
19 
20     }
21 
22     /*开户时使用的3个参数的构造方法*/
23     public Card(String name,String id,String password){
24         this.name = name;
25         this.id = id;
26         this.password = password;
27 
28         this.cardnumber = (new Random().nextInt(899999)+100000)+"";
29         this.balance = "0.0";
30     }
31 
32     /*getter*/
33     public String getName(){
34         return name;
35     }
36     public String getId(){
37         return id;
38     }
39     public String getCardnumber(){
40         return cardnumber;
41     }
42     public String getPassword(){
43         return password;
44     }
45     public String getBalance(){
46         return balance;
47     }
48 
49     /*setter*/
50     public void setName(String name){
51         this.name = name;
52     }
53     public void setId(String id){
54         this.id = id;
55     }
56     public void setCardnumber(String cardnumber){
57         this.cardnumber = cardnumber;
58     }
59     public void setPassword(String password){
60         this.password = password;
61     }
62     public void setBalance(String balance){
63         this.balance = balance;
64     }
65 
66     /*重写toString方法*/
67     @Override
68     public String toString(){
69         return "姓名："+getName()+"\r\n"
70             +"身份证："+getId()+"\r\n"
71             +"卡号："+getCardnumber()+"\r\n"
72             +"密码："+getPassword()+"\r\n"
73             +"余额："+getBalance();
74     }
75 
76 }

 1 package com.kai.li.myutils;
 2 
 3 import java.io.File;
 4 import java.io.InputStream;
 5 import java.io.OutputStream;
 6 import java.io.FileInputStream;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 import java.util.Scanner;
10 import com.kai.li.abc.Card;
11 
12 /**
13   *define functions byself
14   *@auther kai li
15   */
16 public class MyUtils{
17 
18     /*read file contents*/
19     public static String readFileContents(String filename)throws IOException{
20         
21         File file = new File(filename);
22         InputStream in = new FileInputStream(file);
23     
24         int i = -1;
25         byte[] str = new byte[1024];
26         String strs = "";
27 
28         while((i = in.read(str)) != -1){
29             strs = new String(str,0,i);
30         }
31         
32         in.close();
33         return strs;
34         
35     }
36     
37     /*write string to a file*/
38     public static void writeToFile(String filename,Card card)throws IOException{
39 
40         File file = new File(filename);
41         OutputStream out = new FileOutputStream(file);
42 
43         String str = card.toString();
44     
45         if(!file.exists())
46             file.createNewFile();
47 
48         out.write(str.getBytes());
49 
50         out.close();
51 
52     }
53     
54     /*read string by scanner*/
55     public static String scanner(){
56         Scanner scanner = new Scanner(System.in);
57         return scanner.nextLine();
58     }
59     
60     /*read int by scanner*/
61     public static int scannerInt(){
62         Scanner scanner = new Scanner(System.in);
63         return scanner.nextInt();
64     }
65 }

 

转载于:https://www.cnblogs.com/kaililikai/p/5932085.html