对Java第七-八周学习内容及三次作业总结
一、前言概括
Java学习过程中的问题和内容概括：
1.这后面部分的学习主要的重点依旧是对面向对象编程设计思想的学习以及实践
2.也浅层地学习了几个特殊类和接口的使用法和异常处理
3.同时学习了如何使用JavaFX进行图形化界面设计以及最为重要的事件驱动编程
4.也学习了内部类，匿名类，以及Lmabda表达式简化事件处理
5.作业的问题：接口设计的缺陷以及对实际需求分析和编辑思维的缺点导致
不能很好的设计好各个实体类，或者不知道如何去把握如何设计类以及类之间关系
6.作业总体来说难度不大，但是巧在对类关系的处理，以及后续的扩展性问题，
尤其在ATM取款这题上体现出一个好的结果的优越性
二、题目集问题分析
第七次题目集1.图形卡片排序游戏
代码如下：
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static Scanner input = new Scanner(System.in);//静态的input可以让不同的类使用
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
int num = input.nextInt();
while (num != 0) {//图形选择合法性判断
if (num < 0 || num > 4) {
System.out.println("Wrong Format");
System.exit(0);
}
list.add(num);
num = input.nextInt();
}
DealCardList dealCardList = new DealCardList(list);
if (!dealCardList.validate()) {//数据合法性判断
System.out.println("Wrong Format");
System.exit(0);
}
dealCardList.showResult();
input.close();//输入关闭
}
}
Main类中主要是对多数据总的合法性的检测
改进的肯能性：可以把总的合法性检测设计成一个单独类
public abstract class Shape {
private String shape;
public Shape() {
super();
// TODO Auto-generated constructor stub
}
public Shape(String shape) {
super();
this.shape = shape;
}
public String getShapeName() {
return shape;
}
public void setShapeName( String shape) {
this.shape=shape;
}
public abstract double getArea();//计算面积
public abstract boolean validate();//合法性检测
public abstract String toString();//格式化输出
}
Shape类为抽象父类，作为各种图形的父类
public class Circle extends Shape {
private double radius;
public Circle() {
super();
// TODO Auto-generated constructor stub
}
public Circle(double radius) {
super();
this.radius = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
@Override
public double getArea() {//圆形面积计算
// TODO Auto-generated method stub
double area = 0;
area = Math.pow(radius, 2)*Math.PI;
return area;
}
@Override
public boolean validate() {//圆形合法性检测
// TODO Auto-generated method stub
if(this.radius <= 0) {
return false;
}
return true ;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Circle:"+String.format("%.2f", this.getArea());
}
}
public class Rectangle extends Shape {
private double width;
private double length;
public Rectangle() {
super();
// TODO Auto-generated constructor stub
}
public Rectangle(double width, double length) {
super();
this.width = width;
this.length = length;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
@Override
public double getArea() {//矩形面积计算
double area = 0;
area = width * length;
return area;
}
@Override
public boolean validate() {//矩形合法性检测
if(width <= 0 || length <= 0 ) {
return false;
}
return true;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Rectangle:"+String.format("%.2f", this.getArea());
}
}
public class Trapezoid extends Shape {
private double topSide;
private double bottomSide;
private double height;
public Trapezoid() {
super();
// TODO Auto-generated constructor stub
}
public Trapezoid(double topSide, double bottomSide, double height) {
super();
this.topSide = topSide;
this.bottomSide = bottomSide;
this.height = height;
}
public double getTopSide() {
return topSide;
}
public void setTopSide(double topSide) {
this.topSide = topSide;
}
public double getBottomSide() {
return bottomSide;
}
public void setBottomSide(double bottomSide) {
this.bottomSide = bottomSide;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
@Override
public double getArea() {//梯形面积计算
// TODO Auto-generated method stub
double area = 0;
area = (this.topSide+this.bottomSide)*this.height*0.5;
return area;
}
@Override
public boolean validate() {//梯形合法性检测
// TODO Auto-generated method stub
if(this.topSide <= 0 || this.bottomSide <= 0 || this.height <= 0) {
return false;
}
return true;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Trapezoid:"+String.format("%.2f", this.getArea());
}
}
public class Triangle extends Shape {
private double side1;
private double side2;
private double side3;
public Triangle(double side1, double side2, double side3) {
super();
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
public Triangle() {
super();
// TODO Auto-generated constructor stub
}
@Override
public double getArea() {//计算三角形面积
// TODO Auto-generated method stub
double area = 0;
double halfPerimeter = (side1 + side2 + side3)/2;
//这种计算方法更简单，主要是因为如果用其他的三角形计算方法造成误差
area = Math.sqrt(halfPerimeter*(halfPerimeter-side1)*(halfPerimeter-side2)*(halfPerimeter-side3));
return area;
}
@Override
public boolean validate() {
// TODO Auto-generated method stub
if(side1 + side2 <= side3 || side1 + side3 <= side2 || side2 + side3 <= side1) {//根据两边之和必定大于第三边来判断合法性
return false;
}
return true;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Triangle:"+String.format("%.2f", this.getArea());
}
}
这几个Shape类的子类，根据各图形子类的自身情况，实现三个抽象方法就行了
public interface Comparable {
public boolean compareTo(Card card);
}
为了符合开闭原则所以选择设计了一接口，用于提供一个比较的方法
public class Card implements Comparable{
private Shape shape;
public Card() {
super();
// TODO Auto-generated constructor stub
}
public Card(Shape shape) {
super();
this.shape = shape;
}
public Shape getShape() {
return shape;
}
public void setShape(Shape shape) {
this.shape = shape;
}
public boolean compareTo(Card card) {//比较两个卡片中图像属性的面积
if(this.shape.getArea()<card.getShape().getArea()) {
return true;
}
return false;
}
}
该类用于存储一个图形属性，由于图形的多态，为了方便在后面的控制类对这些需要存储的对象进行处理，
所以设计这一个Card类，更好的一起处理不同的子类。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
public class DealCardList {
private ArrayList<Card> list = new ArrayList<Card>();
public DealCardList() {
super();
// TODO Auto-generated constructor stub
}
public DealCardList(ArrayList<Integer> list) {
super();
Scanner input = new Scanner(System.in);
Iterator<Integer> it = list.iterator();
while(it.hasNext()) {
switch (it.next()) {
case 1:
this.list.add(new Card(new Circle(input.nextDouble())));
break;
case 2:
this.list.add(new Card(new Rectangle(input.nextDouble(),input.nextDouble())));
break;
case 3:
this.list.add(new Card(new Triangle(input.nextDouble(),input.nextDouble(),input.nextDouble())));
break;
case 4:
this.list.add(new Card(new Trapezoid(input.nextDouble(),input.nextDouble(),input.nextDouble())));
break;
}
}
}
public boolean validate() {
Iterator<Card> ite = list.iterator();
while(ite.hasNext()) {
if(ite.next().getShape().validate() == false) {
return false;
}
}
return true;
}
public void cardSort() {//卡牌排序
for(int i = 0 ; i< list.size()-1;i++) {
for(int j = 0 ; j<list.size() - 1- i;j++) {
if(list.get(j).getShape().getArea() < list.get(j+1).getShape().getArea()) {
Card temp = list.get(j);
list.set(j, list.get(j+1));
list.set(j+1, temp);
}
}
}
}
public double getAllArea() {//总面积计算
Iterator<Card> ite = list.iterator();
double sum = 0.0 ;
while(ite.hasNext()) {
sum += ite.next().getShape().getArea();
}
return sum;
}
public void showResult() {//控制显示
System.out.println("The original list:");
for(int i = 0 ; i < list.size() ; i++) {
System.out.print(list.get(i).getShape().toString()+" ");
}
System.out.println();
this.cardSort();
System.out.println("The sorted list:");
for(int i = 0 ; i < list.size() ; i++) {
System.out.print(list.get(i).getShape().toString()+" ");
}
System.out.println();
System.out.println("Sum of area:"+String.format("%.2f", this.getAllArea()));
}
}
类图如下：
关系分析
首先设计了一个抽象父类Shape,然后Circel、Triangle、Rectangle、Trapezoid四个类继承自Shape类，
Shape类里有三个抽象方法，这四个子类只要根据各自特点，重写方法就行，Card类实现comparable接口，并有一个Shape类属性所以
他们两个类是组合关系，从而方便控制类进行处理。
复杂度分析：
由图可看出复杂度最高的是DealCardList，由于要循环进行计算面积和排序所以复杂度会稍微
高一些，但是目前并没有想到好的改进的算法方法，但是我觉得或许采用list的sort方法可以实
现简化。
第七次题目集2.图形卡片分组游戏
代码如下：
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static Scanner input = new Scanner(System.in);//静态的input可以让不同的类使用
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
int num = input.nextInt();
while (num != 0) {//图形选择合法性判断
if (num < 0 || num > 4) {
System.out.println("Wrong Format");
System.exit(0);
}
list.add(num);
num = input.nextInt();
}
DealCardList dealCardList = new DealCardList(list);
if (!dealCardList.validate()) {//数据合法性判断
System.out.println("Wrong Format");
System.exit(0);
}
dealCardList.showResult();
input.close();//输入关闭
}
}
Main类中主要是对多数据总的合法性的检测
改进的肯能性：可以把总的合法性检测设计成一个单独类
public abstract class Shape {
private String shape;
public Shape() {
super();
// TODO Auto-generated constructor stub
}
public Shape(String shape) {
super();
this.shape = shape;
}
public String getShapeName() {
return shape;
}
public void setShapeName( String shape) {
this.shape=shape;
}
public abstract double getArea();//计算面积
public abstract boolean validate();//合法性检测
public abstract String toString();//格式化输出
}
Shape类为抽象父类，作为各种图形的父类
public class Circle extends Shape {
private double radius;
public Circle() {
super();
// TODO Auto-generated constructor stub
}
public Circle(double radius) {
super();
this.radius = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
@Override
public double getArea() {//圆形面积计算
// TODO Auto-generated method stub
double area = 0;
area = Math.pow(radius, 2)*Math.PI;
return area;
}
@Override
public boolean validate() {//圆形合法性检测
// TODO Auto-generated method stub
if(this.radius <= 0) {
return false;
}
return true ;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Circle:"+String.format("%.2f", this.getArea());
}
}
public class Rectangle extends Shape {
private double width;
private double length;
public Rectangle() {
super();
// TODO Auto-generated constructor stub
}
public Rectangle(double width, double length) {
super();
this.width = width;
this.length = length;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
@Override
public double getArea() {//矩形面积计算
double area = 0;
area = width * length;
return area;
}
@Override
public boolean validate() {//矩形合法性检测
if(width <= 0 || length <= 0 ) {
return false;
}
return true;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Rectangle:"+String.format("%.2f", this.getArea());
}
}
public class Trapezoid extends Shape {
private double topSide;
private double bottomSide;
private double height;
public Trapezoid() {
super();
// TODO Auto-generated constructor stub
}
public Trapezoid(double topSide, double bottomSide, double height) {
super();
this.topSide = topSide;
this.bottomSide = bottomSide;
this.height = height;
}
public double getTopSide() {
return topSide;
}
public void setTopSide(double topSide) {
this.topSide = topSide;
}
public double getBottomSide() {
return bottomSide;
}
public void setBottomSide(double bottomSide) {
this.bottomSide = bottomSide;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
@Override
public double getArea() {//梯形面积计算
// TODO Auto-generated method stub
double area = 0;
area = (this.topSide+this.bottomSide)*this.height*0.5;
return area;
}
@Override
public boolean validate() {//梯形合法性检测
// TODO Auto-generated method stub
if(this.topSide <= 0 || this.bottomSide <= 0 || this.height <= 0) {
return false;
}
return true;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Trapezoid:"+String.format("%.2f", this.getArea());
}
}
public class Triangle extends Shape {
private double side1;
private double side2;
private double side3;
public Triangle(double side1, double side2, double side3) {
super();
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
public Triangle() {
super();
// TODO Auto-generated constructor stub
}
@Override
public double getArea() {//计算三角形面积
// TODO Auto-generated method stub
double area = 0;
double halfPerimeter = (side1 + side2 + side3)/2;
//这种计算方法更简单，主要是因为如果用其他的三角形计算方法造成误差
area = Math.sqrt(halfPerimeter*(halfPerimeter-side1)*(halfPerimeter-side2)*(halfPerimeter-side3));
return area;
}
@Override
public boolean validate() {
// TODO Auto-generated method stub
if(side1 + side2 <= side3 || side1 + side3 <= side2 || side2 + side3 <= side1) {//根据两边之和必定大于第三边来判断合法性
return false;
}
return true;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Triangle:"+String.format("%.2f", this.getArea());
}
}
这几个Shape类的子类，根据各图形子类的自身情况，实现三个抽象方法就行了
public interface Comparable {
public boolean compareTo(Card card);
}
为了符合开闭原则所以选择设计了一接口，用于提供一个比较的方法
public class Card implements Comparable{
private Shape shape;
public Card() {
super();
// TODO Auto-generated constructor stub
}
public Card(Shape shape) {
super();
this.shape = shape;
}
public Shape getShape() {
return shape;
}
public void setShape(Shape shape) {
this.shape = shape;
}
public boolean compareTo(Card card) {//比较两个卡片中图像属性的面积
if(this.shape.getArea()<card.getShape().getArea()) {
return true;
}
return false;
}
}
同样的该类用于存储一个图形属性，由于图形的多态，为了方便在后面的控制类对这些需要存储的对象进行处理，
所以设计这一个Card类，更好的一起处理不同的子类。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
public class DealCardList implements Spearated {
private ArrayList<Card> list = new ArrayList<Card>();
public DealCardList() {
super();
// TODO Auto-generated constructor stub
}
public DealCardList(ArrayList<Integer> list) {
super();
Scanner input = new Scanner(System.in);
Iterator<Integer> it = list.iterator();
while (it.hasNext()) {//数据输入
switch (it.next()) {
case 1:
this.list.add(new Card(new Circle(input.nextDouble())));
break;
case 2:
this.list.add(new Card(new Rectangle(input.nextDouble(), input.nextDouble())));
break;
case 3:
this.list.add(new Card(new Triangle(input.nextDouble(), input.nextDouble(), input.nextDouble())));
break;
case 4:
this.list.add(new Card(new Trapezoid(input.nextDouble(), input.nextDouble(), input.nextDouble())));
break;
}
}
}
public boolean validate() {//数据合法性检测
Iterator<Card> ite = list.iterator();
while (ite.hasNext()) {
if (ite.next().getShape().validate() == false) {
return false;
}
}
return true;
}
public ArrayList<Card>[] getSparated() {//数据分类
ArrayList<Card>[] listArray = new ArrayList[4];
ArrayList<Card> list1 = new ArrayList<>();
ArrayList<Card> list2 = new ArrayList<>();
ArrayList<Card> list3 = new ArrayList<>();
ArrayList<Card> list4 = new ArrayList<>();
for (int i = 0; i < this.list.size(); i++) {
if (list.get(i).getShape().getShapeName().equals("Circle")) {
list1.add(list.get(i));
} else if (list.get(i).getShape().getShapeName().equals("Rectangle")) {
list2.add(list.get(i));
} else if (list.get(i).getShape().getShapeName().equals("Triangle")) {
list3.add(list.get(i));
} else if (list.get(i).getShape().getShapeName().equals("Trapezoid")) {
list4.add(list.get(i));
}
}
listArray[0] = list1;
listArray[1] = list2;
listArray[2] = list3;
listArray[3] = list4;
return listArray;
}
public void cardSort(ArrayList<Card> list) {//数据排序
for (int i = 0; i < list.size() - 1; i++) {
for (int j = 0; j < list.size() - 1 - i; j++) {
if (list.get(j).compareTo(list.get(j + 1)) < 0) {
Card temp = list.get(j);
list.set(j, list.get(j + 1));
list.set(j + 1, temp);
}
}
}
}
public double getAllArea() {//总面积计算
Iterator<Card> ite = list.iterator();
double sum = 0.0;
while (ite.hasNext()) {
sum += ite.next().getShape().getArea();
}
return sum;
}
public void showResult() {//结果显示
System.out.println("The original list:");
System.out.print("[");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i).getShape().toString() + " ");
}
System.out.println("]");
ArrayList<Card>[] listArray = this.getSparated();
System.out.println("The Separated List:");
for (int j = 0; j < 4; j++) {
System.out.print("[");
for (int i = 0; i < listArray[j].size(); i++) {
System.out.print(listArray[j].get(i).getShape().toString() + " ");
}
System.out.print("]");
}
System.out.println();
System.out.println("The Separated sorted List:");
double max =0;
for (int j = 0; j < 4; j++) {
this.cardSort(listArray[j]);
double sum =0.0;
System.out.print("[");
for (int i = 0; i < listArray[j].size(); i++) {
System.out.print(listArray[j].get(i).getShape().toString() + " ");
sum += listArray[j].get(i).getShape().getArea();
}
if(max<sum) {
max = sum;
}
System.out.print("]");
}
System.out.println();
System.out.println("The max area:"+String.format("%.2f", max));
}
}
这类区别于上一次作业之处是，在上次作业的基础上加上了对图形的分类，所以在这个控制类中增加了
分类的方法，并将分的类存储在各个Arraylist中，再对showResult() 进行按照输出格式
类图如下：
关系分析
首先设计了一个抽象父类Shape,然后Circel、Triangle、Rectangle、Trapezoid四个类继承自Shape类，
Shape类里有三个抽象方法，这四个子类只要根据各自特点，重写方法就行，Card类实现comparable接口，并有一个Shape类属性所以
他们两个类是组合关系，从而方便一个DealCardList 实现了接口Spearated的控制类进行数据处理。
复杂度分析：
同样依旧由图可看出复杂度最高的是DealCardList，由于要循环进行计算面积和排序所以复杂度会稍微
高一些，但是目前并没有想到好的改进的算法方法，但是我觉得或许采用list的sort方法可以实现简化。、
第八次题目集1. ATM机类结构设计（一）
代码如下：
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Agentdeal agent = new Agentdeal();
agent.infoImport();//信息导入
agent.doOperate();//ATM操作
}
}
Main实现控制类，然进行调用信息导入和ATM操作
接下来是各个实物类的安排，类似套娃般一个接着一个
public class Card {
private final String cardID;
private String passWord;
public Card() {
super();
// TODO Auto-generated constructor stub
cardID = null;
}
public Card(String cardID, String passWord) {
super();
this.cardID = cardID;
this.passWord = passWord;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public String getCardID() {
return cardID;
}
public boolean isPassWordValid(String passWord) {
if(this.passWord.equals(passWord)) {
return true;
}
return false;
}
public boolean isMatched(String cardID) {
if(this.cardID.equalsIgnoreCase(cardID)) {
return true;
}
return false;
}
@Override
public String toString() {
return cardID;
}
}
public class Account {
private double balance;
private String accountID;
private ArrayList<Card> cardSet;
public Account() {
super();
cardSet = new ArrayList();
// TODO Auto-generated constructor stub
}
public Account(double balance, String accountID, ArrayList<Card> cardSet) {
super();
this.balance = balance;
this.accountID = accountID;
this.cardSet = cardSet;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public String getAccountID() {
return accountID;
}
public void setAccountId(String accountID) {
this.accountID = accountID;
}
public ArrayList<Card> getCardSet() {
return cardSet;
}
public void setCardSet(ArrayList<Card> cardSet) {
this.cardSet = cardSet;
}
public void addCard(Card card) {
this.cardSet.add(card);
}
public boolean amountValidCheck(double amount ) {
if(amount > this.balance) {
return false;
}
return true;
}
public boolean cardMatch(String card) {
Iterator<Card> it = cardSet.iterator();
while(it.hasNext()) {
if(it.next().getCardID().equals(card)) {
return true;
}
}
return false;
}
public void deposit(double amount) {
balance -= amount;
}
public void withDraw(double amount) {
balance -= amount ;
}
public String balanceCheck() {
return "¥"+String.format("%.2f", this.balance);
}
@Override
public String toString() {
return "当前余额为¥"+String.format("%.2f", this.balance);
}
}
public class User {
private String name;
private ArrayList<Account> accountSet;
public User() {
super();
this.accountSet = new ArrayList();
// TODO Auto-generated constructor stub
}
public User(String name, ArrayList<Account> accountSet) {
super();
this.name = name;
this.accountSet = accountSet;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public ArrayList<Account> getAccountSet() {
return accountSet;
}
public void setAccountSet(ArrayList<Account> accountSet) {
this.accountSet = accountSet;
}
public void addAccount(Account account) {
this.accountSet.add(account);
}
public boolean accountMatch(String account) {
Iterator<Account> it = accountSet.iterator();
while(it.hasNext()) {
if(it.next().getAccountID().equals(account)) {
return true;
}
}
return false;
}
@Override
public String toString() {
return name;
}
}
public class Bank {
private String name;
private ArrayList<User> userSet ;
private ArrayList<ATM> ATMSet;
public Bank() {
super();
// TODO Auto-generated constructor stub
this.userSet = new ArrayList();
this.ATMSet = new ArrayList();
}
public Bank(String name, ArrayList<User> userset, ArrayList<ATM> ATMSet) {
super();
this.name = name;
this.userSet = userset;
this.ATMSet = ATMSet;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public ArrayList<User> getUserSet() {
return userSet;
}
public void setUserSet(ArrayList<User> userSet) {
this.userSet = userSet;
}
public ArrayList<ATM> getATMSet() {
return ATMSet;
}
public void setATMSet(ArrayList<ATM> aTMSet) {
ATMSet = aTMSet;
}
public void addUser(User newUser) {
this.userSet.add(newUser);
}
public void addATM(ATM newATM) {
this.ATMSet.add(newATM);
}
public boolean userMatch(String name) {
Iterator<User> it = userSet.iterator();
while(it.hasNext()) {
if(it.next().getName().equals(name)) {
return true;
}
}
return false;
}
public boolean ATMMatch(String num) {
Iterator<ATM> it = ATMSet.iterator();
while(it.hasNext()) {
if(it.next().getNum().equals(num)) {
return true;
}
}
return false;
}
@Override
public String toString() {
return name;
}
}
public class UnionPay {
private ArrayList<Bank> bankSet ;
public UnionPay() {
super();
// TODO Auto-generated constructor stub
bankSet = new ArrayList();
}
public UnionPay(ArrayList<Bank> bankSet) {
super();
this.bankSet = bankSet;
}
public ArrayList<Bank> getBankSet() {
return bankSet;
}
public void setBankSet(ArrayList<Bank> bankSet) {
this.bankSet = bankSet;
}
public boolean bankMatch(String bank) {//是否匹配该银行
Iterator<Bank> it = bankSet.iterator();
while(it.hasNext()) {
if(it.next().getName().equals(bank)) {
return true;
}
}
return false;
}
}
public class ATM {
private String num;
public ATM() {
super();
// TODO Auto-generated constructor stub
}
public ATM(String num) {
super();
this.num = num;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public void deposit(Account account,double amount) {
account.deposit(amount);
}
public void withDraw(Account account ,double amount) {
account.withDraw(amount);
}
public void banlanceCheck(Account account) {
account.balanceCheck();
}
@Override
public String toString() {
return num;
}
}
我把这些实体类设计成套娃般的组合关系，卡放在账号中，账号放在用户中，ATM,用户再放在银行中
而银行放在银联中。
import java.util.Iterator;
public class Find {
public static Bank findBank(UnionPay unionPay, String ATM) {//根基ATM序号寻找银行
Iterator<Bank> bankItr = unionPay.getBankSet().iterator();
while (bankItr.hasNext()) {
Bank temp = bankItr.next();
Iterator<ATM> ATMItr = temp.getATMSet().iterator();
while (ATMItr.hasNext()) {
if (ATMItr.next().getNum().equals(ATM)) {
return temp;
}
}
}
return null;
}
public static Account findAccount(UnionPay unionPay, String card) {//根据卡号寻找账户
Iterator<Bank> bankItr = unionPay.getBankSet().iterator();
while (bankItr.hasNext()) {
Bank bankTemp = bankItr.next();
Iterator<User> userItr = bankTemp.getUserSet().iterator();
while (userItr.hasNext()) {
User userTemp = userItr.next();
Iterator<Account> accountItr = userTemp.getAccountSet().iterator();
while (accountItr.hasNext()) {
Account accountTemp = accountItr.next();
Iterator<Card> cardItr = accountTemp.getCardSet().iterator();
while (cardItr.hasNext()) {
Card cardTemp = cardItr.next();
if (cardTemp.getCardID().equals(card)) {
return accountTemp;
}
}
}
}
}
return null;
}
public static Card findCard(UnionPay unionPay, String card) {// 根据卡号寻找卡
Iterator<Bank> bankItr = unionPay.getBankSet().iterator();
while (bankItr.hasNext()) {
Bank bankTemp = bankItr.next();
Iterator<User> userItr = bankTemp.getUserSet().iterator();
while (userItr.hasNext()) {
User userTemp = userItr.next();
Iterator<Account> accountItr = userTemp.getAccountSet().iterator();
while (accountItr.hasNext()) {
Account accountTemp = accountItr.next();
Iterator<Card> cardItr = accountTemp.getCardSet().iterator();
while (cardItr.hasNext()) {
Card cardTemp = cardItr.next();
if (cardTemp.getCardID().equals(card)) {
return cardTemp;
}
}
}
}
}
return null;
}
public static Bank findBank1(UnionPay unionPay, String card) {// 根据卡号寻找银行
Iterator<Bank> bankItr = unionPay.getBankSet().iterator();
while (bankItr.hasNext()) {
Bank bankTemp = bankItr.next();
Iterator<User> userItr = bankTemp.getUserSet().iterator();
while (userItr.hasNext()) {
User userTemp = userItr.next();
Iterator<Account> accountItr = userTemp.getAccountSet().iterator();
while (accountItr.hasNext()) {
Account accountTemp = accountItr.next();
Iterator<Card> cardItr = accountTemp.getCardSet().iterator();
while (cardItr.hasNext()) {
Card cardTemp = cardItr.next();
if (cardTemp.getCardID().equals(card)) {
return bankTemp;
}
}
}
}
}
return null;
}
public static User findUser(Bank bank, Account account) {// 根据账户寻找银行
Iterator<User> userItr = bank.getUserSet().iterator();
while (userItr.hasNext()) {
User userTemp = userItr.next();
Iterator<Account> accountItr = userTemp.getAccountSet().iterator();
while (accountItr.hasNext()) {
Account accountTemp = accountItr.next();
Iterator<Card> cardItr = accountTemp.getCardSet().iterator();
if (accountTemp.equals(account)) {
return userTemp;
}
}
}
return null;
}
public static Bank findBank(UnionPay unionPay, User user) {// 根据用户寻找银行
Iterator<Bank> bankItr = unionPay.getBankSet().iterator();
while (bankItr.hasNext()) {
Bank bankTemp = bankItr.next();
if (bankTemp.getUserSet().contains(user)) {
return bankTemp;
// Iterator<User> userItr = bankTemp.getUserSet().iterator();
// while(userItr.hasNext()) {
// User userTemp = userItr.next();
// Iterator<User> cardItr = accountTemp.getCardSet().iterator();
//
// if(accountTemp.equals(account)) {
// return userTemp;
//
// }
}
}
return null;
}
}
设置一个类含多种静态方法，方便用于根据卡号找到其所属卡，用户，账号，银行。
寻找方法是利用其这些实体类的套娃式嵌套关系，进行嵌套的迭代循环匹配进而
返回要找的对象。
public abstract class AbstractAgent {
};
import java.util.Iterator;
import java.util.Scanner;
public class Agentdeal extends AbstractAgent {
private UnionPay unionPay;
/*
这里是利用其无参构造法初始化各数据
*/
public void infoImport() {//信息导入
ATM ATM01 = new ATM("01");
ATM ATM02 = new ATM("02");
ATM ATM03 = new ATM("03");
ATM ATM04 = new ATM("04");
ArrayList<ATM> ATMSet01 = new ArrayList();
ATMSet01.add(ATM01);
ATMSet01.add(ATM02);
ATMSet01.add(ATM03);
ATMSet01.add(ATM04);
ATM ATM05 = new ATM("05");
ATM ATM06 = new ATM("06");
ArrayList<ATM> ATMSet02 = new ArrayList();
ATMSet02.add(ATM05);
ATMSet02.add(ATM06);
Card card01 = new Card("6217000010041315709", "88888888");
Card card02 = new Card("6217000010041315715", "88888888");
ArrayList<Card> cardSet1 = new ArrayList();
cardSet1.add(card01);
cardSet1.add(card02);
Card card03 = new Card("6217000010041315718", "88888888");
ArrayList<Card> cardSet2 = new ArrayList();
cardSet2.add(card03);
Card card04 = new Card("6217000010051320007", "88888888");
ArrayList<Card> cardSet3 = new ArrayList();
cardSet3.add(card04);
Card card05 = new Card("6222081502001312389", "88888888");
ArrayList<Card> cardSet4 = new ArrayList();
cardSet4.add(card05);
Card card06 = new Card("6222081502001312390", "88888888");
ArrayList<Card> cardSet5 = new ArrayList();
cardSet5.add(card06);
Card card07 = new Card("6222081502001312399", "88888888");
Card card08 = new Card("6222081502001312400", "88888888");
ArrayList<Card> cardSet6 = new ArrayList();
cardSet6.add(card07);
cardSet6.add(card08);
Card card09 = new Card("6222081502051320785", "88888888");
ArrayList<Card> cardSet7 = new ArrayList();
cardSet7.add(card09);
Card card10 = new Card("6222081502051320786", "88888888");
ArrayList<Card> cardSet8 = new ArrayList();
cardSet8.add(card10);
Account account01 = new Account(10000.00, "3217000010041315709", cardSet1);
Account account02 = new Account(10000.00, "3217000010041315715", cardSet2);
Account account03 = new Account(10000.00, "3217000010051320007", cardSet3);
Account account04 = new Account(10000.00, "3222081502001312389", cardSet4);
Account account05 = new Account(10000.00, "3222081502001312390", cardSet5);
Account account06 = new Account(10000.00, "3222081502001312399", cardSet6);
Account account07 = new Account(10000.00, "3222081502051320785", cardSet7);
Account account08 = new Account(10000.00, "3222081502051320786", cardSet8);
ArrayList<Account> accountSet1 = new ArrayList();
accountSet1.add(account01);
accountSet1.add(account02);
ArrayList<Account> accountSet2 = new ArrayList();
accountSet2.add(account03);
ArrayList<Account> accountSet3 = new ArrayList();
accountSet3.add(account04);
accountSet3.add(account05);
accountSet3.add(account06);
ArrayList<Account> accountSet4 = new ArrayList();
accountSet4.add(account07);
accountSet4.add(account08);
User user01 = new User("杨过", accountSet1);
User user02 = new User("郭靖", accountSet2);
User user03 = new User("张无忌", accountSet3);
User user04 = new User("韦小宝", accountSet4);
ArrayList<User> userSet1 = new ArrayList<>();
userSet1.add(user01);
userSet1.add(user02);
ArrayList<User> userSet2 = new ArrayList<>();
userSet2.add(user03);
userSet2.add(user04);
Bank bank01 = new Bank("中国建设银行", userSet1, ATMSet01);
Bank bank02 = new Bank("中国工商银行", userSet2, ATMSet02);
ArrayList<Bank> bankSet = new ArrayList<>();
bankSet.add(bank01);
bankSet.add(bank02);
this.unionPay = new UnionPay(bankSet);
}
public UnionPay getUnionPay() {//获取银联
return unionPay;
}
public void setUnionPay(UnionPay unionPay) {//设置银联
this.unionPay = unionPay;
}
public void doOperate() {//操作方法
Scanner input = new Scanner(System.in);
ArrayList<String> outSet = new ArrayList<>();
String temp = input.nextLine();
while (!temp.equals("#")) {//输入#停止输入
temp = temp.trim();
String[] str = temp.split("[ ]+");//根据空格切割
if (str.length == 4) {//如果得到的字符串个数为4进行下面的操作
Bank bank = Find.findBank1(unionPay, str[0]);//根据卡号找到银行
if (bank == null) {
Iterator<String> itr = outSet.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
System.out.println("Sorry,this card does not exist.");
System.exit(0);
}
Account account = Find.findAccount(unionPay, str[0]);
User user = Find.findUser(bank, account);
Card card = Find.findCard(unionPay, str[0]);
if (!card.isPassWordValid(str[1])) {
Iterator<String> itr = outSet.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
System.out.println("Sorry,your password is wrong.");
System.exit(0);
}
String ATMnum = str[2];
if(Find.findBank(unionPay, str[2])==null){
Iterator<String> itr = outSet.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
System.out.println("Sorry,the ATM's id is wrong.");
System.exit(0);
}else if (!bank.equals(Find.findBank(unionPay, str[2]))) {
Iterator<String> itr = outSet.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
System.out.println("Sorry,cross-bank withdrawal is not supported.");
System.exit(0);
}
double amount = Double.parseDouble(str[3]);
if (!account.amountValidCheck(amount)) {
Iterator<String> itr = outSet.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
if (amount > 0) {
account.withDraw(amount);
outSet.add(user.getName() + "在" + bank.getName() + "的" + ATMnum + "号 ATM 机上取款¥"
+ String.format("%.2f", amount));
outSet.add(account.toString());
} else {
account.deposit(amount);
outSet.add(user.getName() + "在" + bank.getName() + "的" + ATMnum + "号 ATM 机上存款¥"
+ String.format("%.2f", -amount));
outSet.add(account.toString());
}
} else {
Account account = Find.findAccount(unionPay, str[0]);
outSet.add("¥"+String.format("%.2f", account.getBalance()));
}
temp = input.nextLine();
}
Iterator<String> itr = outSet.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
}
}
这个类是控制类，利用无参构造法进行导入数据，然后在进行操作
再进行顺序结构的安排。
类图如下：
思路分析：但是按照自己的思路是这样的，通过套娃般的镶嵌方法，把这些类联系在一起
如卡作为账号的属性集合，账号作为用户的属性集合，用户作为银行的属性集合，ATM作
为银行的一个属性集合，银行作为银联作为的一个集合属性。这样的话就把各个信息对应
起来了。
存在的问题，如果获得一个银行卡号，要求通过银行卡号知道其对应的卡或者其他的信息
那么久要进过多层迭代才能找到对应的信息。这样很麻烦，同时这类之间的关系有问题，
严格意义上来说用户和银行没有直接关系，而且一个用具可以在不同银行有多个账户，所
以，应该让账户隶属银行和用户，这样把用户给提出来，这样类的关系更为合理。
复杂度分析：
其负债度太高，第一数运维Find类里的查找方法复杂度太高正如前面说的，那种嵌套似的
类的关系，在查找它对应的关系的啥时候，非常麻烦，而且需要大量的迭代遍历。
解决方法：
在已给实物类中连接它上层关系，就相当于C语言的双向链表，这样查询起来就可以简化。
第九次题目集1. ATM机类结构设计（二）
```java
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
UnionPay unionPay = new UnionPay();
unionPay.setRate(0.05);
Bank ccb = new Bank("1001","中国建设银行");
Bank icbc = new Bank("1002","中国工商银行");
Bank abc = new Bank("1003","中国农业银行");
unionPay.addBank(ccb);
unionPay.addBank(icbc);
unionPay.addBank(abc);
ATM aTM1 = new ATM("01",ccb,0.02);
ATM aTM2 = new ATM("02",ccb,0.02);
ATM aTM3 = new ATM("03",ccb,0.02);
ATM aTM4 = new ATM("04",ccb,0.02);
ATM aTM5 = new ATM("05",icbc,0.03);
ATM aTM6 = new ATM("06",icbc,0.03);
ATM aTM7 = new ATM("07",abc,0.04);
ATM aTM8 = new ATM("08",abc,0.04);
ATM aTM9 = new ATM("09",abc,0.04);
ATM aTM10 = new ATM("10",abc,0.04);
ATM aTM11 = new ATM("11",abc,0.04);
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("杨过");
User Guojing = new User("郭靖");
User Zhangwuji = new User("张无忌");
User Weixiaobao = new User("韦小宝");
User ZhangSanFeng = new User("张三丰");
User LingHuChong = new User("令狐冲");
User QiaoFeng = new User("乔峰");
User HongQIGong =new User("洪七公");
Account ccbAcc1 = new Account("3217000010041315709",10000.00,Yangguo,ccb);
Account ccbAcc2 = new Account("3217000010041315715",10000.00,Yangguo,ccb);
Account ccbAcc3 = new Account("3217000010051320007",10000.00,Guojing,ccb);
Account icbcAcc1 = new Account("3222081502001312389",10000.00,Zhangwuji,icbc);
Account icbcAcc2 = new Account("3222081502001312390",10000.00,Zhangwuji,icbc);
Account icbcAcc3 = new Account("3222081502001312399",10000.00,Zhangwuji,icbc);
Account icbcAcc4 = new Account("3222081502051320785",10000.00,Weixiaobao,icbc);
Account icbcAcc5 = new Account("3222081502051320786",10000.00,Weixiaobao,icbc);
CreditAccount ccbAccCredit = new CreditAccount("3640000010045442002",10000.00,ZhangSanFeng,ccb,50000);
CreditAccount icbcAccCredit = new CreditAccount("3640000010045441009",10000.00,LingHuChong,icbc,50000);
CreditAccount abcAccCredit = new CreditAccount("3630000010033431001",10000.00,QiaoFeng,abc,50000);
CreditAccount abcAccCredit2 = new CreditAccount("3630000010033431001",10000.00,HongQIGong,abc,50000);
ccb.addAccount(ccbAcc1);
ccb.addAccount(ccbAcc2);
ccb.addAccount(ccbAcc3);
icbc.addAccount(icbcAcc1);
icbc.addAccount(icbcAcc2);
icbc.addAccount(icbcAcc3);
icbc.addAccount(icbcAcc4);
icbc.addAccount(icbcAcc5);
ccb.addAccount(ccbAccCredit);
icbc.addAccount(icbcAccCredit);
abc.addAccount(abcAccCredit);
abc.addAccount(abcAccCredit2);
Yangguo.addAccount(ccbAcc1);
Yangguo.addAccount(ccbAcc2);
Guojing.addAccount(ccbAcc3);
Zhangwuji.addAccount(icbcAcc1);
Zhangwuji.addAccount(icbcAcc2);
Zhangwuji.addAccount(icbcAcc3);
Weixiaobao.addAccount(icbcAcc4);
Weixiaobao.addAccount(icbcAcc5);
ZhangSanFeng.addAccount(ccbAccCredit);
LingHuChong.addAccount(icbcAccCredit);
QiaoFeng.addAccount(abcAccCredit);
HongQIGong.addAccount(abcAccCredit2);
Card ccbCard1 = new Card("6217000010041315709","88888888",ccbAcc1,"DebitCard");
Card ccbCard2 = new Card("6217000010041315715","88888888",ccbAcc1,"DebitCard");
Card ccbCard3 = new Card("6217000010041315718","88888888",ccbAcc2,"DebitCard");
Card ccbCard4 = new Card("6217000010051320007","88888888",ccbAcc3,"DebitCard");
Card icbcCard5 = new Card("6222081502001312389","88888888",icbcAcc1,"DebitCard");
Card icbcCard6 = new Card("6222081502001312390","88888888",icbcAcc2,"DebitCard");
Card icbcCard7 = new Card("6222081502001312399","88888888",icbcAcc3,"DebitCard");
Card icbcCard8 = new Card("6222081502001312400","88888888",icbcAcc3,"DebitCard");
Card icbcCard9 = new Card("6222081502051320785","88888888",icbcAcc4,"DebitCard");
Card icbcCard10 = new Card("6222081502051320786","88888888",icbcAcc5,"DebitCard");
Card ccbCard11 = new Card("6640000010045442002","88888888",ccbAccCredit,"CreditCard");
Card ccbCard12 = new Card("6640000010045442003","88888888",ccbAccCredit,"CreditCard");
Card icbcCard13 = new Card("6640000010045441009","88888888",icbcAccCredit,"CreditCard");
Card abcCard14 = new Card("6630000010033431001","88888888",abcAccCredit,"CreditCard");
Card abcCard15 = new Card("6630000010033431008","88888888",abcAccCredit2,"CreditCard");
ccbAcc1.addCard(ccbCard1);
ccbAcc1.addCard(ccbCard2);
ccbAcc2.addCard(ccbCard3);
ccbAcc3.addCard(ccbCard4);
icbcAcc1.addCard(icbcCard5);
icbcAcc2.addCard(icbcCard6);
icbcAcc3.addCard(icbcCard7);
icbcAcc3.addCard(icbcCard8);
icbcAcc4.addCard(icbcCard9);
icbcAcc5.addCard(icbcCard10);
ccbAccCredit.addCard(ccbCard11);
ccbAccCredit.addCard(ccbCard12);
icbcAccCredit.addCard(icbcCard13);
abcAccCredit.addCard(abcCard14);
abcAccCredit2.addCard(abcCard15);
StringBuilder sb = new StringBuilder();
String data;
while(!((data = input.nextLine()).equals("#"))) {
sb.append(data + "\n");
}
String[] dt = sb.toString().split("\n");
for(int i = 0; i < dt.length; i++) {
String[] dataLine = dt[i].toString().split("\\s+");
if(dataLine.length == 1) {
GetBalance gb = new GetBalance(unionPay);
System.out.println(String.format("业务：查询余额 ¥%.2f", gb.getBalance(dataLine[0])));
}else {
Agent wd = new Agent(unionPay,dataLine[0],dataLine[1],dataLine[2],Double.parseDouble(dataLine[3]));
wd.withdraw();
}
}
}
}
在这次实验。使用了老师的代码框架，在`Main`类里选择类信息导入
可能改进之处，我觉得应该使得主类代码更加简洁，所以可以在控制类
转么设置一个方法进行信息导入
```java
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.getATMID().equals(ATMID)) {
return aTM;
}
}
}
return null;
}
}
该类是用于数据合法性检验，所以设置成静态方法，同时一样的
使用了镶嵌的迭代进行判断的。
class Agent {
private UnionPay unionPay;
private String cardNO;
private String cardPassword;
private String ATMID;
private double amount;
public Agent() {
super();
// TODO Auto-generated constructor stub
}
public Agent(UnionPay unionPay, String cardNO, String cardPassword, String aTMID, double amount) {
super();
this.unionPay = unionPay;
this.cardNO = cardNO;
this.cardPassword = cardPassword;
ATMID = aTMID;
this.amount = amount;
}
public Agent(String cardNO, String cardPassword, String aTMID, double amount) {
super();
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();
double limitmoney = 0;
/**
* 校验卡密码是否正确
*/
if (!card.getCardPassword().equals(cardPassword)) {
System.out.println("Sorry,your password is wrong.");
System.exit(0);
}
/**
* 校验是否为跨行取款
*/
double interest = 0.0;
if (account.getBank().getBankNO() != aTM.getBank().getBankNO()) {
interest = aTM.getInterest();
}
/**
* 校验取款金额是否大于余额且为贷记卡
*/
double total = 0;
if(balance-amount>0) {
total = amount+amount*interest;
}else if(balance<0) {
total = amount+amount*interest+amount*unionPay.getRate();
}else {
total = amount+amount*interest+(amount-balance)*unionPay.getRate();
}
if (card.getType().equals("DebitCard")) {
if (total > balance) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}else {
limitmoney = ((CreditAccount)account).getCreditLimit();
if(limitmoney+balance <total) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
// 取款更新余额操作
if (amount >= 0) {
account.setBalance(balance - total);
showResult(account, 1,aTM);
} else {
account.setBalance(balance - amount);
showResult(account, 0,aTM);
}
}
public void showResult(Account account, int flag,ATM aTM) {
String type = "";
if (flag == 1) {
type = "取款";
} else {
type = "存款";
amount *= -1;
}
String userName = account.getUser().getName();
String bankName = aTM.getBank().getBankName();
System.out.println("业务：取款 "+userName + "在" + bankName + "的" + ATMID + "号ATM机上" + type + String.format("¥%.2f", amount));
System.out.println("当前余额为" + String.format("¥%.2f", account.getBalance()));
}
}
控制类有种判断方法在其中，主要用来进行对各种类的关系协调、
同时又对操作的选择
class ATM {
private String ATMID;
private Bank bank = null;
private double interest;
public ATM() {
super();
// TODO Auto-generated constructor stub
}
public ATM(String aTMID, Bank bank,double interest) {
super();
ATMID = aTMID;
this.bank = bank;
this.interest = interest;
}
public String getATMID() {
return ATMID;
}
public void setATMID(String aTMID) {
ATMID = aTMID;
}
public Bank getBank() {
return bank;
}
public void setBank(Bank bank) {
this.bank = bank;
}
public double getInterest() {
return interest;
}
public void setInterest(double interest) {
this.interest = interest;
}
}
class Account {
private String accountNO;
private double balance = 0;
private User user = null;
private Bank bank = null;
private static ArrayList<Card> list = new ArrayList<Card>();
public Account() {
super();
// TODO Auto-generated constructor stub
}
public Account(String accountNO, double balance, User user, Bank bank) {
super();
this.accountNO = accountNO;
this.balance = balance;
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 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 DebitAccount extends Account {
public DebitAccount() {
super();
// TODO Auto-generated constructor stub
}
public DebitAccount(String accountNO, double balance, User user, Bank bank) {
super(accountNO, balance, user, bank);
// TODO Auto-generated constructor stub
}
}
class User {
private String ID;
private String name;
private String Phone;
ArrayList<Account> list = new ArrayList<Account>();
public User() {
super();
// TODO Auto-generated constructor stub
}
public User(String name) {
super();
this.name = name;
}
public User(String iD, String name, String phone) {
super();
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 Card {
private String cardNO;
private String cardPassword;
private Account account = null;
private String type;
public Card() {
super();
// TODO Auto-generated constructor stub
}
public Card(String cardNO, String cardPassword, Account account, String type) {
super();
this.cardNO = cardNO;
this.cardPassword = cardPassword;
this.account = account;
this.type = type;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getCardNO() {
return cardNO;
}
public void setCardNO(String cardNO) {
this.cardNO = cardNO;
}
public String getCardPassword() {
return cardPassword;
}
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
public void setCardPassword(String cardPassword) {
this.cardPassword = cardPassword;
}
public boolean checkCard() {
Pattern p = Pattern.compile("\\d{16}+");
Matcher m = p.matcher(this.cardNO);
return m.matches();
}
public boolean checkPassword(String password) {
return this.cardPassword.equals(password);
}
}
class Bank {
private String bankNO;
private String bankName;
private ArrayList<Account> accountList = new ArrayList<Account>();
private ArrayList<ATM> ATMList = new ArrayList<ATM>();
public Bank() {
super();
// TODO Auto-generated constructor stub
}
public Bank(String bankNO, String bankName) {
super();
this.bankNO = bankNO;
this.bankName = bankName;
}
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 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 CreditAccount extends Account {
private double creditLimit = 50000;
public CreditAccount() {
super();
// TODO Auto-generated constructor stub
}
public CreditAccount(String accountNO, double balance, User user, Bank bank,double creditLimit) {
super(accountNO, balance, user, bank);
this.creditLimit = creditLimit;
// TODO Auto-generated constructor stub
}
public double getCreditLimit() {
return creditLimit;
}
public void setCreditLimit(double creditLimit) {
this.creditLimit = creditLimit;
}
}
class UnionPay {
private ArrayList<Bank> bankList = new ArrayList<Bank>();
private double rate;
public UnionPay() {
super();
// TODO Auto-generated constructor stub
}
public UnionPay(ArrayList<Bank> bankList,double rate) {
super();
this.bankList = bankList;
this.rate = rate;
}
public ArrayList<Bank> getBankList() {
return bankList;
}
public void setBankList(ArrayList<Bank> bankList) {
this.bankList = bankList;
}
public double getRate() {
return rate;
}
public void setRate(double rate) {
this.rate = rate;
}
public void addBank(Bank bank) {
this.bankList.add(bank);
}
public void removeBank(Bank bank) {
this.bankList.remove(bank);
}
}
各种实体类，但是在这次作业中对各种实体类的关系进行了调整和改进
比如说不再是一味的嵌套的模式，而是卡属于账号，账号属银行和用户，
银行属于属于银联，ATM属于银行，但是为了方便根据一个类寻找它的
上下两个从属关系，类的上一级也作为属性定义在一个类中。
class GetBalance {
private UnionPay unionPay;
public GetBalance() {
super();
// TODO Auto-generated constructor stub
}
public GetBalance(UnionPay unionPay) {
super();
this.unionPay = unionPay;
}
public double getBalance(String cardNO) {
return ValidateData.getCardbyCardNO(unionPay, cardNO).getAccount().getBalance();
}
}
class ValidateCheck {
public static boolean check(UnionPay unionPay,String cardNO,String cardPassword,String ATMID,double amount) {
/**
* 校验该卡是否存在
*/
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.getCardPassword().equals(cardPassword)) {
System.out.println("Sorry,your password is wrong.");
System.exit(0);
}
/**
* 校验取款金额是否大于余额
*/
if (amount > balance) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
/**
* 校验是否为跨行取款
*/
if (account.getBank().getBankNO() != aTM.getBank().getBankNO()) {
return true;
}
return false;
}
}
这个类主要用于判断是否余额充足以及是否跨行取款
类图分析：
相比上次作业做出了一些改进，思路是这样的，在套娃般的镶嵌方法的基础上，把这些类联系在一起
如卡作为账号的一个属性集合，账号作为用户的一个属性集合和银行的一个属性集合，ATM作
为银行的一个属性集合，银行作为银联作为的一个集合属性，同时每个实体类的属性添加
一个上层次的所属对象。这样的话就他们按照双向链表一般连接起来了。
复杂度分析
正如上面：
上次所想的利用双向性的确使得复杂度降低了，但是负责度依旧大于10
也就是说这种设计方式依旧纯在问题，需要多层遍历才能匹配对应信息。
暂时无改进方案。
采坑心得
改成才通过
在自身的编译器运行没有问题，可能存在的问题，如果放在一个class文件下，
由于在main类里设置了一个static类型的Scanner的对象，所以其他
地方设置同名的input会导致输入失效，此时改为调用main类里才能正常
输入。
总结：
1.虽然数着三次作业更为简单，但是学习到的东西却非常重要
比如说在ATM机这两次作业中，体会到了一个好的类的关系的重
要性，可以简化很多东西，同时只有认知得到了类之间的关系和
需求的合理性才能做出好的类关系设计，例如，此后钱得到余额
到底是放卡中作为属性还是账户？如果没有处理好其需求的合理
性就不能很好的做出一个好的结构。
2.上次遗留下的问题：
子类继承父类，子类拥有了父类的所有属性和方法。
程序验证，父类的私有属性和方法子类是无法直接访问的。当然私有属性可以通过
public修饰的getter和setter方法访问到的，但是私有方法不行。
假设：子类不能够继承父类的私有属性和方法
那么：分析内存后，会发现，当一个子类被实例化的时候，默认会先调用父类的构
造方法对父类进行初始化，即在内存中创建一个父类对象，然后再父类对象的外部
放上子类独有的属性，两者合起来成为一个子类的对象。
所以：子类继承了父类的所有属性和方法或子类拥有父类的所有属性和方法是对的，
只不过父类的私有属性和方法，子类是无法直接访问到的。即只是拥有，但是无法使用。
3.作业方面的建议，希望老师不要一开始就提高一些类图和思路，希望老师先给学生一些
自我思考的空间，然后在快截止的前一两天再给出一些思路提示，为一些毫无头绪的一些
提示。
浙公网安备 33010602011771号