20201334-张益栋---blog作业03总结

第三阶段 blog

　　感受：大一下学期最后的二十几天了，剩下的学习时间已经不多了，各科学习情况步入尾声，即将迎来各科作业的期末考试，这几次的编程作业总体趋势也是比较偏向一个综合性、总结性的作业目的，能让我们把学过的东西都结合起来，串联起一系列我们学过的知识，这才是我们学到最后的状态。学习就是这样的，将一样东西学好之后，再去学习下一样新的内容，全部学习了解完之后尝试着把学过的内容整合起来，学会灵活运用这才算是我们学会了。

　　对这几次作业整体上还是比较难的，需要花费比原来作业更多的时间在这次作业上，需要的是我们的耐心和勤奋慢慢琢磨，总会做出来的！

 ·　　接下来我们就开门见山的来讲解，这几次的作业吧。

（1）前言：总结三次题目集的知识点、题量、难度等情况

题目集7：

首先来看看题目7-1，题目7-1的简介如下：

 

 

 

 1，知识点（多）

Circle(圆形) Rectangle (矩形) Triangle(三角形) Trapezoid(梯形)这些形状在继承Shape类时，涉及到继承的知识点。

当使用 Shape xxx = new xxx()； 涉及到了多态知识。

camparable接口的简单使用。

2.题量（不大）

7-1的题目工作量不算太大，主要算法就是使用ArrayList来储存用户输入的代表图形形状的数字，让后将ArrayList传入一个类的构造方法中，对每一个arraylist中的数据进行处理，就拿Rectangle来打比方，如果Arraylist中数据是2时，输入长方形的长宽，创建一个Rectangle类，在另一个以Shape作为属性的card类中，以它作为对象数组用Arrarlist储存每一个card类，用能获得shape类的名字，例如Rectangle

类似的，用能得到shape的面积，周长也就是差不多如此），总的说题量不是很大，总体思路清晰，基本上没有什么算法，就一个冒泡排序，差不多就这样了。

 3.难度（不大）

难度不大，就只是简单的类的创建（Circle circle = new Circle();），类的继承，多态的运用，对象数组的创建和使用。对于输入，输出的格式处理。

 

 

其次题目7-2.

 

 

 

 很显然这个题目与7-1的题目很相似，其实就是题目7-1的拓展，只需要在7-1代码上进行些许修改即可。

1.知识点（多而类似）

类的创建，类的继承，多态的理解，对象链表的创建，camparable接口，排序算法的运用。

2.题量（不大）

题量比题目7-1稍稍提升，大概增加了100多行代码左右。

3.难度（不大）

难度在7-1的·基础上，感觉就是只多增加了几个对象链表，其他方面难度没有太多的增加。

 

 

题目集8：

 

 

 

 

 

 1.知识点（少儿难）

将生活中实际的问题转化为编程问题求解，重要的是理解实际生活中多种概念之间的关系理解，例如：账户，银行，银行卡，ATM机，银联。要将生活中真实存在的实例相互之间的关系理理清楚了，并且将这种生活中实例存在的关系，用代码中多种类的关系表达清楚，首先就要我们深刻理解，多种类与类之间的关系，所以这个题目主要涉及的知识点就是，把生活中的问题转化为编程问题来处理的能力。还有一些更具体的知识点，比如：

2.题量（大）

题量主要就是存在于对于各种类之间的设计，对于输入的数据储存与使用和对输入截至的准确判断，对错误输入的准确判断（当用户输入的错误的数据时，程序要判断错误输入的先后顺序，然后输出相应的错误提示内容。

3.难度（大）

 准确理解类生活中问题将此转化为变成问题解决，难度处在于整体结构的设计。

 

 

题目集9：

 

 

注意解题报告！

 

 

 

 1.知识点（少）

在题目集8的基础上扩充了一些，关于增加一些操作的处理。

2.题量（一般）

题量一般

3.难度（略大）

难度略大

 

（2）设计与分析：重点对题目的提交源码进行分析，可参考SourceMonitor的生成报表内容以及PowerDesigner的相应类图，要有相应的解释和心得（做到有图有真相），本次Blog必须分析的内容如下：

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

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

先来看看SourceMonitor中各项数据代表的意思：

 

总行数(Lines)：包括空行在内的代码行数；

语句数目(Statements)：在C语言中，语句是以分号结尾的。分支语句if，循环语句for、while，跳转语句goto都被计算在内，预处理语句#include、#define和#undef也被计算在内，对其他的预处理语句则不作计算，在#else和#endif、#elif和#endif之间的语句将被忽略；

分支语句比例(Percent Branch Statements)：该值表示分支语句占语句数目的比例，这里的“分支语句”指的是使程序不顺序执行的语句，包括if、else、for、while和switch；

注释比例(Percent Lines with Comments)：该值指示注释行（包括/*……*/和//……形式的注释）占总行数的比例；

函数数目(Functions)：指示函数的数量；

平均每个函数包含的语句数目(Average Statements per Function)：总的函数语句数目除以函数数目得到该值；

函数圈复杂度(Function Complexity)：圈复杂度指示一个函数可执行路径的数目，以下语句为圈复杂度的值贡献1：if/else/for/while语句，三元运算符语句，if/for/while判断条件中的"&&"或“||”，switch语句，后接break/goto/ return/throw/continue语句的case语句，catch/except语句；

函数深度(Block Depth)：函数深度指示函数中分支嵌套的层数。

对其他语言，SourceMonitor输出不同的度量值，例如在C++度量值中包括类的数目(Classes)，在HTML中包括各个标签的数目(HTML Tags)、超链接数目(Hyperlinks)等。

3.度量值的呈现样式

SourceMonitor从几个不同的视图层次，为我们展示以上列举的度量值，包括项目视图、检查点视图和函数视图。

项目视图(project view)

SourceMonitor下建立项目须在一个文件夹下进行，该文件夹下的源码文件可以被分成一个或几个检查点，项目视图下列出了各个检查点的度量值信息。

检查点视图(checkpoint view)

检查点视图中列出了某个检查点中包含的各个源代码文件的度量值信息。

函数视图(method view)

函数视图中展示了某个检查点下，某个源文件中所有函数的度量信息，双击某函数可以跳转到源文件中该函数的相应位置。

 

 

1.题目7（7-1)、（7-2），题目集8，题目集9SourceMonitor的生成报表内容以及PowerDesigner的相应类图和代码依次如下：

先来看看题目集7（7-1）。

代码量303行（包含空行在内的代码行数），总体代码量不是很大，而且花费的时间也不是很多，但是细心编写的同学会发现，这确实是在用心编写的时候能收获到的带代码的一种冥冥之中的感觉，这种感觉会让人越写越上瘾，继续下去，在写代码时享受这种独特的只有代码人能体会的充实的感觉！

下面让我们一起来看看source monitor生成的图表，来分析一下，具体的代码内部详细的，关于每个类，每个方法的细节描述。

 

从这张图中我们可以得到以下内容，再加上我们的一些粗糙的分析，如下：

语句数目（Statement）：没有考虑太多的 语句注意事项，所以可能语句数目量会比较大一些，没有严格要求这一项。

分支语句比例（Percent Branch Statement）：意思是使程序不顺序执行的语句，包括if、else、for、while、switch，我的代码中尽量减少了多余的分支语句局的出现。

注释比例（percent Lines with Comments）：总体来说注释的量相对较少；

类和接口的数量（class and interface）：可以在表中看到类和接口的数量是9，包含了Triangle、Trapezoid、Rectangle、Main、Circle、DealCardList、Shape、Card八个类，和一个Compareable接口。

然后在是对代码生成类图的简要分析： 

可以在类图中看到Shape的子类包括Circle、Triangle、Rectangle、Trapezoid一共四个子类。

card对象用来储存shape的几种子类，而DealCardList用Arraylist来储存Card对象，形成card的对象数组。

具体的思路就是，将输入的数字转化成形状存入Card的对象数组中，将出入的各个形状的相应数据（如边长，半径等），再利用每一个形状中的方法来计算面积和周长。

具体代码如下。

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

public class Main {
//在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
//使用Main.input.next…即可（避免采坑）
public static Scanner input = new Scanner(System.in);
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<Integer>();
int num = input.nextInt();
while(num != 0){
if(num < 0 || num > 4){
System.out.println("Wrong Format");
System.exit(0);
}
list.add(num);
num = input.nextInt();
}
DealCardList dealCardList = new DealCardList(list);
if(!dealCardList.validate()){
System.out.println("Wrong Format");
System.exit(0);
}
dealCardList.showResult();
input.close();
}
}

 

interface Comparable{

}
class DealCardList{
ArrayList<Card> list = new ArrayList<Card>();
public DealCardList(){

}
public DealCardList(ArrayList<Integer>list ){
//Card card = new Card();
for(int i = 0;i<list.size();i++) {
switch(list.get(i)) {
case 1:
Card card = new Card();
Shape circle = new Circle(Main.input.nextDouble());
card.setShape(circle);
card.getShape().setShapeName("Circle");
this.list.add(card);break;
case 2:Card card1 = new Card();
Shape Rectangle = new Rectangle(Main.input.nextDouble(),Main.input.nextDouble());
card1.setShape(Rectangle);
card1.getShape().setShapeName("Rectangle");
this.list.add(card1);break;
case 3:
Card card2 = new Card();
Shape Triangle = new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble());
card2.setShape(Triangle);
card2.getShape().setShapeName("Triangle");
this.list.add(card2);break;
case 4:
Card card3 = new Card();
Shape Trapezoid = new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble());
card3.setShape(Trapezoid);
card3.getShape().setShapeName("Trapezoid");
this.list.add(card3);break;
}
}
}
public boolean validate(){
for(int i = 0;i<list.size();i++) {
if(list.get(i).getShape().validate()==false) {
return false;
}
}
return true;

}
public void cardSort() {

}
public double getAllArea() {
return 0;

}
public void showResult() {
System.out.println("The original list:");
for(int i = 0;i<list.size();i++) {
System.out.print(list.get(i).getShape().getShapeName()+":"+String.format("%.2f",list.get(i).getShape().getArea())+" ");
}
System.out.println("\nThe sorted list:");
for(int i=1;i<list.size();i++) {
for(int j = 0;j<list.size()-i;j++) {
if(list.get(j).getShape().getArea()<list.get(j+1).getShape().getArea()) {
Card temp = list.get(j+1);

list.set(j+1, list.get(j));
list.set(j, temp);
}
}
}
double sum = 0;
for(int i = 0;i<list.size();i++) {
System.out.print(list.get(i).getShape().getShapeName()+":"+String.format("%.2f",list.get(i).getShape().getArea())+" ");
sum+=list.get(i).getShape().getArea();
}
System.out.print("\nSum of area:"+String.format("%.2f",sum));
}
}
class Card implements Comparable {
private Shape shape;
public Card(){

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

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

}
public Shape(String shapeName){
this.shapeName = shapeName;
}
public String getShapeName() {
return shapeName;
}
public void setShapeName(String shapeName) {
this.shapeName = shapeName;
}
abstract double getArea();
abstract boolean validate();
@Override
public String toString() {
return "Shape [shapeName=" + shapeName + "]";
}

}
class Trapezoid extends Shape{
private double topSide;
private double bottomSide;
private double height;
public Trapezoid(){

}
public Trapezoid(double topSide,double bottomSide,double height){
this.bottomSide = bottomSide;
this.height = height;
this.topSide = topSide;
}
@Override
public double getArea() {
// TODO Auto-generated method stub
return (topSide+bottomSide)*height/2;

}

@Override
public boolean validate() {
// TODO Auto-generated method stub
if(topSide<=0||bottomSide<=0||height<=0)
return false;
return true;

}

}
class Circle extends Shape{
private double radius;
public Circle(){

}
public Circle(double radius){
this.radius = radius;

}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
@Override
public double getArea() {
// TODO Auto-generated method stub

return radius*radius*Math.PI;
}
@Override
public boolean validate() {
// TODO Auto-generated method stub
if(radius<=0)
return false;
return true;
}

}
class Rectangle extends Shape{
private double width;
private double length;

public Rectangle(double length, double width) {
// TODO Auto-generated constructor stub
this.length = length;
this.width = width;
}

@Override
public double getArea() {
// TODO Auto-generated method stub
return length*width;
}

@Override
public boolean validate() {
// TODO Auto-generated method stub
if(width<=0||length<=0)
return false;
return true;
}

public double getWidth() {
return width;
}

public void setWidth(double width) {
this.width = width;
}

public double getLength() {
return length;
}

public void setLength(double length) {
this.length = length;
}

}
class Triangle extends Shape{
private double side1;
private double side2;
private double side3;

public Triangle(double side1, double side2, double side3) {
// TODO Auto-generated constructor stub
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}

@Override
public double getArea() {
double p = (side1+side2+side3)/2.0;
// TODO Auto-generated method stub
//System.out.print(p);
return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
}

@Override
public boolean validate() {
// TODO Auto-generated method stub
if((side1<=0||side2<=0||side3<=0)||((side1+side2<side3)||(side3+side2<side1)||(side1+side3<side2)))
return false;
return true;
}

public double getSide1() {
return side1;
}

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

public double getSide2() {
return side2;
}

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

public double getSide3() {
return side3;
}

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

}

 

 接下来是对题目集7（7-2）的对于代码综合的个人评测与理解：

首先source monitor 生成的图表如下：

 可以看到表中lines数值为384行，代码本身也是在上一次的作业中的迭代升级，在类的个数上没有做太大的变化，只是在一些细节方面有些许的进一步的要求，所以代码量没有相差的多大。

 

对于代码语句的简要分析如下：

语句数目（Statement）：语句数目的数量是235，这样的数值表明用量也是有点大了。

分支语句比例（Percent Branch Statement）：分支语句的数目是14.5，意思的是使程序不按顺序执行的语句的数量，这样的数据还是说得过去的。

注释比例（percent Lines with Comments）：不写或者写很少的注释是一个很不好的习惯，这样会让读你写代码的人，读起来很费劲，大大降低了代码的可读性。

类和接口（class and interface）：可以从表中看吃接口和类的数量是8个。

平均每个方法包含的语句（Average Statements per Method）：平均每个方法包含的语句3—4句。

平均复杂度（Average Complexity）：平均复杂度是1.68，感觉上还是蛮好的。

 

 

 

可以从这张类图上看得到，总体上与上一题目没有多大的改变，只是在有一些算法的设计上与原来的有一些区别，具体是在输出的时候，要将Rectangle、Triangle、Circle和Trapezoid这几种形状按类型排号，而且还要注意要将输出的每个形状的面积按照大小顺序排序，其实说实话也没又加上多少的难度，可以理解为老师是为了锻炼我们对代码理解的能力。这些额外的加上去的东西就是我们在算法上要考虑的问题，在设计上考虑代码的排版问题。

代码如下：

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

public class Main {
//在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
//使用Main.input.next…即可（避免采坑）
public static Scanner input = new Scanner(System.in);
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<Integer>();
int num = input.nextInt();
int p=0;
while(num != 0){
p++;
if(num < 0 || num > 4){
System.out.println("Wrong Format");
System.exit(0);
}
list.add(num);
num = input.nextInt();
}

DealCardList dealCardList = new DealCardList(list);
if(!dealCardList.validate()||p==0){
System.out.println("Wrong Format");
System.exit(0);
}
dealCardList.showResult();
input.close();
}
}

 

//interface Comparable{
// void sort();
//
//}
class DealCardList{
ArrayList<Card> list = new ArrayList<Card>();
ArrayList<Integer>list1 = new ArrayList<Integer>();
ArrayList<Card> listCircle = new ArrayList<Card>();
ArrayList<Card> listRectangle = new ArrayList<Card>();
ArrayList<Card> listTriangle = new ArrayList<Card>();
ArrayList<Card> listT = new ArrayList<Card>();

public DealCardList(){

}
public DealCardList(ArrayList<Integer>list ){
list1 = list;
//Card card = new Card();
for(int i = 0;i<list.size();i++) {
switch(list.get(i)) {
case 1:
Card card = new Card();
Shape circle = new Circle(Main.input.nextDouble());
card.setShape(circle);
card.getShape().setShapeName("Circle");
this.list.add(card);break;
case 2:Card card1 = new Card();
Shape Rectangle = new Rectangle(Main.input.nextDouble(),Main.input.nextDouble());
card1.setShape(Rectangle);
card1.getShape().setShapeName("Rectangle");
this.list.add(card1);break;
case 3:
Card card2 = new Card();
Shape Triangle = new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble());
card2.setShape(Triangle);
card2.getShape().setShapeName("Triangle");
this.list.add(card2);break;
case 4:
Card card3 = new Card();
Shape Trapezoid = new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble());
card3.setShape(Trapezoid);
card3.getShape().setShapeName("Trapezoid");
this.list.add(card3);break;
}
}
}
public boolean validate(){
for(int i = 0;i<list.size();i++) {
if(list.get(i).getShape().validate()==false) {
return false;
}
}
return true;

}
public void cardSort() {
System.out.println("The original list:");
System.out.print("[");
for(int i = 0;i<list.size();i++) {
System.out.print(list.get(i).getShape().getShapeName()+":"+String.format("%.2f",list.get(i).getShape().getArea())+" ");
}
System.out.println("]");
System.out.println("The Separated List:");
int k=1;
for(int j = 0;j<4;j++) {

System.out.print("[");
for(int i = 0;i<list.size();i++) {
if(list1.get(i)==k) {
switch(k) {
case 1:listCircle.add(list.get(i));break;
case 2:listRectangle.add(list.get(i));break;
case 3:listTriangle.add(list.get(i));break;
case 4:listT.add(list.get(i));break;
}
//listC.add(list.get(i));
System.out.print(list.get(i).getShape().getShapeName()+":"+String.format("%.2f",list.get(i).getShape().getArea())+" ");
}
}
k++;
System.out.print("]");
}System.out.println("\nThe Separated sorted List:");
// sort(listCircle);
// sort(listRectangle);
// sort(listTriangle);
// sort(listT);
System.out.print("\nThe max area:"+String.format("%.2f",Math.max(Math.max(sort(listCircle), sort(listRectangle)),Math.max(sort(listTriangle),sort(listT)))));
}
double sort(ArrayList<Card> list) {
for(int i=0;i<list.size()-1;i++) {
for(int j =0;j<list.size()-1-i;j++) {
switch(list.get(j).compareTo(list.get(j+1))) {
case 1:Card card = list.get(j);
list.set(j, list.get(j+1));
list.set(j+1, card);
}
}
}
System.out.print("[");
double sum =0;
for(int i =0;i<list.size();i++) {
sum+=list.get(i).getShape().getArea();
System.out.print(list.get(i).getShape().getShapeName()+":"+String.format("%.2f",list.get(i).getShape().getArea())+" ");
}
System.out.print("]");
return sum;
}
// Arrays.sort(list));
// for(int i = 0;i<list.size()-1;i++) {
// list.get(i).compareTo(list.get(i+1));
// }
// System.out.println("\nThe sorted list:");
// for(int i=1;i<list.size();i++) {
// for(int j = 0;j<list.size()-i;j++) {
// if(list.get(j).getShape().getArea()<list.get(j+1).getShape().getArea()) {
// Card temp = list.get(j+1);
//
// list.set(j+1, list.get(j));
// list.set(j, temp);
// }
// }
// }
// for(int i = 0;i<list.size();i++) {
// System.out.print(list.get(i).getShape().getShapeName()+":"+String.format("%.2f",list.get(i).getShape().getArea())+" ");
// }
//

// public ArrayList sort(){
//
// }
public double getAllArea() {
double sum = 0;
for(int i = 0;i<list.size();i++) {
sum+=list.get(i).getShape().getArea();
}
return sum;

}
public void showResult() {
cardSort();
// System.out.print("\nSum of area:"+String.format("%.2f",getAllArea()));

}
}

class Card implements Comparable<Card>{
private Shape shape;
public Card(){

}
public Card(Shape shape){
this.shape = shape;
}
public Shape getShape() {
return shape;
}
public void setShape(Shape shape) {
this.shape = shape;
}
@Override
public int compareTo(Card card) {
// TODO Auto-generated method stub
if(this.getShape().getArea()<card.getShape().getArea())
return 1;
else if(this.getShape().getArea()==card.getShape().getArea())
return 0;

return -1;

}

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

}
public Shape(String shapeName){
this.shapeName = shapeName;
}
public String getShapeName() {
return shapeName;
}
public void setShapeName(String shapeName) {
this.shapeName = shapeName;
}
abstract double getArea();
abstract boolean validate();
@Override
public String toString() {
return "Shape [shapeName=" + shapeName + "]";
}

}
class Trapezoid extends Shape{
private double topSide;
private double bottomSide;
private double height;
public Trapezoid(){

}
public Trapezoid(double topSide,double bottomSide,double height){
this.bottomSide = bottomSide;
this.height = height;
this.topSide = topSide;
}
@Override
public double getArea() {
// TODO Auto-generated method stub
return (topSide+bottomSide)*height/2;

}

@Override
public boolean validate() {
// TODO Auto-generated method stub
if(topSide<=0||bottomSide<=0||height<=0)
return false;
return true;

}

}
class Circle extends Shape{
private double radius;
public Circle(){

}
public Circle(double radius){
this.radius = radius;

}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
@Override
public double getArea() {
// TODO Auto-generated method stub

return radius*radius*Math.PI;
}
@Override
public boolean validate() {
// TODO Auto-generated method stub
if(radius<=0)
return false;
return true;
}

}
class Rectangle extends Shape{
private double width;
private double length;

public Rectangle(double length, double width) {
// TODO Auto-generated constructor stub
this.length = length;
this.width = width;
}

@Override
public double getArea() {
// TODO Auto-generated method stub
return length*width;
}

@Override
public boolean validate() {
// TODO Auto-generated method stub
if(width<=0||length<=0)
return false;
return true;
}

public double getWidth() {
return width;
}

public void setWidth(double width) {
this.width = width;
}

public double getLength() {
return length;
}

public void setLength(double length) {
this.length = length;
}

}
class Triangle extends Shape{
private double side1;
private double side2;
private double side3;

public Triangle(double side1, double side2, double side3) {
// TODO Auto-generated constructor stub
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}

@Override
public double getArea() {
double p = (side1+side2+side3)/2.0;
// TODO Auto-generated method stub
//System.out.print(p);
return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
}

@Override
public boolean validate() {
// TODO Auto-generated method stub
if((side1<=0||side2<=0||side3<=0)||((side1+side2<side3)||(side3+side2<side1)||(side1+side3<side2)))
return false;
return true;
}

public double getSide1() {
return side1;
}

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

public double getSide2() {
return side2;
}

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

public double getSide3() {
return side3;
}

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

}

 题目集8的source monitor的图表和代码生成的类图如下：

 总体代码数量才237行，但是这并不是老师考察的点，所以老师也没有过于重视对于代码量这方面的要求。

 如下是代码的关于类，方法，注释等的细节分析。

source monitor的具体分析如下：

语句数目（Statement）：80在预料的范围之内

平均函数圈复杂度（function Complexity）：平均圈复杂度的数量是1.29

 

 

 

如上类图内容包括ATM继承并且关联Agent类，然后Agent关联Bank类最后用main类将ATM类，Agent类，User类Account类，Bank类集合起来处理。

可能类中还有一些关系没有表示出来，可能是因为生成类图工具的原因。

 

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

public class Main{
public static void main(String args []) {
Scanner input = new Scanner (System.in);
Agent agent = new Agent();
ATM atm = new ATM(agent);
StringBuilder str = new StringBuilder();
String s = input.nextLine();
while(s.equals("#") != true) {
str.append(s);
str.append('\n');
s = input.nextLine();
}
s = str.toString();
String arr [] = s.split("\n");
for(int j = 0 ;j<arr.length;j++) {
String arr1 []= arr[j].split("\\s+");
if(arr1.length==1) {
atm.fun2(arr1[0]);
}
if(arr1.length==4) {
atm.fun1(arr1[0], arr1[1], arr1[2], Double.parseDouble(arr1[3]));
}
}
}
}
class Card {
private String cardNumber;

public String getCardNumber() {
return cardNumber;
}

public void setCardNumber(String cardNumber) {
this.cardNumber = cardNumber;
}


}
class Account {
private String accountNumber;
ArrayList<Card> cardList = new ArrayList<Card>();
private double money ;
private String bankname;
private String username;
public String getBankname() {
return bankname;
}
public void setBankname(String bankname) {
this.bankname = bankname;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
public String getAccountNumber() {
return accountNumber;
}
public void setAccountNumber(String accountNumber) {
this.accountNumber = accountNumber;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}
class User{
private String name;
ArrayList <Account> accountList= new ArrayList<Account>();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Bank{
ArrayList<String> name = new ArrayList<String>();
ArrayList <Account> accountList= new ArrayList<Account>();
ArrayList<User> userList = new ArrayList<User>();
ArrayList<Card> cardList =new ArrayList<Card>();


}
class Agent{
Bank bank = new Bank();
Agent(){
put("杨过","中国建设银行","3217000010041315709",10000,"6217000010041315709");
Card card0 = new Card();
card0.setCardNumber("6217000010041315715");
this.bank.accountList.get(0).cardList.add(card0);
put("杨过","中国建设银行","3217000010041315715",10000,"6217000010041315718");
put("郭靖","中国建设银行","3217000010051320007",10000,"6217000010051320007");
put("张无忌","中国工商银行","3222081502001312389",10000,"6222081502001312389");
put("张无忌","中国工商银行","3222081502001312390",10000,"6222081502001312390");
put("张无忌","中国工商银行","3222081502001312399",10000,"6222081502001312399");
Card card1 = new Card();
card1.setCardNumber("6222081502001312400");
this.bank.accountList.get(5).cardList.add(card1);
put("韦小宝","中国工商银行","3222081502051320785",10000,"6222081502051320785");
put("韦小宝","中国工商银行","3222081502051320786",10000,"6222081502051320786");

}
void put (String username,String bankname,String accountnumber,double money,String cardnumber) {
User user = new User();
Card card = new Card();
Account account = new Account();
account.setUsername(username);
user.setName(username);
card.setCardNumber(cardnumber);
account.cardList.add(card);
account.setAccountNumber(accountnumber);
account.setMoney(money);
account.setBankname(bankname);
bank.name.add(bankname);
bank.userList.add(user);
bank.cardList.add(card);
bank.accountList.add(account);

}

}
class ATM extends Agent{
private String cardnumber;
private String cardpass;
private String atmnumber;
private double money;

Agent agent = new Agent();
ATM(Agent agent){
this.agent = agent;
}
public String getCardnumber() {
return cardnumber;
}
public void setCardnumber(String cardnumber) {
this.cardnumber = cardnumber;
}
public String getCardpass() {
return cardpass;
}
public void setCardpass(String cardpass) {
this.cardpass = cardpass;
}
public String getAtmnumber() {
return atmnumber;
}
public void setAtmnumber(String atmnumber) {
this.atmnumber = atmnumber;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
void fun2(String arr) {
for(int i = 0;i<agent.bank.accountList.size();i++) {
for(int j =0 ;j<agent.bank.accountList.get(i).cardList.size();j++) {
if(arr.compareTo(agent.bank.accountList.get(i).cardList.get(j).getCardNumber())==0) {
System.out.println("¥"+agent.bank.accountList.get(i).getMoney()+"0");
}

}
}
}
void fun1(String cardnumber,String cardpass,String atmnumber,double money){

this.money = money;
this.atmnumber = atmnumber;
this.cardnumber = cardnumber;

int flag =0;
for(int i = 0;i<agent.bank.accountList.size();i++) {
for(int j =0 ;j<agent.bank.accountList.get(i).cardList.size();j++) {
if(cardnumber.compareTo(agent.bank.accountList.get(i).cardList.get(j).getCardNumber())==0)
{ flag++;
if((atmnumber.equals("01")||atmnumber.equals("02")||atmnumber.equals("03")||atmnumber.equals("04")||atmnumber.equals("05")||atmnumber.equals("06"))==false) {
System.out.println("Sorry,the ATM's id is wrong."); System.exit(0);

}
else {
if(cardpass.equalsIgnoreCase("88888888")==false) {
System.out.println("Sorry,your password is wrong.");
System.exit(0);

}
else {

if(this.money>0) {
if(this.money>=agent.bank.accountList.get(i).getMoney()) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);

}else {if(agent.bank.accountList.get(i).getBankname().equals("中国工商银行")&&(atmnumber.equals("05")||atmnumber.equals("06"))==false) {
System.out.println("Sorry,cross-bank withdrawal is not supported."); System.exit(0);

}
if(agent.bank.accountList.get(i).getBankname().equals("中国建设银行")&&(atmnumber.equals("01")||atmnumber.equals("02")||atmnumber.equals("03")||atmnumber.equals("04"))==false) {
System.out.println("Sorry,cross-bank withdrawal is not supported."); System.exit(0);

}
agent.bank.accountList.get(i).setMoney(agent.bank.accountList.get(i).getMoney()-this.money);
System.out.println(agent.bank.accountList.get(i).getUsername()+"在"+agent.bank.accountList.get(i).getBankname()+"的"+this.atmnumber+"号ATM机上取款¥"+this.money+"0\n当前余额为¥"+agent.bank.accountList.get(i).getMoney()+"0");
}
}
else {if(agent.bank.accountList.get(i).getBankname().equals("中国工商银行")&&(atmnumber.equals("05")||atmnumber.equals("06"))==false) {
System.out.println("Sorry,cross-bank withdrawal is not supported.");
System.exit(0);

}
if(agent.bank.accountList.get(i).getBankname().equals("中国建设银行")&&(atmnumber.equals("01")||atmnumber.equals("02")||atmnumber.equals("03")||atmnumber.equals("04"))==false) {
System.out.println("Sorry,cross-bank withdrawal is not supported.");
System.exit(0);
}
agent.bank.accountList.get(i).setMoney(agent.bank.accountList.get(i).getMoney()-this.money);
System.out.println(agent.bank.accountList.get(i).getUsername()+"在"+agent.bank.accountList.get(i).getBankname()+"的"+this.atmnumber+"号ATM机上存款¥"+-this.money+"0\n当前余额为¥"+agent.bank.accountList.get(i).getMoney()+"0");

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

}
}
}题目集9的source monitor报表及生成的类图如下：

 

 代码量是730行，再这几次作业中可以说是代码量最大的一次了，但是如果我们明确了，各种类与类之间的关系，就可以简单地编写出代码（前提很重要！准确理解类与类之间的关系。）这就又涉及到各种类与类之间的关系，上面我介绍了各种类与类之间的关系。

语句数目（Statement）：399的语句数量，对于700多行代码来说，还是蛮合适的。

分支语句比例（Percent Branch Statement）：说明在编写代码的过程中我用了大量的，if，else等改变程序运行顺序的语句，明知道这样的语句会然代码的质量下降，但是到现在没有办法不用这样的操作来完成作业，哎学的东西还是不够多哦。

注释比例（percent Lines with Comments）：代码缺少注释，这是代码人始终要注意的一个点，习惯写注释一定要牢记于心。

类与接口的数目（class and Interface）：可以在报表中看到此项数目是9个，包括Card、ATM、UnioPay、Bark、Account。Withdraw、VlidateData、AccountCredit、AccountDebit几个类。

 

 

 整体代码综合性高，考察的方面较为广泛，对学生的各方面考察较为具体。主要考查的是与题目集8一样的类与类之间的关系，搞清楚类与类之间的关系来这种题目就迎刃而解了。与题目集8最大的不同就是，题目集9在题目及8的基础上加上了一些再类关系处理上的复杂性，因为加入了关于借记卡和贷记卡的账户样式，加入了关于跨行取款利息与超额取款利息的细节，准确理解老师的意图，在类的关系上加上这样的一些东西。

 

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","中国建设银行",0.02);
Bank icbc = new Bank("1002","中国工商银行",0.03);
Bank abc = new Bank("1003","中国农业银行",0.04);

unionPay.addBank(ccb);
unionPay.addBank(icbc);
unionPay.addBank(abc);

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);
ATM aTM7 = new ATM("07",abc);
ATM aTM8 = new ATM("08",abc);
ATM aTM9 = new ATM("09",abc);
ATM aTM10 = new ATM("10",abc);
ATM aTM11 = new ATM("11",abc);

ccb.addATM(aTM1);
ccb.addATM(aTM2);
ccb.addATM(aTM3);
ccb.addATM(aTM4);
icbc.addATM(aTM5);
icbc.addATM(aTM6);
abc.addATM(aTM7);
abc.addATM(aTM8);
abc.addATM(aTM9);
abc.addATM(aTM10);
abc.addATM(aTM11);

User Yangguo = new User("360101200102122324","杨过","13856223254");
User Guojing = new User("360101200012302552","郭靖","13800021124");
User Zhangwuji = new User("360502199805163221","张无忌","13952110011");
User Weixiaobao = new User("360201200513243326","韦小宝","13025996587");
User Zhangsanfeng = new User("1","张三丰","1");
User Linhuchong = new User("2","令狐冲","2");
User Qiaofeng = new User("3","乔峰","3");
User Hongqigong = new User("4","洪七公","4");

Account ccbAcc1 = new AccountDebit("3217000010041315709",10000.00,Yangguo,ccb,"debit",0);
Account ccbAcc2 = new AccountDebit("3217000010041315715",10000.00,Yangguo,ccb,"debit",0);
Account ccbAcc3 = new AccountDebit("3217000010051320007",10000.00,Guojing,ccb,"debit",0);
Account icbcAcc1 = new AccountDebit("3222081502001312389",10000.00,Zhangwuji,icbc,"debit",0);
Account icbcAcc2 = new AccountDebit("3222081502001312390",10000.00,Zhangwuji,icbc,"debit",0);
Account icbcAcc3 = new AccountDebit("3222081502001312399",10000.00,Zhangwuji,icbc,"debit",0);
Account icbcAcc4 = new AccountDebit("3222081502051320785",10000.00,Weixiaobao,icbc,"debit",0);
Account icbcAcc5 = new AccountDebit("3222081502051320786",10000.00,Weixiaobao,icbc,"debit",0);
Account ccbAcc4 = new AccountCredit("3640000010045442002",10000.00,Zhangsanfeng,ccb,"credit",50000);
Account icbcAcc6 = new AccountCredit("3640000010045441009",10000.00,Linhuchong,icbc,"credit",50000);
Account abcAcc1 = new AccountCredit("3630000010033431001",10000.00,Qiaofeng,abc,"credit",50000);
Account abcAcc2 = new AccountCredit("3630000010033431008",10000.00,Hongqigong,abc,"credit",50000);

ccb.addAccount(ccbAcc1);
ccb.addAccount(ccbAcc2);
ccb.addAccount(ccbAcc3);
icbc.addAccount(icbcAcc1);
icbc.addAccount(icbcAcc2);
icbc.addAccount(icbcAcc3);
icbc.addAccount(icbcAcc4);
icbc.addAccount(icbcAcc5);
ccb.addAccount(ccbAcc4);
icbc.addAccount(icbcAcc6);
abc.addAccount(abcAcc1);
abc.addAccount(abcAcc2);

Yangguo.addAccount(ccbAcc1);
Yangguo.addAccount(ccbAcc2);
Guojing.addAccount(ccbAcc3);
Zhangwuji.addAccount(icbcAcc1);
Zhangwuji.addAccount(icbcAcc2);
Zhangwuji.addAccount(icbcAcc3);
Weixiaobao.addAccount(icbcAcc4);
Weixiaobao.addAccount(icbcAcc5);
Zhangsanfeng.addAccount(ccbAcc4);
Linhuchong.addAccount(icbcAcc6);
Qiaofeng.addAccount(abcAcc1);
Hongqigong.addAccount(abcAcc2);

Card ccbCard1 = new Card("6217000010041315709","88888888",ccbAcc1);
Card ccbCard2 = new Card("6217000010041315715","88888888",ccbAcc1);
Card ccbCard3 = new Card("6217000010041315718","88888888",ccbAcc2);
Card ccbCard4 = new Card("6217000010051320007","88888888",ccbAcc3);
Card icbcCard5 = new Card("6222081502001312389","88888888",icbcAcc1);
Card icbcCard6 = new Card("6222081502001312390","88888888",icbcAcc2);
Card icbcCard7 = new Card("6222081502001312399","88888888",icbcAcc3);
Card icbcCard8 = new Card("6222081502001312400","88888888",icbcAcc3);
Card icbcCard9 = new Card("6222081502051320785","88888888",icbcAcc4);
Card icbcCard10 = new Card("6222081502051320786","88888888",icbcAcc5);
Card ccbCard11 = new Card("6640000010045442002","88888888",ccbAcc4);
Card ccbCard12 = new Card("6640000010045442003","88888888",ccbAcc4);
Card icbcCard13 = new Card("6640000010045441009","88888888",icbcAcc6);
Card abcCard14 = new Card("6630000010033431001","88888888",abcAcc1);
Card abcCard15 = new Card("6630000010033431008","88888888",abcAcc2);

ccbAcc1.addCard(ccbCard1);
ccbAcc1.addCard(ccbCard2);
ccbAcc2.addCard(ccbCard3);
ccbAcc3.addCard(ccbCard4);
icbcAcc1.addCard(icbcCard5);
icbcAcc2.addCard(icbcCard6);
icbcAcc3.addCard(icbcCard7);
icbcAcc3.addCard(icbcCard8);
icbcAcc4.addCard(icbcCard9);
icbcAcc5.addCard(icbcCard10);
ccbAcc4.addCard(ccbCard11);
ccbAcc4.addCard(ccbCard12);
icbcAcc6.addCard(icbcCard13);
abcAcc1.addCard(abcCard14);
abcAcc2.addCard(abcCard15);

StringBuilder sb = new StringBuilder();

String data;

while(!((data = input.nextLine()).equals("#"))) {
sb.append(data + "\n");
}

String[] dt = sb.toString().split("\n");
for(int i = 0; i < dt.length; i++) {
String[] dataLine = dt[i].toString().split("\\s+");

if(dataLine.length == 1) {
GetBalance gb = new GetBalance(unionPay);
System.out.println("业务：查询余额 "+String.format("¥%.2f", gb.getBalance(dataLine[0])));
}else {
Withdraw wd = new Withdraw(unionPay,dataLine[0],dataLine[1],dataLine[2],Double.parseDouble(dataLine[3]));
wd.withdraw();
}
}
}
}

class Bank {
private double tax;

public double getTax() {
return tax;
}

public void setTax(double tax) {
this.tax = tax;
}

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

public Bank() {
super();
// TODO Auto-generated constructor stub
}

public Bank(String bankNO, String bankName,double tax) {
super();
this.tax = tax;
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;
private String Phone;
ArrayList<Account> list = new ArrayList<Account>();

public User() {
super();
// TODO Auto-generated constructor stub
}

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

public String getID() {
return ID;
}

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

public String getPhone() {
return Phone;
}

public void setPhone(String phone) {
Phone = phone;
}

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 double balance = 0;
private User user = null;
private Bank bank = null;
private static ArrayList<Card> list = new ArrayList<Card>();
private String AccountType;
private double loan;

public double getLoan() {
return loan;
}

public void setLoan(double loan) {
this.loan = loan;
}

public void setAccountType(String accountType) {
AccountType = accountType;
}

public String getAccountType() {
return AccountType;
}
public Account() {
super();
// TODO Auto-generated constructor stub
}

public Account(String accountNO, double balance, User user, Bank bank) {
super();
this.accountNO = accountNO;
this.balance = balance;
this.user = user;
this.bank = bank;
}

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

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

public double getBalance() {
return balance;
}

public void setBalance(double balance) {
this.balance = balance;
}

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;
}

public static Account getAmountbyCardNO(String cardNO) {
Iterator<Card> cardItr = Account.list.iterator();
Card card = null;

while(cardItr.hasNext()) {
card = cardItr.next();
if(card.getCardNO().equals(cardNO)) {
return card.getAccount();
}
}

return null;
}
}
class AccountDebit extends Account{
public AccountDebit(String accountNO, double balance, User user, Bank bank , String AccountType,double loan) {
super();
super.setBalance(balance);
super.setAccountNO(accountNO);
super.setBank(bank);
super.setUser(user);
super.setAccountType(AccountType);
super.setLoan(loan);
}
}
class AccountCredit extends Account{
public AccountCredit(String accountNO, double balance, User user, Bank bank,String AccountType,double loan) {
super();
super.setBalance(balance);
super.setAccountNO(accountNO);
super.setBank(bank);
super.setUser(user);
super.setAccountType(AccountType);
super.setLoan(loan);
}
}

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

public Card() {
super();
// TODO Auto-generated constructor stub
}

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

public String getCardNO() {
return cardNO;
}

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

public String getCardPassword() {
return cardPassword;
}

public Account getAccount() {
return account;
}

public void setAccount2(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() {
super();
// TODO Auto-generated constructor stub
}

public ATM(String aTMID, Bank bank) {
super();
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 Withdraw {
private UnionPay unionPay;
private String cardNO;
private String cardPassword;
private String ATMID;
private double amount;
private ATM atm;

public ATM getAtm() {
return atm;
}

public void setAtm(ATM atm) {
this.atm = atm;
}

public Withdraw() {
super();
// TODO Auto-generated constructor stub
}

public Withdraw(UnionPay unionPay, String cardNO, String cardPassword, String aTMID, double amount) {
super();
this.unionPay = unionPay;
this.cardNO = cardNO;
this.cardPassword = cardPassword;
ATMID = aTMID;
this.amount = amount;
}

public Withdraw(String cardNO, String cardPassword, String aTMID, double amount) {
super();
this.cardNO = cardNO;
this.cardPassword = cardPassword;
ATMID = aTMID;
this.amount = amount;
}

public void withdraw() {
/**
* 校验该卡是否存在
*/
Card card = ValidateData.getCardbyCardNO(unionPay, cardNO);
if (card == null) {
System.out.println("Sorry,this card does not exist.");
System.exit(0);
}

/**
* 校验ATM是否存在
*/
ATM aTM = ValidateData.getATMbyATMID(unionPay, ATMID);
if (aTM == null) {
System.out.println("Sorry,the ATM's id is wrong.");
System.exit(0);
}
this.atm = aTM;

Account account = Account.getAmountbyCardNO(cardNO);
double balance = account.getBalance();

/**
* 校验卡密码是否正确
*/
if (!card.getCardPassword().equals(cardPassword)) {
System.out.println("Sorry,your password is wrong.");
System.exit(0);
}

/**
* 校验取款金额是否大于余额
*/
double taxation1 = 0;
double taxation2 = 0;
if (atm.getBank().getBankName() != account.getBank().getBankName()) {
taxation2 = amount * atm.getBank().getTax();
if (account.getAccountType().equals("debit")) {
if(account.getBalance()<amount+taxation2){
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
else {
if(account.getBalance() >= amount)
taxation1 = 0;
else if(account.getBalance() >= 0)
taxation1 = (amount - account.getBalance())*0.05;
else
taxation1 = amount * 0.05;

if(taxation1+amount+taxation2>account.getLoan()+account.getBalance()){
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
}
else {
if (account.getAccountType().equals("debit")) {
if (amount > account.getBalance()) {
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
else {
if(account.getBalance() >= amount)
taxation1 = 0;
else if(account.getBalance() >= 0)
taxation1 = (amount - account.getBalance())*0.05;
else
taxation1 = amount * 0.05;
if(amount + taxation1 > account.getLoan() + account.getBalance()){
System.out.println("Sorry,your account balance is insufficient.");
System.exit(0);
}
}
}
account.setBalance(balance - amount- taxation1 - taxation2);//取款更新余额操作
if (amount >= 0) {
showResult(account, 1, aTM);
} else {
showResult(account, 0, aTM);
}

}

public void showResult(Account account, int flag, ATM atm) {
String type = "";
if (flag == 1) {
type = "取款";
} else {
type = "存款";
amount *= -1;
}

String userName = account.getUser().getName();
String bankName = atm.getBank().getBankName();
System.out.println("业务：取款 " + userName + "在" +
bankName + "的" + ATMID + "号ATM机上" + type + String.format("¥%.2f", amount));
System.out.println("当前余额为" + String.format("¥%.2f", account.getBalance()));
}
}

class ValidateData {
/**
* 校验卡号是否存在
* @param unionPay
* @param cardNO
* @return
*/
public static Card getCardbyCardNO(UnionPay unionPay,String cardNO) {
Card card = null;
Iterator<Bank> bankItr = unionPay.getBankList().iterator();

while(bankItr.hasNext()) {
ArrayList<Account> accountList = bankItr.next().getAccountList();
Iterator<Account> accountItr = accountList.iterator();
while(accountItr.hasNext()) {
ArrayList<Card> cardList = accountItr.next().getList();
Iterator<Card> cardItr = cardList.iterator();
while(cardItr.hasNext()) {
card = cardItr.next();
if(card.getCardNO().equals(cardNO)) {
return card;
}
}
}
}
return null;
}

/**
* 校验ATM ID是否存在
* @param unionPay
* @param ATMID
* @return
*/
public static ATM getATMbyATMID(UnionPay unionPay,String ATMID) {
Iterator<Bank> bankItr = unionPay.getBankList().iterator();
Bank bank = null;
ATM aTM = null;

while(bankItr.hasNext()) {
bank = bankItr.next();
Iterator<ATM> aTMItr = bank.getATMList().iterator();

while(aTMItr.hasNext()) {
aTM = aTMItr.next();
if(aTM.getATMID().equals(ATMID)) {
return aTM;
}
}
}
return null;
}
}

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

public UnionPay() {
super();
// TODO Auto-generated constructor stub
}

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

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

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

public void addBank(Bank bank) {
this.bankList.add(bank);
}

public void removeBank(Bank bank) {
this.bankList.remove(bank);
}
}

class GetBalance {
private UnionPay unionPay;

public GetBalance() {
super();
// TODO Auto-generated constructor stub
}

public GetBalance(UnionPay unionPay) {
super();
this.unionPay = unionPay;
}

public double getBalance(String cardNO) {
return ValidateData.getCardbyCardNO(unionPay, cardNO).getAccount().getBalance();
}
}

（3）采坑心得：对源码的提交过程中出现的问题及心得进行总结，务必做到详实，拿数据、源码及测试结果说话，切忌假大空

在下面这张图片中，我提交了多次，而最后发现错误在于，我没有搞清楚每个Card对应的账户编号，但是我一直在调试，忽略了这个小毛病导致我找了好久的错误，希望下次我们都能够，将自己的思路理清楚，不会犯这样的错误。

 

 

学的还是很不够的，在这些知识点方面还是需要多练练，多多去了解的，因为对于这些作业来说，真正的其实是在他人的辅导下才得以写完的，我自己掌握的知识点还是完全不够的，在这里的第一的作业里。

我们需要改进的就是多态，继承，抽象的运用，在我写的代码里面这些东西并没有好好得体现出来，所以如果需要改进的话我们可以多加入几个单独的实体类，来对账户类进行一个继承，对其代码中的相似的方法，我们可以写一个抽象类来对他们相同的代码功能进行一个大概的书写，再由相应的类实现相应的接口，实现其中的方法，这样一来就更加的符合题目的要求了，一举两得，于此同时，这次的作业我的复杂度是超标的，所欲对于代码的调整和简化是很有必要的，我们需要对其中的if语句，或者其他的重复代码进行一个修改，才能降低其复杂度。

（4）改进建议：对相应题目的编码改进给出自己的见解，做到可持续改进

 我觉得改进的方面确实还有很多，例如下图，我没有准确理解老师给我们说的ATM机中类图的关系，从而有了下面的类图（下面类图存在的错误是，没有按照来时要求的那样来编写代码，没有准确表达类与类之间的关系，虽然我的代码能做到和老师一样的运行结果，但是，这并不能说明什么，毕竟我没有按照老师写的要求来写，就是我完成任务的不到位的具体体现）

 

刚拿到题目的时候，不能就开始写，这样格式不对的话，就前功尽弃了，还有就是准确理解题目中要用到的东西，如果再做一次这样的作业，我会建议我自己准确理解类和类之间的关系，这样才能更好的用代码将自己想要表达的意思写清楚，才能达到事半功倍的效果。

（5）总结：对本阶段三次题目集的综合性总结，学到了什么，哪些地方需要进一步学习及研究，对教师、课程、作业、实验、课上及课下组织方式等方面的改进建议及意见。

经过这几次难度有所提高的题目，感觉自己的编程能力提高了很多，在一写细节的地方我学习到了很多技巧性地东西，例如：再ATM机的题目中输入的截至标志是“#”，就是你输入玩你要输入的数据之后，输入“#”，就能戒指输入：老师给的代码是这样的

 就像这个处理输入的模式，在我没看老师的代码之前我是没有想到的。而且，之前我的代码还是有漏洞的，不是能完全处理键盘的输入。所以我觉得老师这样处理的方式，会让我铭记于心的。

写代码就射这样的，需要不断的摸索，不断地积累，因为知识是学不完的，不能一蹴而就，每天积累一点点，每天都会用进步，就像这次作业中老师的处理方式，比我的要好，这样我就学会了更好的处理方式，就是这样的不断积累自己不会的，慢慢进步！