OOP第三次作业
OOP第三阶段作业总结
一、前言
题目来源于PTA题目集7-9，以下是对它在知识点，题量，难度上的一个总结。
题目集7
- 知识点：Comparable 接口的应用、compareTo（）方法的重写、抽象类的应用、“单一职责”原则和“开-闭”原则，ArrayList的应用等
- 题量：正常
- 难度：适中
题目集8、9
- 知识点：比较综合，主要考验的就是对类图的理解和如何设计类与类之间的关系
- 题量：正常
- 难度：较难
二、设计与分析
1、题目集7（7-1）、（7-2）两道题目的递进式设计分析总结
题目集7（7-1）
①对继承和多态的运用，在类的设计中得到充分的体现，对每个图形都继承于一个图形父类，在声明时只需要声明父类即可，而类的实体根据需要来创建出来即可，不用去追究声明的类型是什么，极大的方便了对功能的操作过程；
②ArrayList泛型的应用方法，将计算出来的数据放在数组中，同时调用ArrayList类的方法可以对数据进行排序，省去了长段的排序代码，同时数据也方便输出。③Comparable接口及泛型的应用，接口的使用可以体现多继承，方便了类之间去各自体现相应的功能，可操作性得以加强。
源代码：
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static Scanner scanner = new Scanner(System.in);
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<>();
int input = scanner.nextInt();
while(input != 0){
if(input!=1&&input!=2&&input!=3&&input!=4){
System.out.println("Wrong Format");
System.exit(1);
}
list.add(input);
input = scanner.nextInt();
}
DealList dealList = new DealList(list);
if(!dealList.validate()){
System.out.println("Wrong Format");
System.exit(1);
}
dealList.showResult();
}
}
class Card implements Comparable<Card>{
Shape shape;
Card(Shape shape){
this.shape=shape;
}
public Shape getShape() {
return shape;
}
@Override
public int compareTo(Card card) {
return Double.compare(card.shape.getArea(), this.shape.getArea());
}
}
class DealList {
ArrayList<Card> cardList=new ArrayList<>();
DealList(ArrayList<Integer> list){
for (Integer integer : list) {
switch (integer) {
case 1:{
double r = Main.scanner.nextDouble();
Circle circle = new Circle(r);
Card card = new Card(circle);
card.getShape().setShapeName("Circle");
cardList.add(card);break;
} case 2:{
double a = Main.scanner.nextDouble();
double b = Main.scanner.nextDouble();
Rectangle rectangle = new Rectangle(a, b);
Card card = new Card(rectangle);
card.getShape().setShapeName("Rectangle");
cardList.add(card);break;
} case 3:{
double a = Main.scanner.nextDouble();
double b = Main.scanner.nextDouble();
double c = Main.scanner.nextDouble();
Triangle triangle = new Triangle(a, b, c);
Card card = new Card(triangle);
card.getShape().setShapeName("Triangle");
cardList.add(card);break;
} case 4:{
double a = Main.scanner.nextDouble();
double b = Main.scanner.nextDouble();
double c = Main.scanner.nextDouble();
Trapezoid trapezoid = new Trapezoid(a, b, c);
Card card = new Card(trapezoid);
card.getShape().setShapeName("Trapezoid");
cardList.add(card);break;
}
}
}
}
public boolean validate() {
for (Card card : cardList) {
if (!card.getShape().validate())
return false;
}
return true;
}
public void cardSort() {
Collections.sort(cardList);
}
public double getAllArea() {
double s=0;
for (Card card : cardList) s = s + card.getShape().getArea();
return s;
}
public void showResult() {
System.out.println("The original list:");
for (Card card : cardList) {
System.out.print(card.getShape()+" ");
}
System.out.println("\nThe sorted list:");
cardSort();
for (Card card : cardList) {
System.out.print(card.getShape()+" ");
}
System.out.print("\nSum of area:"+new DecimalFormat("0.00").format(getAllArea()));
}
}
abstract class Shape {
private String shapeName;
Shape(){
}
public String getShapeName() {
return shapeName;
}
public void setShapeName(String shapeName) {
this.shapeName=shapeName;
}
abstract double getArea();
abstract boolean validate();
public String toString() {
return getShapeName()+":"+new DecimalFormat("0.00").format(getArea());
}
}
class Circle extends Shape{
private final double radius;
Circle(double radius){
this.radius=radius;
}
double getArea() {
return Math.PI*Math.pow(radius,2);
}
boolean validate() {
return radius > 0;
}
}
class Rectangle extends Shape{
private final double width;
private final double length;
Rectangle (double width,double length){
this.width=width;
this.length=length;
}
public double getArea() {
return width*length;
}
public boolean validate() {
return width > 0 && length > 0;
}
}
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 p=(side1+side2+side3)/2;
return Math.sqrt (p*(p-side1)*(p-side2)*(p-side3));
}
public boolean validate() {
return side1>0&&side2>0&&side3>0&&side1 + side2 > side3 && side1 + side3 > side2 && side2 + side3 > side1;
}
}
class Trapezoid extends Shape{
private final double up;
private final double down;
private final double height;
Trapezoid(double up, double down, double height){
this.down =down;
this.height=height;
this.up =up;
}
public double getArea() {
return (up + down)*height/2;
}
public boolean validate() {
return up > 0 && down > 0 && height > 0;
}
}
类图：
复杂度分析图：
题目集7（7-2）
该题是对（7-1）的递进式设计，在对原有的程序基础上添加的分组功能，对于类设计的“ 开闭 ”、“单一”原则有了更好的体现，每个类的功能添加由各自来实现，那里出现了问题就能很快的被发现，同时方便了功能的添加，是对（7-1）类的设计的一种检验，让类的设计的原则更加深入人心。
题目：
源代码：
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Main {
public static Scanner scanner = new Scanner(System.in);
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<>();
int input = scanner.nextInt();
while(input != 0){
if(input!=1&&input!=2&&input!=3&&input!=4){
System.out.println("Wrong Format");
System.exit(1);
}
list.add(input);
input = scanner.nextInt();
}
DealList dealList = new DealList(list);
if(dealList.validate())
dealList.showResult();
else{
System.out.println("Wrong Format");
System.exit(1);
}
}
}
abstract class Shape {
private String shapeName;
public Shape() {
}
public String getShapeName() {
return shapeName;
}
public void setShapeName(String shapeName) {
this.shapeName = shapeName;
}
abstract public double getArea() ;
abstract public boolean validate() ;
public String toString() {
return getShapeName() + ":" + new DecimalFormat("0.00").format(getArea());
}
}
class Card implements Comparable<Card> {
Shape shape;
public Card() {
}
public Shape getShape() {
return shape;
}
public void setShape(Shape shape) {
this.shape = shape;
}
public int compareTo(Card card) {
return Double.compare(card.shape.getArea(), shape.getArea());
}
}
class DealList {
java.util.List<Card> List = new ArrayList<>();
List <Card> List1 = new ArrayList<>();
List <Card> List2 = new ArrayList<>();
List <Card> List3 = new ArrayList<>();
List <Card> List4 = new ArrayList<>();
double[] m = new double[4];
public DealList(ArrayList<Integer> list) {
for (Integer integer : list) {
if (integer!=0) {
switch (integer){
case 1:
Circle circle=new Circle(Main.scanner.nextDouble());
Card card1=new Card();
card1.setShape(circle);
card1.getShape().setShapeName("Circle");
List.add(card1);
List1.add(card1);
m[0]=m[0]+card1.getShape().getArea();
break;
case 2:
Rectangle rectangle=new Rectangle(Main.scanner.nextDouble(),Main.scanner.nextDouble());
Card card2=new Card();
card2.setShape(rectangle);
card2.getShape().setShapeName("Rectangle");
List.add(card2);
List2.add(card2);
m[1]=m[1]+card2.getShape().getArea();
break;
case 3:
Triangle triangle=new Triangle(Main.scanner.nextDouble(),Main.scanner.nextDouble(),Main.scanner.nextDouble());
Card card3=new Card();
card3.setShape(triangle);
card3.getShape().setShapeName("Triangle");
List.add(card3);
List3.add(card3);
m[2]=m[2]+card3.getShape().getArea();
break;
case 4:
Trapezoid trapezoid=new Trapezoid(Main.scanner.nextDouble(),Main.scanner.nextDouble(),Main.scanner.nextDouble());
Card card4=new Card();
card4.setShape(trapezoid);
card4.getShape().setShapeName("Trapezoid");
List.add(card4);
List4.add(card4);
m[3]=m[3]+card4.getShape().getArea();
break;
}
}
}
}
public boolean validate() {
for (Card card:List) {
if(card.getShape().validate()) {
return true;
}
}
return false;
}
public void cardSort() {
Collections.sort(List);
}
public double getAllArea() {
double a=0;
for (Card card:List) {
a+=card.getShape().getArea();
}
return a;
}
public void showResult() {
System.out.println("The original list:");
System.out.print("[");
for (Card card : List) {
System.out.print(card.getShape()+" ");
}
System.out.print("]\n");
System.out.println("The Separated List:");
System.out.print("[");
for (Card card4 : List1) {
System.out.print(card4.getShape().getShapeName() + ":" + new DecimalFormat("0.00").format(card4.getShape().getArea()) + " ");
}
System.out.print("][");
for (Card card3 : List2) {
System.out.print(card3.getShape().getShapeName() + ":" + new DecimalFormat("0.00").format(card3.getShape().getArea()) + " ");
}
System.out.print("][");
for (Card card2 : List3) {
System.out.print(card2.getShape().getShapeName() + ":" + new DecimalFormat("0.00").format(card2.getShape().getArea()) + " ");
}
System.out.print("][");
for (Card card1 : List4) {
System.out.print(card1.getShape().getShapeName() + ":" + new DecimalFormat("0.00").format(card1.getShape().getArea()) + " ");
}
System.out.print("]\n");
System.out.println("The Separated sorted List:");
Collections.sort(List1);
System.out.print("[");
for (Card element : List1) {
System.out.print(element.getShape().getShapeName() + ":" + new DecimalFormat("0.00").format(element.getShape().getArea()) + " ");
}
System.out.print("]");
Collections.sort(List2);
System.out.print("[");
for (Card item : List2) {
System.out.print(item.getShape().getShapeName() + ":" + new DecimalFormat("0.00").format(item.getShape().getArea()) + " ");
}
System.out.print("]");
Collections.sort(List3);
System.out.print("[");
for (Card value : List3) {
System.out.print(value.getShape().getShapeName() + ":" + new DecimalFormat("0.00").format(value.getShape().getArea()) + " ");
}
System.out.print("]");
Collections.sort(List4);
System.out.print("[");
for (Card card : List4) {
System.out.print(card.getShape().getShapeName() + ":" + new DecimalFormat("0.00").format(card.getShape().getArea()) + " ");
}
System.out.print("]\n");
double b=0;
for (double v : m) {
if (v>b) {
b = v;
}
}
System.out.print("The max area:"+new DecimalFormat("0.00").format(b)+"\n");
}
}
class Circle extends Shape {
private final double radius;
Circle(double radius){
this.radius=radius;
}
@Override
public double getArea() {
return Math.PI*Math.pow(radius,2);
}
@Override
public boolean validate() {
return radius > 0;
}
}
class Rectangle extends Shape {
private final double width;
private final double length;
Rectangle (double width,double length){
this.width=width;
this.length=length;
}
@Override
public double getArea() {
return width*length;
}
@Override
public boolean validate() {
return width > 0 && length > 0;
}
}
class Triangle extends Shape {
double side1,side2,side3;
Triangle(double side1,double side2,double side3){
this.side1=side1;
this.side2=side2;
this.side3=side3;
}
@Override
public double getArea() {
double p=(side1+side2+side3)/2;
return Math.sqrt (p*(p-side1)*(p-side2)*(p-side3));
}
@Override
public boolean validate() {
return side1>0&&side2>0&&side3>0&&side1 + side2 > side3 && side1 + side3 > side2 && side2 + side3 > side1;
}
}
class Trapezoid extends Shape {
private final double up;
private final double down;
private final double height;
Trapezoid(double up, double down, double height) {
this.down = down;
this.height = height;
this.up = up;
}
@Override
public double getArea() {
return (up + down) * height / 2;
}
@Override
public boolean validate() {
return up > 0 && down > 0 && height > 0;
}
}
类图：
复杂度分析图：
2、题目集8和题目集9两道ATM机仿真题目的设计思路分析总结
这两道ATM机仿真题目也是呈现一种递进式的设计，对类的设计的考察也是重中之重，将每个功能模块的职责赋予到每个类中，对类之间的关系要分析到位，什么里面有什么要拿捏到位，将类之间关联起来，构成一个框架，功能主体也就自然而然的出来了，同时也方便数据输入时能快速定位到相应的类，让数据良好的被处理，得到相应的输出结果。正因为题目集8对类的良好的设计，才能在题目集9中加入新的功能。在对功能实现进行设计时要考虑好每个类的负责模块，类与类之间的关系，使代码能让人一目了然。
题目集8：
题目：
源代码：
import java.util.ArrayList;
import java.util.Objects;
import java.util.Scanner;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
ArrayList<ATM> atm = new ArrayList<>();
ArrayList<String> list = new ArrayList<>();
ArrayList<Integer> n = new ArrayList<>();
String s;
double a = 10000.00;
double b = 10000.00;
double c = 10000.00;
double d = 10000.00;
ATM atm1;
while((s = input.nextLine()) != null) {
if(s.equals("#")) {
break;
}
list.add(s);
list.add("\n");
}
StringBuilder str = new StringBuilder();
for (String value : list) {// 字符串拼接
str.append(value);
}
String [] p = str.toString().split("\\n+");//转换成String
for (String value : p) {
String[] m = value.split("\\s+");
int i = 0;
switch (m[i]) {
case "6217000010041315709":
case "6217000010041315715":
case "6217000010041315718":
if (i == m.length - 1) {
n.add(3);
atm1 = new ATM("杨过", "中国建设银行", null, null, a);
atm.add(atm1);
continue;
}
atm1 = new ATM("杨过", "中国建设银行", m[i + 2], m[i + 3], a);
atm1.judge(m[i + 1], m[i + 2], Double.parseDouble(m[i + 3]));
if (Objects.equals(m[i + 2], "01") || m[i + 2].equals("02") || m[i + 2].equals("03") || m[i + 2].equals("04")) {
a = a - Double.parseDouble(m[i + 3]);
atm.add(atm1);
if (Double.parseDouble(atm1.getAccount().getAccount()) > 0) {
n.add(1);
} else if (Double.parseDouble(atm1.getAccount().getAccount()) < 0) n.add(2);
else n.add(3);
} else {
System.out.println("Sorry,cross-bank withdrawal is not supported.");
System.exit(0);
}
break;
case "6217000010051320007":
if (i == m.length - 1) {
n.add(3);
atm1 = new ATM("郭靖", "中国建设银行", null, null, b);
atm.add(atm1);
continue;
}
atm1 = new ATM("郭靖", "中国建设银行", m[i + 2], m[i + 3], b);
atm1.judge(m[i + 1], m[i + 2], Double.parseDouble(m[i + 3]));
if (m[i + 2].equals("01") || m[i + 2].equals("02") || m[i + 2].equals("03") || m[i + 2].equals("04")) {
b = b - Double.parseDouble(m[i + 3]);
atm.add(atm1);
if (Double.parseDouble(atm1.getAccount().getAccount()) > 0) {
n.add(1);
} else if (Double.parseDouble(atm1.getAccount().getAccount()) < 0) n.add(2);
else n.add(3);
} else {
System.out.println("Sorry,cross-bank withdrawal is not supported.");
System.exit(0);
}
break;
case "6222081502001312389":
case "6222081502001312390":
case "6222081502001312399":
case "6222081502001312400":
if (i == m.length - 1) {
n.add(3);
atm1 = new ATM("张无忌", "中国工商银行", null, null, c);
atm.add(atm1);
continue;
}
atm1 = new ATM("张无忌", "中国工商银行", m[i + 2], m[i + 3], c);
atm1.judge(m[i + 1], m[i + 2], Double.parseDouble(m[i + 3]));
if (m[i + 2].equals("05") || m[i + 2].equals("06")) {
c = c - Double.parseDouble(m[i + 3]);
atm.add(atm1);
if (Double.parseDouble(atm1.getAccount().getAccount()) > 0) {
n.add(1);
} else if (Double.parseDouble(atm1.getAccount().getAccount()) < 0) n.add(2);
else n.add(3);
} else {
System.out.println("Sorry,cross-bank withdrawal is not supported.");
System.exit(0);
}
break;
case "6222081502051320785":
case "6222081502051320786":
if (i == m.length - 1) {
n.add(3);
atm1 = new ATM("韦小宝", "中国工商银行", null, null, d);
atm.add(atm1);
continue;
}
atm1 = new ATM("韦小宝", "中国工商银行", m[i + 2], m[i + 3], d);
atm1.judge(m[i + 1], m[i + 2], Double.parseDouble(m[i + 3]));
if (m[i + 2].equals("05") || m[i + 2].equals("06")) {
d = d - Double.parseDouble(m[i + 3]);
atm.add(atm1);
if (Double.parseDouble(atm1.getAccount().getAccount()) > 0) {
n.add(1);
} else if (Double.parseDouble(atm1.getAccount().getAccount()) < 0) n.add(2);
else n.add(3);
} else {
System.out.println("Sorry,cross-bank withdrawal is not supported.");
System.exit(0);
}
break;
default:
System.out.println("Sorry,this card does not exist.");
break;
}
}
for(int i = 0;i<atm.size();i++) {
atm.get(i).showResult(n.get(i));
}
}
}
class Bank extends ChinaUnionPay{
Bank(String n){
this.setBankName(n);
}
}
class User{
private String userName;
User(String n){
this.userName = n;
}
public String getName() {
return userName;
}
public void setName(String n) {
this.userName = n;
}
}
class Account{
private final String account;
Account(String n){
this.account = n;
}
public String getAccount() {
return account;
}
}
class Card{
private final double card;
Card(double n){
this.card = n;
}
public double getCard() {
return card;
}
}
class ATM{//ATM类
private String number;
private final Card card;
private final Account account;
private final Bank bank;
private final User user;
ATM(String userName,String bankName,String n,String num,double c){
card = new Card(c);
account = new Account(num);
bank = new Bank(bankName);
user = new User(userName);
this.setNumber(n);
}
public void setNumber(String n) {
this.number = n;
}
public String getNumber() {
return number;
}
public void judge(String n,String m,double a) {
if(!Pattern.matches("[0][1-6]", m)) {
System.out.println("Sorry,the ATM's id is wrong.");
System.exit(0);
}
if(!Pattern.matches("8{8}", n)) {
System.out.println("Sorry,your password is wrong.");
System.exit(0);
}
if(a > 10000) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
public void showResult(int n) {
if(n == 1) {
System.out.println(user.getName() + "在" + bank.getBankName() +"的" + this.getNumber() + "号ATM机上取款¥" + String.format("%.2f",Math.abs(Double.parseDouble(getAccount().getAccount()))));
System.out.println("当前余额为¥" + String.format("%.2f",((card.getCard()-Double.parseDouble(getAccount().getAccount())))));
}
else if(n == 2) {
System.out.println(user.getName() + "在" + bank.getBankName() +"的" + this.getNumber() + "号ATM机上存款¥" + String.format("%.2f",Math.abs(Double.parseDouble(getAccount().getAccount()))));
System.out.println("当前余额为¥" + String.format("%.2f",((card.getCard()-Double.parseDouble(getAccount().getAccount())))));
}
else {
System.out.println("¥"+String.format("%.2f",card.getCard()));
}
}
public Account getAccount() {
return account;
}
}
class ChinaUnionPay{
private String bankName;
public String getBankName() {
return bankName;
}
public void setBankName(String n) {
this.bankName = n;
}
}
类图：
复杂度分析图：
题目集9：
题目：
源代码：
import java.util.ArrayList;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
WithDraw w = new WithDraw();
w.input();
}
}
class WithDraw
{
YinLian yinlian = new YinLian();
WithDraw()
{
}
boolean kyn(String a,String b,String c,double d)
{
Bank bank = SeekAtm(c);
Zhanna account = accountPassword(a,b);
if(account != null && bank != null)
{
//检查是否存款还是取款
if(!(d >= 0))//存款
{
account.seyMoney(account.getMoney() - d);
System.out.println("业务：存款 "+account.yonhu.name+"在"+ bank.name+"的"+c+"号ATM机上存款");
System.out.printf("¥%.2f",Math.abs(d));
}
else//取款
{
//检查是否跨行
if(bank .equals(account.yonhu.bank) )//同行
{
if(account.getMoney() >=d&& account.getMoney() > 0)
{
account.seyMoney(account.getMoney() - d);
}
else if(account.getMoney() < d && account.getMoney() > 0)
{
double v = (account.getMoney() - d) * 1.05;
account.seyMoney(v);
}
else//
{
double v1 = account.getMoney() - (d * 1.05);
account.seyMoney(v1);
}
}
if(!(bank .equals(account.yonhu.bank) ))//跨行
{
if(account.getMoney() >=d && account.getMoney() > 0)
{
account.seyMoney(account.getMoney() - (d* bank.shouxifei));
}
else if(account.getMoney()< d && account.getMoney() > 0)
{
double money = (account.getMoney() - d)*(bank.shouxifei + 0.05);
account.seyMoney(account.getMoney() - (account.getMoney()* bank.shouxifei));
account.seyMoney(account.getMoney() + money);
}
else//
{
account.seyMoney(account.getMoney() - (d*(0.05+ bank.shouxifei)));
}
}
//检查是否超钱
if(account.leiXin == 1 && account.getMoney() < 0)
{
System.out.println("Sorry,your account balance is insufficient.");
return false;
}
else if(account.leiXin == 2 && account.getMoney() < -50000)
{
System.out.println("Sorry,your account balance is insufficient.");
return false;
}
System.out.print("业务：取款 "+account.yonhu.name+"在"+ bank.name+"的"+c+"号ATM机上取款");
System.out.printf("¥%.2f",Math.abs(d));
System.out.printf("\n当前余额为¥%.2f\n",account.getMoney());
}
return true;
}
else {
return false;
}
}
Bank SeekAtm(String bianhao)//查找Atm所属银行
{
Bank bank = yinlian.SeekAtm(bianhao);
if(bank != null)
{
return bank;
}
else
{
System.out.println("Sorry,the ATM's id is wrong.");
return null;
}
}
class UserData{
public String userName;
public String bank;
public String account;
public double money;
public String cardNum;
public UserData(String userName, String bank, String account, double money, String cardNum) {
this.userName = userName;
this.bank = bank;
this.account = account;
this.money = money;
this.cardNum = cardNum;
}
}
Zhanna seekAccount(String account)//查找银行卡所属账号
{
Zhanna zhanhao = yinlian.SeekYinhanka(account);
if(zhanhao != null)
{
return zhanhao;
}
else
{
System.out.println("Sorry,this card does not exist.");
return null;
}
}
Zhanna accountPassword(String a, String b)//卡号密码是否匹配
{
Zhanna zhanhao = seekAccount(a);
if(zhanhao != null)
{
if(zhanhao.people(a, b))
{
return zhanhao;
}
else
{
System.out.println("Sorry,your password is wrong.");
for(int i=0;i<5;i++){
for(int j=0;j<5;j++);
}
return null;
}
}
return null;
}
void seek(String a)
{
Zhanna zhanhao = seekAccount(a);
if(zhanhao != null)
{
System.out.printf("业务：查询余额 ¥%.2f",zhanhao.getMoney());
}
}
public static String [] deal(String input)
{
return input.split("\\s+");
}
void input()
{
String atmid;
double money;
Scanner sc = new Scanner(System.in);
String input=sc.nextLine();
while(!input.equals("#"))
{
String []arry=deal(input);
if(arry.length==1)
{
seek(arry[0]);
}
else
{
atmid = arry[2];
money = Double.parseDouble(arry[3]);
if (!kyn(arry[0], arry[1], atmid, money)) {
for(int i=0;i<5;i++){
for(int j=0;j<5;j++);
}
return;
}
}
input=sc.nextLine();
}
}
}
class YinLian
{
ArrayList<Bank> ayinhan = new ArrayList<>();
YinLian()
{
Bank bank = new Bank("中国建设银行",1.02);
Bank bank2 = new Bank("中国工商银行",1.03);
Bank bank3 = new Bank("中国农业银行",1.04);
bank.atmSet("01");
bank.Aatm.get(0).SatYinhan(bank);
bank.atmSet("02");
bank.Aatm.get(1).SatYinhan(bank);
bank.atmSet("03");
bank.Aatm.get(2).SatYinhan(bank);
bank.atmSet("04");
bank.Aatm.get(3).SatYinhan(bank);
bank.setUser("杨过");
bank.setUser("郭靖");
bank.setUser("张三丰");
bank.Ayonhu.get(0).zanies(1);
bank.Ayonhu.get(0).zanies(1);
bank.Ayonhu.get(1).zanies(1);
bank.Ayonhu.get(2).zanies(2);
bank.Ayonhu.get(0).Azhanhao.get(0).AddYinHanKa("6217000010041315709");
bank.Ayonhu.get(0).Azhanhao.get(0).AddYinHanKa("6217000010041315715");
bank.Ayonhu.get(0).Azhanhao.get(1).AddYinHanKa("6217000010041315718");
bank.Ayonhu.get(1).Azhanhao.get(0).AddYinHanKa("6217000010051320007");
bank.Ayonhu.get(2).Azhanhao.get(0).AddYinHanKa("6640000010045442002");
bank.Ayonhu.get(2).Azhanhao.get(0).AddYinHanKa("6640000010045442003");
bank2.atmSet("05");
bank2.atmSet("06");
bank2.setUser("张无忌");
bank2.setUser("韦小宝");
bank2.setUser("令狐冲");
bank2.Ayonhu.get(0).zanies(1);
bank2.Ayonhu.get(0).zanies(1);
bank2.Ayonhu.get(0).zanies(1);
bank2.Ayonhu.get(1).zanies(1);
bank2.Ayonhu.get(1).zanies(1);
bank2.Ayonhu.get(2).zanies(2);
bank2.Ayonhu.get(0).Azhanhao.get(0).AddYinHanKa("6222081502001312389");
bank2.Ayonhu.get(0).Azhanhao.get(1).AddYinHanKa("6222081502001312390");
bank2.Ayonhu.get(0).Azhanhao.get(2).AddYinHanKa("6222081502001312399");
bank2.Ayonhu.get(0).Azhanhao.get(2).AddYinHanKa("6222081502001312400");
bank2.Ayonhu.get(1).Azhanhao.get(0).AddYinHanKa("6222081502051320785");
bank2.Ayonhu.get(1).Azhanhao.get(1).AddYinHanKa("6222081502051320786");
bank2.Ayonhu.get(2).Azhanhao.get(0).AddYinHanKa("6640000010045441009");
bank3.atmSet("07");
bank3.atmSet("08");
bank3.atmSet("09");
bank3.atmSet("10");
bank3.atmSet("11");
bank3.setUser("乔峰");
bank3.setUser("洪七公");
bank3.Ayonhu.get(0).zanies(2);
bank3.Ayonhu.get(1).zanies(2);
bank3.Ayonhu.get(0).Azhanhao.get(0).AddYinHanKa("6630000010033431001");
bank3.Ayonhu.get(1).Azhanhao.get(0).AddYinHanKa("6630000010033431008");
ayinhan.add(bank);
ayinhan.add(bank2);
ayinhan.add(bank3);
}
Zhanna SeekYinhanka(String kahao)//查找银行卡的账号
{
for (Bank bank : ayinhan) {
if (bank.SeekYinhanka(kahao) != null) {
return bank.SeekYinhanka(kahao);
}
}
return null;
}
Bank SeekAtm(String bianhao)//查找Atm的银行
{
for (Bank bank : ayinhan) {
if (bank.SeekAtm(bianhao) != null) {
for(int i=0;i<5;i++){
for(int j=0;j<5;j++);
}
return bank.SeekAtm(bianhao);
}
}
return null;
}
}
class Bank
{
String name;
double shouxifei;
ArrayList<Atm> Aatm = new ArrayList<>();
ArrayList<Yonhu> Ayonhu = new ArrayList<>();
Bank(String name, double shouxifei)
{
this.name = name;
this.shouxifei = shouxifei;
}
void atmSet(String a)
{
Atm atm = new Atm(a);
Aatm.add(atm);
}
void setUser(String y)
{
Yonhu yonhu = new Yonhu(y,this);
Ayonhu.add(yonhu);
}
Zhanna SeekYinhanka(String kahao)//查找银行卡的账号
{
for (Yonhu yonhu : Ayonhu) {
if (yonhu.SeekRihanna(kahao) != null) {
for(int i=0;i<5;i++){
for(int j=0;j<5;j++);
}
return yonhu.SeekRihanna(kahao);
}
}
return null;
}
Bank SeekAtm(String bianhao)//查找Atm的账号
{
for (Atm atm : Aatm) {
if (atm.SeekAtm(bianhao)) {
for(int i=0;i<5;i++){
for(int j=0;j<5;j++);
}
return this;
}
}
return null;
}
}
class Atm
{
String bianhao;
Bank bank;
Atm(String bianhao)
{
this.bianhao = bianhao;
}
void SatYinhan(Bank bank)
{
this.bank = bank;
}
boolean SeekAtm(String bianhao)
{
for(int i=0;i<5;i++){
for(int j=0;j<5;j++);
}
return this.bianhao.equals(bianhao);
}
}
class Yonhu
{
String name;
Bank bank;
ArrayList<Zhanna> Azhanhao = new ArrayList<>();
Yonhu(String name, Bank bank)
{
this.name = name;
this.bank = bank;
}
void zanies(int l)
{
Zhanna zhanhao = new Zhanna(10000.0,l,this);
Azhanhao.add(zhanhao);
}
Zhanna SeekRihanna(String kahao)//查找银行卡的账号
{
for (Zhanna zhanhao : Azhanhao) {
if (zhanhao.seekCard(kahao) != null) {
return zhanhao.seekCard(kahao);
}
}
return null;
}
}
class Zhanna
{
private double qian;
Yonhu yonhu;
int leiXin;//1借记账号2贷记账号
ArrayList<BankCard> Ananda = new ArrayList<>();
Zhanna(double qian, int leiXin, Yonhu yonhu)
{
this.qian = qian;
this.leiXin = leiXin;
this.yonhu = yonhu;
}
void AddYinHanKa(String ka)
{
BankCard yinHanKa = new BankCard(ka, "88888888");
Ananda.add(yinHanKa);
}
void seyMoney(double money)
{
this.qian = money;
}
double getMoney()
{
return this.qian;
}
Zhanna seekCard(String account)//查找银行卡的账号
{
for (BankCard bankCard : Ananda) {
if (bankCard.verifyAccount(account)) {
for(int i=0;i<5;i++){
for(int j=0;j<5;j++);
}
return this;
}
}
return null;
}
boolean people(String account, String password)//账号密码是否匹配
{
for (BankCard bankCard : Ananda) {
if (bankCard.verifyAccount(account)) {
if (bankCard.pin(password)) {
return true;
}
}
}
return false;
}
}
class BankCard
{
private final String account;
private final String password;
BankCard(String ka, String pass)
{
this.account = ka;
this.password = pass;
}
boolean verifyAccount(String account)//判断卡号是否相同
{
return this.account.equals(account);
}
boolean pin(String password)//判断密码是否相同
{
return this.password.equals(password);
}
}
类图：
复杂度分析图：
三、采坑心得
①题目集7（7-1）、（7-2）的输入测试数据是很讲究的，也使得对每个数据进行处理变得有些难，要确保每个输入测试数据能有效的处理就需要我们去细分好每个数据，理解每个数据代表着什么，在按相应的处理方法得到结果，一开始，我对每个数据进行了独立处理，这其实很费时间，也耗内存，更好的做法是按相应的类型做一个区分，是那个类型的图形就到那个图形的列表就行；其后数据的处理方法，也是一个难点，需要去做一个好的设计，让处理方法能够有效的处理好数据，得出相应的结果；同时一个程序要完善好，就要把bug减少，我们在处理错误数据时，要分析好数据是否错误，是那种类型的错误，把错误的数据处理好也是我们要去构思的，像这个题目集7就要针对图形的构成规则，去处理错误的数据。
②题目集8和题目集9，这两道题都是考的对类的设计，我们需要对类的设计进行一个好的构思，分析好每个类之间相互的关系，有利于我们去实现相应的功能，我们很多时候没有分析好类与类之间的关系就开始写代码，然后发现错误后再来改正，这对我们写代码的进度来讲是很不好的，会耽误我们大量的时间，而类的设计就是我们一个好的设计方案，按照这个方案来能有效的缩减我们完成代码的时间，也能让我们更简便的去完成功能的相应代码。起初做这道题时也是没有做好类的设计，就使得我的功能代码很难做好，方法也显得很复杂，在了解清楚类的关系之后，去设计方法就可以得心应手了。
③题目集7为了偷懒，嫌麻烦，重复的地方直接复制粘贴了，修改时忘了把Triangle改成Trapezoid，导致错误，而且找了很久才发现，真是太粗心了（裂开）
④在判断三角形的合法性时，判断条件只考虑了三边都要单独大于零，两边之和大于第三边，忽略了两边之差小于第三边
⑤在构造方法中包含了类的确定，不需要对shapeName进行set，之前重复了，完全是多余的。
⑥在获得不同图形间的最大面积的方法中，因为用的是数组，就没有考虑数组的长度，导致出现数组为空的情况，最开始Array.sort的方法也使用错误，它只能对数组排序，而不能对图形内部不同的面积进行排序。
四、改进建议
①题目集7（7-1）、（7-2）的功能主体上都差不多，有计算图形面积、排序、计算面积的和等功能，但是功能仍然比较简单，对图形其他方面内容没有涉及，例如可以从几何图形变成立体图形的求面积、求体积等其他和图形有关的内容。
②题目集8和题目集9可以对银行其他功能进行完善，后续也可加上图形界面，做成一个比较完善的银行ATM的系统，对其他有关银行的类做出一个好的关系处理，使整体的类的设计完善，对其的功能进行多样化，形成一个完整的ATM机的管理体系。
五、总结
通过这三次题目集学到了继承、多态的应用、ArrayList泛型的应用方法、Comparable接口、及对泛型的应用、单一职责原则的应用与“开-闭”原则的应用，对类设计的原则也有了更深的理解，对类的关系也有了比较好的了解，对类的设计方面的能力要加强，对Java的高级应用要学习，不能只停留在对Java的基础应用里面，要继续跟进，深入全面的学习java。
浙公网安备 33010602011771号