最新介面api外掛 Swagger3 更新配置詳解

阿新 • • 發佈：2021-12-13

1、前言

　　　這三次作業並沒有什麼新的知識點，都是對之前學習的東西進行應用，主要有：1、繼承、多型的應用；2、ArrayList泛型的應用方法；3、Comparable介面及泛型的應用；4、單一職責原則的應用；　　　　　　　　　　5、“開-閉”原則的應用。還有一些銀行、ATM機、銀行卡的相關課外知識，我是我之前沒了解過的。

　　　題量也是比較少，三次作業只有四道題，當然難度也是有的，像設計第八次作業的類，

要使得程式的可維護性高，這樣第九次作業才好寫，這得花點功夫。

2、設計與分析

　　（1）題目集7（7-1）、（7-2）兩道題目的遞進式設計分析總結

　　　　　題目7（7-1）詳情：

7-1 圖形卡片排序遊戲 (40 分)　　　　　

　　　　　　掌握類的繼承、多型性使用方法以及介面的應用。詳見作業指導書 2020-OO第07次作業-1指導書V1.0.pdf

　　　　　　輸入格式:

　　　　　　　　首先，在一行上輸入一串數字（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 ，注意，各圖形輸出之間用空格分開，且輸出最後存在一個用於分隔的空格；

　　　　　　　　排序後的各圖形型別及面積，格式同排序前的輸出；

　　　　　　　　所有圖形的面積總和，格式為Sum of area:總面積值。

類圖：




import java.util.Arrays;
import java.util.ArrayList;
import java.util.Scanner;

public class Main{
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		ArrayList<Shape> shape=new ArrayList<>();
		int card=input.nextInt();
		ArrayList<Integer> cardarr=new ArrayList<>();
		while(card!=0) {
			cardarr.add(card);
			card=input.nextInt();
		}
		for(int i=0;i<cardarr.size();i++) {
			if(cardarr.get(i)<0||cardarr.get(i)>4) {
				System.out.println("Wrong Format");
				System.exit(0);
			}
		}
		
		for(int i=0;i<cardarr.size();i++) {
			if(cardarr.get(i)<0) {
				System.out.println("Wrong Format");
				System.exit(0);
			}
			switch(cardarr.get(i)){
			case 1:
				double radius=input.nextDouble();
				shape.add(new Circle(radius));
				break;
				
			case 2:
				double width,length;
				width=input.nextDouble();
				length=input.nextDouble();
				shape.add(new Rectangle(width, length));
				break;
				
			case 3:
				double[] side=new double[3];
				double side1,side2,side3;
				side[0]=input.nextDouble();
				side[1]=input.nextDouble();
				side[2]=input.nextDouble();
				Arrays.sort(side);
				side1=side[0];
				side2=side[1];
				side3=side[2];
				shape.add(new Triangle(side1,side2,side3));
				break;
				
			case 4:
				double upper,lower,high;
				upper=input.nextDouble();
				lower=input.nextDouble();
				high=input.nextDouble();
				shape.add(new Trapezoid(upper, lower, high));
				break;
				
			}
		}
		
		Tool.checkValidity(shape);
		System.out.println("The original list:");
		for(Shape i : shape) {
			System.out.print(i.name+":"+i.toString()+" ");
		}
		System.out.println();
		System.out.println("The sorted list:");
		Shape[] shape1=(Shape[])shape.toArray(new Shape[shape.size()]);
		Arrays.sort(shape1);
		
		for(Shape i : shape1) {
			System.out.print(i.name+":"+i.toString()+" ");
		}
		System.out.println();
		System.out.println("Sum of area:"+Tool.sum(shape));
		input.close();
}
}

abstract class Shape{
	String name;
	
	abstract double getArea();
	abstract boolean validate();
	
	public String toString(){
		return String.format("%.2f", getArea());
	}
	
}

class Circle extends Shape implements Comparable<Shape>{
	double radius;
	
	public Circle() {
		this.name="Circle";
	}
	public Circle(double radius){
		this.name="Circle";
		this.radius=radius;
	}
	
	double getArea(){
		return Math.PI*Math.pow(radius, 2);
	}
	boolean validate(){
		if(radius<=0)
			return false;
		else
			return true;
					
	}
	@Override
	public int compareTo(Shape circle) {
		// TODO 自動生成的方法存根
		if(this.getArea()<circle.getArea())
			return 1;
		else if(this.getArea()>circle.getArea())
			return -1;
		return 0;
	}
	
}

class Rectangle extends Shape implements Comparable<Shape>{
	double width,length;
	public Rectangle() {
		this.name="Rectangle";
	}
	public Rectangle(double width,double length){
		this.name="Rectangle";
		this.length=length;
		this.width=width;
	}
	
	double getArea(){
		return width*length;
	}
	
	boolean validate(){
		if(width<0||length<0){
			return false;
		}
		else
			return true;
	}
	public int compareTo(Shape rectangle) {
		// TODO 自動生成的方法存根
		if(this.getArea()<rectangle.getArea())
			return 1;
		else if(this.getArea()>rectangle.getArea())
			return -1;
		return 0;
	}
}

class Triangle extends Shape implements Comparable<Shape>{
	double side1,side2,side3;
	
	public Triangle() {
		this.name="Triangle";
	}
	public Triangle(double side1,double side2,double side3) {
		this.name="Triangle";
		this.side1=side1;
		this.side2=side2;
		this.side3=side3;
	}
	
	double getArea() {
		double s=(side1+side2+side3)/2;
		return Math.sqrt(s*(s-side1)*(s-side2)*(s-side3));
		
	}
	boolean validate() {
		if(side1<0||side2<0||side3<0)
			return false;
		else {
			if(side1+side2<=side3||side2-side1>side3)
				return false;
			return true;
		}
	}
	public int compareTo(Shape triangle) {
		// TODO 自動生成的方法存根
		if(this.getArea()<triangle.getArea())
			return 1;
		else if(this.getArea()>triangle.getArea())
			return -1;
		return 0;
	}
}
class Trapezoid extends Shape implements Comparable<Shape>{

	double upper,lower,high;
    
    public Trapezoid() {
    	this.name="Trapezoid";
    }
    
    public Trapezoid(double upper, double lower, double high) {
    	this.name="Trapezoid";
        this.upper = upper;
        this.lower = lower;
        this.high = high;
    }
    
    
    
    double getArea(){
        return (upper+lower)*high/2;
    }
    
    boolean validate(){
    	if(upper<0||lower<0||high<0)
    		return false;
    	else
    		return true;
    }
    
    public int compareTo(Shape trapezoid) {
		// TODO 自動生成的方法存根
		if(this.getArea()<trapezoid.getArea())
			return 1;
		else if(this.getArea()>trapezoid.getArea())
			return -1;
		return 0;
	}

}

class Tool{
	
	
	public static String sum(ArrayList<Shape> shape) {
		double sum=0;
		
		for(int i=0;i<shape.size();i++){
			sum+=shape.get(i).getArea();
		}
		
		return String.format("%.2f", sum);
	}
	
	public static void checkValidity(ArrayList<Shape> shape) {
		if(shape.isEmpty())
			return;
		for(int i=0;i<shape.size();i++) {
			if(!shape.get(i).validate()){
				System.out.println("Wrong Format");
				System.exit(0);
			}
				
		}
		
	}
}

Metrics Details For File 'Main.java'

Parameter Value
========= =====
Project Directory C:\Users\14768\workspace\Contacts\src\ptaTest/
File Name Main.java
Lines 266
Statements 172
Percent Branch Statements 21.5
Method Call Statements 59
Percent Lines with Comments 1.5
Classes and Interfaces 7
Methods per Class 3.43
Average Statements per Method 5.38
Line Number of Most Complex Method 11
Name of Most Complex Method Main.main()
Maximum Complexity 14
Line Number of Deepest Block 34
Maximum Block Depth 5
Average Block Depth 2.32
Average Complexity 2.63

Most Complex Methods in 7 Class(es): Complexity, Statements, Max Depth, Calls

Circle.Circle() 1, 2, 2, 0
Circle.Circle() 1, 1, 2, 0
Circle.compareTo() 3, 5, 2, 4
Circle.getArea() 1, 1, 2, 1
Circle.validate() 3, 4, 2, 0
Main.main() 14, 58, 5, 29
Rectangle.compareTo() 3, 5, 2, 4
Rectangle.getArea() 1, 1, 2, 0
Rectangle.Rectangle() 1, 3, 2, 0
Rectangle.Rectangle() 1, 1, 2, 0
Rectangle.validate() 4, 4, 3, 0
Shape.toString() 1, 1, 2, 1
Tool.checkValidity() 4, 6, 4, 6
Tool.sum() 2, 4, 3, 2
Trapezoid.compareTo() 3, 5, 2, 4
Trapezoid.getArea() 1, 1, 2, 0
Trapezoid.Trapezoid() 1, 4, 2, 0
Trapezoid.Trapezoid() 1, 1, 2, 0
Trapezoid.validate() 5, 4, 2, 0
Triangle.compareTo() 3, 5, 2, 4
Triangle.getArea() 1, 2, 2, 2
Triangle.Triangle() 1, 4, 2, 0
Triangle.Triangle() 1, 1, 2, 0
Triangle.validate() 6, 6, 3, 0

Block Depth Statements

0 11
1 32
2 81
3 12
4 11
5 25
6 0
7 0
8 0
9+ 0

這道題目的思路不會很難，對於生成的類圖裡面也很清晰的涵蓋了每個圖形的自己的方法和屬性，對於繼承來說，解決這道題目是很好的方法。子類具有父類所有非private的屬性，方法；子類可以擁有自己的屬性和方法，即子類對父類的拓展子類可以用自己的方式實現父類的方法（即子類重寫父類方法）；提高的類的耦合性（繼承缺點：耦合性越高，程式碼的獨立性越差。）但是從自己寫的這個程式碼以及圈複雜度來看，自己的這份程式碼質量不高

.題目集七（7-2 圖形卡片分組遊戲）

題目分析：本題在第一題上做了些許改進，首先對輸出有了區別，其次多了一項對相同型別圖形的輸出以及將其排序輸出，對程式碼有較多的增加，用陣列進行面積的儲存，並將其進行排序輸出。



import java.util.Arrays;
import java.util.Collections;
import java.util.ArrayList;
import java.util.Scanner;


public class Main{
	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);
		dealCardList.checkValidity();
		
		dealCardList.showResult();
		
		input.close();
}
}

abstract class Shape implements Comparable<Shape>{
	String name;
	
	abstract double getArea();
	abstract boolean validate();
	
	public String toString(){
		return String.format("%.2f", getArea());
	}
	public String getShapeName() {
		return name;
	}
	public int compareTo(Shape shape) {
		// TODO 自動生成的方法存根
		if(shape.getArea()<shape.getArea())
			return 1;
		else if(shape.getArea()>shape.getArea())
			return -1;
		return 0;
	}
}

class Circle extends Shape {
	double radius;
	
	public Circle() {
		this.name="Circle";
	}
	public Circle(double radius){
		this.name="Circle";
		this.radius=radius;
	}
	
	double getArea(){
		return Math.PI*Math.pow(radius, 2);
	}
	boolean validate(){
		if(radius<=0)
			return false;
		else
			return true;
					
	}
	
	
}

class Rectangle extends Shape {
	double width,length;
	public Rectangle() {
		this.name="Rectangle";
	}
	public Rectangle(double width,double length){
		this.name="Rectangle";
		this.length=length;
		this.width=width;
	}
	
	double getArea(){
		return width*length;
	}
	
	boolean validate(){
		if(width<0||length<0){
			return false;
		}
		else
			return true;
	}
	
}

class Triangle extends Shape {
	double side1,side2,side3;
	
	public Triangle() {
		this.name="Triangle";
	}
	public Triangle(double side1,double side2,double side3) {
		this.name="Triangle";
		this.side1=side1;
		this.side2=side2;
		this.side3=side3;
	}
	
	double getArea() {
		double s=(side1+side2+side3)/2;
		return Math.sqrt(s*(s-side1)*(s-side2)*(s-side3));
		
	}
	boolean validate() {
		if(side1<0||side2<0||side3<0)
			return false;
		else {
			if(side1+side2<=side3||side2-side1>side3)
				return false;
			return true;
		}
	}
	
}
class Trapezoid extends Shape {

	double upper,lower,high;
    
    public Trapezoid() {
    	this.name="Trapezoid";
    }
    
    public Trapezoid(double upper, double lower, double high) {
    	this.name="Trapezoid";
        this.upper = upper;
        this.lower = lower;
        this.high = high;
    }
    
    
    
    double getArea(){
        return (upper+lower)*high/2;
    }
    
    boolean validate(){
    	if(upper<0||lower<0||high<0)
    		return false;
    	else
    		return true;
    }
    
    

}
class Card implements Comparable<Card>{
	Shape shape;
	public Card() {
	}
	public Card(Shape shape){
		this.shape=shape;
	}
	
	public Shape getShape() {
		return shape;
	}
	
	
	
	public int compareTo(Card card) {
		// TODO 自動生成的方法存根
		if(this.shape.getArea()<card.shape.getArea())
			return 1;
		else if(this.shape.getArea()>card.shape.getArea())
			return -1;
		return 0;
	}
}

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

	
	
	public DealCardList() {
		// TODO 自動生成的建構函式存根
	}
	public DealCardList(ArrayList<Integer> list) {
		for(int i=0;i<list.size();i++) {
			if(list.get(i)<0) {
				System.out.println("Wrong Format");
				System.exit(0);
			}
			switch(list.get(i)){
			case 1:
				double radius=Main.input.nextDouble();
				Circle circle=new Circle(radius);
				cardList.add(new Card(circle));
				break;
				
			case 2:
				double width,length;
				width=Main.input.nextDouble();
				length=Main.input.nextDouble();
				Rectangle rectangle=new Rectangle(width,length);
				cardList.add(new Card(rectangle));
				break;
				
			case 3:
				double[] side=new double[3];
				double side1,side2,side3;
				side[0]=Main.input.nextDouble();
				side[1]=Main.input.nextDouble();
				side[2]=Main.input.nextDouble();
				Arrays.sort(side);
				side1=side[0];
				side2=side[1];
				side3=side[2];
				Triangle triangle=new Triangle(side1,side2,side3);
				cardList.add(new Card(triangle));
				break;
				
			case 4:
				double upper,lower,high;
				upper=Main.input.nextDouble();
				lower=Main.input.nextDouble();
				high=Main.input.nextDouble();
				Trapezoid trapezoid=new Trapezoid(upper,lower,high);
				cardList.add(new Card(trapezoid));
				break;
				
			}
		}
	}
	
	public void SeparatedShow() {
        System.out.println("The Separated List:");
        ArrayList<Card> cardList1 = new ArrayList<Card>();
        ArrayList<Card> cardList2 = new ArrayList<Card>();
        ArrayList<Card> cardList3 = new ArrayList<Card>();
        ArrayList<Card> cardList4 = new ArrayList<Card>();
        for (Card temp: cardList) {
            if(temp.getShape().getShapeName().equals("Circle")) {
                cardList1.add(temp);
                continue;
            }
            if(temp.getShape().getShapeName().equals("Rectangle")) {
                cardList2.add(temp);
                continue;
            }
            if(temp.getShape().getShapeName().equals("Triangle")) {
                cardList3.add(temp);
                continue;
            }
            if(temp.getShape().getShapeName().equals("Trapezoid")) {
                cardList4.add(temp);
                continue;
            }
        }
        showArrayList(cardList1);
        showArrayList(cardList2);
        showArrayList(cardList3);
        showArrayList(cardList4);
        System.out.println();
        Collections.sort(cardList1);
        Collections.sort(cardList2);
        Collections.sort(cardList3);
        Collections.sort(cardList4);
        System.out.println("The Separated sorted List:");
        showArrayList(cardList1);
        showArrayList(cardList2);
        showArrayList(cardList3);
        showArrayList(cardList4);
        System.out.println();
        System.out.print("The max area:");
        double[] shuzu = new double[4];
        shuzu[0] = getAllArea(cardList1);
        shuzu[1] = getAllArea(cardList2);
        shuzu[2] = getAllArea(cardList3);
        shuzu[3] = getAllArea(cardList4);
        double max = 0;
        for(int i = 0 ; i < 4 ; i ++) {
            if(shuzu[i] > max) {
                max = shuzu[i];
            }
        }
        System.out.printf("%.2f",max);

    }
	
	private void showArrayList(ArrayList<Card> cardList) {
		System.out.print("[");
		for(Card i : cardList)
			System.out.print(i.shape.name+":"+i.shape.toString()+" ");
		System.out.print("]");
	}
	
	public void checkValidity() {
		if(cardList.isEmpty())
			return;
		for(int i=0;i<cardList.size();i++) {
			if(!cardList.get(i).shape.validate()){
				System.out.println("Wrong Format");
				System.exit(0);
			}
				
		}
		
	}
	
	public double getAllArea(ArrayList<Card> cards) {
		double sum=0;
		
		for(int i=0;i<cards.size();i++){
			sum+=cards.get(i).shape.getArea();
		}
		
		return sum;
		
	}
	
	public double max(double [] array){
		double max=0;
		int i=0;
		for(i=0;i<array.length;i++){
			if(array[i]>max){
				max=array[i];
			}
		}
		return max;	
	}
	
	public void showResult() {
		/*if(cardList.isEmpty()) {
			System.out.println("The original list:");
			System.out.println("[]");
			System.out.println("The Separated sorted List:");
			System.out.println("[][][][]");
			System.out.println("The Separated sorted List:");
			System.out.println("[][][][]");			
			System.out.println("The max area:0.00");
			System.exit(0);
		}*/

		System.out.println("The original list:");
		System.out.print("[");
		for(Card i : cardList) {
			System.out.print(i.shape.name+":"+i.shape.toString()+" ");
		}
		System.out.println("]");
		SeparatedShow();
		
	
	}
	
}

Metrics Details For File 'Main.java'

Parameter Value
========= =====
Project Directory C:\Users\14768\workspace\Contacts\src\ptaTest/
File Name Main.java
Lines 367
Statements 224
Percent Branch Statements 18.3
Method Call Statements 91
Percent Lines with Comments 3.5
Classes and Interfaces 8
Methods per Class 4.00
Average Statements per Method 5.31
Line Number of Most Complex Method 197
Name of Most Complex Method DealCardList.SeparatedShow()
Maximum Complexity 8
Line Number of Deepest Block 205
Maximum Block Depth 5
Average Block Depth 2.32
Average Complexity 2.34

Most Complex Methods in 8 Class(es): Complexity, Statements, Max Depth, Calls

Card.Card() 1, 1, 2, 0
Card.Card() 1, 0, 0, 0
Card.compareTo() 3, 5, 2, 4
Card.getShape() 1, 1, 2, 0
Circle.Circle() 1, 2, 2, 0
Circle.Circle() 1, 1, 2, 0
Circle.getArea() 1, 1, 2, 1
Circle.validate() 3, 4, 2, 0
DealCardList.checkValidity() 4, 6, 4, 6
DealCardList.DealCardList() 8, 38, 5, 10
DealCardList.DealCardList() 1, 0, 0, 0
DealCardList.getAllArea() 2, 4, 3, 1
DealCardList.max() 3, 6, 4, 0
DealCardList.SeparatedShow() 8, 40, 4, 42
DealCardList.showArrayList() 2, 4, 2, 3
DealCardList.showResult() 2, 6, 3, 5
Main.main() 4, 12, 4, 9
Rectangle.getArea() 1, 1, 2, 0
Rectangle.Rectangle() 1, 3, 2, 0
Rectangle.Rectangle() 1, 1, 2, 0
Rectangle.validate() 4, 4, 3, 0
Shape.compareTo() 3, 5, 2, 4
Shape.getShapeName() 1, 1, 2, 0
Shape.toString() 1, 1, 2, 1
Trapezoid.getArea() 1, 1, 2, 0
Trapezoid.Trapezoid() 1, 4, 2, 0
Trapezoid.Trapezoid() 1, 1, 2, 0
Trapezoid.validate() 5, 4, 2, 0
Triangle.getArea() 1, 2, 2, 2
Triangle.Triangle() 1, 4, 2, 0
Triangle.Triangle() 1, 1, 2, 0
Triangle.validate() 6, 6, 3, 0

Block Depth Statements

0 12
1 42
2 107
3 17
4 17
5 29
6 0
7 0
8 0
9+ 0

把一些計算的方法都分了類。這樣就對於自己和讀者都很好理解，修改的時候就很清晰。不像我自己的程式碼一樣，Maximum Complexity的數值都已經上了五六十了。我覺得自己真的應該去重寫了。所以，就此我到處找資料以及寫程式碼應該注意的細節，找到自己以後應該養成的好習慣。比如：如果一個函式裡面，包含了同一個抽象層級的多個函式，這樣也是算只做一件事，但是如果包含了不同抽象層級的，那就是做了很多事；要做一個到大功能x ,就要先做第一個中等功能xx，要做一箇中等功能xx就得先做一個小功能xxx。然後做第二個中等功能yy,要做中等功能yy，就要先做小功能yyy........通過一層層分解,就能保證函式只做一件事了。函式的引數和函式名不是一個抽象層級上的東西，會讓別人閱讀的時候感覺有點困難，在一個函式中儘量不要使用引數，或者只有一個引數，要是3個以上的引數，那確實有點多了，除非特別必要，不然真的不要寫那麼多引數，太多了讓人容易誤解。還有一個非常值得注意的是不要使用引數作為返回值！！！一定要使用函式返回值，不然真的讓人很難讀懂你的程式碼；函式要麼做什麼事，要麼回答是什麼事，二者不可兼得，要是兩個都做往往會做的很混亂；

題目集八：設計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","中國工商銀行");
    	unionPay.addBank(ccb);
    	unionPay.addBank(icbc);
    	
    	ATM aTM1 = new ATM("01",ccb);
    	ATM aTM2 = new ATM("02",ccb);
    	ATM aTM3 = new ATM("03",ccb);
    	ATM aTM4 = new ATM("04",ccb);
    	ATM aTM5 = new ATM("05",icbc);
    	ATM aTM6 = new ATM("06",icbc);
    	
    	ccb.addATM(aTM1);
    	ccb.addATM(aTM2);
    	ccb.addATM(aTM3);
    	ccb.addATM(aTM4);
    	icbc.addATM(aTM5);
    	icbc.addATM(aTM6);
    	
    	User Yangguo = new User("360101200102122324","楊過");
    	User Guojing = new User("360101200012302552","郭靖");
    	User Zhangwuji = new User("360502199805163221","張無忌");
    	User Weixiaobao = new User("360201200513243326","韋小寶");
    	
    	Account ccbAcc1 = new Account("3217000010041315709",Yangguo,ccb);
    	Account ccbAcc2 = new Account("3217000010041315715",Yangguo,ccb);
    	Account ccbAcc3 = new Account("3217000010051320007",Guojing,ccb);
    	Account icbcAcc1 = new Account("3222081502001312389",Zhangwuji,icbc);
    	Account icbcAcc2 = new Account("3222081502001312390",Zhangwuji,icbc);
    	Account icbcAcc3 = new Account("3222081502001312399",Zhangwuji,icbc);
    	Account icbcAcc4 = new Account("3222081502051320785",Weixiaobao,icbc);
    	Account icbcAcc5 = new Account("3222081502051320786",Weixiaobao,icbc);
    	
    	ccb.addAccount(ccbAcc1);
    	ccb.addAccount(ccbAcc2);
    	ccb.addAccount(ccbAcc3);
    	icbc.addAccount(icbcAcc1);
    	icbc.addAccount(icbcAcc2);
    	icbc.addAccount(icbcAcc3);
    	icbc.addAccount(icbcAcc4);
    	icbc.addAccount(icbcAcc5);
    
    	
    	Yangguo.addAccount(ccbAcc1);
    	Yangguo.addAccount(ccbAcc2);
    	Guojing.addAccount(ccbAcc3);
    	Zhangwuji.addAccount(icbcAcc1);
    	Zhangwuji.addAccount(icbcAcc2);
    	Zhangwuji.addAccount(icbcAcc3);
    	Weixiaobao.addAccount(icbcAcc4);
    	Weixiaobao.addAccount(icbcAcc5);
    	
    	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);
    	
    	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);
    	
    	
    	String str;	
		StringBuilder ss=new StringBuilder();
		while((str=input.nextLine())!=null){
			if(str.equals("#"))
				break;
			
			ss.append(str);
			ss.append('\n');
		}
		
		String data=ss.toString();
		
		DealData dealData=new DealData(data);
    	dealData.showResult();
    }
    	
    	
}

class Bank {
    private String bankNO;
    private String bankName;
    private ArrayList<Account> accountList = new ArrayList<Account>();
    private ArrayList<ATM> ATMList = new ArrayList<ATM>();

    public Bank() {
    }

    public Bank(String bankNO, String bankName) {
        this.bankNO = bankNO;
        this.bankName = bankName;
    }

    public String getBankNO() {
        return bankNO;
    }

    public void setBankNO(String bankNO) {
        this.bankNO = bankNO;
    }

    public String getBankName() {
        return bankName;
    }

    public void setBankName(String bankName) {
        this.bankName = bankName;
    }

    public void addAccount(Account account) {
        this.accountList.add(account);
    }

    public void removeAccount(Account account) {
        this.accountList.remove(account);
    }
    
    public void addATM(ATM aTM) {
    	this.ATMList.add(aTM);
    }
    
    public void removeATM(ATM aTM) {
    	this.ATMList.remove(aTM);
    }

	public ArrayList<Account> getAccountList() {
		return accountList;
	}

	public void setAccountList(ArrayList<Account> accountList) {
		this.accountList = accountList;
	}

	public ArrayList<ATM> getATMList() {
		return ATMList;
	}

	public void setATMList(ArrayList<ATM> aTMList) {
		ATMList = aTMList;
	}
}

class User {
    private String ID;
    private String name;
    ArrayList<Account> list = new ArrayList<Account>();

    public User() {
    }    

    public User(String iD, String name) {
		this.ID = iD;
		this.name = name;
	}

	public String getID() {
        return ID;
    }

    public void setID(String iD) {
        ID = iD;
    }


    public String getName() {
		return name;
	}

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

	public void addAccount(Account account) {
        this.list.add(account);
    }

    public void removeAccount(Account account) {
        this.list.remove(account);
    }
}

class Account {
    private String accountNO;
    private User user;
    private Bank bank;
    private double balance;
    static ArrayList<Card> list = new ArrayList<>();
    private ArrayList<Card> cards = new ArrayList<>();

    public Account() {
    }   
    
    public void setBalance(double balance) {
 		this.balance = balance;
 	}
     
     public double getBalance() {
 		return balance;
 	}
     
    public Account(String accountNO, User user, Bank bank) {
		this.accountNO = accountNO;
		this.user = user;
		this.bank = bank;
		this.balance=10000;
    }

	public void addCard(Card card) {
		cards.add(card);
		list.add(card);
    }

    public void removeCard(Card card) {
        list.remove(card);
    }





    public String getAccountNO() {
        return accountNO;
    }

    public void setAccountNO(String accountNO) {
        this.accountNO = accountNO;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

	public Bank getBank() {
		return bank;
	}

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

	public ArrayList<Card> getList() {
		return list;
	}

	public void setList(ArrayList<Card> list) {
		Account.list = list;
	}
	
}

class Card {
    private String cardNO;
    private String cardPassword;
    private Account account;

    public Card() {
     
    }

    public Card(String cardNO, String cardPassword, Account account) {
        super();
        this.cardNO = cardNO;
        this.cardPassword = cardPassword;
        this.account = account;
    }
    
 

    public String getCardNO() {
        return cardNO;
    }

    public void setCardNO(String cardNO) {
        this.cardNO = cardNO;
    }

    public String getCardPassword() {
        return cardPassword;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    public void setCardPassword(String cardPassword) {
        this.cardPassword = cardPassword;
    }

    public boolean checkCard() {
        Pattern p = Pattern.compile("\\d{16}+");
        Matcher m = p.matcher(this.cardNO);
        return m.matches();
    }

    public boolean checkPassword(String password) {
        return this.cardPassword.equals(password);
    }    
}

class ATM {
    private String ATMID;
    private Bank bank = null;

    public ATM() {

    }   

    public ATM(String aTMID, Bank bank) {
		ATMID = aTMID;
		this.bank = bank;
	}

	public String getATMID() {
        return ATMID;
    }

    public void setATMID(String aTMID) {
        ATMID = aTMID;
    }

	public Bank getBank() {
		return bank;
	}

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


class UnionPay {
	private ArrayList<Bank> bankList=new ArrayList<>();

	public UnionPay() {
	}

	public UnionPay(ArrayList<Bank> bankList) {
		this.bankList = bankList;
	}

	public ArrayList<Bank> getBankList() {
		return bankList;
	}

	public void setBankList(ArrayList<Bank> bankList) {
		this.bankList = bankList;
	}
	
	public void addBank(Bank bank) {
		this.bankList.add(bank);
	}
	
	public void removeBank(Bank bank) {
		this.bankList.remove(bank);
	}	
}


class DealData {
	String[] data;
	
	public DealData(String data) {
		this.data=data.split("\n");
	}
	
	
	void checkValid(String[] in) {
		String cardID=in[0];
		String passWord=in[1];
		String ATMID=in[2];
		double count=Double.parseDouble(in[3]);
		
		int i;
		for(i=0;i<Account.list.size();i++) {
			if(Account.list.get(i).getCardNO().equals(cardID)){
				break;
			}
		}
		
		if(i==Account.list.size()){
			System.out.println("Sorry,this card does not exist.");
			System.exit(0);
		}
		
		
		if(!Account.list.get(i).checkPassword(passWord)){
			System.out.println("Sorry,your password is wrong.");
			System.exit(0);
		}
		int j;
		for(j=0;j<Account.list.get(i).getAccount().getBank().getATMList().size();j++){
			if(Account.list.get(i).getAccount().getBank().getATMList().get(j).getATMID().equals(ATMID))
				break;
		}
		
		
		if(j==Account.list.get(i).getAccount().getBank().getATMList().size()) {
			if(ATMID.matches("0[56]")){
				System.out.println("Sorry,cross-bank withdrawal is not supported.");
				System.exit(0);
			}
			System.out.println("Sorry,the ATM's id is wrong.");
			System.exit(0);
		}
		
		if(Account.list.get(i).getAccount().getBalance()<count) {
			System.out.println("Sorry,your account balance is insufficient.");
			System.exit(0);
		}
		
			
	}
	
	void checkValid(String cardID) {
		int i;
		for(i=0;i<Account.list.size();i++) {
			if(Account.list.get(i).getCardNO().equals(cardID)){
				break;
			}
		}
		
		if(i==Account.list.size()){
			System.out.println("Sorry,this card does not exist.");
			System.exit(0);
		}
	}
	
	Card getCurrentCard(String cardID) {
		int i;
		for(i=0;i<Account.list.size();i++) {
			if(Account.list.get(i).getCardNO().equals(cardID)){
				return Account.list.get(i);
			}
		}
		
		return null;
	}
	
	void operation(Card card,String[] cardInfo) {
		
			
		if(cardInfo.length==4) {
			double count=Double.parseDouble(cardInfo[3]);
			String countStr=String.format("%.2f", Math.abs(count));
			checkValid(cardInfo);
			if(count<0)
				System.out.println(card.getAccount().getUser().getName()+"在"+card.getAccount().getBank().getBankName()+"的"+cardInfo[2]+"號ATM機上存款¥"+countStr);
			else
				System.out.println(card.getAccount().getUser().getName()+"在"+card.getAccount().getBank().getBankName()+"的"+cardInfo[2]+"號ATM機上取款¥"+countStr);
			System.out.println("當前餘額為¥"+updateBalance(card, count));
			return;
		}
		
		if(cardInfo.length==1) {
			checkValid(cardInfo[0]);
			String countStr=String.format("%.2f", card.getAccount().getBalance());
			System.out.println("¥"+countStr);
			return;
		}
		
		
	}
	
	String updateBalance(Card card,double count) {
		if(count>0) {
			card.getAccount().setBalance(card.getAccount().getBalance()-count);
			return String.format("%.2f", card.getAccount().getBalance());
		}
		
		else {
			card.getAccount().setBalance(card.getAccount().getBalance()-count);
			return String.format("%.2f", card.getAccount().getBalance());
		}
			
	}
	
	void showResult() {
		ArrayList<String[]> cardinfo=new ArrayList<>();
		for(int i=0 ;i<data.length;i++) {
			cardinfo.add(data[i].split("\\s+"));
		}
		
		for(String[] i : cardinfo) {
			operation(getCurrentCard(i[0]), i);
		}
	}
	
	
}

Metrics Details For File 'Main.java'

Parameter Value
========= =====
Project Directory C:\Users\14768\workspace\Contacts\src\ptaTest/
File Name Main.java
Lines 525
Statements 279
Percent Branch Statements 6.5
Method Call Statements 116
Percent Lines with Comments 0.0
Classes and Interfaces 8
Methods per Class 8.00
Average Statements per Method 2.84
Line Number of Most Complex Method 403
Name of Most Complex Method DealData.checkValid()
Maximum Complexity 10
Line Number of Deepest Block 435
Maximum Block Depth 4
Average Block Depth 1.72
Average Complexity 1.24

Most Complex Methods in 8 Class(es): Complexity, Statements, Max Depth, Calls

Account.Account() 1, 4, 2, 0
Account.Account() 1, 0, 0, 0
Account.addCard() 1, 2, 2, 2
Account.getAccountNO() 1, 1, 2, 0
Account.getBalance() 1, 1, 2, 0
Account.getBank() 1, 1, 2, 0
Account.getList() 1, 1, 2, 0
Account.getUser() 1, 1, 2, 0
Account.removeCard() 1, 1, 2, 1
Account.setAccountNO() 1, 1, 2, 0
Account.setBalance() 1, 1, 2, 0
Account.setBank() 1, 1, 2, 0
Account.setList() 1, 1, 2, 0
Account.setUser() 1, 1, 2, 0
ATM.ATM() 1, 2, 2, 0
ATM.ATM() 1, 0, 0, 0
ATM.getATMID() 1, 1, 2, 0
ATM.getBank() 1, 1, 2, 0
ATM.setATMID() 1, 1, 2, 0
ATM.setBank() 1, 1, 2, 0
Bank.addAccount() 1, 1, 2, 1
Bank.addATM() 1, 1, 2, 1
Bank.Bank() 1, 2, 2, 0
Bank.Bank() 1, 0, 0, 0
Bank.getAccountList() 1, 1, 2, 0
Bank.getATMList() 1, 1, 2, 0
Bank.getBankName() 1, 1, 2, 0
Bank.getBankNO() 1, 1, 2, 0
Bank.removeAccount() 1, 1, 2, 1
Bank.removeATM() 1, 1, 2, 1
Bank.setAccountList() 1, 1, 2, 0
Bank.setATMList() 1, 1, 2, 0
Bank.setBankName() 1, 1, 2, 0
Bank.setBankNO() 1, 1, 2, 0
Card.Card() 1, 4, 2, 1
Card.Card() 1, 0, 0, 0
Card.checkCard() 1, 3, 2, 3
Card.checkPassword() 1, 1, 2, 1
Card.getAccount() 1, 1, 2, 0
Card.getCardNO() 1, 1, 2, 0
Card.getCardPassword() 1, 1, 2, 0
Card.setAccount() 1, 1, 2, 0
Card.setCardNO() 1, 1, 2, 0
Card.setCardPassword() 1, 1, 2, 0
DealData.checkValid() 4, 6, 3, 7
DealData.checkValid() 10, 25, 4, 38
DealData.DealData() 1, 1, 2, 0
DealData.getCurrentCard() 3, 5, 4, 5
Main.main() 2, 73, 3, 39
UnionPay.addBank() 1, 1, 2, 1
UnionPay.getBankList() 1, 1, 2, 0
UnionPay.removeBank() 1, 1, 2, 1
UnionPay.setBankList() 1, 1, 2, 0
UnionPay.UnionPay() 1, 1, 2, 0
UnionPay.UnionPay() 1, 0, 0, 0
User.addAccount() 1, 1, 2, 1
User.getID() 1, 1, 2, 0
User.getName() 1, 1, 2, 0
User.removeAccount() 1, 1, 2, 1
User.setID() 1, 1, 2, 0
User.setName() 1, 1, 2, 0
User.User() 1, 2, 2, 0
User.User() 1, 0, 0, 0

Block Depth Statements

0 13
1 84
2 154
3 25
4 3
5 0
6 0
7 0
8 0
9+ 0

對於ATM機程式碼總結:由於這次的程式碼沒有類圖,僅僅知道需要建立些什麼類,使得大家的思維一時間跟不上來,需要完全靠自己思考來編寫程式碼和程式碼的框架,是大家第一次寫這樣難度的程式碼遇見的情況,當然,這或許就是這次題目的最難點,需要完全靠自己來設計進行編寫.但是這次的編寫也是有老師提示的,就是雙向連結串列,雙向連結串列也是這次的程式碼最精彩的部分,其次是該次程式碼的面向物件的框架,由於是我們自己就行編寫的,想要編寫出擁有面向物件思維的程式碼也是需要進行很多的思考.總之這次程式碼是同時鍛鍊了我們面向物件的思維方式和自己進行框架設計的能力

踩坑心得

1.判斷三角形是否合法是,沒有完全考慮三邊的情況.
2.ATM機的資料進行儲存時,儲存錯誤:

改進建議：

多使用Java中的思想封裝啊多型啊介面啊理解其中的優缺點以及適用性；
對於很多未知的功能查閱資料最快的還是看例項有時候一大堆文字可能看不懂這個時候需要我們通過例項去理解以及自己去設斷點去除錯；
對於第七次的第二個卡片的題目我認為在相同的型別的圖形面積進行比較這一塊可以再新建一個arraylist進行自定義排序這樣就省略了一次一次去必讓程式碼看上去更加的整潔了；

總結：

1.對於複雜的功能有了一定的規劃能力以及對於程式的整體構思會比剛學進步很多；

2.對於程式設計應該有預設遵守的規則，在自己的程式設計過程中也犯過很多也花費了大量時間去修改自己程式碼的錯誤；

3.功能實現要慢慢來不能急還有有些功能不要一想不出來就去查閱不然很容易被思維侷限住，先入為主的代入進去後面完成一些別的功能就會更加複雜花費時間。還是要因題而異，對功能進行規劃；

4.對於程式設計整體的思想還有待學習以及非常需要細心；

最新介面api外掛 Swagger3 更新配置詳解

1、前言

2、設計與分析

Metrics Details For File 'Main.java'

0 11
1 32
2 81
3 12
4 11
5 25
6 0
7 0
8 0
9+ 0

Metrics Details For File 'Main.java'

0 12
1 42
2 107
3 17
4 17
5 29
6 0
7 0
8 0
9+ 0

Metrics Details For File 'Main.java'

0 13
1 84
2 154
3 25
4 3
5 0
6 0
7 0
8 0
9+ 0

踩坑心得

改進建議：

總結：

最新介面api外掛 Swagger3 更新配置詳解

最新介面api外掛 Swagger3 更新配置詳解

Swagger3 更新配置詳解

Java非侵入式API介面文件工具apigcc用法詳解

VSCode的使用配置以及VSCode外掛的安裝教程詳解

VSCode外掛安裝完成後的配置詳解

Charles安裝配置詳解(windows10,最新Android/iOS配置)

前臺主頁搭建、後臺主頁輪播圖介面設計、跨域問題詳解、前後端互通、後端自定義配置、git軟體的初步介紹

Java獲取介面所有實現類的方式詳解

iOS 通用連結（Universal Link）配置詳解

SpringAOP中的註解配置詳解

Eclipse中maven的配置詳解

Win10 64位使用壓縮包安裝最新MySQL8.0.18的教程(圖文詳解)

PLSQL Developer連線Oracle11g 64位資料庫配置詳解(圖文)

Linux redis-Sentinel配置詳解

docker官方mysql映象自定義配置詳解

Ubuntu 17.10安裝phpMyAdmin資料庫管理工具配置詳解

MySQL主從原理及配置詳解

MySQL 5.6下table_open_cache引數優化合理配置詳解

nginx伺服器中access_log日誌分析與配置詳解

最新介面api外掛 Swagger3 更新配置詳解

1、 前言

2、 設計與分析

Metrics Details For File 'Main.java'

0 11 1 32 2 81 3 12 4 11 5 25 6 0 7 0 8 0 9+ 0

Metrics Details For File 'Main.java'

0 12 1 42 2 107 3 17 4 17 5 29 6 0 7 0 8 0 9+ 0

Metrics Details For File 'Main.java'

0 13 1 84 2 154 3 25 4 3 5 0 6 0 7 0 8 0 9+ 0

踩坑心得

改進建議 ：

總結：

相關推薦

1、前言

2、設計與分析

0 11
1 32
2 81
3 12
4 11
5 25
6 0
7 0
8 0
9+ 0

0 12
1 42
2 107
3 17
4 17
5 29
6 0
7 0
8 0
9+ 0

0 13
1 84
2 154
3 25
4 3
5 0
6 0
7 0
8 0
9+ 0

改進建議：