1 package com.kai.li.message;
2
3 import com.kai.li.abc.ATMABC;
4
5 /**
6 *本类定义所有界面输出内容
7 *分为6个内部类
8 *依次是主界面，开户界面，查询界面，存款界面，取款界面，退出界面
9 */
10 public class ShowView{
11 public static class Main{
12 public static void display(){
13 System.out.println("银行自助终端系统");
14 System.out.println("****************************");
15 System.out.println("0.------开户");
16 System.out.println("1.------查询");
17 System.out.println("2.------存款");
18 System.out.println("3.------取款");
19 System.out.println("4.------退出");
20 System.out.println("****************************");
21 }
22 public static void showSelect(){
23 System.out.println("请选择你要执行的功能：");
24 }
25 public static void showReset(){
26 System.out.println("您选择的菜单不存在");
27 System.out.println("请重新选择：");
28 showSelect();
29 }
30 }
31 public static class OpenAccount{
32 public static void display(){
33 System.out.println("****************************");
34 System.out.println("您选择的为开户功能");
35 showInputName();
36 }
37 public static void showInputName(){
38 System.out.println("请输入您的姓名：");
39 }
40 public static void showInputId(){
41 System.out.println("请输入您的身份证号：");
42 }
43 public static void showResetId(){
44 System.out.println("您输入的身份证号格式不正确，请重新输入");
45 showInputId();
46 }
47 public static void showInputPassword(){
48 System.out.println("请输入您的密码：");
49 }
50 public static void showResetPassword(){
51 System.out.println("您输入的密码格式不正确，请重新输入");
52 showInputPassword();
53 }
54 public static void showSuccess(){
55 System.out.println("开户成功，谢谢使用！");
56 }
57 }
58 public static class Query{
59 public static void display(){
60 System.out.println("****************************");
61 System.out.println("您选择的为查询功能");
62 showQueryCardNumber();
63 }
64 public static void showQueryCardNumber(){
65 System.out.println("请输入您要查询的卡号：");
66 }
67 public static void showResetCardNumber(){
68 System.out.println("您输入的卡号不存在，请重新输入");
69 showQueryCardNumber();
70 }
71 public static void showInputPassword(){
72 System.out.println("请输入您的密码：");
73 }
74 public static void showResetPassword(){
75 System.out.println("您输入的密码格式不正确，请重新输入");
76 showInputPassword();
77 }
78 public static void showCardInfo(){
79 System.out.println("您查询的账号信息为：");
80 System.out.println("****************************");
81 }
82 public static void showCardMessage(ATMABC atmABC){
83 System.out.println(atmABC.card);
84 System.out.println("友情提示：您的账户余额为"+atmABC.checkBalance()+"元");
85 }
86 }
87 public static class Deposit{
88 public static void display(){
89 System.out.println("****************************");
90 System.out.println("您选择的为存款功能");
91 showDepositCardNumber();
92 }
93 public static void showDepositCardNumber(){
94 System.out.println("请输入您要存款的卡号：");
95 }
96 public static void showResetCardNumber(){
97 System.out.println("您输入的卡号不存在，请重新输入");
98 showDepositCardNumber();
99 }
100 public static void showInputPassword(){
101 System.out.println("请输入您的密码：");
102 }
103 public static void showResetPassword(){
104 System.out.println("您输入的密码格式不正确，请重新输入");
105 showInputPassword();
106 }
107 public static void showCardInfo(){
108 System.out.println("您要存款的账号信息为：");
109 System.out.println("****************************");
110 }
111 public static void showDepositMoney(){
112 System.out.println("请输入您要存款的金额：");
113 }
114 public static void showError(){
115 System.out.println("您输入的金额无效，系统将自动进入主界面");
116 }
117 public static void showSuccess(){
118 System.out.println("存款成功，谢谢使用！");
119 }
120 }
121 public static class Withdrawal{
122 public static void display(){
123 System.out.println("****************************");
124 System.out.println("您选择的为取款功能");
125 showWithdrawalCardNumber();
126 }
127 public static void showWithdrawalCardNumber(){
128 System.out.println("请输入您要取款的卡号：");
129 }
130 public static void showResetCardNumber(){
131 System.out.println("您输入的卡号不存在，请重新输入");
132 showWithdrawalCardNumber();
133 }
134 public static void showInputPassword(){
135 System.out.println("请输入您的密码：");
136 }
137 public static void showResetPassword(){
138 System.out.println("您输入的密码格式不正确，请重新输入");
139 showInputPassword();
140 }
141 public static void showCardInfo(){
142 System.out.println("您要取款的账号信息为：");
143 System.out.println("****************************");
144 }
145 public static void showWithdrawalMoney(){
146 System.out.println("请输入您要取款的金额：");
147 }
148 public static void showError(){
149 System.out.println("您输入的金额无效，系统将自动进入主界面");
150 }
151 public static void showSuccess(){
152 System.out.println("取款成功，谢谢使用！");
153 }
154 }
155 public static class Exit{
156 public static void exit(){
157 System.out.println("系统已成功推出，谢谢使用！");
158 }
159 }
160 }
1 package com.kai.li.myutils;
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.myutils;
2
3 import java.util.Scanner;
4
5 /**
6 *用户输入类
7 *用来接收用户的各种输入值
8 *包括界面选择的数值，姓名，身份证号，密码，金额，银行卡号
9 */
10 public class MyScanner{
11
12 @SuppressWarnings("resource")
13 public static String getValue(){ //获取用户输入值的通用方法
14 Scanner scanner = new Scanner(System.in);
15 String str = scanner.nextLine();
16 return str;
17 }
18 public static String getViewNumber(){ //获取用户输入的数值，用于选择需要进入的界面
19 return getValue();
20 }
21 public static String getName(){ //获取用户输入的姓名
22 return getValue();
23 }
24 public static String getId(){ //获取用户输入的身份证号
25 return getValue();
26 }
27 public static String getPassword(){ //获取用户输入的密码
28 return getValue();
29 }
30 public static String getMoney(){ //获取用户输入的金额
31 return getValue();
32 }
33 public static String getCardNumber(){ //获取用户输入的银行卡号
34 return getValue();
35 }
36
37 }
1 package com.kai.li.myutils;
2
3 import java.util.ArrayList;
4 import java.util.List;
5 import java.util.Random;
6 import java.io.File;
7 import java.io.InputStream;
8 import java.io.OutputStream;
9 import java.io.FileInputStream;
10 import java.io.FileOutputStream;
11 import java.io.ObjectOutputStream;
12 import java.io.ObjectInputStream;
13 import java.io.IOException;
14 import com.kai.li.abc.DepositCard;
15
16 /**
17 *define functions myself
18 *@author caw lid
19 */
20 public class MyUtils{
21
22 /*read string from file contents*/
23 public static String readFileContents(String filename)throws IOException{
24 File file = new File(filename);
25 InputStream in = new FileInputStream(file);
26 int i = -1;
27 byte[] str = new byte[1024];
28 String strs = "";
29 while((i = in.read(str)) != -1){
30 strs = new String(str,0,i);
31 }
32 in.close();
33 return strs;
34 }
35
36 /*write string to a file*/
37 public static void writeToFile(String filename,String contents)throws IOException{
38 File file = new File(filename);
39 if(!file.exists())
40 file.createNewFile();
41 OutputStream out = new FileOutputStream(file,true);
42 String str = contents;
43 out.write(str.getBytes());
44 out.close();
45 }
46
47 /*read an object from a textfile*/
48 @SuppressWarnings("unchecked")
49 public static List<DepositCard> readObject(String filename)throws Exception{
50 File file = new File(filename);
51 List<DepositCard> listCard = new ArrayList<>();
52 if(file.exists()){
53 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
54 listCard = (List<DepositCard>)ois.readObject();
55 ois.close();
56 return listCard;
57 }
58 return null;
59 }
60
61 /*write an object to a textfile*/
62 public static void writeObject(String filename,List<DepositCard> card)throws IOException{
63 File file = new File(filename);
64 if(!file.exists())
65 file.createNewFile();
66 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
67 oos.writeObject(card);
68 oos.close();
69 }
70
71 /*get a number as String and assign the length*/
72 public static String getStringNumber(int length){
73 String str = "";
74 Random random = new Random();
75 for(int i = 0;i < length;i ++){
76 int num = random.nextInt(10);
77 str +=num;
78 }
79 return str;
80 }
81 }
1 package com.kai.li.model;
2
3 import com.kai.li.abc.ATMABC;
4 import com.kai.li.view.DepositView;
5 import com.kai.li.view.MainView;
6 import com.kai.li.view.OpenAccountView;
7 import com.kai.li.view.QueryView;
8 import com.kai.li.message.ShowView;
9 import com.kai.li.view.WithdrawalView;
10
11 /**
12 *主界面控制器类
13 *接收用户输入数值
14 *根据用户输入，判断需要启动的相应界面视图
15 */
16 public class MainModel{
17
18 ATMABC atmABC;
19
20 public MainModel(ATMABC atmABC){
21 this.atmABC = atmABC;
22 }
23
24 /*方法实现区*/
25 /*根据用户输入，选择进入相应界面视图*/
26 public void selectView(String number){ //传入用户输入的命令参数
27 switch(number){ //switch接收传入参数
28 case "0":
29 new OpenAccountView(atmABC); //选择0时，实例化开户界面对象，进入开户界面
30 break;
31 case "1":
32 new QueryView(atmABC); //选择1时，实例化查询界面对象，进入查询界面
33 break;
34 case "2":
35 new DepositView(atmABC); //选择2时，实例化存款界面对象，进入存款界面
36 break;
37 case "3":
38 new WithdrawalView(atmABC); //选择3时，实例化取款界面对象，进入取款界面
39 break;
40 case "4":
41 ShowView.Exit.exit(); //选择4时，显示退出提示信息
42 System.exit(1); //退出系统
43 break;
44 default:
45 ShowView.Main.showReset(); //输入不合法时，显示输入不正确的提示信息
46 new MainView(atmABC); //实例化主界面对象，重新启动主界面视图
47 break;
48 }
49 }
50 }
1 package com.kai.li.model;
2
3 import static com.kai.li.myutils.MyUtils.readObject;
4 import static com.kai.li.myutils.MyUtils.writeObject;
5 import java.io.File;
6 import java.util.List;
7 import com.kai.li.abc.DepositCard;
8 import com.kai.li.view.MainView;
9 import com.kai.li.abc.ATMABC;
10 import com.kai.li.message.ShowView.Query;
11
12 /**
13 *本类为开户控制器类
14 *本类功能为保存视图类接收的用户输入数据
15 *将数据保存到card变量
16 *将card变量添加到abcbank的集合中去
17 *给通用模型的方法传递数据让其保存到文件
18 */
19 public class CommonModel{
20
21 /*成员属性定义区*/
22 ATMABC atmABC; //定义ATM机对象
23 String filename;
24
25 /*构造方法区*/
26 /*无参构造方法*/
27 public CommonModel(ATMABC atmABC){
28 initialize(atmABC); //初始化成员变量
29 //从文件读取读取农业银行的所有账户信息到ATM机的成员属性
30 readInfoFromFile(filename);
31 }
32
33 /*方法实现区*/
34
35 /*初始化成员变量*/
36 public void initialize(ATMABC atmABC){
37 this.atmABC = atmABC; //传入ATM机对象赋值
38 filename = "d:"+File.separator+"abcdepositcard.txt";
39 }
40
41 /*开户相关方法区*/
42 /*保存姓名到card对象中*/
43 public void saveName(String name){ //传递姓名参数
44 atmABC.card.setName(name); //调用card的方法保存姓名
45 }
46 /*保存身份证号到card对象中*/
47 public void saveId(String id){ //传递身份证号参数
48 atmABC.card.setId(id); //调用card的方法保存身份证号
49 }
50 /*保存密码到card对象中*/
51 public void savePassword(String password){ //传递密码参数
52 atmABC.card.setPassword(password); //调用card的方法保存密码
53 }
54 /*开户并保存数据到文件*/
55 public void openAccount(){
56 //调用ATM机方法进行开户
57 atmABC.openAccount(atmABC.card.getName(),atmABC.card.getId(),atmABC.card.getPassword());
58 //重新初始化用于保存临时储蓄卡账户的变量card
59 atmABC.card = new DepositCard();
60 //调用自身的方法将数据写入文件
61 saveToFile(filename,atmABC.getListCard());
62 }
63
64 /*检查卡号密码，输出账号信息共3个方法*/
65 /*检查卡号是否存在*/
66 public boolean checkCardNumber(String cardNumber){
67 for(DepositCard depositCard:atmABC.getListCard()){
68 if(cardNumber.equals(depositCard.getCardNumber())){
69 atmABC.card = depositCard;
70 return true;
71 }
72 }
73 return false;
74 }
75 /*检查密码是否正确*/
76 public boolean checkPassword(String password){
77 if(password.equals(atmABC.card.getPassword()))
78 return true;
79 return false;
80 }
81 /*输出账户信息，atm中的card以及card余额单独显示的信息*/
82 public void showCardInfo(){
83 Query.showCardMessage(this.atmABC);
84 }
85
86 /*存款，取款方法*/
87 /*存款方法*/
88 public void deposit(double money){
89 for(DepositCard depositCard:atmABC.getBank().getListCard()){
90 if(atmABC.card.equals(depositCard)){
91 atmABC.deposit(money);
92 depositCard = atmABC.card;
93 break;
94 }
95 }
96 //调用通用模型类的方法将数据写入文件
97 saveToFile(filename,atmABC.getListCard());
98 new MainView(atmABC);
99 }
100 /*取款方法*/
101 public void withdrawal(double money){
102 for(DepositCard depositCard:atmABC.getListCard()){
103 if(atmABC.card.equals(depositCard)){
104 atmABC.withdrawal(money);
105 depositCard = atmABC.card;
106 break;
107 }
108 }
109 //调用通用模型类的方法将数据写入文件
110 saveToFile(filename,atmABC.getListCard());
111 new MainView(atmABC);
112 }
113
114 /*保存，读取文件数据，共3个方法*/
115 /*保存数据到文件，覆盖而不追加*/
116 public void saveToFile(String filename,List<DepositCard> listCard){
117 try{
118 writeObject(filename,listCard);
119 }catch(Exception e){
120 e.printStackTrace();
121 }
122 }
123 /*读取文件内容到指定容器listCard*/
124 public void readInfoFromFile(String filename){
125 try{
126 atmABC.getBank().setListCard(readObject(filename));
127 }catch(Exception e){
128 e.printStackTrace();
129 }
130 }
131 }
1 package com.kai.li.client;
2
3 import com.kai.li.abc.ATMABC;
4 import com.kai.li.view.MainView;
5
6 /**
7 *定义客户端的类
8 *本类功能为启动主界面
9 */
10 public class Client{
11 public static void main(String[] args){ //main方法，程序入口，实例化一个农业银行的ATM对象，
12 ATMABC atmABC = new ATMABC(); //为保证始终一台ATM机，需要进行参数传递
13 new MainView(atmABC); //启动ATM机的主界面视图
14 }
15 }
1 package com.kai.li.view;
2
3 import static com.kai.li.myutils.MyScanner.*;
4 import com.kai.li.abc.ATMABC;
5 import com.kai.li.message.ShowView;
6 import com.kai.li.model.MainModel;
7
8 /**
9 *本类为主界面视图类
10 *本类传入主界面控制器对象
11 *本类功能为：界面视图的输出，用户输入，根据用户选择调用控制器的方法进入相应界面
12 */
13 public class MainView{
14
15 /*构造方法区*/
16 /*无参构造方法*/
17 public MainView(ATMABC atmABC){
18 this.display() //显示主界面并给出提示
19 .selectView(getViewNumber(),new MainModel(atmABC)); //进入用户选择的视图界面
20 }
21
22 /*方法实现区*/
23 /*选择视图界面的方法，需要传入两个参数，一个是用户输入的选择命令，一个是主界面控制器对象*/
24 public MainView selectView(String number,MainModel mainController){
25 mainController.selectView(number); //调用主界面控制器对象的视图界面选择方法
26 return this;
27 }
28 /*显示主界面视图的方法*/
29 public MainView display(){
30 ShowView.Main.display(); //显示本界面的主视图
31 ShowView.Main.showSelect(); //显示让用户输入命令的提示信息
32 return this;
33 }
34 }
1 package com.kai.li.view;
2
3
4 /*initialize(atmABC); //初始化成员属性
5
6 display(); //显示本界面的主视图并提示用户输入姓名
7
8 checkName(getName()); //根据用户输入的姓名给出相应提示
9
10 checkId(getId()); //根据用户输入的身份证号给出相应提示
11
12 checkPassword(getPassword());*/ //根据用户输入的密码给出相应提示
13
14 import static com.kai.li.myutils.MyScanner.*;
15 import com.kai.li.abc.ATMABC;
16 import com.kai.li.model.CommonModel;
17 import com.kai.li.myutils.Check;
18 import static com.kai.li.message.ShowView.*;
19
20 /**
21 *本类为开户界面类
22 *本类持有一个对象变量，为通用控制器类的实例对象
23 *本类通过调用Check类进行数值合法性判断
24 *本类功能有四个
25 *1 输出界面信息
26 *2 接收用户输入的数据
27 *3 根据接收数据给出相应提示
28 *4 将合法数值传递给控制器类中的方法进行保存
29 */
30 /***
31 *
32 * @author Administrator
33 *
34 */
35 public class OpenAccountView{
36
37 /*成员属性定义区*/
38 CommonModel commonController; //定义通用控制器类
39 ATMABC atmABC; //定义ATM机对象
40
41 /*构造方法区*/
42 /*无参构造方法*/
43 /***
44 *
45 * @param atmABC
46 */
47 public OpenAccountView(ATMABC atmABC){
48
49 this.initialize(atmABC) //初始化成员属性
50 .display() //显示本界面的主视图并提示用户输入姓名
51 .checkName(getName()) //根据用户输入的姓名给出相应提示
52 .checkId(getId()) //根据用户输入的身份证号给出相应提示
53 .checkPassword(getPassword()); //根据用户输入的密码给出相应提示
54 }
55
56 /*方法实现区*/
57 /*初始化成员变量*/
58 public OpenAccountView initialize(ATMABC atmABC){
59 commonController = new CommonModel(atmABC); //初始化开户控制器对象
60 this.atmABC = atmABC; //传入ATM机对象赋值
61 return this;
62 }
63 /*显示视图*/
64 public OpenAccountView display(){
65 OpenAccount.display(); //显示本界面的主视图并提示用户输入姓名
66 return this;
67 }
68 /*根据用户输入姓名给出相应提示*/
69 public OpenAccountView checkName(String name){ //接收用户输入姓名参数
70 commonController.saveName(name); //调用控制器方法保存姓名信息
71 OpenAccount.showInputId(); //提示用户输入身份证号
72 return this;
73 }
74 /*根据用户输入身份证号给出相应提示*/
75 public OpenAccountView checkId(String id){ //接收用户输入身份证号
76 if(!Check.checkId(id)){ //检查用户输入的身份证号合法性
77 OpenAccount.showResetId(); //不合法时输出格式不正确的提示信息
78 checkId(getId()); //不合法时递归调用自身，重新验证用户身份证号输入
79 }else{
80 OpenAccount.showInputPassword(); //合法时提示用户输入密码
81 commonController.saveId(id); //合法时调用控制器方法保存用户身份证号
82 }
83 return this;
84 }
85 /*根据用户输入密码给出相应提示*/
86 public OpenAccountView checkPassword(String password){ //接收用户输入密码
87 if(!Check.checkPassword(password)){ //检查用户输入密码的合法性
88 OpenAccount.showResetPassword(); //不合法时输出格式不正确的提示信息
89 checkPassword(getPassword()); //不合法时递归调用自身，重新验证用户密码输入
90 }else{
91 OpenAccount.showSuccess(); //合法时输出开户成功信息的提示
92 commonController.savePassword(password); //合法时调用控制器方法保存用户密码
93 commonController.openAccount(); //合法时通知控制器开户并将数据进行保存
94 new MainView(atmABC); //合法时实例化主界面对象回到主界面
95 }
96 return this;
97 }
98 }
1 package com.kai.li.view;
2
3 import static com.kai.li.myutils.MyScanner.*;
4 import com.kai.li.myutils.Check;
5 import com.kai.li.abc.ATMABC;
6 import com.kai.li.message.ShowView;
7 import com.kai.li.model.CommonModel;
8
9 /*****/
10 public class QueryView{
11
12 ATMABC atmABC;
13 CommonModel commonController;
14
15 public QueryView(ATMABC atmABC){
16
17 this.initialize(atmABC) //初始化成员变量
18 .display() //显示本界面的主视图并提示用户输入卡号
19 .checkCardNumber(getCardNumber()) //根据用户输入的卡号给出相应提示
20 .checkPassword(getPassword()); //根据用户输入密码给出相应提示
21 }
22
23 public QueryView initialize(ATMABC atmABC){
24 this.atmABC = atmABC; //实例化同一台ATM机对象
25 commonController = new CommonModel(atmABC); //实例化控制器对象
26 return this;
27 }
28 public QueryView display(){
29 ShowView.Query.display(); //显示本界面的主视图并提示用户输入卡号
30 return this;
31 }
32 public QueryView checkCardNumber(String cardNumber){
33 if(!Check.checkCardNumber(cardNumber) ||
34 !commonController.checkCardNumber(cardNumber)){
35 ShowView.Query.showResetCardNumber();
36 checkCardNumber(getCardNumber());
37 }else{
38 ShowView.Query.showInputPassword();
39 }
40 return this;
41 }
42 public QueryView checkPassword(String password){
43 if(!Check.checkPassword(password) ||
44 !commonController.checkPassword(password)){
45 ShowView.Query.showResetPassword();
46 checkPassword(getPassword());
47 }else{
48 ShowView.Query.showCardInfo();
49 commonController.showCardInfo();
50 new MainView(atmABC);
51 }
52 return this;
53 }
54 }
1 package com.kai.li.view;
2
3 import static com.kai.li.myutils.MyScanner.*;
4 import com.kai.li.abc.ATMABC;
5 import com.kai.li.message.ShowView;
6 import com.kai.li.model.CommonModel;
7 import com.kai.li.myutils.Check;
8
9 /*****/
10 public class DepositView{
11
12 ATMABC atmABC;
13 CommonModel commonController;
14
15 public DepositView(ATMABC atmABC){
16
17 this.initialize(atmABC)
18 .display()
19 .checkCardNumber(getCardNumber())
20 .checkPassword(getPassword())
21 .checkMoney(getMoney());
22 }
23
24 public DepositView initialize(ATMABC atmABC){
25 this.atmABC = atmABC;
26 commonController = new CommonModel(atmABC);
27 return this;
28 }
29 public DepositView display(){
30 ShowView.Deposit.display();
31 return this;
32 }
33 public DepositView checkCardNumber(String cardNumber){
34 if(!Check.checkCardNumber(cardNumber) ||
35 !commonController.checkCardNumber(cardNumber)){
36 ShowView.Deposit.showResetCardNumber();
37 checkCardNumber(getCardNumber());
38 }else{
39 ShowView.Deposit.showInputPassword();
40 }
41 return this;
42 }
43 public DepositView checkPassword(String password){
44 if(!Check.checkPassword(password) ||
45 !commonController.checkPassword(password)){
46 ShowView.Deposit.showResetPassword();
47 checkPassword(getPassword());
48 }else{
49 ShowView.Deposit.showCardInfo();
50 commonController.showCardInfo();
51 ShowView.Deposit.showDepositMoney();
52 }
53 return this;
54 }
55 public DepositView checkMoney(String money){
56 if(!Check.checkMoney(money)){
57 ShowView.Deposit.showError();
58 checkMoney(getMoney());
59 }else{
60 ShowView.Deposit.showSuccess();
61 commonController.deposit(Double.parseDouble(money.trim()));
62 new MainView(atmABC);
63 }
64 return this;
65 }
66 }
1 package com.kai.li.view;
2
3 import com.kai.li.myutils.Check;
4 import static com.kai.li.myutils.MyScanner.*;
5 import com.kai.li.abc.ATMABC;
6 import com.kai.li.message.ShowView;
7 import com.kai.li.model.CommonModel;
8
9 /****/
10 public class WithdrawalView{
11
12 ATMABC atmABC;
13 CommonModel commonController;
14
15 public WithdrawalView(ATMABC atmABC){
16
17 this.initialize(atmABC)
18 .display()
19 .checkCardNumber(getCardNumber())
20 .checkPassword(getPassword())
21 .checkMoney(getMoney());
22 }
23
24 public WithdrawalView initialize(ATMABC atmABC){
25 this.atmABC = atmABC;
26 commonController = new CommonModel(atmABC);
27 return this;
28 }
29 public WithdrawalView display(){
30 ShowView.Withdrawal.display();
31 return this;
32 }
33 public WithdrawalView checkCardNumber(String cardNumber){
34 if(!Check.checkCardNumber(cardNumber) ||
35 !commonController.checkCardNumber(cardNumber)){
36 ShowView.Withdrawal.showResetCardNumber();
37 checkCardNumber(getCardNumber());
38 }else{
39 ShowView.Withdrawal.showInputPassword();
40 }
41 return this;
42 }
43 public WithdrawalView checkPassword(String password){
44 if(!Check.checkPassword(password) ||
45 !commonController.checkPassword(password)){
46 ShowView.Withdrawal.showResetPassword();
47 checkPassword(getPassword());
48 }else{
49 ShowView.Withdrawal.showCardInfo();
50 commonController.showCardInfo();
51 ShowView.Withdrawal.showWithdrawalMoney();
52 }
53 return this;
54 }
55 public WithdrawalView checkMoney(String money){
56 if(!Check.checkMoney(money)){
57 ShowView.Withdrawal.showError();
58 checkMoney(getMoney());
59 }else{
60 ShowView.Withdrawal.showSuccess();
61 commonController.withdrawal(Double.parseDouble(money.trim()));
62 new MainView(atmABC);
63 }
64 return this;
65 }
66 }
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.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 import java.util.List;
8
9 /**
10 *ATM机的实现类
11 *本类为农业银行的ATM机类
12 *本类继承自父类的方法有三个
13 *三个方法是：查询余额，存款，取款
14 *本类实现父类的抽象方法有一个
15 *实现的抽象方法是：开户
16 *本类成员属性有：银行类型
17 *成员属性银行类型使用枚举类赋值
18 */
19 public class ATMABC extends AATM{
20
21 /**成员变量定义区**/
22 private EBank type; //成员属性：定义发卡行名称
23 private BankABC bank; //成员属性：定义农业银行对象
24
25 /**构造方法定义区**/
26 /*无参构造方法*/
27 public ATMABC(){
28 this.card = new DepositCard(); //初始化：父类继承过来的储蓄卡对象
29 this.type = EBank.ABC; //初始化：枚举类给发卡行名称赋值
30 this.bank = BankABC.getBankABC(); //初始化：单例模式初始化银行对象
31 }
32
33 /**Override方法区**/
34 @Override
35 /*重写父类抽象方法实现开户功能*/
36 public boolean openAccount(String name,String id,String password){
37 card = new DepositCard(name,id,password); //根据传入参数实例化储蓄卡对象
38 card.setType(this.type); //给储蓄卡对象设置发卡行
39 card.setCardNumber(getStringNumber(8)); //给储蓄卡对象随机生成8位数卡号
40 for(DepositCard card:bank.getListCard()){ //循环遍历农业银行所有的已开户账户
41 if(this.card.equals(card)) //判断新生成储蓄卡对象是否在农业银行账户集合中存在
42 return false; //如果存在，返回false
43 }
44 bank.getListCard().add(card); //如果不存在，则将新开户账户加入到农业银行账户集合
45 return true; //并且返回true
46 }
47
48 /*getter方法区*/
49 public BankABC getBank(){ //获取农业银行的对象
50 return bank;
51 }
52 public EBank getType(){ //获取ATM机的银行类型属性
53 return type;
54 }
55 public List<DepositCard> getListCard(){ //获取农业银行账户集合
56 return bank.getListCard();
57 }
58 }
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 public void setListCard(List<DepositCard> listCard) {
31 this.listCard = listCard;
32 }
33
34 /*私有化的构造方法*/
35 private BankABC(){
36 type = EBank.ABC; //使用枚举类型初始化银行类型
37 name = type.getName(); //使用枚举类型的属性初始化银行名称
38 listCard = new ArrayList<DepositCard>(); //使用List接口的实现类ArrayList初始化银行卡账户集合
39 }
40
41 /*getter方法区*/
42 public static BankABC getBankABC(){ //定义静态工厂方法取得自身实例
43 return bank;
44 }
45 public EBank getEBank(){ //获取私有属性银行类型的值
46 return type;
47 }
48 public String getName(){ //获取私有属性银行名称的值
49 return name;
50 }
51 public List<DepositCard> getListCard(){ //获取私有属性银行卡账户集合的值
52 return listCard;
53 }
54 }
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() + "
"
101 + "姓名：" + getName() + "
"
102 + "身份证号：" + getId() + "
"
103 + "银行卡号：" + getCardNumber() + "
"
104 + "密码：" + getPassword() + "
"
105 + "余额：" + getBalance();
106 }
107 }
