前言：

　　最近一段時間學習的習題均意在讓我們加深瞭解類的繼承、多型性使用方法等等面對物件程式設計的特性。並且通過試題還了解到了一些程式設計的基本原則與java中的集合框架，通過習題的實踐還讓我瞭解到了合理設計類與合理設計類的功能的重要性。

7-1

　　考慮一款適合於小學生的卡片（Card）排序遊戲，其規則為隨機發放一些卡片給學生，卡片分為四種形狀：圓形（Circle）、矩形（Rectangle）、三角形（Triangle）及梯形（Trapezoid），並給出各種卡片的相應引數，要求學生能夠迅速求出各卡片的面積大小然後將卡片按照其面積值從大到小進行排序，同時求出所有卡片的面積之和。

輸入格式:

• 在一行上輸入一串數字（1~4，整數），其中，1代表圓形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各數字之間以一個或多個空格分隔，以“0”結束。例如：1 3 4 2 1 3 4 2 1 3 0
• 根據第一行數字所代表的卡片圖形型別，依次輸入各圖形的相關引數，例如：圓形卡片需要輸入圓的半徑，矩形卡片需要輸入矩形的寬和長，三角形卡片需要輸入三角形的三條邊長，梯形需要輸入梯形的上底、下底以及高。各資料之間用一個或多個空格分隔。

輸出格式:

• 如果圖形數量非法（<=0）或圖形屬性值非法（數值<0以及三角形三邊不能組成三角形），則輸出Wrong Format。
• 如果輸入合法，則正常輸出，所有數值計算後均保留小數點後兩位即可。輸出內容如下：

1. 排序前的各圖形型別及面積，格式為[圖形名稱1:面積值1圖形名稱2:面積值2 …圖形名稱n:面積值n ]，注意，各圖形輸出之間用空格分開，且輸出最後存在一個用於分隔的空格，在結束符“]”之前；
2. 輸出分組後的圖形型別及面積，格式為[圓形分組各圖形型別及面積][矩形分組各圖形型別及面積][三角形分組各圖形型別及面積][梯形分組各圖形型別及面積]，各組內格式為圖形名稱:面積值。按照“Circle、Rectangle、Triangle、Trapezoid”的順序依次輸出；
3. 各組內圖形排序後的各圖形型別及面積，格式同排序前各組圖形的輸出；
4. 各組中面積之和的最大值輸出，格式為The max area:面積值

參考類圖：

不同形狀均繼承Shape，在card類中依賴了一個Shape型別的物件，由於各種形狀都繼承Shape於是該變數可以表示任意一個形狀，體現了多型性。

做為抽象類的shape類，其中定義了得到面積getarea方法的，用來檢驗輸入資料是否正確的validate方法，還有重寫了object類的就是tostring方法，繼承了他的子類，就可以利用這些方法來檢測自身資料是否合理，或者重寫方法得到面積，卡類依賴了一個shape類，通過實現介面可以使得它可以簡單排序。　　　　　　

由題目可知要求依據面積對幾個形狀的 進行排序，可以用collections的sort方法對一個列表的元素進行快速排序，為了讓列表中的元素依照指定的方式進行排序使Card類實現comparable介面並重寫介面方法，依據面積進行排序。

@Override
    public int compareTo(Card o) {
        // TODO 自動生成的方法存根
        if(shape.getArea()>o.getShape().getArea())
            return -1;
        if(shape.getArea()==o.getShape().getArea())
            return 0;
        if(shape.getArea()<o.getShape().getArea())
            return 1;
         return 0;
    }
}

　　在習題7-2中要求

輸入的圖形按照圖形型別進行分組並輸出

輸出格式:

• 如果圖形數量非法（<=0）或圖形屬性值非法（數值<0以及三角形三邊不能組成三角形），則輸出Wrong Format。
• 如果輸入合法，則正常輸出，所有數值計算後均保留小數點後兩位即可。輸出內容如下：

1. 排序前的各圖形型別及面積，格式為[圖形名稱1:面積值1圖形名稱2:面積值2 …圖形名稱n:面積值n ]，注意，各圖形輸出之間用空格分開，且輸出最後存在一個用於分隔的空格，在結束符“]”之前；
2. 輸出分組後的圖形型別及面積，格式為[圓形分組各圖形型別及面積][矩形分組各圖形型別及面積][三角形分組各圖形型別及面積][梯形分組各圖形型別及面積]，各組內格式為圖形名稱:面積值。按照“Circle、Rectangle、Triangle、Trapezoid”的順序依次輸出；
3. 各組內圖形排序後的各圖形型別及面積，格式同排序前各組圖形的輸出；
4. 各組中面積之和的最大值輸出，格式為The max area:面積值。

　　可知只需要在對各個相同的圖形類做一個合併就可以，可以格外設立多個列表裝入相同形狀的物件如何利用sort方法就可以做到快速排序。

 1 ArrayList<Card> carlist=new ArrayList<>();
 2     ArrayList<Card> listOfci=new ArrayList<>();
 3     ArrayList<Card> listOfjuxing=new ArrayList<>();
 4     ArrayList<Card> listOfsjx=new ArrayList<>();
 5     ArrayList<Card> listOftixing=new ArrayList<>();
 6     DealCardList(ArrayList<Integer> list){
 7         for(int i=0;i<list.size();i++) {
 8             if(list.get(i)==1) {
 9                 Circle ci=new Circle(Main.input.nextDouble());
10                 carlist.add(new Card(ci));
11                 listOfci.add(carlist.get(i));
12             }
13         if(list.get(i)==2) {
14             cfx cf=new cfx(Main.input.nextDouble(), Main.input.nextDouble());
15             carlist.add(new Card(cf));
16             listOfjuxing.add(carlist.get(i));
17         }
18         if(list.get(i)==3) {
19             carlist.add(new Card(new sjx(Main.input.nextDouble(), Main.input.nextDouble(),Main.input.nextDouble())));
20         listOfsjx.add(carlist.get(i));}
21             if(list.get(i)==4) {
22             
23         carlist.add(new Card(new tixing(Main.input.nextDouble(), Main.input.nextDouble(), Main.input.nextDouble())));
24         listOftixing.add(carlist.get(i));
25         }
26     }
27     

7-1 7-2 Atm類設計　　

1.作業目標編寫一個銀行ATM機的模擬程式，能夠完成使用者的存款、取款以及查詢餘額功能。

輸入格式:

每一行輸入一次業務操作，可以輸入多行，最終以字元#終止。具體每種業務操作輸入格式如下：

• 存款、取款功能輸入資料格式：卡號 密碼 ATM機編號 金額（由一個或多個空格分隔）， 其中，當金額大於0時，代表取款，否則代表存款。
• 查詢餘額功能輸入資料格式：卡號　　

　　　本次作業中銀行卡包含借記卡和信用卡兩類，且允許跨行辦理相關業務,借記業務與跨行取款業務均需要手續費。

　　　手續費預設均從銀行卡所對應的賬戶中自動扣除。

　　　跨行業務手續費收取比例由ATM機隸屬銀行決定，例如，使用者手持中國工商銀行的銀行卡在中國建設銀行的ATM上進行取款操作，則手續費收取比例為中國建設銀行的相應比例，按初始化資料中的規定為取款金額的2%。

　　　跨行查詢餘額不收取手續費。

　　　透支取款手續費由中國銀聯統一規定為5%，最大透支金額均為50000元

類圖：

可知程式的一切功能都由UnionPay進入，程式的資料初始化由InitDate類來完成，模擬的借記操作由Withdraw類來完成，下面放上程式碼。

  1 package Ptatext;
  2 
  3 import java.util.ArrayList;
  4 import java.util.Iterator;
  5 import java.util.Scanner;
  6 import java.util.regex.Matcher;
  7 import java.util.regex.Pattern;
  8 
  9 /**
 10  * 賬戶抽象類
 11  * 
 12  * @author Administrator
 13  * @date
 14  */
 15 abstract class AbstractAccount {
 16     private String accountNO;// 賬號
 17     private double balance = 0;// 餘額
 18     private User user = null;// 使用者
 19     private Bank bank = null;// 所屬銀行
 20     private double ratio = 0;// 透支取款手續費
 21     private double overdrawAmount = 0;// 可透支金額
 22     private static ArrayList<Card> list = new ArrayList<Card>();
 23 
 24     public AbstractAccount() {
 25         super();
 26         // TODO Auto-generated constructor stub
 27     }
 28 
 29     public AbstractAccount(String accountNO, double balance, User user, Bank bank, double ratio,
 30         double overdrawAmount) {
 31         super();
 32         this.accountNO = accountNO;
 33         this.balance = balance;
 34         this.user = user;
 35         this.bank = bank;
 36         this.ratio = ratio;
 37         this.overdrawAmount = overdrawAmount;
 38     }
 39 
 40     public String getAccountNO() {
 41         return accountNO;
 42     }
 43 
 44     public void setAccountNO(String accountNO) {
 45         this.accountNO = accountNO;
 46     }
 47 
 48     public double getBalance() {
 49         return balance;
 50     }
 51 
 52     public void setBalance(double balance) {
 53         this.balance = balance;
 54     }
 55 
 56     public User getUser() {
 57         return user;
 58     }
 59 
 60     public void setUser(User user) {
 61         this.user = user;
 62     }
 63 
 64     public double getOverdrawAmount() {
 65         return overdrawAmount;
 66     }
 67 
 68     public void setOverdrawAmount(double overdrawAmount) {
 69         this.overdrawAmount = overdrawAmount;
 70     }
 71 
 72     public Bank getBank() {
 73         return bank;
 74     }
 75 
 76     public void setBank(Bank bank) {
 77         this.bank = bank;
 78     }
 79 
 80     public double getRatio() {
 81         return ratio;
 82     }
 83 
 84     public void setRatio(double ratio) {
 85         this.ratio = ratio;
 86     }
 87 
 88     public static ArrayList<Card> getList() {
 89         return list;
 90     }
 91 
 92     public static void setList(ArrayList<Card> list) {
 93         AbstractAccount.list = list;
 94     }
 95 
 96     public void addCard(Card card) {
 97         list.add(card);
 98     }
 99 
100     public void removeCard(Card card) {
101         list.remove(card);
102     }
103 }
104 
105 /**
106  * ATM機類
107  * 
108  * @author Administrator
109  * @date
110  */
111 class ATM {
112     private String ATMID;
113     private Bank bank = null;// ATM所隸屬銀行
114 
115     public ATM() {
116         super();
117         // TODO Auto-generated constructor stub
118     }
119 
120     public ATM(String aTMID, Bank bank) {
121         super();
122         ATMID = aTMID;
123         this.bank = bank;
124     }
125 
126     public String getATMID() {
127         return ATMID;
128     }
129 
130     public void setATMID(String aTMID) {
131         ATMID = aTMID;
132     }
133 
134     public Bank getBank() {
135         return bank;
136     }
137 
138     public void setBank(Bank bank) {
139         this.bank = bank;
140     }
141 }
142 
143 /**
144  * 工具類，和上次程式不同處之一，希望大家思考下該類的作用
145  * 
146  * @author Administrator
147  * @date
148  */
149 class ATMUtil {
150     /**
151      * 根據卡號獲取銀行卡，卡號正確則返回卡物件，否則返回null
152      * 
153      * @param unionPay
154      * @param cardNO
155      * @return
156      */
157     public static Card getCardbyCardNO(UnionPay unionPay, String cardNO) {
158         Card card = null;
159         Iterator<Bank> bankItr = unionPay.getBankList().iterator();
160 
161         while (bankItr.hasNext()) {
162             ArrayList<AbstractAccount> accountList = bankItr.next().getAccountList();
163             Iterator<AbstractAccount> accountItr = accountList.iterator();
164             while (accountItr.hasNext()) {
165                 ArrayList<Card> cardList = accountItr.next().getList();
166                 Iterator<Card> cardItr = cardList.iterator();
167                 while (cardItr.hasNext()) {
168                     card = cardItr.next();
169                     if (card.getCardNO().equals(cardNO)) {
170                         return card;
171                     }
172                 }
173             }
174         }
175         return null;
176     }
177 
178     /**
179      * 根據ATM ID求得ATM物件，如果ID正確則返回ATM物件，否則返回null
180      * 
181      * @param unionPay
182      * @param ATMID
183      * @return
184      */
185     public static ATM getATMbyATMID(UnionPay unionPay, String ATMID) {
186         Iterator<Bank> bankItr = unionPay.getBankList().iterator();
187         Bank bank = null;
188         ATM aTM = null;
189 
190         while (bankItr.hasNext()) {
191             bank = bankItr.next();
192             Iterator<ATM> aTMItr = bank.getATMList().iterator();
193 
194             while (aTMItr.hasNext()) {
195                 aTM = aTMItr.next();
196                 if (aTM.getATMID().equals(ATMID)) {
197                     return aTM;
198                 }
199             }
200         }
201         return null;
202     }
203 
204     /**
205      * 根據卡號獲取改卡所隸屬的賬號，若卡號正確，則返回賬號物件，否則返回null
206      * 
207      * @param cardNO
208      * @return
209      */
210     public static AbstractAccount getAccountbyCardNO(String cardNO) {
211         Iterator<Card> cardItr = AbstractAccount.getList().iterator();
212         Card card = null;
213 
214         while (cardItr.hasNext()) {
215             card = cardItr.next();
216             if (card.getCardNO().equals(cardNO)) {
217                 return card.getAccount();
218             }
219         }
220         return null;
221     }
222 }
223 
224 /**
225  * 銀行類
226  * 
227  * @author Administrator
228  * @date
229  */
230 class Bank {
231     private String bankNO;// 銀行編號
232     private String bankName;// 銀行名稱
233     private double commission;// 跨行業務收取的手續費
234     // 銀行擁有的賬戶列表
235     private ArrayList<AbstractAccount> accountList = new ArrayList<AbstractAccount>();
236     // 銀行擁有的ATM機列表
237     private ArrayList<ATM> ATMList = new ArrayList<ATM>();
238 
239     public Bank() {
240         super();
241         // TODO Auto-generated constructor stub
242     }
243 
244     public Bank(String bankNO, String bankName, double commission) {
245         super();
246         this.bankNO = bankNO;
247         this.bankName = bankName;
248         this.commission = commission;
249     }
250 
251     public String getBankNO() {
252         return bankNO;
253     }
254 
255     public void setBankNO(String bankNO) {
256         this.bankNO = bankNO;
257     }
258 
259     public String getBankName() {
260         return bankName;
261     }
262 
263     public void setBankName(String bankName) {
264         this.bankName = bankName;
265     }
266 
267     public double getCommission() {
268         return commission;
269     }
270 
271     public void setCommission(double commission) {
272         this.commission = commission;
273     }
274 
275     public void addAccount(AbstractAccount account) {
276         this.accountList.add(account);
277     }
278 
279     public void removeAccount(AbstractAccount account) {
280         this.accountList.remove(account);
281     }
282 
283     public void addATM(ATM aTM) {
284         this.ATMList.add(aTM);
285     }
286 
287     public void removeATM(ATM aTM) {
288         this.ATMList.remove(aTM);
289     }
290 
291     public ArrayList<AbstractAccount> getAccountList() {
292         return accountList;
293     }
294 
295     public void setAccountList(ArrayList<AbstractAccount> accountList) {
296         this.accountList = accountList;
297     }
298 
299     public ArrayList<ATM> getATMList() {
300         return ATMList;
301     }
302 
303     public void setATMList(ArrayList<ATM> aTMList) {
304         ATMList = aTMList;
305     }
306 }
307 
308 /**
309  * 銀行卡類，大家思考下該類與賬戶類的關係，例如使用者的餘額為什麼不是設定在Card類中
310  * 
311  * @author Administrator
312  * @date
313  */
314 class Card {
315     private String cardNO;// 卡號
316     private String cardPassword;// 密碼
317     private AbstractAccount account = null;// 該卡所屬賬號
318 
319     public Card() {
320         super();
321         // TODO Auto-generated constructor stub
322     }
323 
324     public Card(String cardNO, String cardPassword, AbstractAccount account) {
325         super();
326         this.cardNO = cardNO;
327         this.cardPassword = cardPassword;
328         this.account = account;
329     }
330 
331     public String getCardNO() {
332         return cardNO;
333     }
334 
335     public void setCardNO(String cardNO) {
336         this.cardNO = cardNO;
337     }
338 
339     public String getCardPassword() {
340         return cardPassword;
341     }
342 
343     public AbstractAccount getAccount() {
344         return account;
345     }
346 
347     public void setAccount(AbstractAccount account) {
348         this.account = account;
349     }
350 
351     public void setCardPassword(String cardPassword) {
352         this.cardPassword = cardPassword;
353     }
354 
355     public boolean checkCard() {
356         Pattern p = Pattern.compile("\\d{16}+");
357         Matcher m = p.matcher(this.cardNO);
358         return m.matches();
359     }
360 
361     public boolean checkPassword(String password) {
362         return this.cardPassword.equals(password);
363     }
364 
365 }
366 
367 /**
368  * 信用卡類，繼承自抽象賬戶類
369  * 
370  * @author Administrator
371  * @date
372  */
373 class CreditAccount extends AbstractAccount {
374 
375     public CreditAccount() {// 貸記賬戶
376         super();
377         // TODO Auto-generated constructor stub
378         this.setRatio(0.05);
379     }
380 
381     public CreditAccount(String accountNO, double balance, User user, Bank bank, double ratio, double overdrawAmount) {
382         super(accountNO, balance, user, bank, 0.05, 50000.00);// 這是取巧但並不好的一種設計，大家思考下
383         // TODO Auto-generated constructor stub
384     }
385 }
386 
387 /**
388  * 借記卡類，繼承自抽象賬戶類
389  * 
390  * @author Administrator
391  * @date 2021/06/12
392  */
393 class DebitAccount extends AbstractAccount {// 借記賬戶
394 
395     public DebitAccount() {
396         super();
397         this.setRatio(0);
398         // TODO Auto-generated constructor stub
399     }
400 
401     public DebitAccount(String accountNO, double balance, User user, Bank bank, double ratio, double overdrawAmount) {
402         super(accountNO, balance, user, bank, 0, 0.00);// 同信用卡類的設計
403         // TODO Auto-generated constructor stub
404     }
405 }
406 
407 /**
408  * 業務類，查詢餘額
409  * 
410  * @author Administrator
411  * @date
412  */
413 class GetBalance {
414     private UnionPay unionPay;// UnionPay類為一切業務類的入口
415 
416     public GetBalance() {
417         super();
418         // TODO Auto-generated constructor stub
419     }
420 
421     public GetBalance(UnionPay unionPay) {
422         super();
423         this.unionPay = unionPay;
424     }
425 
426     public double getBalance(String cardNO) {
427         return ATMUtil.getCardbyCardNO(unionPay, cardNO).getAccount().getBalance();
428     }
429 }
430 
431 /**
432  * 資料初始化類
433  * 
434  * @author Administrator
435  * @date
436  */
437 class InitData {
438 
439     public InitData() {
440         // TODO Auto-generated constructor stub
441     }
442 
443     public static UnionPay initData() {
444         UnionPay unionPay = new UnionPay();
445 
446         Bank ccb = new Bank("1001", "中國建設銀行", 0.02);
447         Bank icbc = new Bank("1002", "中國工商銀行", 0.03);
448         Bank abc = new Bank("1003", "中國農業銀行", 0.04);// new
449         unionPay.addBank(ccb);
450         unionPay.addBank(icbc);
451         unionPay.addBank(abc);// new
452 
453         ATM aTM1 = new ATM("01", ccb);
454         ATM aTM2 = new ATM("02", ccb);
455         ATM aTM3 = new ATM("03", ccb);
456         ATM aTM4 = new ATM("04", ccb);
457         ATM aTM5 = new ATM("05", icbc);
458         ATM aTM6 = new ATM("06", icbc);
459         ATM aTM7 = new ATM("07", abc);// new
460         ATM aTM8 = new ATM("08", abc);// new
461         ATM aTM9 = new ATM("09", abc);// new
462         ATM aTM10 = new ATM("10", abc);// new
463         ATM aTM11 = new ATM("11", abc);// new
464 
465         ccb.addATM(aTM1);
466         ccb.addATM(aTM2);
467         ccb.addATM(aTM3);
468         ccb.addATM(aTM4);
469         icbc.addATM(aTM5);
470         icbc.addATM(aTM6);
471         abc.addATM(aTM7);// new
472         abc.addATM(aTM8);// new
473         abc.addATM(aTM9);// new
474         abc.addATM(aTM10);// new
475         abc.addATM(aTM11);// new
476 
477         User Yangguo = new User("360101200102122324", "楊過", "13856223254");
478         User Guojing = new User("360101200012302552", "郭靖", "13800021124");
479         User Zhangwuji = new User("360502199805163221", "張無忌", "13952110011");
480         User Weixiaobao = new User("360201200513243326", "韋小寶", "13025996587");
481         User Zhangsanfeng = new User("360102199713459810", "張三丰", "13677871290");// new
482         User Linghuchong = new User("360503190299878473", "令狐沖", "13609899238");// new
483         User Qiaofeng = new User("360607194313666711", "喬峰", "13677871290");// new
484         User Hongqigong = new User("363220987809872234", "洪七公", "13609009454");// new
485 
486         AbstractAccount ccbAcc1 = new DebitAccount("3217000010041315709", 10000.00, Yangguo, ccb, 0, 0);
487         AbstractAccount ccbAcc2 = new DebitAccount("3217000010041315715", 10000.00, Yangguo, ccb, 0, 0);
488         AbstractAccount ccbAcc3 = new DebitAccount("3217000010051320007", 10000.00, Guojing, ccb, 0, 0);
489         AbstractAccount ccbAcc4 = new CreditAccount("3640000010045442002", 10000.00, Zhangsanfeng, ccb, 0.05, 50000.00);// new
490 
491         AbstractAccount icbcAcc1 = new DebitAccount("3222081502001312389", 10000.00, Zhangwuji, icbc, 0, 0);
492         AbstractAccount icbcAcc2 = new DebitAccount("3222081502001312390", 10000.00, Zhangwuji, icbc, 0, 0);
493         AbstractAccount icbcAcc3 = new DebitAccount("3222081502001312399", 10000.00, Zhangwuji, icbc, 0, 0);
494         AbstractAccount icbcAcc4 = new DebitAccount("3222081502051320785", 10000.00, Weixiaobao, icbc, 0, 0);
495         AbstractAccount icbcAcc5 = new DebitAccount("3222081502051320786", 10000.00, Weixiaobao, icbc, 0, 0);
496         AbstractAccount icbcAcc6 =
497             new CreditAccount("3640000010045441009", 10000.00, Linghuchong, icbc, 0.05, 50000.00);// new
498 
499         AbstractAccount abcAcc1 = new CreditAccount("3630000010033431001", 10000.00, Qiaofeng, abc, 0.05, 50000.00);// new
500         AbstractAccount abcAcc2 = new CreditAccount("3630000010033431008", 10000.00, Hongqigong, abc, 0.05, 50000.00);// new
501 
502         ccb.addAccount(ccbAcc1);
503         ccb.addAccount(ccbAcc2);
504         ccb.addAccount(ccbAcc3);
505         ccb.addAccount(ccbAcc4);// new
506 
507         icbc.addAccount(icbcAcc1);
508         icbc.addAccount(icbcAcc2);
509         icbc.addAccount(icbcAcc3);
510         icbc.addAccount(icbcAcc4);
511         icbc.addAccount(icbcAcc5);
512         icbc.addAccount(icbcAcc6);// new
513 
514         abc.addAccount(abcAcc1);// new
515         abc.addAccount(abcAcc2);// new
516 
517         Yangguo.addAccount(ccbAcc1);
518         Yangguo.addAccount(ccbAcc2);
519         Guojing.addAccount(ccbAcc3);
520         Zhangsanfeng.addAccount(ccbAcc4);// new
521 
522         Zhangwuji.addAccount(icbcAcc1);
523         Zhangwuji.addAccount(icbcAcc2);
524         Zhangwuji.addAccount(icbcAcc3);
525         Weixiaobao.addAccount(icbcAcc4);
526         Weixiaobao.addAccount(icbcAcc5);
527         Linghuchong.addAccount(icbcAcc6);// new
528 
529         Qiaofeng.addAccount(abcAcc1);// new
530         Hongqigong.addAccount(abcAcc2);// new
531 
532         Card ccbCard1 = new Card("6217000010041315709", "88888888", ccbAcc1);
533         Card ccbCard2 = new Card("6217000010041315715", "88888888", ccbAcc1);
534         Card ccbCard3 = new Card("6217000010041315718", "88888888", ccbAcc2);
535         Card ccbCard4 = new Card("6217000010051320007", "88888888", ccbAcc3);
536 
537         Card icbcCard5 = new Card("6222081502001312389", "88888888", icbcAcc1);
538         Card icbcCard6 = new Card("6222081502001312390", "88888888", icbcAcc2);
539         Card icbcCard7 = new Card("6222081502001312399", "88888888", icbcAcc3);
540         Card icbcCard8 = new Card("6222081502001312400", "88888888", icbcAcc3);
541         Card icbcCard9 = new Card("6222081502051320785", "88888888", icbcAcc4);
542         Card icbcCard10 = new Card("6222081502051320786", "88888888", icbcAcc5);
543 
544         Card ccbCard11 = new Card("6640000010045442002", "88888888", ccbAcc4);// new
545         Card ccbCard12 = new Card("6640000010045442003", "88888888", ccbAcc4);// new
546 
547         Card icbcCard13 = new Card("6640000010045441009", "88888888", icbcAcc6);// new
548 
549         Card abcCard14 = new Card("6630000010033431001", "88888888", abcAcc1);// new
550         Card abcCard15 = new Card("6630000010033431008", "88888888", abcAcc2);// new
551 
552         ccbAcc1.addCard(ccbCard1);
553         ccbAcc1.addCard(ccbCard2);
554         ccbAcc2.addCard(ccbCard3);
555         ccbAcc3.addCard(ccbCard4);
556         ccbAcc4.addCard(ccbCard11);// new
557         ccbAcc4.addCard(ccbCard12);// new
558 
559         icbcAcc1.addCard(icbcCard5);
560         icbcAcc2.addCard(icbcCard6);
561         icbcAcc3.addCard(icbcCard7);
562         icbcAcc3.addCard(icbcCard8);
563         icbcAcc4.addCard(icbcCard9);
564         icbcAcc5.addCard(icbcCard10);
565         icbcAcc6.addCard(icbcCard13);// new
566 
567         abcAcc1.addCard(abcCard14);// new
568         abcAcc2.addCard(abcCard15);// new
569 
570         return unionPay;
571     }
572 }
573 
574 /**
575  * 銀聯類
576  * 
577  * @author Administrator
578  * @date
579  */
580 class UnionPay {
581     private ArrayList<Bank> bankList = new ArrayList<Bank>();// 銀聯包含的銀行列表
582 
583     public UnionPay() {
584         super();
585         // TODO Auto-generated constructor stub
586     }
587 
588     public UnionPay(ArrayList<Bank> bankList) {
589         super();
590         this.bankList = bankList;
591     }
592 
593     public ArrayList<Bank> getBankList() {
594         return bankList;
595     }
596 
597     public void setBankList(ArrayList<Bank> bankList) {
598         this.bankList = bankList;
599     }
600 
601     public void addBank(Bank bank) {
602         this.bankList.add(bank);
603     }
604 
605     public void removeBank(Bank bank) {
606         this.bankList.remove(bank);
607     }
608 }
609 
610 /**
611  * 使用者類
612  * 
613  * @author Administrator
614  * @date
615  */
616 class User {
617     private String ID;// 身份證號
618     private String name;// 姓名
619     private String Phone;// 電話號碼
620     ArrayList<AbstractAccount> list = new ArrayList<AbstractAccount>();// 該使用者擁有的賬戶列表（注意，賬戶可能隸屬於不同銀行
621 
622     public User() {
623         super();
624         // TODO Auto-generated constructor stub
625     }
626 
627     public User(String iD, String name, String phone) {
628         super();
629         ID = iD;
630         this.name = name;
631         Phone = phone;
632     }
633 
634     public String getID() {
635         return ID;
636     }
637 
638     public void setID(String iD) {
639         ID = iD;
640     }
641 
642     public String getPhone() {
643         return Phone;
644     }
645 
646     public void setPhone(String phone) {
647         Phone = phone;
648     }
649 
650     public String getName() {
651         return name;
652     }
653 
654     public void setName(String name) {
655         this.name = name;
656     }
657 
658     public void addAccount(AbstractAccount ccbAcc1) {
659         this.list.add(ccbAcc1);
660     }
661 
662     public void removeAccount(DebitAccount account) {
663         this.list.remove(account);
664     }
665 }
666 
667 /**
668  * 業務類，取款類
669  * 
670  * @author Administrator
671  * @date
672  */
673 class Withdraw {
674     // 以下屬性為取款需要輸入的資訊
675     private UnionPay unionPay;// 銀聯，一切業務操作的入口
676     private String cardNO;// 卡號
677     private String cardPassword;// 密碼
678     private String ATMID;// ATM編號
679     private double amount;// 取款金額
680 
681     // 根據卡號獲取卡物件
682     private Card card = null;
683     // 根據ATM編號獲取ATM物件
684     private ATM aTM = null;
685     // 根據卡號獲取對應賬號
686     private AbstractAccount account = null;
687     // 根據ATM或ATM所屬銀行物件
688     private Bank bank = null;
689 
690     public Withdraw() {
691         super();
692         // TODO Auto-generated constructor stub
693     }
694 
695     /**
696      * 
697      * @param unionPay
698      * @param cardNO
699      * @param cardPassword
700      * @param aTMID
701      * @param amount
702      */
703     public Withdraw(UnionPay unionPay, String cardNO, String cardPassword, String aTMID, double amount) {
704         super();
705         this.unionPay = unionPay;
706         this.cardNO = cardNO;
707         this.cardPassword = cardPassword;
708         ATMID = aTMID;
709         this.amount = amount;
710     }
711 
712     /**
713      * 求跨行業務手續費
714      * 
715      * @return
716      */
717     public double getCrossBankCommission(double amount) {
718         return amount * bank.getCommission();
719     }
720 
721     /**
722      * 求透支取款手續費
723      * 
724      * @param amount
725      * @return
726      */
727     public double getOverdrawCommission(double amount) {
728         return amount * account.getRatio();
729     }
730 
731     /**
732      * 校驗是否為跨行取款
733      */
734     public boolean isCrossBank() {
735         if (account.getBank().getBankNO() != aTM.getBank().getBankNO()) {
736             return true;
737         }
738         return false;
739     }
740 
741     /**
742      * 判斷是否為信用卡
743      * 
744      * @return
745      */
746     public boolean isCreditAccount() {
747         if (account instanceof CreditAccount) {
748             return true;
749         }
750         return false;
751     }
752 
753     /**
754      * 校驗輸入的資料是否正確 注意：該方法不支援開閉原則，大家可以思考如何設計才能針對各種銀行卡均能夠實現開閉原則
755      * 
756      * @return
757      */
758     public boolean checkData() {
759 
760         // 獲取銀行卡物件
761         card = ATMUtil.getCardbyCardNO(unionPay, cardNO);
762 
763         // 銀行卡不存在（卡號錯誤）
764         if (card == null) {
765             System.out.println("Sorry,this card does not exist.");
766             return false;
767         }
768 
769         // 獲取ATM機物件
770         aTM = ATMUtil.getATMbyATMID(unionPay, ATMID);
771 
772         // ATM機不存在（ATM ID錯誤）
773         if (aTM == null) {
774             System.out.println("Sorry,the ATM's id is wrong.");
775             return false;
776         }
777 
778         // 獲取ATM機所隸屬銀行物件
779         bank = aTM.getBank();
780 
781         // 使用者密碼錯誤
782         if (!card.getCardPassword().equals(cardPassword)) {
783             System.out.println("Sorry,your password is wrong.");
784             return false;
785         }
786 
787         // 根據卡號獲取使用者賬號
788         account = ATMUtil.getAccountbyCardNO(cardNO);
789 
790         // 如果為借記卡
791         if (!isCreditAccount()) {
792             double commission = 0;
793 
794             // 如果為跨行業務，則收取跨行費用
795             if (this.isCrossBank()) {
796                 commission += this.getCrossBankCommission(amount);
797             }
798             // 取款超出餘額
799             if (amount + commission > account.getBalance()) {
800                 System.out.println("Sorry,your account balance is insufficient.");
801                 return false;
802             }
803         }
804 
805         // 如果為信用卡
806         if (isCreditAccount()) {
807             double commission = 0; // 手續費總額
808             double overdrawAmount = 0; // 透支金額
809             double balance = 0; // 當前卡上餘額
810 
811             balance = account.getBalance(); // 獲取當前卡餘額
812 
813             // 有餘額，則透支金額為取款金額與餘額的差值
814             if (balance >= 0) {
815                 overdrawAmount = amount - account.getBalance();
816             } else {// 餘額為負值（已經透支），則透支金額為取款金額
817                 overdrawAmount = amount;
818             }
819 
820             // 收取跨行業務費用
821             if (this.isCrossBank()) {
822                 commission += this.getCrossBankCommission(amount);
823             }
824             // 收取透支費用
825             if (overdrawAmount > 0) {
826                 commission += this.getOverdrawCommission(overdrawAmount);
827             }
828 
829             // 如果取款金額與手續費金額之和大於卡片餘額與可透支最大金額之和，無法取款
830             if (commission + amount > account.getBalance() + account.getOverdrawAmount()) {
831                 System.out.println("Sorry,your account balance is insufficient.");
832                 return false;
833             }
834         }
835 
836         return true;
837     }
838 
839     /**
840      * 該方法支援開閉原則
841      */
842     public void withdraw() {
843         double commission = 0;
844         double overdrawAmount = 0;
845         double balance = 0;
846 
847         balance = account.getBalance();
848 
849         if (balance >= 0) {
850             overdrawAmount = amount - account.getBalance();
851         } else {
852             overdrawAmount = amount;
853         }
854 
855         // 收取跨行費用
856         if (this.isCrossBank()) {
857             commission += this.getCrossBankCommission(amount);
858         }
859         // 收取透支費用
860         if (overdrawAmount > 0) {
861             commission += this.getOverdrawCommission(overdrawAmount);
862         }
863 
864         if (commission + amount > balance + account.getOverdrawAmount()) {
865             System.out.println("Sorry,your account balance is insufficient.");
866             System.exit(0);
867         }
868 
869         this.account.setBalance(balance - amount - commission);
870         showResult(this.account);
871     }
872 
873     /**
874      * 顯示
875      * 
876      * @param account
877      */
878     public void showResult(AbstractAccount account) {
879         String userName = account.getUser().getName();
880         String bankName = aTM.getBank().getBankName();
881         System.out
882             .println("業務：取款 " + userName + "在" + bankName + "的" + ATMID + "號ATM機上取款" + String.format("¥%.2f", amount));
883 
884         System.out.println("當前餘額為" + String.format("¥%.2f", account.getBalance()));
885     }
886 }
887 
888 public class Atm類設計 {
889     public static void main(String[] args) {
890         Scanner input = new Scanner(System.in);
891 
892         UnionPay unionPay = InitData.initData();// 初始化程式資料
893 
894         StringBuilder sb = new StringBuilder();// 用於接收輸入資料
895 
896         String data;
897 
898         // 解析輸入各行資料
899         while (!((data = input.nextLine()).equals("#"))) {
900             sb.append(data + "\n");
901         }
902 
903         String[] dt = sb.toString().split("\n");
904         for (int i = 0; i < dt.length; i++) {
905             String[] dataLine = dt[i].toString().split("\\s+");
906 
907             if (dataLine.length == 1) {// 查詢餘額功能
908                 GetBalance gb = new GetBalance(unionPay);
909                 System.out.println("業務：查詢餘額 " + String.format("¥%.2f", gb.getBalance(dataLine[0])));
910             } else {// 取款功能
911                 Withdraw wd =
912                     new Withdraw(unionPay, dataLine[0], dataLine[1], dataLine[2], Double.parseDouble(dataLine[3]));
913                 if (wd.checkData()) {
914                     wd.withdraw();
915                 } else {
916                     System.exit(0);
917                 }
918             }
919         }
920     }
921 }

　　在寫這題的難處就在於各個功能如何去實現以及各個類如何去設計以及各個類之間的關係。就拿我之前的設計來說

class user{
    String name;
    
    ArrayList<BankCount> mycount=new ArrayList<>();//我的銀行賬號
    public user(String name) {
        this.name = name;
        
        
    }

}

class Yanguo extends user{
    Yanguo(){
        super("楊過");
    BankCount one=new BankCount("中國建設銀行","3217000010041315709");
        one.cardnumb.add("6217000010041315709");
        one.cardnumb.add("6217000010041315715");
        BankCount two=new BankCount("中國建設銀行", "3217000010041315715");
        two.cardnumb.add("6217000010041315718");
        mycount.add(one);
        mycount.add(two);
        
    }
    
}
class Guojin extends user{

    public Guojin() {
    
        super("郭靖");
        // TODO 自動生成的建構函式存根
    BankCount one =new BankCount("中國建設銀行","3217000010051320007");
    one.cardnumb.add("6217000010051320007");
    
    
    }
    
}
class ZhanWuji extends user{

    public ZhanWuji() {
        super("張無忌");
        // TODO 自動生成的建構函式存根
    BankCount one=new BankCount("中國工商銀行", "3222081502001312389");
    one.cardnumb.add("6222081502001312389");
    BankCount two=new BankCount("中國工商銀行","3222081502001312390");
    two.cardnumb.add("6222081502001312390");
    BankCount three=new BankCount("中國工商銀行", "3222081502001312399");
    three.cardnumb.add("6222081502001312399");
    three.cardnumb.add("6222081502001312400");
    mycount.add(one);
    mycount.add(two);
    mycount.add(three);
    
    
    }
    
}

　　每個人（user）設計為一個類，明顯不符合類的設計標準，以及設計功能時以簡略為主，沒有考慮到類的設計原則，導致程式碼看起來雜亂難以看懂。

總結：

通過在這幾次的作業和課堂中我更加了解了java中類設計的原則，如

1、內聚性

類應該被描述為一個單一的實體，而所有的類操作應該在邏輯上相互配合，支援一個一致的目的。

2、一致性

遵循標準java程式設計風格和命名習慣，為類、資料域和方法選取具有資訊的名字，通常風格是將資料域的宣告置於構造方法之前，將構造方法置於方法之前，而對於在多個類中執行相同工作的方法，應該用同一個名字。

3、封裝性

一個類應該用private修飾符隱藏資料域，以免使用者直接訪問它，這使得類更易於維護，只有在希望資料可讀的情況下才提供get方法，希望資料可更新的情況下才提供set方法。

4、清晰性

使用者可以以各種不同組合、順序、以及在各種環境中結合使用多個類，因此在設計一個類時，這個類不應該限制使用者如何以及何時使用該類，方法應在不產生混淆的情況下直觀定義，不應該宣告一個來自其他資料域的資料域。

5、要用類名來引用靜態變數和方法。

6、不要從構造方法中直接傳引數初始化靜態資料域。最好使用靜態的set方法改變靜態資料域。

以及部分java程式設計的基本原則就比如：單一職責原則。

在上述Atm類設計中還對 lterator進行了一個基本瞭解

Iterator（迭代器）

java Iterator（迭代器）不是一個集合，它是一種用於訪問集合的方法，可用於迭代ArrayList和HashSet等集合。

Iterator 是 Java 迭代器最簡單的實現，ListIterator 是 Collection API 中的介面， 它擴充套件了 Iterator 介面

Java中的Iterator功能比較簡單，並且只能單向移動：

　　(1) 使用方法iterator()要求容器返回一個Iterator。第一次呼叫Iterator的next()方法時，它返回序列的第一個元素。注意：iterator()方法是java.lang.Iterable介面,被Collection繼承。

　　(2) 使用next()獲得序列中的下一個元素。

　　(3) 使用hasNext()檢查序列中是否還有元素。

　　(4) 使用remove()將迭代器新返回的元素刪除。

Listlterator

而ListIterator是一個功能更加強大的, 它繼承於Iterator介面,只能用於各種List型別的訪問

相較於上面的迭代器，listlterator可以實現雙向移動遍歷，也可以實現增加或替換元素。