Blogs 3
Blogs 3
一．知识点总结
- ArrayList类
Java提供了ArrayList类，可以用来存储不限定个数的对象。ArrayList类是一种泛型类，具有一个泛型类型E。创建一个ArrayList时，可以指定一个具体的类型来替换E。例如，下面语句创建一个ArrayList，并且将其引用赋值给变量cities。该ArrayList对象可以用于存储字符串。（其余几个类型同此）
ArrayList<String> cities = new ArrayList<>();
实例分析：
import java.util.ArrayList;
import java.util.Scanner;
public class text21 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Scanner input = new Scanner(System.in);
System.out.print("Enter integers(input ends with 0): ");
int value;
do {
value = input.nextInt();
if(!list.contains(value)&&value!=0)
list.add(value);
}while(value!=0);
System.out.print("The distinct numbers are:");
for(int i=0;i<list.size();i++) {
System.out.print(list.get(i)+" ");
}
}
}
此段代码创建了一个存储Integer对象的ArrayList，然后在循环中重复读入数值。对于每个值，如果不在列表中，则将其添加到列表中。可以重写该程序，使用数组替代ArrayList来存储元素。然而，使用ArrayList实现该程序更简单，原因如下：
①ArrayList的大小是灵活的，所以无须提前给定它的大小。而当创建一个数组时，它的大小必须给定。
②ArrayList包含许多有用的方法。比如，可以使用contains方法来测试某个元素是否在列表中。如果使用使用数组，则需要编写额外代码来实现该方法。
数组列表中的元素也可以使用foreach循环来进行遍历，语法如下：
for(elementType element:arrayList){
//Process the element
}
- Comparable接口
假设要设计一个找出两个相同类型对象中较大者的通用方法。这里的对象可以是两个学生、两个日期、两个圆、两个矩形或者两个正方形。为了实现这个方法，这两个对象必须是可比较的。因此，这两个对象都该有的共同行为就是comparable（可比较的）。为此，java提供了Comparable接口。接口的定义如下所示：
piblic interface Comparable<E>{
public int comparaTo(E o);
}
comparaTo 方法判断这个对象相对于给定对象o的顺序，并且当这个对象小于、等于或者大于给定对象o时，分别返回负整数、0或正整数。
Comparable 接口是一个泛型接口。在实现该接口时，泛型类型E被替换成一种具体的类型。Byte、Short、Integer、Long、Float、Double、Character、BigInteger、BigDecimal、Calendar、String以及Date类都实现了Comparable接口。
实例：实现Comparable接口重写compareTo方法
//创建一个汽车类 实现了Comparable接口 接口泛型传递Car
public class Car implements Comparable<Car> {
public int money ;
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
@Override
public int compareTo(Car o) {
return this.getMoney()-o.getMoney();
}
}
//测试方法
public class Test {
public static void main(String[] args) {
//创建汽车对象
Car car1 = new Car();
Car car2 = new Car();
//为每一辆车标金额
car1.setMoney(100);
car2.setMoney(200);
//调用重写的compareTo方法进行比较
int i = car1.compareTo(car2);
int j = car2.compareTo(car1);
int z = car1.compareTo(car1);
System.out.println(i); //结果是-100
System.out.println(j); //结果是 100
System.out.println(z); //结果是 0
}
}
- 类设计的几个原则
①单一职责原则（Single Resposibility Principle，SRP）
专注是一个人的优良品质，同样，单一职责也是一个类的优良设计。单一职责的核心思想：一个类只做好一件事情。
单一职责原则可以看作是高内聚、低耦合在面向对象原则上的引申。类的职责过多，容易导致类间职责依赖，提高耦合度，降低内聚性。通常意义下的单一职责，指的是类只有一种单一功能，不要为类设计过多的功能，交杂不清的功能会使代码杂乱，提高程序开发的难度和系统出错的概率，降低系统的可维护性。
要举个体现单一职责原则的最常见的例子无疑就是STL中的迭代器的设计。有些人觉得容器跟迭代器的分离是不好的设计，觉得增加了复杂度，不如直接把迭代器放在容器里更为简洁。不过很多人还是不这样认为，因为类的数量越多并不代表就越复杂，另外迭代器如果放到容器里面，就会暴露容器的一些内部结构，不太符合封装的思想。还有就是可扩展性的问题，因为对容器的访问遍历会有多种需求，如果把迭代器隔离开来你可以不修改容器类，再定义些特制的迭代器就行了，这样不管有什么奇怪的需求只要写个对应的迭代器出来就行了。
②开放封闭原则（Open Closed Principle，OCP）
开闭原则指的是开放封闭原则，即对扩展开放，对修改封闭。
所谓修改封闭，就是之前设计好的类，不要去修改。比如删除掉一个成员函数、改变成员函数的形参列表或更改数据成员类型等。实现对修改封闭，关键在于抽象化。对一个事物抽象化，实质上是对一个事物进行概括、归纳、总结，将其本质特征抽象地用一个类来表示，这样类才会相对稳定，无需更改。
所谓扩展开放，就是在不改变已存在的类的前提下可以添加很多功能。一般是通过继承和多态来实现，如此一来，可以保持父类的原样，只需在子类中添加些所需的新功能。
“需求总是变化的”，如果遵循开放封闭原则，合理设计就能封闭变化，使类能够灵活的扩展所需的功能。
③接口分离原则（Interface Segregation Principle，ISP）
该原则的核心思想是：使用多个小的专门的接口，而不要使用一个大的总接口。具体而言，接口应该是内聚的，应该避免“胖”接口。一个类对另一个类的依赖应该建立在最小的接口上，而不要强迫依赖不同的方法，这是一种接口污染。
其实简单点的讲与前面说的单一职责类似，这里的接口不是函数接口，而是一个类。C#中的有专门的接口interface，和类区分开来，而且C#中不像C++支持类的多继承，只支持接口的多继承，所以这里可以把接口理解成功能更小更特殊的类，一个接口可能就只要那么几个很少的方法就OK了。
接口分离手段主要有以下两种方式：
（1）利用委托分离接口；
（2）利用多重继承分离接口。
二．题目分析
- 题目集7-1 图形卡片排序游戏
总体来看，本题有以下几个重要知识点：继承、多态的应用；ArrayList泛型的应用方法；Comparable接口及泛型的应用；单一职责原则的应用；“开-闭”原则的应用。 特别地，本次作业在对卡片排序时使用了Comparable 接口，即Card 类实现了Comparable 接口中的 CompareTo()方法。此段源码示例如下：
class Card implements Comparable<Card>{
private Shape shape;
public Card() {
}
public Card(Shape shape) {
super();
this.shape = shape;
}
public Shape getShape() {
return shape;
}
public void setShape(Shape shape) {
this.shape = shape;
}
@Override
public int compareTo(Card card) {
double diff = card.getShape().getArea() - this.getShape().getArea();
if (diff > 0) {
return 1;
} else if (diff < 0) {
return -1;
} else {
return 0;
}
}
}
设计类图如下：
对于本题，给出以下心得和建议：
（1）此程序排序算法的运用应多加重视： （以下给出个人所用排序方式）
public int compareTo(Card card) {
double diff = card.getShape().getArea() - this.getShape().getArea();
if (diff > 0) {
return 1;
} else if (diff < 0) {
return -1;
} else {
return 0;
}
}
（2）在图形类的设计中，要体会面向对象设计原则中的“单一职责”“开-闭”原则的实现方法及其作用。
- 题目集7-2 图形卡片分组游戏
总体来看，本题沿袭了 7-1，主要对卡片（Card）进行分组游戏，要求必须在题目 7-1 的基础上进行进一步改进和完善，并且考虑面向对象设计的“单一职责原则”，思考该程序是否能够符合“开-闭”原则。
本题要实现以下几个功能：
①对各图形信息进行输入并输出； ②输入数据的正确性校验； ③对输入的图形按照图形类型进行分组并输出；④ 对每组内的图形按照面积值降序排序并输出； ⑤求出每组内图形面积的总和；⑥求出所有组的面积总和的最大值并输出。
其中，图形类设计可参考题目7-1 的类层次结构（需要进一步完善），本次作业我们对卡片排序时使用 Comparable 接口或 Comparator 接口。
对于本题编写程序方面，最难的地方就是分组、分别对组内面积元素求和然后再输出面积最大的一组是多少。下面，我展示一下是如何实现这些功能的：
分组：public void cardGroupSort() {
String circle = "[";
String rectangle = "[";
String triangle = "[";
String trapezoid = "[";
Map<String, List<Card>> cards = cardList.stream().collect(Collectors.groupingBy(e -> e.getShape().getShapeName()));
for (Map.Entry<String, List<Card>> entry : cards.entrySet()) {
List<Card> values = entry.getValue();
Collections.sort(values);
switch (entry.getKey().toLowerCase()) {
case "circle":
circle += format(values);
break;
case "rectangle":
rectangle += format(values);
break;
case "triangle":
triangle += format(values);
break;
case "trapezoid":
trapezoid += format(values);
break;
}
}
String format = circle + "]" + rectangle + "]" + triangle + "]" + trapezoid + "]";
System.out.println(format);
}
组内求和及得到最大面积：
public double getGroupMaxArea(){
double maxArea = 0L;
Map<String, List<Card>> cards = cardList.stream().collect(Collectors.groupingBy(e -> e.getShape().getShapeName()));
for (Map.Entry<String, List<Card>> entry : cards.entrySet()) {
double sum = entry.getValue().stream().mapToDouble(e -> e.getShape().getArea()).sum();
if(maxArea < sum) maxArea = sum;
}
return maxArea;
}
设计类图参考如下：
对于本题，关键在于与题目 7-1 比较分析，尤其是注意 ArrayList 工具类的使用；并进一步掌握接口在面向对象程序设计中的作用。使代码复杂度降低，优化代码结构，提高复用性。
- 题目集8 ATM机类结构设计（一）
本题需要实现两大功能：基础数据的初始化；用户存款、取款及查询余额功能。
设计思路分析：根据题目说明，首先设计了六个实体类，UnionPay、Bank、Account、User、Card、ATM类，然后根据一对多的组合关系，Bank类里面定义List<ATM>类型的atm机，在Main类中，用static类型对数据进行初始化，创建多个类对象。在设计方法时，利用各个类的属性进行方法的设计，Bank类中含多个ATM属性对象，那么设计一个isExistAtm()方法检测ATM对象是否在Bank中。总之，各个类都有各个类特定的功能，相互之间又有一定的联系，保证了设计原则中的单一职责原则，同时如果想要增加一些数据，只需要在Main中增添即可，保证了代码的复用性和拓展性。
对于本题，务必注意以下几点：①相关概念均要设计为实体类，业务（控制）类需根据实际需要进行扩充和完善；②务必注意本题目中的各实体类之间的关系，尤其是一对多的组合关系； ③对实体类的设计要做到单一职责原则，且不能缺少规定的实体类；④编程时要考虑面向对象中的封装性在本题目中的应用以及是否有能够扩展的衍生需求。
设计类图参考如下：
通过类图看得出，其实本题类与类之间的关系并不是特别复杂，类与主方法之间的调用关系也很单一，只是本题要处理的信息量比较大，需要用到列表的相关知识。另外，存储了相关数据后读取数据也得根据类与类之间的关系一一调用，很类似于之前我们做过的两个日期类（聚合）的题目。
以下是个人所写的代码，虽然有些小错误导致没有得到满分，但是代码结构还算清楚，逻辑上也没有太大的疏漏，希望与大家共勉：
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
private static List<Card> cards = new ArrayList<>();
private static List<ATM> atms = new ArrayList<>();
static {
UnionPay unionPay = new UnionPay("中国银联");
ATM atm01 = new ATM("01");
ATM atm02 = new ATM("02");
ATM atm03 = new ATM("03");
ATM atm04 = new ATM("04");
ATM atm05 = new ATM("05");
ATM atm06 = new ATM("06");
atms.add(atm01);
atms.add(atm02);
atms.add(atm03);
atms.add(atm04);
atms.add(atm05);
atms.add(atm06);
Bank CCB = new Bank(unionPay, "中国建设银行", new ArrayList<ATM>() {{
add(atm01);
add(atm02);
add(atm03);
add(atm04);
}});
Bank ICB = new Bank(unionPay, "中国工商银行", new ArrayList<ATM>() {{
add(atm05);
add(atm06);
}});
User yg = new User("杨过");
Account account709 = new Account("3217000010041315709", CCB, yg, 10000.00);
cards.add(new Card(account709,"6217000010041315709", "88888888"));
cards.add(new Card(account709,"6217000010041315715", "88888888"));
Account account715 = new Account("3217000010041315715", CCB, yg, 10000.00);
cards.add(new Card(account715, "6217000010041315718", "88888888"));
User gj = new User("郭靖");
Account account007 = new Account("3217000010051320007", CCB, gj, 10000.00);
cards.add(new Card(account007, "6217000010051320007", "88888888"));
User zwj = new User("张无忌");
Account account389 = new Account("3222081502001312389", ICB, zwj, 10000.00);
cards.add(new Card(account389, "6222081502001312389", "88888888"));
Account account390 = new Account("3222081502001312390", ICB, zwj, 10000.00);
cards.add(new Card(account390, "6222081502001312390", "88888888"));
Account account399 = new Account("3222081502001312399", ICB, zwj, 10000.00);
cards.add(new Card(account399,"6222081502001312399", "88888888"));
cards.add(new Card(account399,"6222081502001312400", "88888888"));
User wxb = new User("韦小宝");
Account account785 = new Account("3222081502051320785", ICB, wxb, 10000.00);
cards.add(new Card(account785, "6222081502051320785", "88888888"));
Account account786 = new Account("3222081502051320786", ICB, wxb, 10000.00);
cards.add(new Card(account786,"6222081502051320786", "88888888"));
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
List<String> commands = new ArrayList<>();
String line = scanner.nextLine();
while (!line.equals("#")){
commands.add(line);
line = scanner.nextLine();
}
for (String commond: commands){
String value[] = commond.split("\\s+");
Card card = null;
for (Card c: cards) {
if (c.getNumber().equals(value[0])) {
card = c;
break;
}
}
if (card == null) {
System.out.println("Sorry,this card does not exist.");
break;
}
if (value.length == 1) {
System.out.println(String.format("¥%.2f", card.getAccount().getBalance()));
}else {
String cardPwd = value[1];
String atmNum = value[2];
double amount = Double.valueOf(value[3]);
if (card.getPassword().equals(cardPwd)) {
boolean isExistAtm = false;
for (ATM atm: atms) {
if (atm.getNumber().equals(atmNum)) {
isExistAtm = true;
break;
}
}
if (!isExistAtm) {
System.out.println("Sorry,the ATM's id is wrong.");
break;
}
if (!card.getAccount().getBank().isExistAtm(atmNum)) {
System.out.println("Sorry,cross-bank withdrawal is not supported.");
break;
}
if (amount > 0) {
double diff = card.getAccount().getBalance() - amount;
if (diff > 0) {
card.getAccount().setBalance(diff);
System.out.println(String.format("%s在%s的%s号ATM机上取款¥%.2f",
card.getAccount().getUser().getName(),
card.getAccount().getBank().getName(),
atmNum, Math.abs(amount)));
System.out.println(String.format("当前余额为¥%.2f", card.getAccount().getBalance()));
}else {
System.out.println("Sorry,your account balance is insufficient.");
break;
}
} else {
card.getAccount().setBalance(card.getAccount().getBalance() - amount);
System.out.println(String.format("%s在%s的%s号ATM机上存款¥%.2f",
card.getAccount().getUser().getName(),
card.getAccount().getBank().getName(),
atmNum, Math.abs(amount)));
System.out.println(String.format("当前余额为¥%.2f", card.getAccount().getBalance()));
}
}else {
System.out.println("Sorry,your password is wrong.");
break;
}
}
}
}
}
class UnionPay {
private String name;
public UnionPay(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Bank {
private UnionPay unionPay;
private String name;
private List<ATM> atms;
public Bank(UnionPay unionPay, String name, List<ATM> atms) {
this.unionPay = unionPay;
this.name = name;
this.atms = atms;
}
public UnionPay getUnionPay() {
return unionPay;
}
public void setUnionPay(UnionPay unionPay) {
this.unionPay = unionPay;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<ATM> getAtms() {
return atms;
}
public void setAtms(List<ATM> atms) {
this.atms = atms;
}
public boolean isExistAtm(String no){
for (ATM atm: atms) {
if (atm.getNumber().equals(no)) return true;
}
return false;
}
}
class ATM {
private String number;
public ATM(String number) {
this.number = number;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
}
class Account {
private String number;
private Bank bank;
private User user;
private double balance;
public Account(String number, Bank bank, User user, double balance) {
this.number = number;
this.bank = bank;
this.user = user;
this.balance = balance;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public Bank getBank() {
return bank;
}
public void setBank(Bank bank) {
this.bank = bank;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
class Card {
private String number;
private String password;
private Account account;
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
public Card(Account account, String number, String password) {
this.account = account;
this.number = number;
this.password = password;
}
}
class User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
- 题目集9 ATM机类结构设计（二）
需要特别注意的是，本题中银行卡包含借记卡和信用卡两类，且允许跨行办理相关务（例如在中国建设银行的 ATM 机上使用中国工商银行的银行卡进行业务操作）。编写本题的程序时，一定要注意看清楚题目要求，这个非常重要。
设计思路分析：在老师给的源码基础上设计本次作业代码，首先在Main类中增添一些数据。由于本题改变策略，可以跨行取款操作，那么就分了借记账户与贷记账户，因此在Account类中新增一个int类型的accountType属性，用0代表借记，1代表贷记，这样就可以根据卡号所属的账户类型区别是否能够透支余额。同时由于跨行取款需要手续费，那么就在Bank类中新增一些相应手续费的属性，在UnionPay类中新增透支余额和透支手续费。最后在Withdraw类的withdraw()方法中修改部分代码，使之可以进行跨行取款。在整个设计过程中，实现了代码的重构，并且拓展了部分代码。
对于本题，个人给出以下建议：
①务必注意本题目中的各实体类之间的关系，尤其是一对多的组合关系。
②对实体类的设计要做到单一职责原则，且不能缺少规定的实体类。
③在“合成复用原则”及“单一职责原则”基础上，尽量对上次作业的程序进行重构，使之符合“开-闭”原则。（省时有效）
以下是本人的源码，存在一些问题：以下代码是根据卡找到卡所在的银行，而题目是根据atm机找到银行，跨行取款就会导致显示的是这张卡所在的银行，而不是跨行的那个银行，正确是跨行的那个银行。
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Iterator;
public class Main {
static UnionPay unionPay;
static {
unionPay = new UnionPay(new ArrayList<>());
Bank ccb = new Bank("1001","中国建设银行", 0.02);
Bank icbc = new Bank("1002","中国工商银行", 0.03);
Bank abc = new Bank("1003", "中国农业银行", 0.04);
unionPay.addBank(ccb);
unionPay.addBank(icbc);
unionPay.addBank(abc);
ATM atm1 = new ATM("01", ccb);
ATM atm2 = new ATM("02", ccb);
ATM atm3 = new ATM("03", ccb);
ATM atm4 = new ATM("04", ccb);
ATM atm5 = new ATM("05", icbc);
ATM atm6 = new ATM("06", icbc);
ATM atm7 = new ATM("07", abc);
ATM atm8 = new ATM("08", abc);
ATM atm9 = new ATM("09", abc);
ATM atm10 = new ATM("10`", abc);
ATM atm11 = new ATM("11", abc);
ccb.addATM(atm1);
ccb.addATM(atm2);
ccb.addATM(atm3);
ccb.addATM(atm4);
icbc.addATM(atm5);
icbc.addATM(atm6);
abc.addATM(atm7);
abc.addATM(atm8);
abc.addATM(atm9);
abc.addATM(atm10);
abc.addATM(atm11);
User Yangguo = new User(null,"杨过", null);
User Guojing = new User(null,"郭靖",null);
User Zhangwuji = new User(null,"张无忌",null);
User Weixiaobao = new User(null,"韦小宝",null);
User Zhangsanfeng = new User(null,"张三丰",null);
User Linghucong = new User(null,"令狐冲",null);
User Qiaofeng = new User(null,"乔峰",null);
User Hongqigong = new User(null,"洪七公",null);
Account accountYg1 = new Account("3217000010041315709",10000.00, 0,Yangguo,ccb);
Account accountYg2 = new Account("3217000010041315715",10000.00,0,Yangguo,ccb);
Account accountGj1 = new Account("3217000010051320007",10000.00,0,Guojing,ccb);
Account accountZwj1 = new Account("3222081502001312389",10000.00,0,Zhangwuji,icbc);
Account accountZwj2 = new Account("3222081502001312390",10000.00,0,Zhangwuji,icbc);
Account accountZwj3 = new Account("3222081502001312399",10000.00,0,Zhangwuji,icbc);
Account accountWxb1 = new Account("3222081502051320785",10000.00,0,Weixiaobao,icbc);
Account accountWxb2 = new Account("3222081502051320786",10000.00,0,Weixiaobao,icbc);
Account accountZsf1 = new Account("3640000010045442002",10000.00,1,Zhangsanfeng,ccb);
Account accountLhc1 = new Account("3640000010045441009",10000.00,1,Linghucong,icbc);
Account accountQf1 = new Account("3630000010033431001",10000.00,1,Qiaofeng,abc);
Account accountHqg1 = new Account("3630000010033431008",10000.00,1,Hongqigong,abc);
ccb.addAccount(accountYg1);
ccb.addAccount(accountYg2);
ccb.addAccount(accountGj1);
ccb.addAccount(accountZsf1);
icbc.addAccount(accountZwj1);
icbc.addAccount(accountZwj2);
icbc.addAccount(accountZwj3);
icbc.addAccount(accountWxb1);
icbc.addAccount(accountWxb2);
icbc.addAccount(accountLhc1);
abc.addAccount(accountQf1);
abc.addAccount(accountHqg1);
Yangguo.addAccount(accountYg1);
Yangguo.addAccount(accountYg2);
Guojing.addAccount(accountGj1);
Zhangwuji.addAccount(accountZwj1);
Zhangwuji.addAccount(accountZwj2);
Zhangwuji.addAccount(accountZwj3);
Weixiaobao.addAccount(accountWxb1);
Weixiaobao.addAccount(accountWxb2);
Zhangsanfeng.addAccount(accountZsf1);
Linghucong.addAccount(accountLhc1);
Qiaofeng.addAccount(accountQf1);
Hongqigong.addAccount(accountHqg1);
Card ccbCard1 = new Card("6217000010041315709","88888888",accountYg1);
Card ccbCard2 = new Card("6217000010041315715","88888888",accountYg1);
Card ccbCard3 = new Card("6217000010041315718","88888888",accountYg2);
Card ccbCard4 = new Card("6217000010051320007","88888888",accountGj1);
Card icbcCard5 = new Card("6222081502001312389","88888888",accountZwj1);
Card icbcCard6 = new Card("6222081502001312390","88888888",accountZwj2);
Card icbcCard7 = new Card("6222081502001312399","88888888",accountZwj3);
Card icbcCard8 = new Card("6222081502001312400","88888888",accountZwj3);
Card icbcCard9 = new Card("6222081502051320785","88888888",accountWxb1);
Card icbcCard10 = new Card("6222081502051320786","88888888",accountWxb2);
Card ccbCard11 = new Card("6640000010045442002", "88888888",accountZsf1);
Card ccbCard12 = new Card("6640000010045442003", "88888888",accountZsf1);
Card icbcCard13 = new Card("3640000010045441009", "88888888",accountLhc1);
Card abcCard14 = new Card("3630000010033431001", "88888888",accountQf1);
Card abcCard15 = new Card("3630000010033431008", "88888888",accountHqg1);
accountYg1.addCard(ccbCard1);
accountYg1.addCard(ccbCard2);
accountYg2.addCard(ccbCard3);
accountGj1.addCard(ccbCard4);
accountZwj1.addCard(icbcCard5);
accountZwj2.addCard(icbcCard6);
accountZwj3.addCard(icbcCard7);
accountZwj3.addCard(icbcCard8);
accountWxb1.addCard(icbcCard9);
accountWxb2.addCard(icbcCard10);
accountZsf1.addCard(ccbCard11);
accountZsf1.addCard(ccbCard12);
accountLhc1.addCard(icbcCard13);
accountQf1.addCard(abcCard14);
accountHqg1.addCard(abcCard15);
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
List<String> commands = new ArrayList<>();
String line = scanner.nextLine();
while (!line.equals("#")){
commands.add(line);
line = scanner.nextLine();
}
for(int i = 0; i < commands.size(); i++) {
String[] values = commands.get(i).split("\\s+");
if(values.length == 1) {
double balance = ValidateData.getCardbyCardNO(unionPay, values[0]).getAccount().getBalance();
System.out.println(String.format("业务：查询余额 ¥%.2f", balance));
}else {
Withdraw wd = new Withdraw(unionPay,
values[0], values[1], values[2],
Double.parseDouble(values[3]));
wd.withdraw();
}
}
}
}
class Bank {
private String bankNO;
private String bankName;
private double crossBankServiceCharge;
private ArrayList<Account> accountList = new ArrayList<Account>();
private ArrayList<ATM> ATMList = new ArrayList<ATM>();
public Bank() {}
public Bank(String bankNO, String bankName, double crossBankServiceCharge) {
this.bankNO = bankNO;
this.bankName = bankName;
this.crossBankServiceCharge = crossBankServiceCharge;
}
public String getBankNO() {
return bankNO;
}
public void setBankNO(String bankNO) {
this.bankNO = bankNO;
}
public String getBankName() {
return bankName;
}
public void setBankName(String bankName) {
this.bankName = bankName;
}
public void addAccount(Account account) {
this.accountList.add(account);
}
public void removeAccount(Account account) {
this.accountList.remove(account);
}
public double getCrossBankServiceCharge() {
return crossBankServiceCharge;
}
public void setCrossBankServiceCharge(double crossBankServiceCharge) {
this.crossBankServiceCharge = crossBankServiceCharge;
}
public void addATM(ATM aTM) {
this.ATMList.add(aTM);
}
public void removeATM(ATM aTM) {
this.ATMList.remove(aTM);
}
public ArrayList<Account> getAccountList() {
return accountList;
}
public void setAccountList(ArrayList<Account> accountList) {
this.accountList = accountList;
}
public ArrayList<ATM> getATMList() {
return ATMList;
}
public void setATMList(ArrayList<ATM> aTMList) {
ATMList = aTMList;
}
}
class User {
private String ID;
private String name;
private String Phone;
ArrayList<Account> list = new ArrayList<Account>();
public User() { }
public User(String iD, String name, String phone) {
ID = iD;
this.name = name;
Phone = phone;
}
public String getID() {
return ID;
}
public void setID(String iD) {
ID = iD;
}
public String getPhone() {
return Phone;
}
public void setPhone(String phone) {
Phone = phone;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void addAccount(Account account) {
this.list.add(account);
}
public void removeAccount(Account account) {
this.list.remove(account);
}
}
class Account {
private String accountNO;
private double balance = 0;
// 0 借机 1 贷记
private int accountType;
private User user = null;
private Bank bank = null;
private static ArrayList<Card> list = new ArrayList<Card>();
public Account() {}
public Account(String accountNO, double balance, int accountType,User user, Bank bank) {
this.accountNO = accountNO;
this.balance = balance;
this.accountType = accountType;
this.user = user;
this.bank = bank;
}
public void addCard(Card card) {
list.add(card);
}
public void removeCard(Card card) {
list.remove(card);
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public String getAccountNO() {
return accountNO;
}
public void setAccountNO(String accountNO) {
this.accountNO = accountNO;
}
public int getAccountType() {
return accountType;
}
public void setAccountType(int accountType) {
this.accountType = accountType;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Bank getBank() {
return bank;
}
public void setBank(Bank bank) {
this.bank = bank;
}
public ArrayList<Card> getList() {
return list;
}
public void setList(ArrayList<Card> list) {
Account.list = list;
}
public static Account getAmountbyCardNO(String cardNO) {
Iterator<Card> cardItr = Account.list.iterator();
Card card = null;
while(cardItr.hasNext()) {
card = cardItr.next();
if(card.getCardNo().equals(cardNO)) {
return card.getAccount();
}
}
return null;
}
}
class Card {
private String cardNo;
private String cardPwd;
private Account account;
public Card() {}
public Card(String cardNo, String cardPwd, Account account) {
this.cardNo = cardNo;
this.cardPwd = cardPwd;
this.account = account;
}
public String getCardNo() {
return cardNo;
}
public void setCardNo(String cardNo) {
this.cardNo = cardNo;
}
public String getCardPwd() {
return cardPwd;
}
public void setCardPwd(String cardPwd) {
this.cardPwd = cardPwd;
}
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
}
class ATM {
private String atmNo;
private Bank bank;
public ATM() {}
public ATM(String atmNo, Bank bank) {
this.atmNo = atmNo;
this.bank = bank;
}
public String getAtmNo() {
return atmNo;
}
public void setAtmNo(String atmNo) {
this.atmNo = atmNo;
}
public Bank getBank() {
return bank;
}
public void setBank(Bank bank) {
this.bank = bank;
}
}
class Withdraw {
private UnionPay unionPay;
private String cardNO;
private String cardPassword;
private String ATMID;
private double amount;
public Withdraw() {}
public Withdraw(UnionPay unionPay, String cardNO, String cardPassword, String aTMID, double amount) {
this.unionPay = unionPay;
this.cardNO = cardNO;
this.cardPassword = cardPassword;
ATMID = aTMID;
this.amount = amount;
}
public Withdraw(String cardNO, String cardPassword, String aTMID, double amount) {
this.cardNO = cardNO;
this.cardPassword = cardPassword;
ATMID = aTMID;
this.amount = amount;
}
public void withdraw() {
/**
* 校验该卡是否存在
*/
Card card = ValidateData.getCardbyCardNO(unionPay, cardNO);
if(card == null) {
System.out.println("Sorry,this card does not exist.");
System.exit(0);
}
/**
* 校验ATM是否存在
*/
ATM atm = ValidateData.getATMbyATMID(unionPay, ATMID);
if(atm == null) {
System.out.println("Sorry,the ATM's id is wrong.");
System.exit(0);
}
Account account = Account.getAmountbyCardNO(cardNO);
double balance = account.getBalance();
/**
* 校验卡密码是否正确
*/
if(!card.getCardPwd().equals(cardPassword)) {
System.out.println("Sorry,your password is wrong.");
System.exit(0);
}
double tmpBalance = balance - amount;
if (card.getAccount().getBank() != atm.getBank()) {
double charge = amount * atm.getBank().getCrossBankServiceCharge();
tmpBalance = tmpBalance - charge;
}
if (card.getAccount().getAccountType() == 0) {
if (tmpBalance < 0) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}else if (card.getAccount().getAccountType() == 1){
double charge = 0;
if (balance < 0) {
charge = amount * UnionPay.facilityRate;
} else {
charge = balance - amount < 0 ? Math.abs(balance - amount) * UnionPay.facilityRate : 0;
}
tmpBalance = tmpBalance - charge;
if (tmpBalance >= UnionPay.facilityExtend) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
} else {
System.exit(0);
}
account.setBalance(tmpBalance);//取款更新余额操作
System.out.println(String.format("业务：取款 %s在%s的%s号ATM机上取款¥%.2f",
account.getUser().getName(),
account.getBank().getBankName(),
ATMID, amount));
System.out.println(String.format("当前余额为¥%.2f", getBalance()));
}
public double getBalance(){
return ValidateData.getCardbyCardNO(unionPay, cardNO).getAccount().getBalance();
}
}
class ValidateData {
/**
* 校验卡号是否存在
* @param unionPay
* @param cardNO
* @return
*/
public static Card getCardbyCardNO(UnionPay unionPay,String cardNO) {
Card card = null;
Iterator<Bank> bankItr = unionPay.getBankList().iterator();
while(bankItr.hasNext()) {
ArrayList<Account> accountList = bankItr.next().getAccountList();
Iterator<Account> accountItr = accountList.iterator();
while(accountItr.hasNext()) {
ArrayList<Card> cardList = accountItr.next().getList();
Iterator<Card> cardItr = cardList.iterator();
while(cardItr.hasNext()) {
card = cardItr.next();
if(card.getCardNo().equals(cardNO)) {
return card;
}
}
}
}
return null;
}
/**
* 校验ATM ID是否存在
* @param unionPay
* @param ATMID
* @return
*/
public static ATM getATMbyATMID(UnionPay unionPay,String ATMID) {
Iterator<Bank> bankItr = unionPay.getBankList().iterator();
Bank bank = null;
ATM aTM = null;
while(bankItr.hasNext()) {
bank = bankItr.next();
Iterator<ATM> aTMItr = bank.getATMList().iterator();
while(aTMItr.hasNext()) {
aTM = aTMItr.next();
if(aTM.getAtmNo().equals(ATMID)) {
return aTM;
}
}
}
return null;
}
}
class UnionPay {
public static double facilityExtend = 50000;
public static double facilityRate = 0.05;
private ArrayList<Bank> bankList = new ArrayList<Bank>();
public UnionPay() {}
public UnionPay(ArrayList<Bank> bankList) {
this.bankList = bankList;
}
public ArrayList<Bank> getBankList() {
return bankList;
}
public void setBankList(ArrayList<Bank> bankList) {
this.bankList = bankList;
}
public void addBank(Bank bank) {
this.bankList.add(bank);
}
public void removeBank(Bank bank) {
this.bankList.remove(bank);
}
}
浙公网安备 33010602011771号