第三阶段blog作业

一.前言

1.第七次pta作业有两题，对于我来说难度还是比较大的

 

 

 但好在有强大的网络和热心的同学们可以帮助我去学习我不够明白的东西

所以在第七次的作业中勉强得到了满分的好成绩

第一题是图形卡片排序，不算非常难，第二题是分组，有些困难

在图形类的设计中，体会到了面向对象设计原则中的“开-闭”原则的实现方法及其作用

2.第八次pta作业是atm机模拟程序，能够完成用户的存款、取款以及查询余额功能

对我来说难度也比较大，耗费的时间也比较多

 

 

 

乍一眼看上去这道题的工序非常复杂，但一步一步按照老师作业要求慢慢来也就不那么困难了

 3.第九次pta作业还是atm的模拟程序，在原有的基础加上了一些新的功能以及新的需要存入的信息

 

 对我来说难度较大，耗费时间较多，并且我也没有在第九次作业中得到满分

二.设计与分析

7-1：（1）实现功能 本程序仅用于为学生所玩的游戏提供正确答案的功能，即根据学生得到的卡片种类与数量，给出 排序前和排序后的卡片顺序，同时给出所有卡片的面积之和。 （2）输入输出规则 ①输入规则 首先，在一行上输入一串数字（1~4，整数），其中，1 代表圆形卡片，2 代表矩形卡片，3 代表 三角形卡片，4 代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如： 1 3 4 2 1 3 4 2 1 3 0 然后根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要 输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要 输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。 ②输出规则  如果图形数量非法（小于 0）或图形属性值非法（数值小于 0 以及三角形三边不能组成三 角形），则输出“Wrong Format”。2 / 4  如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。输出内容如下：  排序前的各图形类型及面积，格式为“图形名称 1:面积值 1 图形名称 2:面积值 2 …图形名称 n:面积值 n ”，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格；  排序后的各图形类型及面积，格式同排序前的输出；  所有图形的面积总和，格式为“Sum of area:总面积值”。 

1.本题主要的解题要求：

2.继承、多态的应用；

3.ArrayList泛型的应用方法

4.Comparable接口及泛型的应用

5.单一职责原则的应用

6.“开-闭”原则的应用

源码：

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);
if(!dealCardList.validate()){
System.out.println("Wrong Format");
System.exit(0);
}
dealCardList.showResult();
input.close();
}
}
class DealCardList{

ArrayList<Card> cardList=new ArrayList<Card>();
DealCardList(){

}
DealCardList(ArrayList<Integer> list) {
// TODO 自动生成的构造函数存根
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 void showResult() {
// TODO 自动生成的方法存根
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()));
}

public void cardSort() {
// TODO 自动生成的方法存根
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 boolean validate() {
// TODO 自动生成的方法存根
for(int i=0;i<cardList.size();i++)
{
if(!cardList.get(i).getShape().vaildate())
return false;
}
return true;
}

public double getAllArea() {
// TODO 自动生成的方法存根
double s=0;
for(int i=0;i<cardList.size();i++)
s=s+cardList.get(i).getShape().getArea();
return s;
}
}
class Card{
Shape shape;
Card(){

}
Card(Shape shape){
this.shape=shape;
}
public Shape getShape() {
return shape;
}
public void setShape(Shape shape) {
this.shape = shape;
}
public int compareTo(Card card) {
return 0;

}
}
class Shape{
private String shapeName;
Shape(){

}
Shape(String shapeName){
this.shapeName=shapeName;
}
public String getShapeName() {
return shapeName;
}
public void setShapeName(String shapeName) {
this.shapeName=shapeName;
}
public double getArea() {
return 0.0;
}
public boolean vaildate() {
return true;
}
@Override
public String toString() {
return shapeName;

}
}
class Traperoid extends 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;
}
}
class Triangle extends 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 Circle extends Shape{
private double radius;
Circle(){

}
Circle(double radius){
this.radius=radius;
}
public double getRadius() {
return radius;
}
public void setRadius(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{
private double width;
private double length;
Rectangle(){

}
Rectangle(double width,double length){
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;
}
public double getArea() {
return length*width;
}
public boolean vaildate() {
if(width>0&&length>0)
return true;
else
return false;
}
}

7-2

（1）实现功能 ⚫ 对各图形信息进行输入并输出； ⚫ 输入数据的正确性校验； ⚫ 对输入的图形按照图形类型进行分组并输出，分组原理如下图所示：

 

 

 

⚫ 对每组内的图形按照面积值降序排序并输出； ⚫ 求出每组内图形面积的总和； ⚫ 求出所有组的面积总和的最大值并输出。 （2）输入输出规则2 / 5 ①输入规则 首先，在一行上输入一串数字（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.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int []num = new int[1000];
int flag = 1;
int i = 0,a = 0,b = 0,c = 0,d = 0,A = 0,B = 0,C = 0,D = 0;
int abc = input.nextInt();
if(abc == 0) {
System.out.println("Wrong Format");
}else {
while(abc!=0) {
if(abc<0||abc>4) {
flag = 2;
}
if(abc == 1) {
a++;
}
if(abc == 2) {
b++;
}
if(abc == 3) {
c++;
}
if(abc == 4) {
d++;
}
num[i]=abc;
abc = input.nextInt();
i++;
}
if(flag == 2) {
System.out.print("Wrong Format");
}
else {
int []q = new int[i];
Circle[] circle = new Circle[i];
Rectangle[] rectangle = new Rectangle[i];
Triangle [] triangle = new Triangle[i];
Trapezoid[] trapezoid = new Trapezoid[i];
String w[] = new String[i];
Double []sum = new Double[i];
Double []sum1 = new Double[a];
Double []sum2 = new Double[b];
Double []sum3 = new Double[c];
Double []sum4 = new Double[d];
double s1 = 0;
double s2 = 0;
double s3 = 0;
double s4 = 0;
double max = 0;
Double []maxsum = new Double[4];
for(int j = 0;j<i;j++) {
if(num[j]==1) {
q[j]=1;
circle[j] = new Circle(input.nextDouble());
if(!circle[j].validate()) {
flag = 0;
}
}
if(num[j]==2) {
q[j]=2;
rectangle[j] = new Rectangle(input.nextDouble(),input.nextDouble());
if(!rectangle[j].validate()) {
flag =0 ;
}
}
if(num[j]==3) {
q[j]=3;
triangle[j] = new Triangle(input.nextDouble(),input.nextDouble(),input.nextDouble());
if(!triangle[j].validate()) {
flag = 0;
}
}
if(num[j]==4) {
q[j]=4;
trapezoid[j] = new Trapezoid(input.nextDouble(),input.nextDouble(),input.nextDouble());
if(!trapezoid[j].validate()) {
flag = 0;
}
}
}
if(flag==0) {
System.out.print("Wrong Format");
}
else {
for(int j = 0;j < i;j ++) {
if(q[j]==1) {
sum[j]=circle[j].getArea();
w[j]="Circle:";
sum1[A] = sum[j];
A++;
}
if(q[j]==2) {
sum[j]=rectangle[j].getArea();
w[j]="Rectangle:";
sum2[B] = sum[j];
B++;
}
if(q[j]==3) {
sum[j]=triangle[j].getArea();
w[j]="Triangle:";
sum3[C] = sum[j];
C++;
}
if(q[j]==4) {
sum[j]=trapezoid[j].getArea();
w[j]="Trapezoid:";
sum4[D] = sum[j];
D++;
}
if(sum[j]>max) {
max =sum[j];
}
}
System.out.println("The original list:");
System.out.print("[");
for(int j = 0;j < i;j++) {
System.out.print(w[j]+String.format("%.2f",sum[j])+" ");
}
System.out.print("]");
System.out.println("\nThe Separated List:");
System.out.print("[");
for(int j = 0;j<A;j++) {
System.out.print("Circle:"+String.format("%.2f",sum1[j])+" ");
}
System.out.print("]");
System.out.print("[");
for(int j = 0;j<B;j++) {
System.out.print("Rectangle:"+String.format("%.2f",sum2[j])+" ");
}
System.out.print("]");
System.out.print("[");
for(int j = 0;j<C;j++) {
System.out.print("Triangle:"+String.format("%.2f",sum3[j])+" ");
}
System.out.print("]");
System.out.print("[");
for(int j = 0;j<D;j++) {
System.out.print("Trapezoid:"+String.format("%.2f",sum4[j])+" ");
}
System.out.print("]");
for(int j=0;j<A-1;j++)
{
for(int k=j+1;k<A;k++)
if(sum1[k]>sum1[j])
{

double t =sum1[k];
sum1[k]=sum1[j];
sum1[j]=t;
}
}
for(int j=0;j<B-1;j++)
{
for(int k=j+1;k<B;k++)
if(sum2[k]>sum2[j])
{

double t =sum2[k];
sum2[k]=sum2[j];
sum2[j]=t;
}
}
for(int j=0;j<C-1;j++)
{
for(int k=j+1;k<C;k++)
if(sum3[k]>sum3[j])
{

double t =sum3[k];
sum3[k]=sum3[j];
sum3[j]=t;
}
}
for(int j=0;j<D-1;j++)
{
for(int k=j+1;k<D;k++)
if(sum4[k]>sum4[j])
{

double t =sum4[k];
sum4[k]=sum4[j];
sum4[j]=t;
}
}
System.out.println("\nThe Separated sorted List:");
System.out.print("[");
for(int j = 0;j<A;j++) {
System.out.print("Circle:"+String.format("%.2f",sum1[j])+" ");
s1 += sum1[j];
}
maxsum[0] = s1;
System.out.print("]");
System.out.print("[");
for(int j = 0;j<B;j++) {
System.out.print("Rectangle:"+String.format("%.2f",sum2[j])+" ");
s2 += sum2[j];
}
maxsum[1] = s2;
System.out.print("]");
System.out.print("[");
for(int j = 0;j<C;j++) {
System.out.print("Triangle:"+String.format("%.2f",sum3[j])+" ");
s3 += sum3[j];
}
maxsum[2] = s3;
System.out.print("]");
System.out.print("[");
for(int j = 0;j<D;j++) {
System.out.print("Trapezoid:"+String.format("%.2f",sum4[j])+" ");
s4 += sum4[j];
}
maxsum[3] = s4;
System.out.print("]");
for(int j =0 ;j<4;j++) {
if(max<maxsum[j]) {
max = maxsum[j];
}
}
System.out.println("\nThe max area:"+String.format("%.2f",max));
}
}
}
}
}

class Trapezoid{
private double topSide;
private double bottomSide;
private double height;

public Trapezoid(double topSide,double bottomSide,double height) {
this.bottomSide = bottomSide;
this.height = height;
this.topSide = topSide;
}
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;
}
public boolean validate() {
if(topSide<0||bottomSide<0||height<0) {
return false;
}

else return true;
}

public double getArea() {
return (topSide+bottomSide)*height/2;
}
}
class hr {
public double getTopSide() {
return 0;
}
}
class Circle {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}

public boolean validate() {
if(radius <= 0)
return false;
else return true;
}

public double getArea() {
return Math.PI*radius*radius;
}
}

class Rectangle{
private double width;
private double length;
public Rectangle(double width,double length) {
this.length = length;
this.width = width;
}
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;
}
public boolean validate() {
if(width <0||length<0)
return false;
else
return true;
}
public double getArea() {
return width*length;
}
}
class zyh{
private boolean zyh = false;
}
class Triangle {
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 double getSide1() {
return side1;
}

public void setSide1(double side1) {
this.side1 = side1;
}

public double getSide2() {
return side2;
}

public void setSide2(double side2) {
this.side2 = side2;
}

public double getSide3() {
return side3;
}

public void setSide3(double side3) {
this.side3 = side3;
}

public boolean validate() {
if(side1 <0||side2<0||side3<0||(side1+side2-side3)<=0||(side1+side3-side2)<=0||(side3+side2-side1)<=0)
return false;
else return true;
}

public double getArea() {
return Math.sqrt((side1+side2+side3)*(side1+side2-side3)*(side1+side3-side2)*(side2+side3-side1))/4;
}
}

8-1 ATM机类结构设计（一）

 

 

 

 atm的设计考察了我们很全面的Java知识的储备，需要我们设计很多的类和方法来满足题目提出的要求

输入错误处理

如果输入卡号不存在，则输出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.。

这道题目还是需要花费不少时间的

源码

import java.util.ArrayList;
import java.util.Objects;
import java.util.Scanner;
class Bank{
public Bank() {
}
private String name;
private ArrayList <ATM> atm;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

public ArrayList<ATM> getAtm() {
return atm;
}
public void setAtm(ArrayList<ATM> atm) {
this.atm = atm;
}

}
class Account{
private User user;
private Bank bank;
private String num;
private double money;
private ArrayList <Card> card;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Bank getBank() {
return bank;
}

public String getNum() {
return num;
}

public ArrayList<Card> getCard() {
return card;
}

public void setCard(ArrayList<Card> card) {
this.card = card;
}

public void setBank(Bank bank) {
this.bank = bank;
}

@Override
public String toString() {
return "Account{" +
"user=" + user +
", bank=" + bank +
", num='" + num + '\'' +
", money=" + money +
", card=" + card +
'}';
}

public void setNum(String num) {
this.num = num;
}

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Account account = (Account) o;
return Double.compare(account.money, money) == 0 && Objects.equals(user, account.user) && Objects.equals(bank, account.bank) && Objects.equals(num, account.num) && Objects.equals(card, account.card);
}

@Override
public int hashCode() {
return Objects.hash(user, bank, num, money, card);
}

public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}

}
class User{
private String name;

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

}
class Card{
private Account account;
private String num;
private final String passWord="88888888";
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}

}
class ATM{
private final String num;
public String getNum() {
return num;
}

public ATM(String num) {
super();
this.num = num;
}
}
public class Main {
public static Scanner input = new Scanner(System.in);
public static void main(String[] args){
Bank bank1 = new Bank();
bank1.setName("中国建设银行");
Bank bank2 = new Bank();
bank2.setName("中国工商银行");

User 杨过 = new User();
杨过.setName("杨过");
User 郭靖 = new User();
郭靖.setName("郭靖");
User 张无忌 = new User();
张无忌.setName("张无忌");
User 韦小宝 = new User();
韦小宝.setName("韦小宝");

ATM atm01 = new ATM("01");
ATM atm02 = new ATM("02");

ATM atm03 = new ATM("03");

ATM atm04 = new ATM("04");

ATM atm05 = new ATM("05");

ATM atm06 = new ATM("06");

ArrayList<ATM> atmb1 = new ArrayList<>();
atmb1.add(atm01);
atmb1.add(atm02);
atmb1.add(atm03);
atmb1.add(atm04);
bank1.setAtm(atmb1);
ArrayList<ATM> atmb2 = new ArrayList<>();
atmb2.add(atm05);
atmb2.add(atm06);
bank2.setAtm(atmb2);

Account account1 = new Account();
account1.setMoney(10000.00);
account1.setUser(杨过);
account1.setBank(bank1);
account1.setNum("3217000010041315709");

Account account2 = new Account();
account2.setMoney(10000.00);
account2.setUser(杨过);
account2.setBank(bank1);
account2.setNum("3217000010041315715");

Account account3 = new Account();
account3.setMoney(10000.00);
account3.setUser(郭靖);
account3.setBank(bank2);
account3.setNum("3217000010051320007");

Account account4 = new Account();
account4.setMoney(10000.00);
account4.setUser(张无忌);
account4.setBank(bank2);
account4.setNum("3222081502001312389");

Account account5 = new Account();
account5.setMoney(10000.00);
account5.setUser(张无忌);
account5.setBank(bank2);
account5.setNum("3222081502001312390");

Account account6 = new Account();
account6.setMoney(10000.00);
account6.setUser(张无忌);
account6.setBank(bank2);
account6.setNum("3222081502001312399");

Account account7 = new Account();
account7.setMoney(10000.00);
account7.setUser(韦小宝);
account7.setBank(bank2);
account7.setNum("3222081502051320785");

Account account8 = new Account();
account8.setMoney(10000.00);
account8.setUser(韦小宝);
account8.setBank(bank2);
account8.setNum("3222081502051320786");

Card card1 = new Card();
card1.setAccount(account1);
card1.setNum("6217000010041315709");
Card card2 = new Card();
card2.setAccount(account1);
card2.setNum("6217000010041315715");
Card card3 = new Card();
card3.setAccount(account2);
card3.setNum("6217000010041315718");
Card card4 = new Card();
card4.setAccount(account3);
card4.setNum("6217000010051320007");
Card card5 = new Card();
card5.setAccount(account4);
card5.setNum("6222081502001312389");
Card card6 = new Card();
card6.setAccount(account5);
card6.setNum("6222081502001312390");
Card card7 = new Card();
card7.setAccount(account6);
card7.setNum("6222081502001312399");
Card card8 = new Card();
card8.setAccount(account6);
card8.setNum("6222081502001312400");
Card card9 = new Card();
card9.setAccount(account7);
card9.setNum("6222081502051320785");
Card card10 = new Card();
card10.setAccount(account8);
card10.setNum("6222081502051320786");

ArrayList<Card> cards = new ArrayList<Card>();
cards.add(card1);
cards.add(card2);
cards.add(card3);
cards.add(card4);
cards.add(card5);
cards.add(card6);
cards.add(card7);
cards.add(card8);
cards.add(card9);
cards.add(card10);
ArrayList<String[]> sites = new ArrayList<String[]>();
String a;
int ymy =0;
for(int i=0;;i++)
{
a=input.nextLine();
if(a.equals("#"))
{
break;
}
sites.add(a.split(" +"));
}
for (String[] i : sites) {
for(Card k : cards)
{
if(i[0].equals(k.getNum()))
{
ymy=1;
if(i.length==1)
{
System.out.println("¥"+String.format("%.2f", k.getAccount().getMoney()));
break;
}
if(i[2].matches("0[1-6]"))
{
if(i[1].equals("88888888"))
{
if(Double.parseDouble(i[3])-k.getAccount().getMoney()<0)
{
ArrayList <ATM> l =k.getAccount().getBank().getAtm();
int ymy1=0;
for (ATM o : l) {
if(o.getNum().equals(i[2]))
{
k.getAccount().setMoney(k.getAccount().getMoney()-Double.parseDouble(i[3]));
if(Double.parseDouble(i[3])>0)
System.out.println(k.getAccount().getUser().getName()+"在"+k.getAccount().getBank().getName()+"的"+i[2]+"号ATM机上取款¥"+i[3]);
else
System.out.println(k.getAccount().getUser().getName()+"在"+k.getAccount().getBank().getName()+"的"+i[2]+"号ATM机上存款¥"+String.format("%.2f", -Double.parseDouble(i[3])));

System.out.println("当前余额为¥"+String.format("%.2f", k.getAccount().getMoney()));
ymy1=1;
}
}
if(ymy1==0)
{
System.out.println("Sorry,cross-bank withdrawal is not supported.");
System.exit(0);
}
}
else {

System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}

}
else
{
System.out.println("Sorry,your password is wrong.");
System.exit(0);
}

}
else
{
System.out.println("Sorry,the ATM's id is wrong.");
System.exit(0);

}

}

}
if(ymy==0)
{
System.out.println("Sorry,this card does not exist.");
System.exit(0);
}
}
}
}

9-1ATM机类结构设计（二） 

第二题在第一题的基础上加入了很多的新东西，比如 借记卡，手续费，新人物，新卡号之类的

 

 

 

 源码太长了不便于放出来看

这道题我是在老师发出来的上一题的源码的基础上修改的

最后还是有一个测试点过不了

三.踩坑心得

有的地方有一些无用代码，明明可以合并起来却没有，导致代码实在太长，太繁琐，导致想要修改一些地方的时候太难

务必注意本题目中的各实体类之间的关系，尤其是一对多的组合关系

对实体类的设计要做到单一职责原则，且不能缺少规定的实体类

编程时考虑面向对象中的封装性本题目中的应用以及是否有能够扩展 的衍生需求

在“合成复用原则”及“单一职责原则”基础上，使之符合 “开-闭”原则

四.改进建议

有很多地方的代码可以进行修改使其变得更加简洁

pta可以加上一些测试点的具体数据

五.总结

通过本学期的学习认我学习到了很多东西，明白如何设计类，如何灵活的使用多态与继承，增加了对类的继承，聚合，多态以及接口引用的学习

我认为需要自己本身慢慢培养出强大的自学能力，养成一个良好的编程习惯，主要还是要靠自己去多钻研，多思考

加油加油加油！