JAVA最后一次作业总结

R第三次博客作业——Java第七~九次作业总结

一、前言

1.知识点：

（1）第七次题目集：继承（父类和子类）、方法重写和重载、多态、抽象类、接口的定义和使用、ArrayList类、三种排序方法

（2）第八次题目集：继承（父类和子类）、方法重写和重载、多态、ArrayList类、输入的读取以及控制输出格式

（3）第九次题目集：在八的基础上进行类体系结构上的改进，更多利用数组存储数据和for循环处理重复多次的操作。

2.题量和难度：

      这三次作业相比于前面的作业，题量少，但题目都有一定的难度，需要花费比较多的时间去完成。通过上面的知识点也可以反映，这三次题目集的题目都是属于较为综合性的题目，每道题都有一个类关系体系结构，运用了大量的知识，各个类之间相互配合，完成题目所要求的功能。七-1-图片卡片排序游戏，七-2-图片卡片分组游戏，第二题属于是在第一题的基础上进行的拓展设计；同样，八-1-ATM机类结构设计（一）和九-1-ATM机类结构设计（二），九的设计仅仅是在八的基础上添加了一家银行和四个银行用户，添加了借记账户和借贷账户的分类区别。添加的数据不多，但在添加的过程逐渐暴露出自己题目集八中有关类结构设计的诸多不合理甚至错误，后续花费了比较多的时间进行部分规模的重构，实现了更高效的程序运行。

二、设计与分析：

1.题目集7（7-1）、（7-2）两道题目的递进式设计分析总结

• 题目集7（7-1） 图形卡片排序游戏 (1)：掌握类的继承、多态性使用方法以及接口的应用。

　　输入格式:

• • 首先，在一行上输入一串数字（1~4，整数），其中，1代表圆形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如： 1 3 4 2 1 3 4 2 1 3 0　　
  • 然后根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。　　

　　输出格式:

• • 如果图形数量非法（小于0）或图形属性值非法（数值小于0以及三角形三边不能组成三角形），则输出Wrong Format。　　
  • 如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。输出内容如下：　　

1. 1. 排序前的各图形类型及面积，格式为图形名称1:面积值1图形名称2:面积值2 …图形名称n:面积值n ，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格；　　
   2. 排序后的各图形类型及面积，格式同排序前的输出；　　
   3. 所有图形的面积总和，格式为Sum of area:总面积值。　　

（1）源代码：

  1 package pta;
  2 
  3 import java.util.Scanner;
  4 import java.util.ArrayList;
  5 //import java.util.Arrays;
  6 //import java.util.Collection;
  7 
  8 public class Main {
  9 //在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
 10 //使用Main.input.next…即可（避免采坑）
 11     public static Scanner input = new Scanner(System.in);
 12     public static void main(String[] args){
 13             ArrayList list = new ArrayList(); 
 14             int num = input.nextInt();
 15             while(num != 0){
 16                 if(num < 0 || num > 4){
 17                     System.out.println("Wrong Format");
 18                     System.exit(0);
 19                 }
 20                 list.add(num);
 21                 num = input.nextInt();
 22             }
 23             
 24             DealCardList dealCardList = new DealCardList(list);
 25             if(!dealCardList.validate()){
 26                 System.out.println("Wrong Format");
 27                 System.exit(0);
 28             }
 29             dealCardList.showResult();
 30             input.close();
 31     }
 32 }
 33 class DealCardList{
 34     ArrayList cardList=new ArrayList();
 35     
 36     DealCardList(){
 37         
 38     }
 39     DealCardList(ArrayList list){
 40         //这部分的设计可以理解为list中存放了输入的一连串数据，我们设计算法将每个数据
 41         //分离出来，构建出一个个题目要求的Shape类型的卡片，然后存放到cardList中。
 42         //1代表圆形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。
 43         for(int j=0;j) {
 44             switch(list.get(j)) {
 45                 case 1:{//圆形
 46                     double radius=Main.input.nextDouble();
 47                     Circle circle=new Circle(radius);
 48                     circle.setShapeName("Circle");
 49                     Card circleCard=new Card(circle);
 50                     cardList.add(circleCard);
 51                 }break;
 52                 case 2:{//矩形
 53                     double width=Main.input.nextDouble();
 54                     double length=Main.input.nextDouble();
 55                     Rectangle rectangle=new Rectangle(width,length);
 56                     rectangle.setShapeName("Rectangle");
 57                     Card rectangleCard=new Card(rectangle);
 58                     cardList.add(rectangleCard);
 59                 }break;
 60                 case 3:{//三角形
 61                     double side1=Main.input.nextDouble();
 62                     double side2=Main.input.nextDouble();
 63                     double side3=Main.input.nextDouble();
 64                     Triangle triangle=new Triangle(side1,side2,side3);
 65                     triangle.setShapeName("Triangle");
 66                     Card triangleCard=new Card(triangle);
 67                     cardList.add(triangleCard);
 68                 }break;
 69                 case 4:{//梯形
 70                     double topSide=Main.input.nextDouble();
 71                     double bottomSide=Main.input.nextDouble();
 72                     double height=Main.input.nextDouble();
 73                     Trapezoid trapezoid=new Trapezoid(topSide,bottomSide,height);
 74                     trapezoid.setShapeName("Trapezoid");
 75                     Card trapezoidCard=new Card(trapezoid);
 76                     cardList.add(trapezoidCard);
 77                 }break;
 78                 default:
 79                     System.exit(0);
 80                     break;
 81             }
 82         }
 83     }
 84     boolean validate() {    //校验数据合法性
 85         boolean validity=true;
 86         for(int i=0;i) {
 87             while(!cardList.get(i).getShape().validate())    validity=false;
 88         }
 89         return validity;
 90     }
 91     void cardSort(ArrayList clist) {    //卡片排序
 92         for(int i=0;i) {
 93             for(int j=0;j) {
 94                 if(clist.get(j).comparable(clist.get(j),clist.get(j+1))) {    //若j位置卡片图形面积小于j+1位置卡片图形面积成立，则换位
 95                     Card tempcard=new Card(clist.get(j).getShape());
 96                     clist.get(j).setShape(clist.get(j+1).getShape());
 97                     clist.get(j+1).setShape(tempcard.getShape());
 98                 }
 99             }
100         }
101     }
102     double getAllArea(){    //计算所有图形面积相加起来的总面积
103         double allArea=0;
104         for(int i=0;i) {
105             allArea+=cardList.get(i).getShape().getArea();
106         }
107         return allArea;
108     }
109     void showResult() {        //根据题目要求输出相应结果
110         System.out.println("The original list:");
111         for(int i=0;i) {
112             System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f", cardList.get(i).getShape().getArea())+" ");
113         }
114         cardSort(cardList);
115         System.out.println();
116         System.out.println("The sorted list:");
117         for(int i=0;i) {
118             System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f", cardList.get(i).getShape().getArea())+" ");
119         }
120         System.out.println();
121         System.out.print("Sum of area:"+String.format("%.2f", getAllArea()));
122     }
123 }
124 
125 interface Comparable{
126     boolean comparable(Card card1,Card card2);
127 }
128 class Card implements Comparable{
129     private Shape shape;
130     
131     Card(){
132         
133     }
134     Card(Shape shape){
135         this.shape=shape;
136     }
137     
138     Shape getShape() {
139         return shape;
140     }
141     void setShape(Shape shape) {
142         this.shape=shape;
143     }
144     @Override
145     public boolean comparable(Card card1,Card card2) {
146         // TODO Auto-generated method stub
147         if(card1.getShape().getArea()return true;
148         else    return false;
149     }
150 }
151 
152 abstract class Shape{
153     String shapeName;
154     
155     Shape(){
156         
157     }
158     Shape(String shapeName){
159         this.shapeName=shapeName;
160     }
161     
162     String getShapeName() {
163         return shapeName;
164     }
165     void setShapeName(String shapeName) {
166         this.shapeName=shapeName;
167     }
168     abstract double getArea();
169     abstract boolean validate();
170     public String toString() {
171         return null;
172     }
173 }
174 class Circle extends Shape{
175     private double radius;
176     
177     Circle(){
178         
179     }
180     Circle(double radius){
181         this.radius=radius;
182     }
183     
184     double getRadius(){
185         return radius;
186     }
187     void setRadius(double radius) {
188         this.radius=radius;
189     }
190     @Override
191     double getArea() {
192         // TODO Auto-generated method stub
193         return Math.PI*Math.pow(radius, 2);
194     }
195     @Override
196     boolean validate() {
197         // TODO Auto-generated method stub
198         if(radius>=0)    return true;
199         else    return false;
200     }
201 }
202 class Rectangle extends Shape{
203     private double width;    private double length;
204     
205     Rectangle(){
206         
207     }
208     Rectangle(double width,double length){
209         this.width=width;    this.length=length;
210     }
211     
212     double getWidth(){
213         return width;
214     }
215     void setWidth(double width) {
216         this.width=width;
217     }
218     double getLength() {
219         return length;
220     }
221     void setLength(double length) {
222         this.length=length;
223     }
224     @Override
225     double getArea() {
226         // TODO Auto-generated method stub
227         return width*length;
228     }
229     @Override
230     boolean validate() {
231         // TODO Auto-generated method stub
232         if(width>=0&&length>=0)        return true;
233         else    return false;
234     }
235 }
236 class Triangle extends Shape{
237     private double side1;    private double side2;    private double side3;
238     
239     Triangle(){
240         
241     }
242     Triangle(double side1,double side2,double side3){
243         this.side1=side1;    this.side2=side2;    this.side3=side3;
244     }
245     
246     double getSide1() {
247         return side1;
248     }
249     void setSide1(double side1) {
250         this.side1=side1;
251     }
252     double getSide2() {
253         return side2;
254     }
255     void setSide2(double side2) {
256         this.side2=side2;
257     }
258     double getSide3() {
259         return side3;
260     }
261     void setSide3(double side3) {
262         this.side3=side3;
263     }
264     @Override
265     double getArea() {
266         // TODO Auto-generated method stub
267         double p=0.5*(side1+side2+side3);
268         return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
269     }
270     @Override
271     boolean validate() {
272         // TODO Auto-generated method stub
273         double a=side1;double b=side2;double c=side3;
274         //任意两边之和大于第三边，任意两边之差小于第三边
275         if(a>=0&&b>=0&&c>=0&&a+b>c&&a+c>b&&b+c>a&&a-breturn true;
276         else    return false;
277     }
278 }
279 class Trapezoid extends Shape{
280     private double topSide;        private double bottomSide;        private double height;
281     
282     Trapezoid(){
283         
284     }
285     Trapezoid(double topSide,double bottomSide,double height){
286         this.topSide=topSide;    this.bottomSide=bottomSide;        this.height=height;
287     }
288     
289     double getTopSide() {
290         return topSide;
291     }
292     void setTopSide(double topSide) {
293         this.topSide=topSide;
294     }
295     double getBottomSide() {
296         return bottomSide;
297     }
298     void setBottomSide(double bottomSide) {
299         this.bottomSide=bottomSide;
300     }
301     double getHeight() {
302         return height;
303     }
304     void setHeight(double height) {
305         this.height=height;
306     }
307     @Override
308     double getArea() {
309         // TODO Auto-generated method stub
310         return (topSide+bottomSide)*height*0.5;
311     }
312     @Override
313     boolean validate() {
314         // TODO Auto-generated method stub
315         if(topSide>=0&&bottomSide>=0&&height>=0)    return true;
316         else    return false;
317     }
318 }

（2）SourceMonitor的生成报表内容

 

（3）PowerDesigner的相应类图

 

（4）解释和心得：

 整体的结构呈现是继承与多态，另外有接口的使用。

Main主类：程序运行的入口和数据输入端。

Card卡片类：有两个构造器（默认和带参），一个属性shape，针对属性有相对应get和set方法；

父类Shape形状类：它作为属性存放在Card中，可以通过set方法设置Card中存放什么形状。其中有两个构造器，两个属性shapeName形状名和area形状面积，针对属性有相对应get和set方法。validate方法判断接收属性是否符合构成该形状的规则，属于一个抽象方法。

四个子类Circle圆形类、Rectangle矩形类、Triangle三角形类和Trapezoid梯形类，均继承于父类Shape：每一个形状子类中都有两个构造器，有图形相对应的属性（像圆形的半径、矩形的长宽等等），针对属性有相对应get和set方法。另外重构了父类中的validate方法和getArea方法，判断图形属性是否符合构成图形的规则，计算图形面积并返回相应的值。

Comparable比较接口：含有comparable方法可以比较两个Card中图形的面积大小。

DealCardList处理卡片链表类：有两个构造器，带参构造器中通过输入的数据定义出了所有的卡片，卡片中包含了相对应的图形。属性cardList中存放了所有的卡片。属性allArea存放了该链表中所有卡片图形面积的和，getAllArea方法计算总和。validate方法判断输入图形属性是否合法，cardSort方法用来给卡片进行大小排序，showResult方法按题目要求输出相应的结果。

• 题目集7（7-2） 图形卡片排序游戏 (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. 排序前的各图形类型及面积，格式为[图形名称1:面积值1图形名称2:面积值2 …图形名称n:面积值n ]，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格，在结束符“]”之前；　　
   2. 输出分组后的图形类型及面积，格式为[圆形分组各图形类型及面积][矩形分组各图形类型及面积][三角形分组各图形类型及面积][梯形分组各图形类型及面积]，各组内格式为图形名称:面积值。按照“Circle、Rectangle、Triangle、Trapezoid”的顺序依次输出；　　
   3. 各组内图形排序后的各图形类型及面积，格式同排序前各组图形的输出；　　
   4. 各组中面积之和的最大值输出，格式为The max area:面积值。　　

（1）源代码：

  1 package pta;
  2 
  3 import java.util.Scanner;
  4 import java.util.ArrayList;
  5 
  6 public class Main {
  7 //在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
  8 //使用Main.input.next…即可（避免采坑）
  9     public static Scanner input = new Scanner(System.in);
 10     public static void main(String[] args){
 11             ArrayList list = new ArrayList(); 
 12             int num = input.nextInt();
 13             if(num == 0){
 14                 System.out.println("Wrong Format");
 15                 System.exit(0);
 16             }
 17             while(num != 0){
 18                 if(num < 0 || num > 4){
 19                     System.out.println("Wrong Format");
 20                     System.exit(0);
 21                 }
 22                 list.add(num);
 23                 num = input.nextInt();
 24             }
 25             
 26             DealCardList dealCardList = new DealCardList(list);
 27             if(!dealCardList.validate()){
 28                 System.out.println("Wrong Format");
 29                 System.exit(0);
 30             }
 31             dealCardList.showResult();
 32             input.close();
 33     }
 34 }
 35 class DealCardList{
 36     ArrayList cardList=new ArrayList();
 37     ArrayList circleArray=new ArrayList();
 38     ArrayList rectangleArray=new ArrayList();
 39     ArrayList triangleArray=new ArrayList();
 40     ArrayList trapezoidArray=new ArrayList();
 41     
 42     DealCardList(){
 43         
 44     }
 45     DealCardList(ArrayList list){
 46         //这部分的设计可以理解为list中存放了输入的一连串数据，我们设计算法将每个数据
 47         //分离出来，构建出一个个题目要求的Shape类型的卡片，然后存放到cardList中。
 48         //1代表圆形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。
 49         for(int j=0;j) {
 50             switch(list.get(j)) {
 51                 case 1:{//圆形
 52                     double radius=Main.input.nextDouble();
 53                     Circle circle=new Circle(radius);
 54                     circle.setShapeName("Circle");
 55                     Card circleCard=new Card(circle);
 56                     cardList.add(circleCard);
 57                 }break;
 58                 case 2:{//矩形
 59                     double width=Main.input.nextDouble();
 60                     double length=Main.input.nextDouble();
 61                     Rectangle rectangle=new Rectangle(width,length);
 62                     rectangle.setShapeName("Rectangle");
 63                     Card rectangleCard=new Card(rectangle);
 64                     cardList.add(rectangleCard);
 65                 }break;
 66                 case 3:{//三角形
 67                     double side1=Main.input.nextDouble();
 68                     double side2=Main.input.nextDouble();
 69                     double side3=Main.input.nextDouble();
 70                     Triangle triangle=new Triangle(side1,side2,side3);
 71                     triangle.setShapeName("Triangle");
 72                     Card triangleCard=new Card(triangle);
 73                     cardList.add(triangleCard);
 74                 }break;
 75                 case 4:{//梯形
 76                     double topSide=Main.input.nextDouble();
 77                     double bottomSide=Main.input.nextDouble();
 78                     double height=Main.input.nextDouble();
 79                     Trapezoid trapezoid=new Trapezoid(topSide,bottomSide,height);
 80                     trapezoid.setShapeName("Trapezoid");
 81                     Card trapezoidCard=new Card(trapezoid);
 82                     cardList.add(trapezoidCard);
 83                 }break;
 84                 default:
 85                     System.exit(0);
 86                     break;
 87             }
 88         }
 89     }
 90     boolean validate() {    //校验数据合法性
 91         boolean validity=true;
 92         for(int i=0;i) {
 93             while(!cardList.get(i).getShape().validate())    validity=false;
 94         }
 95         return validity;
 96     }
 97     void cardSeparate(ArrayList clist) {
 98         for(int i=0;i) {
 99             if(clist.get(i).getShape().getShapeName().equals("Circle"))        circleArray.add(clist.get(i));
100             if(clist.get(i).getShape().getShapeName().equals("Rectangle"))        rectangleArray.add(clist.get(i));
101             if(clist.get(i).getShape().getShapeName().equals("Triangle"))        triangleArray.add(clist.get(i));
102             if(clist.get(i).getShape().getShapeName().equals("Trapezoid"))        trapezoidArray.add(clist.get(i));
103         }
104     }
105     void cardSort(ArrayList arrayl) {    //卡片组排序
106         for(int i=0;i) {
107             for(int j=0;j) {
108                 if(arrayl.get(j).comparable(arrayl.get(j),arrayl.get(j+1))) {    //若j位置卡片图形面积小于j+1位置卡片图形面积成立，则换位
109                     Card tempcard=new Card(arrayl.get(j).getShape());
110                     arrayl.get(j).setShape(arrayl.get(j+1).getShape());
111                     arrayl.get(j+1).setShape(tempcard.getShape());
112                 }
113             }
114         }
115     }
116     double getAllArea(ArrayList cardArrayl){    //计算图形组内所有图形面积相加起来的总面积
117         double allArea=0;
118         for(int i=0;i) {
119             allArea+=cardArrayl.get(i).getShape().getArea();
120         }
121         return allArea;
122     }
123     
124     void showResult() {        //根据题目要求输出相应结果
125         System.out.println("The original list:");
126         System.out.print("[");
127         for(int i=0;i) {
128             System.out.print(cardList.get(i).getShape().getShapeName()+":"+String.format("%.2f", cardList.get(i).getShape().getArea())+" ");
129         }
130         System.out.println("]");    //输出完毕并换行
131         
132         cardSeparate(cardList);        //分组
133         System.out.println("The Separated List:");
134         print();
135         
136         cardSort(circleArray);    cardSort(rectangleArray);    cardSort(triangleArray);    cardSort(trapezoidArray);
137         System.out.println("The Separated sorted List:");
138         print();
139         
140         double[] arrayArea= {getAllArea(circleArray),getAllArea(rectangleArray),getAllArea(triangleArray),getAllArea(trapezoidArray)};
141         double maxArrayArea=0;
142         for(int k=0;k) {
143             if(arrayArea[k]>maxArrayArea)    maxArrayArea=arrayArea[k];
144         }
145         System.out.print("The max area:"+String.format("%.2f", maxArrayArea));
146     }
147     void print() {        //输出分组图形数据
148         //圆形组输出
149         System.out.print("[");
150         for(int a=0;a) {
151             System.out.print(circleArray.get(a).getShape().getShapeName()+":"+String.format("%.2f", circleArray.get(a).getShape().getArea())+" ");
152         }
153         System.out.print("]");    //输出完毕
154         //矩形输出
155         System.out.print("[");
156         for(int b=0;b) {
157             System.out.print(rectangleArray.get(b).getShape().getShapeName()+":"+String.format("%.2f", rectangleArray.get(b).getShape().getArea())+" ");
158         }
159         System.out.print("]");    //输出完毕
160         //三角形组输出
161         System.out.print("[");
162         for(int c=0;c) {
163             System.out.print(triangleArray.get(c).getShape().getShapeName()+":"+String.format("%.2f", triangleArray.get(c).getShape().getArea())+" ");
164         }
165         System.out.print("]");    //输出完毕
166         //梯形组输出
167         System.out.print("[");
168         for(int d=0;d) {
169             System.out.print(trapezoidArray.get(d).getShape().getShapeName()+":"+String.format("%.2f", trapezoidArray.get(d).getShape().getArea())+" ");
170         }
171         System.out.println("]");    //输出完毕并换行
172     }
173 }
174 
175 interface Comparable{
176     boolean comparable(Card card1,Card card2);
177 }
178 class Card implements Comparable{
179     private Shape shape;
180     
181     Card(){
182         
183     }
184     Card(Shape shape){
185         this.shape=shape;
186     }
187     
188     Shape getShape() {
189         return shape;
190     }
191     void setShape(Shape shape) {
192         this.shape=shape;
193     }
194     @Override
195     public boolean comparable(Card card1,Card card2) {
196         // TODO Auto-generated method stub
197         if(card1.getShape().getArea()return true;
198         else    return false;
199     }
200 }
201 
202 abstract class Shape{
203     String shapeName;
204     
205     Shape(){
206         
207     }
208     Shape(String shapeName){
209         this.shapeName=shapeName;
210     }
211     
212     String getShapeName() {
213         return shapeName;
214     }
215     void setShapeName(String shapeName) {
216         this.shapeName=shapeName;
217     }
218     abstract double getArea();
219     abstract boolean validate();
220     public String toString() {
221         return null;
222     }
223 }
224 class Circle extends Shape{
225     private double radius;
226     
227     Circle(){
228         
229     }
230     Circle(double radius){
231         this.radius=radius;
232     }
233     
234     double getRadius(){
235         return radius;
236     }
237     void setRadius(double radius) {
238         this.radius=radius;
239     }
240     @Override
241     double getArea() {
242         // TODO Auto-generated method stub
243         return Math.PI*Math.pow(radius, 2);
244     }
245     @Override
246     boolean validate() {
247         // TODO Auto-generated method stub
248         if(radius>=0)    return true;
249         else    return false;
250     }
251 }
252 class Rectangle extends Shape{
253     private double width;    private double length;
254     
255     Rectangle(){
256         
257     }
258     Rectangle(double width,double length){
259         this.width=width;    this.length=length;
260     }
261     
262     double getWidth(){
263         return width;
264     }
265     void setWidth(double width) {
266         this.width=width;
267     }
268     double getLength() {
269         return length;
270     }
271     void setLength(double length) {
272         this.length=length;
273     }
274     @Override
275     double getArea() {
276         // TODO Auto-generated method stub
277         return width*length;
278     }
279     @Override
280     boolean validate() {
281         // TODO Auto-generated method stub
282         if(width>=0&&length>=0)        return true;
283         else    return false;
284     }
285 }
286 class Triangle extends Shape{
287     private double side1;    private double side2;    private double side3;
288     
289     Triangle(){
290         
291     }
292     Triangle(double side1,double side2,double side3){
293         this.side1=side1;    this.side2=side2;    this.side3=side3;
294     }
295     
296     double getSide1() {
297         return side1;
298     }
299     void setSide1(double side1) {
300         this.side1=side1;
301     }
302     double getSide2() {
303         return side2;
304     }
305     void setSide2(double side2) {
306         this.side2=side2;
307     }
308     double getSide3() {
309         return side3;
310     }
311     void setSide3(double side3) {
312         this.side3=side3;
313     }
314     @Override
315     double getArea() {
316         // TODO Auto-generated method stub
317         double p=0.5*(side1+side2+side3);
318         return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
319     }
320     @Override
321     boolean validate() {
322         // TODO Auto-generated method stub
323         double a=side1;double b=side2;double c=side3;
324         //任意两边之和大于第三边，任意两边之差小于第三边
325         if(a>=0&&b>=0&&c>=0&&a+b>c&&a+c>b&&b+c>a&&a-breturn true;
326         else    return false;
327     }
328 }
329 class Trapezoid extends Shape{
330     private double topSide;        private double bottomSide;        private double height;
331     
332     Trapezoid(){
333         
334     }
335     Trapezoid(double topSide,double bottomSide,double height){
336         this.topSide=topSide;    this.bottomSide=bottomSide;        this.height=height;
337     }
338     
339     double getTopSide() {
340         return topSide;
341     }
342     void setTopSide(double topSide) {
343         this.topSide=topSide;
344     }
345     double getBottomSide() {
346         return bottomSide;
347     }
348     void setBottomSide(double bottomSide) {
349         this.bottomSide=bottomSide;
350     }
351     double getHeight() {
352         return height;
353     }
354     void setHeight(double height) {
355         this.height=height;
356     }
357     @Override
358     double getArea() {
359         // TODO Auto-generated method stub
360         return (topSide+bottomSide)*height*0.5;
361     }
362     @Override
363     boolean validate() {
364         // TODO Auto-generated method stub
365         if(topSide>=0&&bottomSide>=0&&height>=0)    return true;
366         else    return false;
367     }
368 }

（2）SourceMonitor的生成报表内容

 

（3）PowerDesigner的相应类图

 

（4）解释和心得：

在上一题的基础上进行的拓展设计，主要的变化在DealCardList处理卡片链表类中。

Main主类：程序运行的入口和数据输入端。

Card卡片类：有两个构造器（默认和带参），一个属性shape，针对属性有相对应get和set方法；

父类Shape形状类：它作为属性存放在Card中，可以通过set方法设置Card中存放什么形状。其中有两个构造器，两个属性shapeName形状名和area形状面积，针对属性有相对应get和set方法。validate方法判断接收属性是否符合构成该形状的规则，属于一个抽象方法。

四个子类Circle圆形类、Rectangle矩形类、Triangle三角形类和Trapezoid梯形类，均继承于父类Shape：每一个形状子类中都有两个构造器，有图形相对应的属性（像圆形的半径、矩形的长宽等等），针对属性有相对应get和set方法。另外重构了父类中的validate方法和getArea方法，判断图形属性是否符合构成图形的规则，计算图形面积并返回相应的值。

Comparable比较接口：含有comparable方法可以比较两个Card中图形的面积大小。

DealCardList处理卡片链表类：有两个构造器，带参构造器中通过输入的数据定义出了所有的卡片，卡片中包含了相对应的图形。属性cardList中存放了所有的卡片。属性allArea存放了该链表中所有卡片图形面积的和，getAllArea方法计算总和。validate方法判断输入图形属性是否合法，cardSeparate方法用来给卡片按类型进行分组，cardSort方法用来给卡片进行大小排序，showResult方法按题目要求输出相应的结果，print方法是我自己添加的方法，由于题目的输出量比较大又有很大的重复性，我就决定使用print方法进行一次输出，后续输出只需调用print方法就好了，传给它不同的参数值。

2.题目集8和题目集9两道ATM机仿真题目的设计思路分析总结

• 题目集8（7-1）ATM机类结构设计（一）：设计ATM仿真系统，具体要求参见作业说明。

　　输入格式:

　　每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业务操作输入格式如下：

• • 存款、取款功能输入数据格式： 卡号 密码 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编号]上存款￥[金额]

　　当前余额为￥[金额]

　　其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。

　　④查询余额业务输出

　　￥[金额]

　　金额保留两位小数。

（1）源代码：

  1 package pta;
  2 
  3 import java.util.Scanner;
  4 import java.util.ArrayList;
  5 
  6 public class Main {
  7     public static Scanner in=new Scanner(System.in);
  8     public static void main(String[] args){
  9         Business.initalization();
 10         Business.process();
 11     }
 12 }
 13 class Business{
 14     //实体对象：一家机构，一个银行链表包含两家银行，两个ATM链表包含6台ATM机器，两个User链表包含4个用户，四个Account链表包含8个银行账户，八个Card链表包含10张银行卡
 15     //包含关系：一家机构包含一个银行链表，一家银行包含一个ATM链表、一个User链表和一个Account链表，一个用户包含一个Account链表，一个账户包含一个Card链表
 16     static ChinaUnionPay chinaUnionPay=new ChinaUnionPay("中国银联");
 17     static ArrayList bankList=new ArrayList();
 18     static ArrayList atmList1=new ArrayList();
 19     static ArrayList atmList2=new ArrayList();
 20     static ArrayList atmList=new ArrayList();    //包含所有ATM机器的链表
 21     static ArrayList userList1=new ArrayList();
 22     static ArrayList userList2=new ArrayList();
 23     static ArrayList userList=new ArrayList();        //包含所有用户
 24     static ArrayList accountList1=new ArrayList();
 25     static ArrayList accountList2=new ArrayList();
 26     static ArrayList accountList1_2=new ArrayList();        //1+2
 27     static ArrayList accountList3=new ArrayList();
 28     static ArrayList accountList4=new ArrayList();
 29     static ArrayList accountList3_4=new ArrayList();        //3+4
 30     static ArrayList accountList=new ArrayList();    //包含所有银行账户的链表
 31     static ArrayList cardList1=new ArrayList();
 32     static ArrayList cardList2=new ArrayList();
 33     static ArrayList cardList3=new ArrayList();
 34     static ArrayList cardList4=new ArrayList();
 35     static ArrayList cardList5=new ArrayList();
 36     static ArrayList cardList6=new ArrayList();
 37     static ArrayList cardList7=new ArrayList();
 38     static ArrayList cardList8=new ArrayList();
 39     static ArrayList cardList=new ArrayList();        //包含所有银行卡的链表
 40     
 41     static void initalization() {
 42         //初始化银行相关数据
 43         //两家银行分别加入银行列表，都隶属于中国银联机构
 44         Bank zjsBank=new Bank("中国建设银行");
 45         bankList.add(zjsBank);
 46         Bank zgsBank=new Bank("中国工商银行");
 47         bankList.add(zgsBank);
 48         chinaUnionPay.setBankList(bankList);
 49         //分别创建两个ATM链表，atmList1和atmList2分别属于中国建设银行和中国工商银行
 50         ATM atm01=new ATM("01"); ATM atm02=new ATM("02");
 51         ATM atm03=new ATM("03"); ATM atm04=new ATM("04");
 52         atmList1.add(atm01); atmList1.add(atm02);
 53         atmList1.add(atm03); atmList1.add(atm04);
 54         zjsBank.setATMList(atmList1);
 55         ATM atm05=new ATM("05"); ATM atm06=new ATM("06");
 56         atmList2.add(atm05); atmList2.add(atm06);
 57         zgsBank.setATMList(atmList2);
 58         
 59         atmList.addAll(atmList1); atmList.addAll(atmList2);
 60         
 61         //初始化用户相关数据
 62         //分别创建两个User链表，userList1和userList2分别属于中国建设银行和中国工商银行
 63         User yg=new User("杨过"); User gj=new User("郭靖");
 64         userList1.add(yg); userList1.add(gj);
 65         zjsBank.setUserList(userList1);
 66         User zwj=new User("张无忌"); User wxb=new User("韦小宝");
 67         userList2.add(zwj); userList2.add(wxb);
 68         zgsBank.setUserList(userList2);
 69         
 70         userList.addAll(userList1); userList.addAll(userList2);
 71         
 72         //分别创建四个Account链表，每个账户初始余额都为10000.00
 73         //其中，accountList1和accountList2属于中国建设银行，它们又先后属于杨过和郭靖
 74         //accountList3和accountList4属于中国工商银行，它们又先后属于张无忌和韦小宝
 75         Account account1=new Account("3217000010041315709");
 76         account1.setBalance(10000.00);//账户余额为10000.00
 77         Account account2=new Account("3217000010041315715");
 78         account2.setBalance(10000.00);//账户余额为10000.00
 79         accountList1.add(account1); accountList1.add(account2);
 80         yg.setAccountList(accountList1);
 81         Account account3=new Account("3217000010051320007");
 82         account3.setBalance(10000.00);//账户余额为10000.00
 83         accountList2.add(account3);
 84         gj.setAccountList(accountList2);
 85         accountList1_2.addAll(accountList1); accountList1_2.addAll(accountList2);
 86         zjsBank.setAccountList(accountList1_2);
 87         
 88         Account account4=new Account("3222081502001312389");
 89         account4.setBalance(10000.00);//账户余额为10000.00
 90         Account account5=new Account("3222081502001312390");
 91         account5.setBalance(10000.00);//账户余额为10000.00
 92         Account account6=new Account("3222081502001312399");
 93         account6.setBalance(10000.00);//账户余额为10000.00
 94         accountList3.add(account4); accountList3.add(account5); accountList3.add(account6);
 95         zwj.setAccountList(accountList3);
 96         Account account7=new Account("3222081502051320785");
 97         account7.setBalance(10000.00);//账户余额为10000.00
 98         Account account8=new Account("3222081502051320786");
 99         account8.setBalance(10000.00);//账户余额为10000.00
100         accountList4.add(account7); accountList4.add(account8);
101         wxb.setAccountList(accountList4);
102         accountList3_4.addAll(accountList3); accountList3_4.addAll(accountList4);
103         zgsBank.setAccountList(accountList3_4);
104         
105         accountList.addAll(accountList1_2); accountList.addAll(accountList3_4);
106         
107         //分别创建八个Card链表，一共包含10张Card，每张银行卡密码默认为“88888888”
108         //card1和card2属于account1，card3属于account2，这三张卡属于杨过
109         //card4属于account3，这一张卡属于郭靖
110         //card5属于account4，card6属于account5，card7和card8属于account6，这四张卡属于张无忌
111         //card9属于account7，card10属于account8，这两张卡属于韦小宝
112         Card card1=new Card("6217000010041315709");
113         card1.setPassword("88888888");//银行卡密码默认为“88888888”
114         Card card2=new Card("6217000010041315715");
115         card2.setPassword("88888888");//银行卡密码默认为“88888888”
116         cardList1.add(card1); cardList1.add(card2);
117         account1.setCardList(cardList1);
118         Card card3=new Card("6217000010041315718");
119         card3.setPassword("88888888");//银行卡密码默认为“88888888”
120         cardList2.add(card3);
121         account2.setCardList(cardList2);    //以上属于杨过
122         
123         Card card4=new Card("6217000010051320007");
124         card4.setPassword("88888888");//银行卡密码默认为“88888888”
125         cardList3.add(card4);
126         account3.setCardList(cardList3);    //以上属于郭靖
127         
128         Card card5=new Card("6222081502001312389");
129         card5.setPassword("88888888");//银行卡密码默认为“88888888”
130         cardList4.add(card5);
131         account4.setCardList(cardList4);
132         Card card6=new Card("6222081502001312390");
133         card6.setPassword("88888888");//银行卡密码默认为“88888888”
134         cardList5.add(card6);
135         account5.setCardList(cardList5);
136         Card card7=new Card("6222081502001312399");
137         card7.setPassword("88888888");//银行卡密码默认为“88888888”
138         cardList6.add(card7);
139         Card card8=new Card("6222081502001312400");
140         card8.setPassword("88888888");//银行卡密码默认为“88888888”
141         cardList6.add(card8);
142         account6.setCardList(cardList6);    //以上属于张无忌
143         
144         Card card9=new Card("6222081502051320785");
145         card9.setPassword("88888888");//银行卡密码默认为“88888888”
146         cardList7.add(card9);
147         account7.setCardList(cardList7);
148         Card card10=new Card("6222081502051320786");
149         card10.setPassword("88888888");//银行卡密码默认为“88888888”
150         cardList8.add(card10);
151         account8.setCardList(cardList8);    //以上属于韦小宝
152         
153         cardList.addAll(cardList1); cardList.addAll(cardList2); cardList.addAll(cardList3); cardList.addAll(cardList4); cardList.addAll(cardList5); cardList.addAll(cardList6); cardList.addAll(cardList7); cardList.addAll(cardList8);
154         
155     }
156     //输入部分
157     static void process() {
158         String keep=Main.in.nextLine();        //按行读取输入
159         while(!keep.equals("#")) {
160             String[] data=keep.split("\\s+");    //输入的每行数据用空格隔开，存为数组
161             
162             if(data.length==1) {
163                 String cardNum=data[0];
164                 query(cardNum);
165                 System.out.println();
166             }
167             else {
168                 String cardNum=data[0];
169                 String password=data[1];
170                 String atmNum=data[2];
171                 String moneyS=data[3];
172                 double money=Double.valueOf(moneyS);
173                 access(cardNum,password,atmNum,money);
174                 System.out.println();
175             }
176             keep=Main.in.nextLine();
177         }
178     }
179     static void access(String cardNum, String password, String atmNum, double money) {
180         //判断卡号是否存在
181         int cardFlag=-1;
182         for(int i=0;i) {
183             if(cardNum.equals(cardList.get(i).getCardNum()))
184                     cardFlag=i;
185         }
186         if(cardFlag==-1) {
187             System.out.print("Sorry,this card does not exist.");
188             System.exit(0);
189         }
190         //判断ATM编号是否存在
191         int atmFlag=-1;
192         for(int j=0;j) {
193             if(atmNum.equals(atmList.get(j).getAtmNum()))
194                     atmFlag=j;
195         }
196         if(atmFlag==-1) {
197             System.out.print("Sorry,the ATM's id is wrong.");
198             System.exit(0);
199         }
200         //判断银行卡密码是否正确
201         if(!password.equals(cardList.get(cardFlag).getPassword())) {
202             System.out.print("Sorry,your password is wrong.");
203             System.exit(0);
204         }
205         //判断取款金额是否合法
206         //找到该银行卡所属账户
207         int accountFlag=-1;
208         for(int i=0;i) {
209             for(int j=0;j) {
210                 if(cardList.get(cardFlag).getCardNum().equals( ( accountList.get(i).getCardList().get(j).getCardNum() ) ) )
211                     accountFlag=i;
212             }
213         }
214         if(money>=accountList.get(accountFlag).getBalance()) {
215             System.out.print("Sorry,your account balance is insufficient.");
216             System.exit(0);
217         }
218         //检测是否为跨行存取款,如果该银行卡账户所属银行和该ATM机所属银行不为同一家，则ERROR
219         //找到该账户所属银行
220         int bank1Flag=-1;        //指向该银行账户所属银行
221         for(int i=0;i) {
222             for(int j=0;j) {
223                 if(accountList.get(accountFlag).getAccNum().equals( ( bankList.get(i).accountList.get(j).getAccNum() ) ) )
224                     bank1Flag=i;
225             }
226         }
227         //找到该ATM机所属银行
228         int bank2Flag=-1;        //指向该ATM机所属银行
229         for(int i=0;i) {
230             for(int j=0;j) {
231                 if(atmList.get(atmFlag).getAtmNum().equals( ( bankList.get(i).atmList.get(j).getAtmNum() ) ) )
232                     bank2Flag=i;
233             }
234         }
235         if(bank1Flag!=bank2Flag) {
236             System.out.print("Sorry,cross-bank withdrawal is not supported.");
237             System.exit(0);
238         }
239         //找到该银行账户用户，进而查询该银行账户用户的用户名
240         int userFlag=-1;
241         for(int i=0;i) {
242             for(int j=0;j) {
243                 if(accountList.get(accountFlag).getAccNum().equals( ( userList.get(i).accountList.get(j).getAccNum() ) ) )
244                     userFlag=i;
245             }
246         }
247         //输出，当金额大于0时，代表取款，否则代表存款
248         if(money>0) {
249             accountList.get(accountFlag).setBalance(accountList.get(accountFlag).getBalance()-money);
250             System.out.println(userList.get(userFlag).getUserName()+"在"+bankList.get(bank1Flag).getBankName()+"的"+atmList.get(atmFlag).getAtmNum()+"号ATM机上取款￥"+String.format("%.2f",money));
251             System.out.print( "当前余额为￥"+ String.format( "%.2f", accountList.get(accountFlag).getBalance() ) );
252         }
253         else {
254             accountList.get(accountFlag).setBalance(accountList.get(accountFlag).getBalance()-money);
255             System.out.println(userList.get(userFlag).getUserName()+"在"+bankList.get(bank1Flag).getBankName()+"的"+atmList.get(atmFlag).getAtmNum()+"号ATM机上存款￥"+String.format("%.2f",Math.abs(money)));
256             System.out.print( "当前余额为￥"+ String.format( "%.2f", accountList.get(accountFlag).getBalance() ) );
257         }
258     }
259     static void query(String cardNum) {
260         int cardFlag=-1;
261         //判断卡号是否存在
262         for(int i=0;i) {
263             if(cardNum.equals(cardList.get(i).getCardNum()))
264                 cardFlag=i;
265         }
266         if(cardFlag==-1) {
267             System.out.print("Sorry,this card does not exist.");
268             System.exit(0);
269         }
270         //找到该卡所在账户，进而查询余额
271         int accountFlag=-1;
272         for(int i=0;i) {
273             for(int j=0;j) {
274                 if( cardNum.equals( accountList.get(i).getCardList().get(j).getCardNum() ) )
275                     accountFlag=i;
276             }
277         }
278         //输出所查询账户余额
279         System.out.print( "￥"+String.format( "%.2f", accountList.get(accountFlag).getBalance() ) );
280     }
281 }
282 
283 class ChinaUnionPay{
284     //机构名称为中国银联，机构包含多家银行
285     private String orgName;
286     ArrayList bankList=new ArrayList();
287     
288     ChinaUnionPay(){
289         
290     }
291     ChinaUnionPay(String orgName){
292         this.orgName=orgName;
293     }
294     
295     String getOrgName() {
296         return orgName;
297     }
298     void setOrgName(String orgName) {
299         this.orgName=orgName;
300     }
301     ArrayList getBankList() {
302         return bankList;
303     }
304     void setBankList(ArrayList bankList) {
305         this.bankList=bankList;
306     }
307 }
308 class Bank{
309     //银行有银行名称，银行下包含多台带编号的ATM机器；
310     //一家银行可以有多个用户，可以开立多个账户
311     private String bankName;
312     ArrayList atmList=new ArrayList();
313     ArrayList userList=new ArrayList();
314     ArrayList accountList=new ArrayList();
315     
316     Bank(){
317         
318     }
319     Bank(String bankName){
320         this.bankName=bankName;
321     }
322     
323     String getBankName() {
324         return bankName;
325     }
326     void setBankName(String bankName) {
327         this.bankName=bankName;
328     }
329     ArrayList getATMList() {
330         return atmList;
331     }
332     void setATMList(ArrayList atmList) {
333         this.atmList=atmList;
334     }
335     ArrayList getUserList() {
336         return userList;
337     }
338     void setUserList(ArrayList userList) {
339         this.userList=userList;
340     }
341     ArrayList getAccountList() {
342         return accountList;
343     }
344     void setAccountList(ArrayList accountList) {
345         this.accountList=accountList;
346     }
347 }
348 class User{
349     //用户有用户名，一名用户可以有多个银行账户
350     private String userName;
351     ArrayList accountList=new ArrayList();
352     
353     User(){
354         
355     }
356     User(String userName){
357         this.userName=userName;
358     }
359     
360     String getUserName() {
361         return userName;
362     }
363     void setUserName(String userName) {
364         this.userName=userName;
365     }
366     ArrayList getAccountList() {
367         return accountList;
368     }
369     void setAccountList(ArrayList accountList) {
370         this.accountList=accountList;
371     }
372 }
373 class Account{
374     //账户有账号、余额，一个银行账户可对应多张银行卡
375     private String accNum; private double balance;
376     ArrayList cardList=new ArrayList();
377     
378     Account(){
379         
380     }
381     Account(String accNum){
382         this.accNum=accNum;
383     }
384     
385     String getAccNum(){
386         return accNum;
387     }
388     void setAccNum(String accNum){
389         this.accNum=accNum;
390     }
391     double getBalance() {
392         return balance;
393     }
394     void setBalance(double balance) {
395         this.balance=balance;
396     }
397     ArrayList getCardList() {
398         return cardList;
399     }
400     void setCardList(ArrayList cardList) {
401         this.cardList=cardList;
402     }
403 }
404 class Card{
405     //银行卡有卡号和密码
406     private String cardNum; private String password;
407     
408     Card(){
409         
410     }
411     Card(String cardNum){
412         this.cardNum=cardNum;
413     }
414     
415     String getCardNum() {
416         return cardNum;
417     }
418     void setCardNum(String cardNum) {
419         this.cardNum=cardNum;
420     }
421     String getPassword() {
422         return password;
423     }
424     void setPassword(String password) {
425         this.password=password;
426     }
427 }
428 class ATM{
429     //ATM机器有对应编号
430     private String atmNum;
431     
432     ATM(){
433         
434     }
435     ATM(String atmNum){
436         this.atmNum=atmNum;
437     }
438     
439     String getAtmNum() {
440         return atmNum;
441     }
442     void setAtmNum(String atmNum) {
443         this.atmNum=atmNum;
444     }
445 }

（2）SourceMonitor的生成报表内容

 

（3）PowerDesigner的相应类图

 

（4）解释和心得：

整体的结构呈现是继承与多态。

Main主类：程序运行的入口和数据输入端。

ChinaUnionPay中国银联类：有两个构造器（默认和带参），属性orgName机构名，bankList中存放了属于机构下的所有Bank银行；

Bank银行类：有两个构造器，属性bankNmae银行名，userList中存放了所有该银行的用户，accountList存放了所有属于该银行的账户，ATMList存放了所有属于该银行的ATM机器，针对属性有相对应get和set方法。

 User用户类：有两个构造器，属性userName用户名，accountList中存放了该用户名下的所有账户，针对属性有相对应get和set方法。

Account账户类：有两个构造器，属性accNum账户号，balance账户余额，cardList中存放了该账户下所有的银行卡，针对属性有相对应的get和set方法。

Card银行卡类：有两个构造器，属性cardNum银行卡号，password银行卡密码，针对属性有相对应的get和set方法。

ATM类：有两个构造器，属性atmNum，针对属性有相对应的get和set方法。

Business业务处理类：里面定义并存放了chinaUnionPay中国银联和所需各种类型ArrayList链表（bank、atm、user、account、card），initalization方法中初始化了题目要求的所有数据，process为处理方法，数据输入口，它调用了后面的access方法用来存取款、query方法用来查询余额。

• 题目集9（7-1）ATM机类结构设计（二）：设计ATM仿真系统，具体要求参见作业说明。

　　输入格式:

　　每一行输入一次业务操作，可以输入多行，最终以字符#终止。具体每种业务操作输入格式如下：

• • 取款功能输入数据格式： 卡号 密码 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编号]上取款￥[金额]

　　当前余额为￥[金额]

　　其中，[]说明括起来的部分为输出属性或变量，金额均保留两位小数。

　　③查询余额业务输出

　　业务：查询余额 ￥[金额]

　　金额保留两位小数。

（1）源代码：

  1 import java.util.Scanner;
  2 import java.util.ArrayList;
  3 
  4 public class Main {
  5     public static Scanner in=new Scanner(System.in);
  6     public static void main(String[] args){
  7         Data.initalization();
  8         Process.input();
  9     }
 10 }
 11 class Data{
 12     static ChinaUnionPay chinaUnionPay=new ChinaUnionPay("中国银联");
 13     static ArrayList bankList=new ArrayList();
 14     static ArrayList atmList=new ArrayList();
 15     static ArrayList userList=new ArrayList();
 16     static ArrayList accountList=new ArrayList();
 17     static ArrayList cardList=new ArrayList();
 18     
 19     static void initalization() {
 20         //中国银联
 21         chinaUnionPay.setMaxOverdraft(50000); chinaUnionPay.setOdRadio(0.05);
 22         //银行3
 23         String[] bankStr= {"中国建设银行","中国工商银行","中国农业银行"}; double[] scRatioStr= {0.02,0.03,0.04};
 24         for(int i=0;i) {
 25             Bank bank=new Bank(bankStr[i]);
 26             bank.setScRatio(scRatioStr[i]);
 27             bankList.add(bank);
 28         }
 29         //ATM机11
 30         String[] atmStr= {"01","02","03","04","05","06","07","08","09","10","11"};
 31         for(int i=0;i) {
 32             ATM atm=new ATM(atmStr[i]);
 33             atmList.add(atm);
 34         }
 35         //归属问题(ATM机属于银行)
 36         for(int j=0;j) {
 37             //01，02，03，04号机器属于中国建设银行
 38             if(atmList.get(j).getAtmNum().equals("01")||atmList.get(j).getAtmNum().equals("02")||atmList.get(j).getAtmNum().equals("03")||atmList.get(j).getAtmNum().equals("04"))
 39                 bankList.get(0).getATMList().add(atmList.get(j));
 40             //05，06号机器属于中国工商银行
 41             if(atmList.get(j).getAtmNum().equals("05")||atmList.get(j).getAtmNum().equals("06"))
 42                 bankList.get(1).getATMList().add(atmList.get(j));
 43             //07，08，09，10，11号机器属于中国农业银行
 44             if(atmList.get(j).getAtmNum().equals("07")||atmList.get(j).getAtmNum().equals("08")||atmList.get(j).getAtmNum().equals("09")||atmList.get(j).getAtmNum().equals("10")||atmList.get(j).getAtmNum().equals("11"))
 45                 bankList.get(2).getATMList().add(atmList.get(j));
 46         }
 47         //用户8
 48         String[] userStr= {"杨过","郭靖","张无忌","韦小宝","张三丰","令狐冲","乔峰","洪七公"};
 49         for(int i=0;i) {
 50             User user=new User(userStr[i]);
 51             userList.add(user);
 52         }
 53         //归属问题(用户属于银行)
 54         for(int j=0;j) {
 55             //杨过，郭靖，张三丰在中国建设银行
 56             if(userList.get(j).getUserName().equals("杨过")||userList.get(j).getUserName().equals("郭靖")||userList.get(j).getUserName().equals("张三丰"))
 57                 bankList.get(0).getUserList().add(userList.get(j));
 58             //张无忌，韦小宝，令狐冲在中国工商银行
 59             if(userList.get(j).getUserName().equals("张无忌")||userList.get(j).getUserName().equals("韦小宝")||userList.get(j).getUserName().equals("令狐冲"))
 60                 bankList.get(1).getUserList().add(userList.get(j));
 61             //乔峰，洪七公在中国农业银行
 62             if(userList.get(j).getUserName().equals("乔峰")||userList.get(j).getUserName().equals("洪七公"))
 63                 bankList.get(2).getUserList().add(userList.get(j));
 64         }
 65         //账户12
 66         String[] accountStr= {"3217000010041315709","3217000010041315715","3217000010051320007","3222081502001312389","3222081502001312390","3222081502001312399","3222081502051320785","3222081502051320786","3640000010045442002","3640000010045441009","3630000010033431001"," 3630000010033431008"};
 67         for(int i=0;i) {
 68             Account account=new Account(accountStr[i]); account.setBalance(10000);
 69             if(i>=0&&i<=7)    account.setType("借记账户");
 70             else    account.setType("贷记账户");
 71             accountList.add(account);
 72         }
 73         //归属问题(账户属于用户)
 74         for(int j=0;j) {
 75             if(j==0||j==1)    userList.get(0).getAccountList().add(accountList.get(j));
 76             if(j==2)    userList.get(1).getAccountList().add(accountList.get(j));
 77             if(j==3||j==4||j==5)    userList.get(2).getAccountList().add(accountList.get(j));
 78             if(j==6||j==7)    userList.get(3).getAccountList().add(accountList.get(j));
 79             if(j==8)    userList.get(4).getAccountList().add(accountList.get(j));
 80             if(j==9)    userList.get(5).getAccountList().add(accountList.get(j));
 81             if(j==10)    userList.get(6).getAccountList().add(accountList.get(j));
 82             if(j==11)    userList.get(7).getAccountList().add(accountList.get(j));
 83         }
 84         //银行卡15
 85         String[] cardStr= {"6217000010041315709","6217000010041315715","6217000010041315718","6217000010051320007","6222081502001312389","6222081502001312390","6222081502001312399","6222081502001312400","6222081502051320785","6222081502051320786","6640000010045442002","6640000010045442003","6640000010045441009","6630000010033431001","6630000010033431008"};
 86         for(int i=0;i) {
 87             Card card=new Card(cardStr[i]);    card.setPassword("88888888");
 88             cardList.add(card);
 89         }
 90         //归属问题(银行卡属于账户)
 91         for(int j=0;j) {
 92             if(j==0||j==1)    accountList.get(0).getCardList().add(cardList.get(j));
 93             if(j==2)    accountList.get(1).getCardList().add(cardList.get(j));
 94             if(j==3)    accountList.get(2).getCardList().add(cardList.get(j));
 95             if(j==4)    accountList.get(3).getCardList().add(cardList.get(j));
 96             if(j==5)    accountList.get(4).getCardList().add(cardList.get(j));
 97             if(j==6||j==7)    accountList.get(5).getCardList().add(cardList.get(j));
 98             if(j==8)    accountList.get(6).getCardList().add(cardList.get(j));
 99             if(j==9)    accountList.get(7).getCardList().add(cardList.get(j));
100             if(j==10||j==11)    accountList.get(8).getCardList().add(cardList.get(j));
101             if(j==12)    accountList.get(9).getCardList().add(cardList.get(j));
102             if(j==13)    accountList.get(10).getCardList().add(cardList.get(j));
103             if(j==14)    accountList.get(11).getCardList().add(cardList.get(j));
104         }
105     }
106 }
107 class Process{
108     static void input() {
109         ArrayList strList=new ArrayList();
110         String keep=Main.in.nextLine();        //keep接收一行数据
111         while(!keep.equals("#")) {
112             String[] data=keep.split("\\s+");        //将keep用空格切割分别存入数组
113             strList.add(data);                        //strList中元素均为data类似的字符数组
114             keep=Main.in.nextLine();
115         }
116         if(keep.equals("#")) {        //接收停止标志“#”
117             for(int i=0;i) {
118                 if(strList.get(i).length==1) {
119                     String cardNum=strList.get(i)[0];
120                     query(cardNum);
121                     System.out.println();
122                 }
123                 else if(strList.get(i).length==4) {
124                     String cardNum=strList.get(i)[0];
125                     String password=strList.get(i)[1];
126                     String atmNum=strList.get(i)[2];
127                     String moneyS=strList.get(i)[3];
128                     double money=Double.valueOf(moneyS);
129                     access(cardNum,password,atmNum,money);
130                     System.out.println();
131                 }
132             }
133         }
134         
135     }
136     static void query(String cardNum){
137         int cardFlag=-1; int accountFlag=-1;
138         cardFlag=lookupCard(cardNum,cardFlag);
139         accountFlag=lookupAccount(cardFlag,accountFlag);
140         
141         //输出所查询账户余额
142         System.out.print( "业务：查询余额 "+"￥"+String.format( "%.2f", Data.accountList.get(accountFlag).getBalance() ) );
143     }
144     static void access(String cardNum,String password,String atmNum,double money) {
145         int cardFlag = -1; int atmFlag=-1; int accountFlag=-1; int userFlag=-1; int bank1Flag=-1; int bank2Flag=-1;
146         cardFlag=lookupCard(cardNum,cardFlag);
147         atmFlag=lookupATM(atmNum,atmFlag);
148         accountFlag=lookupAccount(cardFlag,accountFlag);
149         userFlag=lookupUser(accountFlag,userFlag);
150         bank1Flag=lookupUserBank(userFlag,bank1Flag);
151         bank2Flag=lookupATMBank(atmFlag,bank2Flag);
152         
153         //判断银行卡密码是否正确
154         if(!password.equals(Data.cardList.get(cardFlag).getPassword())) {
155             System.out.print("Sorry,your password is wrong.");
156             System.exit(0);
157         }
158         
159         //取款部分
160         double balance=Data.accountList.get(accountFlag).getBalance();
161         if(bank1Flag==bank2Flag) {        //非跨行取款
162             balance-=money;
163             if(balance>=0) {
164                 Data.accountList.get(accountFlag).setBalance(balance);
165                 System.out.println("业务：取款 "+Data.userList.get(userFlag).getUserName()+"在"+Data.bankList.get(bank2Flag).getBankName()+"的"+Data.atmList.get(atmFlag).getAtmNum()+"号ATM机上取款￥"+String.format("%.2f", money));
166                 System.out.print("当前余额为￥"+String.format("%.2f", Data.accountList.get(accountFlag).getBalance()));
167             }
168             else if(balance<0) {    //涉及到透支取款
169                 out(accountFlag,userFlag,bank2Flag,atmFlag,balance,money);
170             }
171         }
172         else if(bank1Flag!=bank2Flag) {        //跨行取款
173             //取款部分加上取款部分跨行取款的手续费
174             balance-=(money+money*Data.bankList.get(bank2Flag).getScRatio());
175             if(balance>=0) {
176                 Data.accountList.get(accountFlag).setBalance(balance);
177                 System.out.println("业务：取款 "+Data.userList.get(userFlag).getUserName()+"在"+Data.bankList.get(bank2Flag).getBankName()+"的"+Data.atmList.get(atmFlag).getAtmNum()+"号ATM机上取款￥"+String.format("%.2f", money));
178                 System.out.print("当前余额为￥"+String.format("%.2f", Data.accountList.get(accountFlag).getBalance()));
179             }
180             else if(balance<0) {    //涉及到透支取款
181                 out(accountFlag,userFlag,bank2Flag,atmFlag,balance,money);
182             }
183         }
184     }
185     
186     static void out(int accountFlag,int userFlag,int bank2Flag,int atmFlag,double balance,double money) {
187         if(Data.accountList.get(accountFlag).getType().equals("借记账户")) {
188             System.out.print("Sorry,your account balance is insufficient.");
189         }
190         else if(Data.accountList.get(accountFlag).getType().equals("贷记账户")) {
191             //计算透支部分的手续费
192             if(Data.accountList.get(accountFlag).getBalance()>=0) {
193                 balance-=(money-Data.accountList.get(accountFlag).getBalance())*Data.chinaUnionPay.getOdRadio();    //取款由余额加上透支组成
194             }
195             else {
196                 balance-=money*Data.chinaUnionPay.getOdRadio();        //取款全部为透支
197             }
198             
199             //判断此时余额（负值）是否超出了最大透支额度（小于50000）
200             if(balance<-50000) {
201                 System.out.print("Sorry,your account balance is insufficient.");
202             }
203             else if(balance>=-50000){
204                 Data.accountList.get(accountFlag).setBalance(balance);
205                 System.out.println("业务：取款 "+Data.userList.get(userFlag).getUserName()+"在"+Data.bankList.get(bank2Flag).getBankName()+"的"+Data.atmList.get(atmFlag).getAtmNum()+"号ATM机上取款￥"+String.format("%.2f", money));
206                 System.out.print("当前余额为￥"+String.format("%.2f", Data.accountList.get(accountFlag).getBalance()));
207             }
208         }
209     }
210     
211     static int lookupCard(String cardNum,int cardFlag) {
212         //判断卡号是否存在
213         //找到该卡号对应银行卡
214         for(int i=0;i) {
215             if(cardNum.equals(Data.cardList.get(i).getCardNum()))
216                     cardFlag=i;
217         }
218         if(cardFlag==-1) {
219             System.out.print("Sorry,this card does not exist.");
220             System.exit(0);
221         }
222         return cardFlag;
223     }
224     static int lookupATM(String atmNum,int atmFlag) {
225         //判断ATM编号是否存在
226         //找到该ATM编号对应ATM机
227         for(int j=0;j) {
228             if(atmNum.equals(Data.atmList.get(j).getAtmNum()))
229                     atmFlag=j;
230         }
231         if(atmFlag==-1) {
232             System.out.print("Sorry,the ATM's id is wrong.");
233             System.exit(0);
234         }
235         return atmFlag;
236     }
237     static int lookupAccount(int cardFlag,int accountFlag) {
238         //找到该银行卡所属账户
239         for(int i=0;i) {
240             for(int j=0;j) {
241                 if(Data.cardList.get(cardFlag).getCardNum().equals( ( Data.accountList.get(i).getCardList().get(j).getCardNum() ) ) )
242                     accountFlag=i;
243             }
244         }
245         return accountFlag;
246     }
247     static int lookupUser(int accountFlag,int userFlag) {
248         //找到该银行账户用户
249         for(int i=0;i) {
250             for(int j=0;j) {
251                 if(Data.accountList.get(accountFlag).getAccNum().equals( ( Data.userList.get(i).getAccountList().get(j).getAccNum() ) ) )
252                     userFlag=i;
253             }
254         }
255         return userFlag;
256     }
257     static int lookupUserBank(int userFlag,int bank1Flag) {
258         //找到该账户(即该用户)所属银行
259         for(int i=0;i) {
260             for(int j=0;j) {
261                 if(Data.userList.get(userFlag).getUserName().equals( ( Data.bankList.get(i).getUserList().get(j).getUserName() ) ) )
262                     bank1Flag=i;
263             }
264         }
265         return bank1Flag;
266     }
267     static int lookupATMBank(int atmFlag,int bank2Flag) {
268         //找到该ATM机所属银行
269         for(int i=0;i) {
270             for(int j=0;j) {
271                 if(Data.atmList.get(atmFlag).getAtmNum().equals( ( Data.bankList.get(i).getATMList().get(j).getAtmNum() ) ) )
272                     bank2Flag=i;
273             }
274         }
275         return bank2Flag;
276     }
277 }
278 class ChinaUnionPay{
279     //机构名称为中国银联，机构包含多家银行
280     private String orgName;    private double maxOverdraft; private double odRadio;
281     private ArrayList bankList=new ArrayList();
282     
283     ChinaUnionPay(){
284         
285     }
286     ChinaUnionPay(String orgName){
287         this.orgName=orgName;
288     }
289     
290     String getOrgName() {
291         return orgName;
292     }
293     void setOrgName(String orgName) {
294         this.orgName=orgName;
295     }
296     double getMaxOverdraft() {
297         return maxOverdraft;
298     }
299     void setMaxOverdraft(double maxOverdraft) {
300         this.maxOverdraft=maxOverdraft;
301     }
302     double getOdRadio() {
303         return odRadio;
304     }
305     void setOdRadio(double odRadio) {
306         this.odRadio=odRadio;
307     }
308     ArrayList getBankList() {
309         return bankList;
310     }
311     void setBankList(ArrayList bankList) {
312         this.bankList=bankList;
313     }
314 }
315 class Bank{
316     //银行有银行名称，银行下包含多台带编号的ATM机器；
317     //一家银行可以有多个用户
318     private String bankName;    private double scRatio;
319     private ArrayList atmList=new ArrayList();
320     private ArrayList userList=new ArrayList();
321     
322     Bank(){
323         
324     }
325     Bank(String bankName){
326         this.bankName=bankName;
327     }
328     
329     String getBankName() {
330         return bankName;
331     }
332     void setBankName(String bankName) {
333         this.bankName=bankName;
334     }
335     double getScRatio() {
336         return scRatio;
337     }
338     void setScRatio(double scRatio) {
339         this.scRatio=scRatio;
340     }
341     ArrayList getATMList() {
342         return atmList;
343     }
344     void setATMList(ArrayList atmList) {
345         this.atmList=atmList;
346     }
347     ArrayList getUserList() {
348         return userList;
349     }
350     void setUserList(ArrayList userList) {
351         this.userList=userList;
352     }
353 }
354 class ATM{
355     //ATM机器有对应编号
356     private String atmNum;
357     
358     ATM(){
359         
360     }
361     ATM(String atmNum){
362         this.atmNum=atmNum;
363     }
364     
365     String getAtmNum() {
366         return atmNum;
367     }
368     void setAtmNum(String atmNum) {
369         this.atmNum=atmNum;
370     }
371 }
372 class User{
373     //用户有用户名，一名用户可以有多个银行账户
374     private String userName;
375     private ArrayList accountList=new ArrayList();
376     
377     User(){
378         
379     }
380     User(String userName){
381         this.userName=userName;
382     }
383     
384     String getUserName() {
385         return userName;
386     }
387     void setUserName(String userName) {
388         this.userName=userName;
389     }
390     ArrayList getAccountList() {
391         return accountList;
392     }
393     void setAccountList(ArrayList accountList) {
394         this.accountList=accountList;
395     }
396 }
397 class Account{
398     //账户有账号、余额，一个银行账户可对应多张银行卡
399     private String accNum; private double balance;    private String type;
400     private ArrayList cardList=new ArrayList();
401     
402     Account(){
403         
404     }
405     Account(String accNum){
406         this.accNum=accNum;
407     }
408     
409     String getAccNum(){
410         return accNum;
411     }
412     void setAccNum(String accNum){
413         this.accNum=accNum;
414     }
415     double getBalance() {
416         return balance;
417     }
418     void setBalance(double balance) {
419         this.balance=balance;
420     }
421     String getType() {
422         return type;
423     }
424     void setType(String type) {
425         this.type=type;
426     }
427     ArrayList getCardList() {
428         return cardList;
429     }
430     void setCardList(ArrayList cardList) {
431         this.cardList=cardList;
432     }
433 }
434 class Card{
435     //银行卡有卡号和密码
436     private String cardNum; private String password;
437     
438     Card(){
439         
440     }
441     Card(String cardNum){
442         this.cardNum=cardNum;
443     }
444     
445     String getCardNum() {
446         return cardNum;
447     }
448     void setCardNum(String cardNum) {
449         this.cardNum=cardNum;
450     }
451     String getPassword() {
452         return password;
453     }
454     void setPassword(String password) {
455         this.password=password;
456     }
457 }

（2）SourceMonitor的生成报表内容

 

（3）PowerDesigner的相应类图

 

（4）解释和心得：

 主要是在上一题的基础上进行拓展设计，主要变化体现在类结构的设计以及部分类中方法的处理过程。

Main主类：程序运行的入口和数据输入端。

ChinaUnionPay中国银联类：有两个构造器（默认和带参），属性orgName机构名，bankList中存放了属于机构下的所有Bank银行；

Bank银行类：有两个构造器，属性bankNmae银行名，userList中存放了所有该银行的用户，accountList存放了所有属于该银行的账户，ATMList存放了所有属于该银行的ATM机器，针对属性有相对应get和set方法。

 User用户类：有两个构造器，属性userName用户名，accountList中存放了该用户名下的所有账户，针对属性有相对应get和set方法。

Account账户类：有两个构造器，属性accNum账户号，balance账户余额，cardList中存放了该账户下所有的银行卡，针对属性有相对应的get和set方法。

Card银行卡类：有两个构造器，属性cardNum银行卡号，password银行卡密码，针对属性有相对应的get和set方法。

ATM类：有两个构造器，属性atmNum，针对属性有相对应的get和set方法。

（Business业务处理类：里面定义并存放了chinaUnionPay中国银联和所需各种类型ArrayList链表（bank、atm、user、account、card），initalization方法中初始化了题目要求的所有数据，process为处理方法，数据输入口，它调用了后面的access方法用来存取款、query方法用来查询余额。）

以上括号部分为上一次的设计。这一次中我将它分割为了Data数据类和Process处理类。

Data数据类：里面定义并存放了chinaUnionPay中国银联和所需各种类型ArrayList链表（bank、atm、user、account、card），initalization方法中初始化了题目要求的所有数据。

Process处理类：input方法接收输入数据，query方法用来查询余额，access方法用来存取款，out方法输出题目要求的相应结果。另外，我定义了一个int类型数据flag，用它来标记某个实体在它的ArrayList中所处的位置，因此还包含了若干个lookup方法用来分别查找Card，ATM，Account，User，UserBank和ATMBank在其存储链表中所处的位置，并返回flag的值。这样在access存取和query查询方法中利用flag可以很快捷准确地访问到Data类ArrayList中相应的数据。

三、踩坑心得：

以下部分更多是自己在完成作业过程中遇到的一些困难以及我自己的解决办法的记录。

1.图形卡片排序游戏
（1）有关子类与父类的继承关系问题：
刚开始自己对于子类如何从父类中继承属性和方法这个问题上的理解上存在偏差，认为子类只能从父类中直接继承抽象方法，并且在本题中，父类作为一个抽象类，它不能够new出一个实体对象，我便主观地认为抽象类不应该存在构造器（构造方法），甚至认为它其中的参数也毫无意义。但题目文件中给出的类图中，父类Shape是抽象类但它的确存在构造器以及带参构造器，这就让我很困惑一度以为自己看错了题目，一遍一遍确认类图和自己的设计。
就以本题为例，父类Shape中含有私有属性shapeName，有默认构造方法Shape（）和带参构造方法Shape（String shapeName），但同时由于它是抽象类因此Shape是无法在主类主方法main（）中new出shape实体的。但是题目在设计上又要求我们在创建出一个图形时（比如circle）要能给它安上名字（“circle”），这时我才反应过来子类是父类，子类理应当具备父类所具备的所有属性和方法，体现在代码设计上也就是子类直接继承父类的全部属性和方法。因此在这道题的设计上，我在主类主方法中new出了一个circle实体对象，便可以通过子类对象访问父类方法Shape.setShapeName（），来给这个圆形安上“Circle”的名字。
（2）showResult输出结果这一块的问题
还是输出哪些内容、哪种格式等等细节上认真仔细一点，多仔细观察题目的输出。（贴题目输出和自己showResult模块）
要是还有测试点无法通过格式错误，实在自己不好找也可以用PTA上的自定义测试，改正起来还是很快的毕竟不是设计方案上的问题。（贴一个测试区的图）

2.图形卡片分组排序游戏

（1）可以不用新建个Card，然后把需要的Card复制给新Card，直接定一个flag标记这个需要的Card的位置不就好了，通过链表随时把它调出来用就好了。
（2）我们在遍历accountList下的cardList时，第二个for循环j的终点有变。因为第一个account1含有的cardList1的长度和第二个account2含有的cardList2的长度并不完全一样，可以讲毫无关系。
（3）判断两个实体对象是否完全相等不能直接用==。
（4）问题：调用了access（）方法，也给它传参了，但它完全不运行。
在进入该方法前有一个判断未通过导致的未进入access方法，判断字符串是否相等不能用==，而是用equal（）。
（5）因为0在数组或链表中指向第一个元素，所以在定义一个flag用来标记数组或链表中某个特定的元素，并需要通过判断flag是否变化来判断是否找到该特定元素时，flag的初值最好不要设定为0，可以为-1。
（6）有关程序输入部分Scanner.nextLine()方法的使用。按行读取输入数据。

作业九：
1.关于不同方法间传参的问题(见QQ截图举例)

2.有关计算透支部分的问题。如果采用持续负值的计算方法，前提已知该账户已处于透支状态(即余额为负值)，那下次取款计算透支部分仍采用计算公式money-balance，计算出来的透支部分比实际大了余额部分。
解决方法：a，一旦账户余额消耗为零了，判断该账户是否为贷记账户，若否则驳回取款操作，若是则迅速讲余额值修正为正值，进行取款操作，但在这部分输出上，账户余额需要特意标记为负值
b方案，也可以在进行取款操作时，判断余额为正值还是负值，采取不同的计算公式。

四、改进建议

 针对这部分自己感受最深刻的体现在题目集八和题目集九两次设计上。九到八的区别仅仅是添加了一家银行和四名用户，另外一种借贷账户，我却发现自己的源代码需要做相当大的调整，这令我非常的。。。后续自己花费了较多的时间重新进行类结构的设计，感叹自己之前愚蠢思维的同时也是收获和感悟颇多，总结下来有以下两点：

1.多考虑使用数组来存放同类型的、重复操作的信息和数据，对于一些多次重复的操作（例如一个银行账户后续可以进行无数多次的注册，每一个账户都存储了不同的信息，如何更高效地执行完这些操作）多考虑使用for循环来完成，避免多次重复的操作增加自己源代码的规模，效率极低；

2.当程序所涉及的规模较大，类的数量以及各种数据又比较多，设计过程中理清类之间的关系很重要，明确自己所在类使用的类以及方法是存放哪个类或其他结构中，模拟它们之间运作的过程和相互关系。

五、总结

 经过本阶段三次题目集的学习，自己的收获主要有两个方面：

1.由于是较为综合性的作业，每次完成作业中都需要使用大量的Java相关知识，自己也渐渐熟悉和熟练掌握了很多知识的运用；

2.对于培养自己类结构的设计思维上有很大的启发，以后自己也会更侧重这方面的学习和思考。