20201314-李洋的第四次Bolg
------------恢复内容开始------------
一·前言：
（1）前两次作业基本上考验的是对于类的继承，多态，使用方法，以及接口的运用。对于我来说难度适中，题量也适中。
（2）后两次作业Atm机的内容，难度较大，题量也增加，而且代码量也在大幅度增加。
二.设计与分析：
题目集（7-1）
题目如下：
每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业务操作输入格式如下：
- 存款、取款功能输入数据格式：
卡号 密码 ATM机编号 金额（由一个或多个空格分隔）， 其中，当金额大于0时，代表取款，否则代表存款。 - 查询余额功能输入数据格式：
卡号
输出格式:
①输入错误处理
- 如果输入卡号不存在，则输出
Sorry,this card does not exist.。 - 如果输入ATM机编号不存在，则输出
Sorry,the ATM's id is wrong.。 - 如果输入银行卡密码错误，则输出
Sorry,your password is wrong.。 - 如果输入取款金额大于账户余额，则输出
Sorry,your account balance is insufficient.。 - 如果检测为跨行存取款，则输出
Sorry,cross-bank withdrawal is not supported.。
②取款业务输出
输出共两行，格式分别为：
[用户姓名]在[银行名称]的[ATM编号]上取款¥[金额]
当前余额为¥[金额]
其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。
③存款业务输出
输出共两行，格式分别为：
[用户姓名]在[银行名称]的[ATM编号]上存款¥[金额]
当前余额为¥[金额]
其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。
④查询余额业务输出
¥[金额]
金额保留两位小数。
类图如下：
代码如下：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static Scanner input = new Scanner(System.in);
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); 创建一个Card类的链表
if(!dealCardList.validate()){
System.out.println("Wrong Format");
System.exit(0);
}
dealCardList.showResult(); show函数
input.close();
}
}
class Card{ 创建一个Card类
Shape shape;
Card(){
}
Card(Shape shape){ 有参构造方法
this.shape=shape;
}
public Shape getShape() { Shape get函数
return shape;
}
public void setShape(Shape Shape) { Shape set函数
this.shape=shape;
}
}
class DealCardList{ 一个DealCardList的类
ArrayList<Card> cardList=new ArrayList<Card>(); 再类中创建一个Card类型的代码
DealCardList(){
无参构造方法
}
DealCardList(ArrayList<Integer> list){ 有参构造方法
for(int i=0;i<list.size();i++)
{
if(list.get(i)==1) 当输入的数据为1时进行第一种类型的操作
{
double r=Main.input.nextDouble();
Circle circle=new Circle(r);
Card card=new Card(circle);
card.getShape().setShapeName("Circle");
cardList.add(card);
}
if(list.get(i)==2) { 当输入的数据为2时进行第二种类型的操作
double a=Main.input.nextDouble();
double b=Main.input.nextDouble();
Rectangle rectangle=new Rectangle(a,b);
Card card=new Card(rectangle);
card.getShape().setShapeName("Rectangle");
cardList.add(card);
}
if(list.get(i)==3) { 当输入的数据为3时进行第三种类型的操作
double a=Main.input.nextDouble();
double b=Main.input.nextDouble();
double c=Main.input.nextDouble();
Triangle triangle=new Triangle(a,b,c);
Card card=new Card(triangle);
card.getShape().setShapeName("Triangle");
cardList.add(card);
}
if(list.get(i)==4) { 当输入的数据为4时进行第四种类型的操作
double a=Main.input.nextDouble();
double b=Main.input.nextDouble();
double c=Main.input.nextDouble();
Traperoid traperoid=new Traperoid(a,b,c);
Card card=new Card(traperoid);
card.getShape().setShapeName("Trapezoid");
cardList.add(card);
}
}
}
public boolean validate() { 判断合法性的函数
for(int i=0;i<cardList.size();i++)
{if(!cardList.get(i).getShape().vaildate())
return false;}
return true;
}
public void cardSort() {
for(int k=0;k<cardList.size();k++)
for(int i=k+1;i<cardList.size();i++)
{
if(cardList.get(k).getShape().getArea()<cardList.get(i).getShape().getArea())
Collections.swap(cardList, k, i);
}
}
public double getAllArea() { 输出面积的函数
double s=0;
for(int i=0;i<cardList.size();i++)
s=s+cardList.get(i).getShape().getArea(); 将面积加起来
return s;
}
public void showResult() { 展示结果的函数
System.out.println("The original list:");
for(int i=0;i<cardList.size();i++) 开始循环链表分析
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
System.out.println();
System.out.println("The sorted list:");
cardSort();
for(int i=0;i<cardList.size();i++)
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
System.out.println();
System.out.println("Sum of area:"+String.format("%.2f",getAllArea()));
}
}
class Shape { 定义一个 Shape类
private String shapeName;
Shape(){
无参构造方法
}
Shape(String shapeName){
this.shapeName=shapeName; 有参构造方法
}
public String getShapeName() { Shapename的get方法
return shapeName;
}
public void setShapeName(String shapeName) { ShapeName的set方法
this.shapeName=shapeName;
}
public double getArea() { 输出面积的方法
return 0.0;
}
public boolean vaildate() { 判断合法性
return true;
}
}
class Circle extends Shape{ 定义一个Circle类继承Shape类
private double radius;
Circle(){
无参构造方法
}
Circle(double radius){
this.radius=radius; 有参构造方法
}
public double getArea() {
return Math.PI*radius*radius; Area的get方法
}
public boolean vaildate() { 判断合法性的方法
if(radius>0)
return true;
else return false;
}
}
class Rectangle extends Shape{ 定义一个Rectangle的方法继承Shape
private double width,length;
Rectangle (double width,double length){
this.width=width; 定义一个有参构造方法
this.length=length;
}
public double getArea() {
return width*length; Area的get方法
}
public boolean vaildate() { 重构父类中的判断合法性的放法
if(width>0&&length>0)
return true;
else return false;
}
}
class Triangle extends Shape{ 定义一个Triangle的方法并且继承Shape
double side1,side2,side3;
Triangle(double side1,double side2,double side3){
this.side1=side1;
this.side2=side2; 有参构造方法
this.side3=side3;
}
public double getArea() {
double c=(side1+side2+side3)/2; Area的get方法
double s=Math.sqrt(c*(c-side1)*(c-side2)*(c-side3));
return s;
}
public boolean vaildate() { 重构父类中的判断合法性的方法
if(side1+side2>side3&&side1+side3>side2&&side2+side3>side1)
return true;
else
return false;
}
}
class Traperoid extends Shape{ 定义一个Traperoid的方法并且继承Shape
private double topSide,bottomSide,height;
Traperoid(){
} 定义一个无参构造方法
Traperoid(double topSide,double bottomSide,double height){
this.bottomSide=bottomSide;
this.height=height; 定义一个有参构造方法
this.topSide=topSide;
}
public double getArea() { Area的get方法
return (topSide+bottomSide)*height/2;
}
public boolean validate() { 重构父类中的判断合法性的方法
if(topSide>0&&bottomSide>0&&height>0)
return true;
else return false;
}
}
本题小结：
本题主要是考类的继承以及运用，先创建一个Shape的类为父类，在类中写一个面积的方法 和判断合法性的方法
在继续定义其他题中所给的类 并且这些类要继承Shape 在这些子类中 将会重构计算面积的方法 和判断合法性的方法
定义一个计算的类，将输入的数据用链表的形式储存起来，在计算的类中进行分类，例如三角形 矩形等
不同种类的图形将有不同的计算方法 将主类中所输入的数据传入计算的类中进行分析和得出结果 并且输出
题目集（7-2）
题目如下：
- 在一行上输入一串数字（1~4，整数），其中，1代表圆形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如：
1 3 4 2 1 3 4 2 1 3 0 - 根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。
输出格式:
- 如果图形数量非法（<=0）或图形属性值非法（数值<0以及三角形三边不能组成三角形），则输出
Wrong Format。 - 如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。输出内容如下：
- 排序前的各图形类型及面积，格式为
[图形名称1:面积值1图形名称2:面积值2 …图形名称n:面积值n ]，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格，在结束符“]”之前； - 输出分组后的图形类型及面积，格式为
[圆形分组各图形类型及面积][矩形分组各图形类型及面积][三角形分组各图形类型及面积][梯形分组各图形类型及面积]，各组内格式为图形名称:面积值。按照“Circle、Rectangle、Triangle、Trapezoid”的顺序依次输出； - 各组内图形排序后的各图形类型及面积，格式同排序前各组图形的输出；
- 各组中面积之和的最大值输出，格式为
The max area:面积值。
类图如下：
代码如下：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
//在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
//使用Main.input.next…即可（避免采坑）
public static Scanner input = new Scanner(System.in);
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<Integer>(); 定义一个整型的链表
int num = input.nextInt(); 开始输入数据
if(num==0) {
System.out.println("Wrong Format");
System.exit(0);
}
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); 定义一个 dealCardList类型的链表
if(!dealCardList.validate()){
System.out.println("Wrong Format");
System.exit(0);
}
dealCardList.showResult(); show的方法
input.close();
}
}
class Card{ 定义一个Card类
Shape shape;
Card(){
无参构造方法
}
Card(Shape shape){
this.shape=shape; 有参构造方法
}
public Shape getShape() { Shape的get方法
return shape;
}
public void setShape(Shape Shape) {
this.shape=shape; Shape的set方法
}
}
class DealCardList{ 定义一个DealCardList的类
ArrayList<Card> cardList=new ArrayList<Card>(); 定义一个Card类型的链表
DealCardList(){
CardList的无参构造方法
}
DealCardList(ArrayList<Integer> list){ CardList的有参构造方法
for(int i=0;i<list.size();i++)
{ 链表循环 处理数据
if(list.get(i)==1)
{ 第一种类型的处理方法
double r=Main.input.nextDouble();
Circle circle=new Circle(r);
Card card=new Card(circle);
card.getShape().setShapeName("Circle");
cardList.add(card);
}
if(list.get(i)==2) { 第二种类型的处理方法
double a=Main.input.nextDouble();
double b=Main.input.nextDouble();
Rectangle rectangle=new Rectangle(a,b);
Card card=new Card(rectangle);
card.getShape().setShapeName("Rectangle");
cardList.add(card);
}
if(list.get(i)==3) { 第三种类型的处理方法
double a=Main.input.nextDouble();
double b=Main.input.nextDouble();
double c=Main.input.nextDouble();
Triangle triangle=new Triangle(a,b,c);
Card card=new Card(triangle);
card.getShape().setShapeName("Triangle");
cardList.add(card);
}
if(list.get(i)==4) { 第四种类型的处理方法
double a=Main.input.nextDouble();
double b=Main.input.nextDouble();
double c=Main.input.nextDouble();
Traperoid traperoid=new Traperoid(a,b,c);
Card card=new Card(traperoid);
card.getShape().setShapeName("Trapezoid");
cardList.add(card); 继续添加链表中的数据
}
}
}
public boolean validate() { 判断合法性的函数
for(int i=0;i<cardList.size();i++)
{if(!cardList.get(i).getShape().vaildate())
return false;}
return true;
}
public void cardSort() { 输入数据排序
for(int k=0;k<cardList.size();k++)
for(int i=k+1;i<cardList.size();i++)
{
if(cardList.get(k).getShape().getArea()<cardList.get(i).getShape().getArea())
Collections.swap(cardList, k, i);
}
}
public double getAllArea() { AllArea的get方法
double s=0;
for(int i=0;i<cardList.size();i++)
s=s+cardList.get(i).getShape().getArea();
return s;
}
public void showResult() { show的方法
System.out.println("The original list:");
System.out.print("[");
for(int i=0;i<cardList.size();i++)
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
System.out.println("]");
System.out.println("The Separated List:");
System.out.print("[");
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Circle") {
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
}
}
System.out.print("]");
System.out.print("[");
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Rectangle") {
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
}
}
System.out.print("]");
System.out.print("[");
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Triangle") {
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
}
}
System.out.print("]");
System.out.print("[");
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Trapezoid") {
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
}
}
System.out.print("]");
System.out.println();
cardSort();
System.out.println("The Separated sorted List:");
System.out.print("[");
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Circle") {
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
}
}
System.out.print("]");
System.out.print("[");
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Rectangle") {
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
}
}
System.out.print("]");
System.out.print("[");
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Triangle") {
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
}
}
System.out.print("]");
System.out.print("[");
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Trapezoid") {
System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f",cardList.get(i).getShape().getArea())+" ");
}
}
System.out.println("]");
double a=0;
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Circle") {
a=a+cardList.get(i).getShape().getArea();
}
}
double b = 0;
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Rectangle") {
b=b+cardList.get(i).getShape().getArea();
}
}
double c = 0;
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Triangle") {
c=c+cardList.get(i).getShape().getArea();
}
}
double d = 0;
for(int i=0;i<cardList.size();i++) {
if(cardList.get(i).getShape().getShapeName()=="Trapezoid") {
d=d+cardList.get(i).getShape().getArea();
}
}
double[] li=new double[4];
li[0] = a;
li[1] = b;
li[2] = c;
li[3] = d;
double max = 0;
for(int i = 0;i<4;i++) {
if(max<li[i]) {
max = li[i];
}
}
System.out.println("The max area:"+String.format("%.2f",max));
}
}
class Shape { 定义一个Shape的类
private String shapeName;
Shape(){ 无参构造方法
}
Shape(String shapeName){ 有参构造方法
this.shapeName=shapeName;
}
public String getShapeName() { ShapeName的get方法
return shapeName;
}
public void setShapeName(String shapeName) { ShapeName的set方法
this.shapeName=shapeName;
}
public double getArea() { 定义父类中的输出面积方法
return 0.0;
}
public boolean vaildate() { 判断非法性
return true;
}
}
class Circle extends Shape{ 定义一个Circle类继承Shape
private double radius;
Circle(){
定义无参构造方法
}
Circle(double radius){
this.radius=radius;
}
public double getArea() { 重构面积方法·
return Math.PI*radius*radius;
}
public boolean vaildate() { 重构判断合法性的方法
if(radius>0)
return true;
else return false;
}
}
class Rectangle extends Shape{ 定义一个Rectangle的方法继承Shape
private double width,length;
Rectangle (double width,double length){
this.width=width;
this.length=length;
}
public double getArea() { 重构输出面积的方法
return width*length;
}
public boolean vaildate() { 重构判断合法性的方法
if(width>0&&length>0)
return true;
else return false;
}
}
class Triangle extends Shape{ 定义一个Triangle的类继承Shape
double side1,side2,side3;
Triangle(double side1,double side2,double side3){
this.side1=side1;
this.side2=side2;
this.side3=side3;
}
public double getArea() { 重构父类中的输出面积的方法
double c=(side1+side2+side3)/2;
double s=Math.sqrt(c*(c-side1)*(c-side2)*(c-side3));
return s;
}
public boolean vaildate() { 重构父类中的检验合法性的方法
if(side1+side2>side3&&side1+side3>side2&&side2+side3>side1)
return true;
else
return false;
}
}
class Traperoid extends Shape{ 定义一个Traperoid类继承Shape
private double topSide,bottomSide,height;
Traperoid(){
无参构造方法
}
Traperoid(double topSide,double bottomSide,double height){
this.bottomSide=bottomSide; 有参构造方法
this.height=height;
this.topSide=topSide;
}
public double getArea() { 重构父类中的输出面积的方法
return (topSide+bottomSide)*height/2;
}
public boolean validate() { 重构父类中的检验合法性的方法
if(topSide>0&&bottomSide>0&&height>0)
return true;
else return false;
}
}
本题小结：
本题主要是考类的继承以及运用，先创建一个Shape的类为父类，在类中写一个面积的方法 和判断合法性的方法
在继续定义其他题中所给的类 并且这些类要继承Shape 在这些子类中 将会重构计算面积的方法 和判断合法性的方法
定义一个计算的类，将输入的数据用链表的形式储存起来，在计算的类中进行分类，例如三角形 矩形等
相比于上一题 多加入一个分类的排序的问题 难度于上一题难度相似 多加的功能代码实现相对简单 本题还是很容易解决的
习题八：
题目如下：
每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业务操作输入格式如下：
- 存款、取款功能输入数据格式：
卡号 密码 ATM机编号 金额（由一个或多个空格分隔）， 其中，当金额大于0时，代表取款，否则代表存款。 - 查询余额功能输入数据格式：
卡号
输出格式:
①输入错误处理
- 如果输入卡号不存在，则输出
Sorry,this card does not exist.。 - 如果输入ATM机编号不存在，则输出
Sorry,the ATM's id is wrong.。 - 如果输入银行卡密码错误，则输出
Sorry,your password is wrong.。 - 如果输入取款金额大于账户余额，则输出
Sorry,your account balance is insufficient.。 - 如果检测为跨行存取款，则输出
Sorry,cross-bank withdrawal is not supported.。
②取款业务输出
输出共两行，格式分别为：
[用户姓名]在[银行名称]的[ATM编号]上取款¥[金额]
当前余额为¥[金额]
其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。
③存款业务输出
输出共两行，格式分别为：
[用户姓名]在[银行名称]的[ATM编号]上存款¥[金额]
当前余额为¥[金额]
其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。
④查询余额业务输出
¥[金额]
金额保留两位小数。
类图如下：
代码如下：
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(); 定义一个银联类型的链表。
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); 定义10个atm 并且将ATM机于银行绑定
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); ATM机与银行进行双向绑定
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("360101200102122324","杨过","13856223254"); 用User定义7个对象 将将信息储存起来
User Guojing = new User("360101200012302552","郭靖","13800021124");
User Zhangwuji = new User("360502199805163221","张无忌","13952110011");
User Weixiaobao = new User("360201200513243326","韦小宝","13025996587");
User zhangsanfeng = new User("360201200513243326","张三丰","13634751546");
User linghuchong = new User("360201200513243326","令狐冲","15548062973");
User qiaofeng = new User("360201200513243326","乔峰","15144803370");
Account ccbAcc1 = new Account1("3217000010041315709",10000.00,Yangguo,ccb); 账户与用户进行绑定
Account ccbAcc2 = new Account1("3217000010041315715",10000.00,Yangguo,ccb);
Account ccbAcc3 = new Account1("3217000010051320007",10000.00,Guojing,ccb);
Account icbcAcc1 = new Account1("3222081502001312389",10000.00,Zhangwuji,icbc);
Account icbcAcc2 = new Account1("3222081502001312390",10000.00,Zhangwuji,icbc);
Account icbcAcc3 = new Account1("3222081502001312399",10000.00,Zhangwuji,icbc);
Account icbcAcc4 = new Account1("3222081502051320785",10000.00,Weixiaobao,icbc);
Account icbcAcc5 = new Account1("3222081502051320786",10000.00,Weixiaobao,icbc);
Account ccbAcc4 = new Account2("3640000010045442002",10000.00,zhangsanfeng,ccb);
Account icbcAcc6 = new Account2("3640000010045441009",10000.00,linghuchong,icbc);
Account abcAcc1 = new Account2("3630000010033431001",10000.00,qiaofeng,abc);
ccb.addAccount(ccbAcc1); 账户与用户进行双向绑定
ccb.addAccount(ccbAcc2);
ccb.addAccount(ccbAcc3);
ccb.addAccount(ccbAcc4);
icbc.addAccount(icbcAcc1);
icbc.addAccount(icbcAcc2);
icbc.addAccount(icbcAcc3);
icbc.addAccount(icbcAcc4);
icbc.addAccount(icbcAcc5);
icbc.addAccount(icbcAcc6);
abc.addAccount(abcAcc1);
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(ccbAcc4);
linghuchong.addAccount(icbcAcc6);
qiaofeng.addAccount(abcAcc1);
Card ccbCard1 = new Card("6217000010041315709","88888888",ccbAcc1); 卡与用户进行绑定
Card ccbCard2 = new Card("6217000010041315715","88888888",ccbAcc1);
Card ccbCard3 = new Card("6217000010041315718","88888888",ccbAcc2);
Card ccbCard4 = new Card("6217000010051320007","88888888",ccbAcc3);
Card icbcCard5 = new Card("6222081502001312389","88888888",icbcAcc1);
Card icbcCard6 = new Card("6222081502001312390","88888888",icbcAcc2);
Card icbcCard7 = new Card("6222081502001312399","88888888",icbcAcc3);
Card icbcCard8 = new Card("6222081502001312400","88888888",icbcAcc3);
Card icbcCard9 = new Card("6222081502051320785","88888888",icbcAcc4);
Card icbcCard10 = new Card("6222081502051320786","88888888",icbcAcc5);
Card icbcCard11 = new Card("6640000010045442002","88888888",ccbAcc4);
Card icbcCard12 = new Card("6640000010045442003","88888888",ccbAcc4);
Card icbcCard13 = new Card("6640000010045441009","88888888",icbcAcc6);
Card icbcCard14 = new Card("6630000010033431001","88888888",abcAcc1);
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);
ccbAcc4.addCard(icbcCard11);
ccbAcc4.addCard(icbcCard12);
icbcAcc6.addCard(icbcCard13);
abcAcc1.addCard(icbcCard14);
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 {
Withdraw wd = new Withdraw(unionPay,dataLine[0],dataLine[1],dataLine[2],Double.parseDouble(dataLine[3]));
wd.withdraw();
}
}
}
}
class Bank { 创建一个银行的类
private String bankNO;
private String bankName;
private ArrayList<Account> accountList = new ArrayList<Account>(); 创建一个账户类型的链表
private ArrayList<ATM> ATMList = new ArrayList<ATM>(); 创建一个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() { BankNo的get方法
return bankNO;
}
public void setBankNO(String bankNO) { BankNo的set方法
this.bankNO = bankNO;
}
public String getBankName() { BankName的get方法
return bankName;
}
public void setBankName(String bankName) { BankName的set方法
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() { 链表的get方法
return accountList;
}
public void setAccountList(ArrayList<Account> accountList) { 链表的set方法
this.accountList = accountList;
}
public ArrayList<ATM> getATMList() { ATM机的get方法
return ATMList;
}
public void setATMList(ArrayList<ATM> aTMList) { ATM机的set方法
ATMList = aTMList;
}
}
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 iD, String name, String phone) { 有参构造方法
super();
ID = iD;
this.name = name;
Phone = phone;
}
public String getID() { ID的get方法
return ID;
}
public void setID(String iD) { ID的set方法
ID = iD;
}
public String getPhone() {
return Phone; Phone的get方法
}
public void setPhone(String phone) { Phone的set方法
Phone = phone;
}
public String getName() { Name的get方法
return name;
}
public void setName(String name) { Name的set方法
this.name = name;
}
public void addAccount(Account account) { 链表中加入数据的方法
this.list.add(account);
}
public void removeAccount(Account account) { 链表中减少数据的方法
this.list.remove(account);
}
}
class Account1 extends Account{ 定义一个Account1类来继承Account的类
private double Quota = 0;
public Account1() {
super();
// TODO Auto-generated constructor stub 无参构造方法
}
public Account1(String accountNO, double balance, User user, Bank bank) {
super(accountNO, balance, user, bank); 有参构造方法
// TODO Auto-generated constructor stub
}
public Account1(double quota) {
super();
Quota = quota;
}
public double getQuota() { Qupta的get方法
return Quota;
}
public void setQuota(double quota) { Qupta的set方法
Quota = quota;
}
}
class Account2 extends Account{ 定义一个Account2的类来继承Account类
private double Quota = 50000;
public Account2() {
super(); 无参构造方法
// TODO Auto-generated constructor stub
}
public Account2(String accountNO, double balance, User user, Bank bank) { 有参构造方法
super(accountNO, balance, user, bank);
// TODO Auto-generated constructor stub
}
public Account2(double quota) {
super();
Quota = quota;
}
public double getQuota() { Qupta的get方法
return Quota;
}
public void setQuota(double quota) { Qupga的set方法
Quota = quota;
}
}
class Account { 定义一个Account的类
private String accountNO;
private double balance = 0;
private User user = null;
private Bank bank = null;
private static ArrayList<Card> list = new ArrayList<Card>(); 定义一个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() { Balance的get方法
return balance;
}
public void setBalance(double balance) { Balance的set方法
this.balance = balance;
}
public String getAccountNO() { AccountNo的get方法
return accountNO;
}
public void setAccountNO(String accountNO) { AccountNo的set方法
this.accountNO = accountNO;
}
public User getUser() { User的get方法
return user;
}
public void setUser(User user) { User的set方法
this.user = user;
}
public Bank getBank() { Bank的get方法
return bank;
}
public void setBank(Bank bank) { Bank的set方法
this.bank = bank;
}
public ArrayList<Card> getList() { Card类型的链表的get方法
return list;
}
public void setList(ArrayList<Card> list) { Card类型的链表的set方法
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 { 定义一个Card的类
private String cardNO;
private String cardPassword;
private Account account = null;
public Card() {
super(); 无参构造方法
// TODO Auto-generated constructor stub
}
public Card(String cardNO, String cardPassword, Account account) { 有参构造方法
super();
this.cardNO = cardNO;
this.cardPassword = cardPassword;
this.account = account;
}
public String getCardNO() { Card的get方法
return cardNO;
}
public void setCardNO(String cardNO) { Card的set方法
this.cardNO = cardNO;
}
public String getCardPassword() { CardPassword的get方法
return cardPassword;
}
public Account getAccount() {
return account; Account的get方法
}
public void setAccount(Account account) { Account的set方法
this.account = account;
}
public void setCardPassword(String cardPassword) { CardPassword的set方法
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 ATM { 定义一个ATM的类
private String ATMID;
private Bank bank = null;
public ATM() { 无参构造方法
super();
// TODO Auto-generated constructor stub
}
public ATM(String aTMID, Bank bank) {
super(); 有参构造方法
ATMID = aTMID;
this.bank = bank;
}
public String getATMID() { ATMID的get函数
return ATMID;
}
public void setATMID(String aTMID) { ATMID的set函数
ATMID = aTMID;
}
public Bank getBank() { Bank的get函数
return bank;
}
public void setBank(Bank bank) { Bank的set函数
this.bank = bank;
}
}
class Withdraw { 定义一个中间类
private Account1 account1;
private UnionPay unionPay;
private String cardNO;
private String cardPassword;
private String ATMID;
private double amount;
public Withdraw() {
super();
// TODO Auto-generated constructor stub
}
public Withdraw(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 Withdraw(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); 检验ATM机号是否存在
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) {
}
/**
*
*
* 校验是否为跨行取款
*/
if (account.getBank().getBankNO() != aTM.getBank().getBankNO()) { 检验是否为跨行取款
if(account.getClass().getName().equals("Account2")) { //跨行取款 当卡为信用卡时
if(balance>0&&amount>balance) {
double edu = amount-balance;
jisuan1(account,balance,amount,aTM,edu);
}
if(balance<=0) {//当余额小于0时
分情况计算
double edu = amount;
jisuan1(account,balance,amount,aTM,edu);
}
if(balance>0&&amount<=balance) {
double edu = amount;
jisuan1(account,balance,amount,aTM,edu);
}
}
else {
jisuan2(account,balance,amount,aTM);
}
}
else {
if(account.getClass().getName().equals("Account1")) {
jisuan3(account,balance,amount);
}
if(account.getClass().getName().equals("Account2")) {
if(balance>0&&amount>balance) {
double edu = amount-balance;
jisuan4(account,balance,amount, edu);
}
if(balance<=0) {//当余额小于0时
double edu = amount;
jisuan4(account,balance,amount,edu);
}
if(balance>0&&amount<=balance) {
double edu = amount;
jisuan4(account,balance,amount,edu);
}
}
}
if(amount >= 0) {
showResult(account,1,aTM);
}else {
showResult(account,0,aTM);
}
}
public void jisuan1(Account account,double balance,double amount,ATM aTM,double edu) {
if("中国建设银行".equals(aTM.getBank().getBankName())) {
if(balance-(amount*1.05)-(amount*0.02)<-50000) {
account.setBalance(balance-(amount*1.05)-(amount*0.02));
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
if(balance-(amount*1.02)<0&&(balance-(amount*1.05)-(amount*1.02)>=-50000)) {
account.setBalance(balance-(amount*1.05)-(amount*0.02));
}
if((balance-amount-amount*0.02>=0)){
account.setBalance(balance-amount-amount*0.02);
}
}
if("中国工商银行".equals(aTM.getBank().getBankName())) {
if(balance-(amount*1.05)-(amount*0.03)<-50000) {
account.setBalance(balance-(amount*1.05)-(amount*0.03));
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
if((balance-amount-amount*0.03<0)&&(balance-(amount*1.05)-(amount*1.03)>=-50000)) {
account.setBalance(balance-(amount*1.05)-(amount*0.03));
}
if((balance-amount-amount*0.03>=0)){
account.setBalance(balance-amount-amount*0.03);
}
}
if("中国农业银行".equals(aTM.getBank().getBankName())) {
if(balance-(amount*1.05)-(amount*0.04)<-50000) {
account.setBalance(balance-(amount*1.05)-(amount*0.04));
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
if(balance-(amount*1.04)<0&&(balance-(amount*1.05)-(amount*1.04)>=-50000)) {
account.setBalance(balance-(amount*1.05)-(amount*0.04));
}
if((balance-amount-amount*0.04>=0)){
account.setBalance(balance-amount-amount*0.04);
}
}
}
public void jisuan2(Account account,double balance,double amount,ATM aTM) {
if("中国建设银行".equals(aTM.getBank().getBankName())) {
if(balance-amount-amount*0.02<0) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
else {
account.setBalance(balance-amount-amount*0.02);
}
}
if("中国工商银行".equals(aTM.getBank().getBankName())) {
if(balance-amount-amount*0.03<0) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
else {
account.setBalance(balance-amount-amount*0.03);
}
}
if("中国农业银行".equals(aTM.getBank().getBankName())) {
if(balance-amount-amount*0.04<0) {
//a=1;
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
else {
account.setBalance(balance-amount-amount*0.04);
}
}
}
public void jisuan3(Account account,double balance,double amount) {
if(balance-amount<0) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
else {
account.setBalance(balance-amount);
}
}
public void jisuan4(Account account,double balance,double amount,double edu) {
if(balance-(amount*1.05)<-50000) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
if(balance-amount<0) {
if(account.getBalance()>0&&account.getBalance()-amount<0) {
double a = account.getBalance()-amount;
account.setBalance(a*1.05);
}
else {
account.setBalance(balance-(amount*1.05));
}
}
if(balance-amount>=0) {
account.setBalance((balance-amount));
}
}
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 = account.getBank().getBankName();
System.out.println("业务：取款 "+userName + "在" +
atm.getBank().getBankName() + "的" + ATMID + "号ATM机上" + type + String.format("¥%.2f", amount));
System.out.println("当前余额为" + String.format("¥%.2f", account.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.getATMID().equals(ATMID)) {
return aTM;
}
}
}
return null;
}
}
class UnionPay {
private ArrayList<Bank> bankList = new ArrayList<Bank>();
public UnionPay() {
super();
// TODO Auto-generated constructor stub
}
public UnionPay(ArrayList<Bank> bankList) {
super();
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);
}
}
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();
}
}
测试结果：
本题小结：
本题难度较大 难点分别是在刚开始的初始化 也就是双向绑定 ，还有在跨行取款时的计算问题 本题代码量大幅度增加
在绑定时容易出错 绑定的原理就是在链表中输入数据 并且有一种类似于递进的关系 把所有的类套在一起 在绑定的时候
经常会出错 原理也比较难理解 很多链表联系起来 链表中的每一个变量中还是一个链表 在跨行取款时难度也是很大
要判断金额 要判断是否为跨行取款 是否卡号正确 是否账户正确 还有用户的名字 这就需要遍历这些链表 一个个的找
这就容易出现错误 也比较难理解 最后总结为 本题难度很高。
题目集（9）
题目如下：
每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业务操作输入格式如下：
- 取款功能输入数据格式：
卡号 密码 ATM机编号 金额（由一个或多个空格分隔） - 查询余额功能输入数据格式：
卡号
输出格式:
①输入错误处理
- 如果输入卡号不存在，则输出
Sorry,this card does not exist.。 - 如果输入ATM机编号不存在，则输出
Sorry,the ATM's id is wrong.。 - 如果输入银行卡密码错误，则输出
Sorry,your password is wrong.。 - 如果输入取款金额大于账户余额，则输出
Sorry,your account balance is insufficient.。
②取款业务输出
输出共两行，格式分别为：
业务：取款 [用户姓名]在[银行名称]的[ATM编号]上取款¥[金额]
当前余额为¥[金额]
其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。
③查询余额业务输出
业务：查询余额 ¥[金额]
金额保留两位小数。
类图如下：
代码如下：
import java.util.ArrayList;
import java.util.Objects;
import java.util.Scanner;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ATM2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
UnionPay unionPay = new UnionPay();
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); 将ATM与银行进行绑定
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); 银行与ATM机的双向绑定
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("360101200102122324","杨过","13856223254"); 用User的类定义 7个对象 其中有四个为借贷账号（可以欠款）
User Guojing = new User("360101200012302552","郭靖","13800021124");
User Zhangwuji = new User("360502199805163221","张无忌","13952110011");
User Weixiaobao = new User("360201200513243326","韦小宝","13025996587");
/* 增加了四个用户，都是借贷账号*/
User Zhangsanfeng = new User("360502200207260976","张三丰","123456789");
User Linghuchong = new User("360502200207111231","令狐冲","123456789");
User Qiaofeng = new User("360502200210310502","乔峰","9876543210");
User Hongqigong = new User("360502200207114541","洪七公","1122334455");
Account ccbAcc1 = new DebitAccount("3217000010041315709",10000.00,Yangguo,ccb); 用账户与用户进行绑定
Account ccbAcc2 = new DebitAccount("3217000010041315715",10000.00,Yangguo,ccb);
Account ccbAcc3 = new DebitAccount("3217000010051320007",10000.00,Guojing,ccb);
Account icbcAcc1 = new DebitAccount("3222081502001312389",10000.00,Zhangwuji,icbc);
Account icbcAcc2 = new DebitAccount("3222081502001312390",10000.00,Zhangwuji,icbc);
Account icbcAcc3 = new DebitAccount("3222081502001312399",10000.00,Zhangwuji,icbc);
Account icbcAcc4 = new DebitAccount("3222081502051320785",10000.00,Weixiaobao,icbc);
Account icbcAcc5 = new DebitAccount("3222081502051320786",10000.00,Weixiaobao,icbc);
/*新建四个借贷账户*/
Account ccbAcc4 = new CreditAccount("3640000010045442002",10000.00,Zhangsanfeng,ccb);
Account icbcAcc6 = new CreditAccount("3640000010045441009",10000.00,Linghuchong,icbc);
Account abcAcc1 = new CreditAccount("3630000010033431001",10000.00,Qiaofeng,abc);
Account abcAcc2 = new CreditAccount("3630000010033431008",10000.00,Hongqigong,abc);
ccb.addAccount(ccbAcc1);
ccb.addAccount(ccbAcc2);
ccb.addAccount(ccbAcc3);
ccb.addAccount(ccbAcc4); 账户与银行进行绑定
icbc.addAccount(icbcAcc1);
icbc.addAccount(icbcAcc2);
icbc.addAccount(icbcAcc3);
icbc.addAccount(icbcAcc4);
icbc.addAccount(icbcAcc5);
icbc.addAccount(icbcAcc6);
abc.addAccount(abcAcc1);
abc.addAccount(abcAcc2);
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(ccbAcc4);
Linghuchong.addAccount(icbcAcc6);
Qiaofeng.addAccount(abcAcc1);
Hongqigong.addAccount(abcAcc2);
Card ccbCard1 = new Card("6217000010041315709","88888888",ccbAcc1); 卡与账户进行绑定
Card ccbCard2 = new Card("6217000010041315715","88888888",ccbAcc1);
Card ccbCard3 = new Card("6217000010041315718","88888888",ccbAcc2);
Card ccbCard4 = new Card("6217000010051320007","88888888",ccbAcc3);
Card icbcCard5 = new Card("6222081502001312389","88888888",icbcAcc1);
Card icbcCard6 = new Card("6222081502001312390","88888888",icbcAcc2);
Card icbcCard7 = new Card("6222081502001312399","88888888",icbcAcc3);
Card icbcCard8 = new Card("6222081502001312400","88888888",icbcAcc3);
Card icbcCard9 = new Card("6222081502051320785","88888888",icbcAcc4);
Card icbcCard10 = new Card("6222081502051320786","88888888",icbcAcc5);
Card ccbCard11 = new Card("6640000010045442002","88888888",ccbAcc4);
Card ccbCard12 = new Card("6640000010045442003","88888888",ccbAcc4);
Card icbcCard13 = new Card("6640000010045441009","88888888",icbcAcc6);
Card abcCard14 = new Card("6630000010033431001","88888888",abcAcc1);
Card abcCard15 = new Card("6630000010033431008","88888888",abcAcc2);
ccbAcc1.addCard(ccbCard1);
ccbAcc1.addCard(ccbCard2); 账户与卡进行双向绑定
ccbAcc2.addCard(ccbCard3);
ccbAcc3.addCard(ccbCard4);
ccbAcc4.addCard(ccbCard11);
ccbAcc4.addCard(ccbCard12);
icbcAcc1.addCard(icbcCard5);
icbcAcc2.addCard(icbcCard6);
icbcAcc3.addCard(icbcCard7);
icbcAcc3.addCard(icbcCard8);
icbcAcc4.addCard(icbcCard9);
icbcAcc5.addCard(icbcCard10);
icbcAcc6.addCard(icbcCard13);
abcAcc1.addCard(abcCard14);
abcAcc2.addCard(abcCard15);
StringBuilder sb = new StringBuilder();
String data;
while(!("#".equals(data = input.nextLine()))) {
sb.append(data).append("\n"); 对于输入的数据进行处理和拆分使其变为一行一行的数据
}
String[] dt = sb.toString().split("\n");
for (String s : dt) {
String[] dataLine = s.split("\\s+");
if (dataLine.length == 1) {
GetBalance gb = new GetBalance(unionPay); 分情况讨论
System.out.printf("业务：查询余额 ¥%.2f%n", gb.getBalance(dataLine[0]));
} else {
Withdraw wd = new Withdraw(unionPay, dataLine[0], dataLine[1], dataLine[2], Double.parseDouble(dataLine[3]));
wd.withdraw();
}
}
}
}
class Bank { 定义一个银行的类
private String bankNO;
private String bankName;
private ArrayList<Account> accountList = new ArrayList<>(); 定义一个账户类型的链表
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() { BankNo的get方法
return bankNO;
}
public void setBankNO(String bankNO) {
this.bankNO = bankNO; BankNo的set方法
}
public String getBankName() { BankName的get方法
return bankName;
}
public void setBankName(String bankName) { BankName的set方法
this.bankName = bankName;
}
public void addAccount(Account account) {
this.accountList.add(account); Account类型的链表的加入数据的方法
}
public void removeAccount(Account account) { Account类型的链表的减少数据的方法
this.accountList.remove(account);
}
public void addATM(ATM aTM) {
this.ATMList.add(aTM); ATM机加入数据的方法
}
public void removeATM(ATM aTM) {
this.ATMList.remove(aTM); ATM机减少数据的方法
}
public ArrayList<Account> getAccountList() { 账户类型链表的get方法
return accountList;
}
public void setAccountList(ArrayList<Account> accountList) { 账户类型链表的set方法
this.accountList = accountList;
}
public ArrayList<ATM> getATMList() { ATM机类型的链表的get方法
return ATMList;
}
public void setATMList(ArrayList<ATM> aTMList) { ATM机类型的链表的set方法
ATMList = aTMList;
}
}
class User { 定义一个User的类
private String ID;
private String name;
private String Phone;
ArrayList<Account> list = new ArrayList<>(); 定义一个账户类型的链表
public User() {
super(); 无参构造方法
// TODO Auto-generated constructor stub
}
public User(String iD, String name, String phone) { 有参构造方法
super();
ID = iD;
this.name = name;
Phone = phone;
}
public String getID() { ID的get方法
return ID;
}
public void setID(String iD) { ID的set方法
ID = iD;
}
public String getPhone() { Phone的get方法
return Phone;
}
public void setPhone(String phone) { Phone的set方法
Phone = phone;
}
public String getName() { Name的get方法
return name;
}
public void setName(String name) { Name的set方法
this.name = name;
}
public void addAccount(Account account) { Account链表加入数据的方法
this.list.add(account);
}
public void removeAccount(Account account) { Account链表减少数据的方法
this.list.remove(account);
}
}
class Account { 定义一个账户的类
private String accountNO;
private double balance = 0;
private User user = null;
private Bank bank = null;
private double quota;
public void setType(String type) {
this.type = type;
}
private String type = "";
private static ArrayList<Card> list = new ArrayList<>(); 定义一个Card类型的链表
public String getType() {
return type;
}
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) { Card类型链表的加入数据的方法
list.add(card);
}
public void removeCard(Card card) { Card类型链表的减少数据的方法
list.remove(card);
}
public double getBalance() { Balance的get方法
return balance;
}
public void setBalance(double balance) { Balance的set方法
this.balance = balance;
}
public String getAccountNO() { AccountNO的get方法
return accountNO;
}
public void setAccountNO(String accountNO) { AccountNO的set方法
this.accountNO = accountNO;
}
public User getUser() { User的get方法
return user;
}
public void setUser(User user) { User的set方法
this.user = user;
}
public Bank getBank() { Bank的get方法
return bank;
}
public void setBank(Bank bank) { Bank的set方法
this.bank = bank;
}
public ArrayList<Card> getList() { Card类型的链表的get方法
return 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;
}
public double getQuota() { Quota的get方法
return quota;
}
public void setQuota(double quota) { Quota的set方法
this.quota = quota;
}
}
class DebitAccount extends Account{ 定义一个子类来继承Account类
public DebitAccount() {
this.setType("Debit");
this.setQuota(0);
}
public DebitAccount(String accountNO, double balance, User user, Bank bank) { 定义一个有参构造方法
super(accountNO, balance, user, bank);
this.setType("Debit");
this.setQuota(0);
}
}
class CreditAccount extends Account{
public CreditAccount() { 定义一个子类来继承Account类
this.setType("Credit");
this.setQuota(0);
}
public CreditAccount(String accountNO, double balance, User user, Bank bank) {
super(accountNO, balance, user, bank); 定义一个有参构造方法
this.setType("Credit");
this.setQuota(0);
}
}
class Card { 定义一个Card类
private String cardNO;
private String cardPassword;
private Account account = null;
public Card() { 无参构造方法
super();
// TODO Auto-generated constructor stub
}
public Card(String cardNO, String cardPassword, Account account) { 有参构造方法
super();
this.cardNO = cardNO;
this.cardPassword = cardPassword;
this.account = account;
}
public String getCardNO() { CardNO的get方法
return cardNO;
}
public void setCardNO(String cardNO) {
this.cardNO = cardNO; CardNO的set方法
}
public String getCardPassword() { CardPasswoyrd的get方法
return cardPassword;
}
public Account getAccount() { CardPassword的set方法
return account;
}
public void setAccount(Account account) { Account的set方法
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 ATM { 定义一个ATM的类
private String ATMID;
private Bank bank = null;
public ATM() { 无参构造方法
super();
// TODO Auto-generated constructor stub
}
public ATM(String aTMID, Bank bank) { 有参构造方法
super();
ATMID = aTMID;
this.bank = bank;
}
public String getATMID() { ATMID的get方法
return ATMID;
}
public void setATMID(String aTMID) { ATMID的set方法
ATMID = aTMID;
}
public Bank getBank() { Bank的get方法
return bank;
}
public void setBank(Bank bank) {
this.bank = bank; Bank的set方法
}
}
class Withdraw { 定义一个中间类
private UnionPay unionPay;
private String cardNO;
private String cardPassword;
private String ATMID;
private double amount;
public Withdraw() {
super(); 无参构造方法
// TODO Auto-generated constructor stub
}
public Withdraw(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 Withdraw(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) { 判断ATM机号是否存在
System.out.println("Sorry,the ATM's id is wrong.");
System.exit(0);
}
Account account = Account.getAmountbyCardNO(cardNO);
assert account != null;
double balance = account.getBalance();
/*
校验卡密码是否正确
*/
if(!card.getCardPassword().equals(cardPassword)) { 判断密码是否存在
System.out.println("Sorry,your password is wrong.");
System.exit(0);
}
/*
校验是否为跨行取款 判断该用户是否为跨行取款
*/
if (!account.getBank().getBankNO().equals(aTM.getBank().getBankNO())) {
bankNotMatch(account, balance,aTM);
}
else{
double gap;
switch (account.getType()){
case "Credit": 分情况进行计算
if(amount > balance && balance >= 0) {
gap = Math.abs(amount - balance);
account.setQuota(account.getQuota() + gap);
account.setBalance(balance - amount - gap * 0.05);
}
else if(balance < 0){
gap = amount;
account.setQuota(account.getQuota() + gap);
account.setBalance(balance - amount - gap * 0.05);
}
else{
account.setBalance(balance - amount);
}
if(account.getQuota() >= 50000){
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
break;
case "Debit":
if(balance < amount){
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
account.setBalance(balance - amount);
break;
}
}
if(amount >= 0) {
showResult(account,1,aTM);
}else {
showResult(account,0,aTM);
}
}
private void bankNotMatch(Account account, double balance,ATM atm) {
if("Credit".equals(account.getType())){
withDraw1(account, balance, atm);
}
else{
withDraw(account, balance, atm);
}
}
private void withDraw(Account account, double balance, ATM atm) {
if("中国建设银行".equals(atm.getBank().getBankName())){
if(balance - amount - amount * 0.02 < 0){
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
account.setBalance(balance - amount - amount * 0.02);
}
if("中国工商银行".equals(atm.getBank().getBankName())){
if(balance - amount - amount * 0.03 < 0){
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
account.setBalance(balance - amount - amount * 0.03);
}
if("中国农业银行".equals(atm.getBank().getBankName())) {
if(balance - amount - amount * 0.04 < 0){
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
account.setBalance(balance - amount - amount * 0.04);
}
}
private void withDraw1(Account account, double balance, ATM atm){//先把账户里所有的钱全部取完，乘上跨行的利息，剩下的钱乘上0.05
double balance1 = account.getBalance();
double gap;
if(balance1 >= 0 && amount - balance > 0){
gap = amount - balance1;
account.setQuota(account.getQuota() + gap);
if("中国建设银行".equals(atm.getBank().getBankName())){
account.setBalance(balance1 - amount - amount * 0.02);
}
if("中国工商银行".equals(atm.getBank().getBankName())){
account.setBalance(balance1 - amount - amount * 0.03);
}
if("中国农业银行".equals(atm.getBank().getBankName())) {
account.setBalance(balance1 - amount - amount * 0.04);
}
account.setBalance(account.getBalance() - gap * 0.05);
}
else if(balance1 < 0){
gap = amount;
account.setQuota(account.getQuota() + gap);
if("中国建设银行".equals(atm.getBank().getBankName())){
account.setBalance(balance1 - amount - amount * 0.02);
}
if("中国工商银行".equals(atm.getBank().getBankName())){
account.setBalance(balance1 - amount - amount * 0.03);
}
if("中国农业银行".equals(atm.getBank().getBankName())) {
account.setBalance(balance1 - amount - amount * 0.04);
}
account.setBalance(account.getBalance() - gap * 0.05);
}
else{
if("中国建设银行".equals(atm.getBank().getBankName())){
account.setBalance(balance1 - amount - amount * 0.02);
}
if("中国工商银行".equals(atm.getBank().getBankName())){
account.setBalance(balance1 - amount - amount * 0.03);
}
if("中国农业银行".equals(atm.getBank().getBankName())) {
account.setBalance(balance1 - amount - amount * 0.04);
}
}
if(account.getQuota() > 50000){
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
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 = account.getBank().getBankName();
String bankName = atm.getBank().getBankName();
System.out.println("业务："+type+" "+userName + "在" +
bankName + "的" + ATMID + "号ATM机上" + type + String.format("¥%.2f", amount));
System.out.println("当前余额为" + String.format("¥%.2f", account.getBalance()));
}
}
class ValidateData {
/**
* 校验卡号是否存在
* @param unionPay
* @param cardNO
*/
public static Card getCardbyCardNO(UnionPay unionPay, String cardNO) {
Card card = null;
for (Bank bank : unionPay.getBankList()) {
ArrayList<Account> accountList = bank.getAccountList();
for (Account account : accountList) {
ArrayList<Card> cardList = account.getList();
for (Card value : cardList) {
card = value;
if (card.getCardNO().equals(cardNO)) {
return card;
}
}
}
}
return null;
}
/**
* 校验ATM ID是否存在
* @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();
for (ATM atm : bank.getATMList()) {
aTM = atm;
if (aTM.getATMID().equals(ATMID)) {
return aTM;
}
}
}
return null;
}
}
class UnionPay {
private ArrayList<Bank> bankList = new ArrayList<Bank>();
public UnionPay() {
super();
// TODO Auto-generated constructor stub
}
public UnionPay(ArrayList<Bank> bankList) {
super();
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);
}
}
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 Objects.requireNonNull(ValidateData.getCardbyCardNO(unionPay, cardNO)).getAccount().getBalance();
}
}
运行测试
本题小结：
本题难度较大 难点分别是在刚开始的初始化 也就是双向绑定 ，还有在跨行取款时的计算问题 本题代码量大幅度增加
在绑定时容易出错 绑定的原理就是在链表中输入数据 并且有一种类似于递进的关系 把所有的类套在一起 在绑定的时候
经常会出错 原理也比较难理解 很多链表联系起来 链表中的每一个变量中还是一个链表 在跨行取款时难度也是很大
要判断金额 要判断是否为跨行取款 是否卡号正确 是否账户正确 还有用户的名字 这就需要遍历这些链表 一个个的找
这就容易出现错误 也比较难理解 最后总结为 本题难度很高。相比于上一题 本题多加了一个借记卡的内容 这部分的
难度又大大增加 不仅要判断是否为跨行取款 还得判断是否为借记卡 还判断欠款是否小于50000，还有利息的计算
很容易出错 本题为所有题中最难的一道 。、
采坑心得：
这几次作业来讲 其实面向对象主要的难点在于 类于类之间的联系 这种联系就是导致了题目的难度大大增加，就本人来讲
对于类之间的关系 梳理不太通顺 导致我做作业时非常困难 报错地方很多 尤其是最后两题 初始化一方面 双向绑定 很难理解
也很难运用 但是可以看明白代码 但自己写的时候 还不能够完整的写出 说到底还是对于知识点掌握不牢固。
总结：
虽然这几次作业已经完成 但是询问了很多同学 对于我自己来说 单独完成这些作业 还是有很大问题 知识点把握不太牢固
代码经常会出现报错 但是在写作业中 会增加自己的知识储备 一个个问题的克服 自己的知识储备也慢慢增多。
浙公网安备 33010602011771号