OOP1~3次作业心得体会
OOP 1~3次作业心得体会
22201709-刘隽涛
目录
（1）对于面向对象程序设计的理解和想法
（2）对于oop前三次作业的理解
（3）设计与分析，测试分析性能，踩坑心得及下次改进的建议
（4）总结与看法：）
关于java与面对对象的个人理解
从上个学期的C语言启蒙和一点点的python学习，我们在大一下学期开始了java面向对象程序设计的学习，
对于java的学习个人的理解与体会：
关于语法：
1.第一次接触时，对于java的语法还不熟悉主函数和构造函数构造类时等茫然
对于封装和私有化，使用构造方法构造对象等的不熟悉。
2.对于各类数据类型的存储范围还不够清晰。
3.Boolean值的return应该写在哪里。
关于类：
1.用多种类去解决问题，尽量做到类之间的低耦合，将问题拆分，各司其职。
2.对于私有化，引用变量访问对象。
3.封装后的顺序及引用
对于OOP前三次作业难点的理解和出错点分析
第一次作业
1.str:表示为分隔符，默认为空格，但是不能为空('')。若字符串中没有分隔符，则把整个字符串作为列表的一个元素
例如：s.split('')是不合法的表达
num:表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量
[n]:表示选取第n个分片
2.b.charAt(i)字符串的索引
3. char[] c = str.toCharArray();字符串转为字符数组
4.//Integer.toString将int类型转变为string类型
//Integer.parseInt(hh)将字符串看成hh输出
第二次作业
1.print输出是看清楚题干是输出俩位小数还是整个float浮点型
分别为（“%.2f”，a）和（（float）a+......+......)
2.a.substring(0,2);//字符串内提取字符
括号内前一个数字代表字符串开头，后一个数字代表字符串结尾(但不包含)
s.substring(a, b)表示截取下标从a开始到b结束的字符，包含第a个字符但是不包含第b个字符，可以看成[a,b)。
3.判断直角三角形时不能直接使用x*x+y*y==z*z判断，得注意精度（double和float的使用），以及证明直角三角形存在误差。可以设置一个很小的误差比如0.000001.
第三次作业
1.构造含参，无参对象
2.私有化，使用this引用数据域，调用构造方法
3.数据域的封装
设计与分析
ps：SourceMonitor里图表的含义：
- Lines： 指的是代码总行数
- Statements：语句的行数，语句是以分号结尾的。这个C中有所不同。
- Percent Branch Statement：分支数占总语句数的百分比
- Method Call Statement：方法调用语句数
- Percent Lines with Comments：注释语句占总语句数的百分比
- Classes and Interfaces：类和接口数
- Methods per Class：每个类平均包含函数个数
- Average Statements per Method：每个函数平均包含的语句个数函数深度（Block Depth）：函数深度是函数中分支嵌套的层数。
- 对应有最大深度（Max Depth）和平均深度（Avg Depth）。
- Line Number of Complex Method：最复杂函数的行号（最复杂指的是McCabe复杂度值为最高）
- Maximum Complexity：该类中最复杂函数的复杂度（最复杂指的是McCabe复杂度值为最高）
- Line Number of Deepest Block：最深层语句块的行号
-
函数复杂度（Function Complexity）复杂度指1个函数可履行路径的数目，以下语句为复杂度的值贡献1：if/else/for/while语句，3元运算符语句，if/for/while判断条件中的"&&"或“||”，switch语句，
后接break/goto/ return/throw/continue语句的case语句，catch/except语句等。对应有最大复杂度（Max Complexity）和平均复杂度（Avg Complexity）。
第一次作业
7-3 求定积分
作者：刘凤良 单位：天津仁爱学院
一、定积分的概念
根据以上理论，求定积分：
输入格式:
输入定积分下限，定积分上限，区间[a,b]被分割的份数。
输出格式:
输出定积分的值，保留4位小数。
输入样例:
1 2 100
输出样例:
2.3334
代码展示：
import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner in = new Scanner(System.in); double from = in.nextDouble(); double to = in.nextDouble(); int count = in.nextInt(); count = count*1000; double dx = (to-from)/count;//矩形的宽 double s = 0.0;//面积 for (int i = 1; i <=count; i++) { double y = from+i*dx; s = s + (y*y); } System.out.printf("%.4f",s*dx); }
}
踩坑心得：count范围扩大，使得积分近似值可以更准确，将需要积分的部分分为更多的小块，近似值更加准确。
改进建议：要需求入手将问题进行拆分，各司其职，虽然问题简单，但部分要求并未达到良好。
第二次作业
7-5 学号识别
作者：蔡轲 单位：南昌航空大学
学校的学号由8位数字组成，前两位是入学年份（省略了20）；第3、4位是学院编号，01代表材料学院，02代表机械学院，03代表外语学院，20代表软件学院；第5、6位是学院内部班级编号，最后两位是班级内部学号。如：18011103，入学年份是2018年，材料学院，11班，03号
输入格式:
8位数字组成的学号。例如：18011103
注意：输入学号不是8位或者学院编号不是01、02、03、20其中之一，属于非法输入
输出格式:
学号每一项的完整说明。例如：
入学年份：2018年
学院：材料学院
班级：11
学号：03
注意：如非法输入，输出“Wrong Format"
输入样例:
在这里给出一组输入。例如：
18011103
输出样例:
在这里给出相应的输出。例如：
入学年份：2018年 学院：材料学院 班级：11 学号：03
输入样例1:
在这里给出一组输入。例如：
18013
输出样例1:
在这里给出相应的输出。例如：
Wrong Format
代码展示：
import java.util.Scanner; public class Main { public static void main(String[] args) { String a; String year,college,clas,num; Scanner in = new Scanner(System.in); a = in.next(); if(8!=a.length()) { System.out.print("Wrong Format"); return; } year = a.substring(0,2);//字符串内提取字符 college = a.substring(2,4); clas = a.substring(4,6); num = a.substring(6,8); if(college.equalsIgnoreCase("01")) { college = "材料学院"; }else if(college.equalsIgnoreCase("02")) { college = "机械学院"; }else if(college.equalsIgnoreCase("03")) { college = "外语学院"; }else if(college.equalsIgnoreCase("20")) { college = "软件学院"; }else { System.out.print("Wrong Format"); return; } System.out.print("入学年份：20"+year+"年\n" + "学院："+college+"\n" + "班级："+clas+"\n" + "学号："+num); } }
踩坑心得：a.substring(0,2)--字符串内提取字符，括号内前一个数字代表字符串开头，后一个数字代表字符串结尾(但不包含)；s.substring(a, b)表示截取下标从a开始到b结束的字符，包含第a个字符但是不包含第b个字符，可以看成[a,b)。
改进建议：最大复杂度（Max Complexity）和平均复杂度（Avg Complexity）几乎没有，要熟练java中的语法。
7-8 判断三角形类型
作者：段喜龙 单位：南昌航空大学
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。
输出格式:
（1）如果输入数据非法，则输出“Wrong Format”；
（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；
（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；
（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；
（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；
（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；
（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。
输入样例1:
在这里给出一组输入。例如：
50 50 50.0
输出样例1:
在这里给出相应的输出。例如：
Equilateral triangle
输入样例2:
在这里给出一组输入。例如：
60.2 60.2 80.56
输入样例3:
在这里给出一组输入。例如：
0.5 20.5 80
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
代码展示：
import java.util.Scanner; public class Main{ public static void main(String args[]){ Scanner in = new Scanner(System.in); double x,y,z,t; x = in.nextFloat(); y = in.nextFloat(); z = in.nextFloat(); if(x>y){ t=x;x=y;y=t; } if(x>z){ t=x;x=z;z=t; } if(y>z){ t=y;y=z;z=t; } if(x>=1&&x<=200&&y>=1&&y<=200&&z>=1&&z<=200){ if(x+y>z) { if (x == y && y == z) { System.out.print("Equilateral triangle\n"); }else if (x * x + y * y - z * z < 0.000001 && x == y) { System.out.print("Isosceles right-angled triangle\n"); } else if ((x==y&&x!=z)||(x==z&&x!=y)||(y==z&&y!=x)) { System.out.print("Isosceles triangle\n"); } else if (x * x + y * y - z * z<0.000001 ) { System.out.print("Right-angled triangle\n"); } else { System.out.print("General triangle\n"); } } else System.out.print("Not a triangle\n"); } else System.out.print("Wrong Format\n"); } }
踩坑心得：在此处不能使用x*x+y*y==z*z进行判断会有误差，因使用x * x + y * y - z * z < 0.000001，注意精度（double和float的使用），以及证明直角三角形存在误差，设置一个很小的误差比如0.000001。
改进建议：最大复杂度（Max Complexity）和平均复杂度（Avg Complexity）远超良好，完全不合格（😓），类（class）太少，要学会将问题拆分，降低耦合度，每个模块的类和函数只干自己的部分，函数嵌套太深，减少函数嵌套，培养拆分问题能力，是面向对象oop课程的关键点之一，
加强自己的注释，要记得写注释。
第三次作业
7-3 定义日期类.
作者：段喜龙 单位：南昌航空大学
定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。
注意：不允许使用Java中和日期相关的类和方法，否则按0分处理。
要求：Date类结构如下图所示：
输入格式:
在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。
输出格式:
- 当输入数据非法及输入日期不存在时，输出“Date Format is Wrong”；
- 当输入日期合法，输出下一天，格式如下：Next day is:年-月-日
输入样例1:
在这里给出一组输入。例如：
1912 12 25
输出样例1:
在这里给出相应的输出。例如：
Next day is:1912-12-26
输入样例2:
在这里给出一组输入。例如：
2001 2 30
输出样例2:
在这里给出相应的输出。例如：
Date Format is Wrong
代码展示：
import java.util.*; class Date{ private int day; private int month; private int year; int[] m = new int[] {0,31,28,31,30,31,30,31,31,31,30,31,30,31}; //无参构造 public void Date() { this.day = day; } public int getMonth() { return month; } public int getYear() { return year; } //含参构造 public void Date(int year , int month, int day) { this.day = day; this.month = month; this.year = year; } public void setDay(int day) { this.day = day; } public void setMonth(int month) { this.month = month; } public void setYear(int year) { this.year = year; } public int getDay() { return day; } public boolean isLeapYear(int year) { if(year%400==0||(year%100!=0 && year%4 == 0)) { return true; } else return false; } public boolean checkInputValidity() { boolean result = false; if(this.year>=1900&&this.year<=2000&&this.month>=1&&this.month<=12&&this.day>=1&&this.day<=31) { if(this.isLeapYear(year)) { if(this.day>29&&this.month==2){ result = false; } else { result = true; } } //闰年判定 else if(!this.isLeapYear(year)) { if(this.day>28&&this.month==2){ result = false; } else { result = true; } } } return result; } //具体日期+1情况讨论 public void getNextDate() { if(!this.isLeapYear(year)) { this.m[2]=28; } else if(this.isLeapYear(year)) { this.m[2]=29; } if(this.month==12) { if(this.day==31) { this.year=year+1; this.month=1; this.day=1; } else { this.day=this.day+1; this.year=year; this.month=month; } } else { if(this.day==this.m[this.month]) { this.month=month+1; this.day=1; this.year=year; } else { this.year=year; this.month=month; this.day=day+1; } } System.out.printf("Next day is:%d-%d-%d\n",this.year,this.month,this.day); } } public class Main { public static void main(String[] args) { Scanner in =new Scanner(System.in); int year = in.nextInt(); int month = in.nextInt(); int day = in.nextInt(); Date d = new Date(); d.setDay(day); d.setMonth(month); d.setYear(year); d.isLeapYear(year); d.checkInputValidity(); if(!d.checkInputValidity()) { System.out.println("Date Format is Wrong"); } else if(d.checkInputValidity()) { d.getNextDate(); } } }
踩坑心得：题干需求此案构建一个Date的类，运用了有参构造与无参构造。类里的year，month，day都进行了私有化，这些私有变量将用this.来获取。再用题目中构造反对函数来进行构建函数。首先闰年判断，在实现闰年判断后，判断每个月份的合理（1~12月），再就判断每个月的日期是否合理（30日和31日/2月份分闰年和非闰年对应29和28），然后判断加一天后日期是否合理，需要跨月份，最后是12月跨年份进行增加。类Date编写完成后，在主类Main中构件对象date（Date date = new Date();）就可以通过date.调用类中的方法。
改进建议：根据SourceMonitor显示，该代码大部分在绿色合理区域，在算法和构造无参含参方面要更加熟练，调用私有化变量，进行封装也需要更加熟练，注释量要增加！
7-4 日期类设计
作者：段喜龙 单位：南昌航空大学
参考题目3和日期相关的程序，设计一个类DateUtil，该类有三个私有属性year、month、day（均为整型数），其中，year∈[1820,2020] ,month∈[1,12] ,day∈[1,31] , 除了创建该类的构造方法、属性的getter及setter方法外，需要编写如下方法：
public boolean checkInputValidity();//检测输入的年、月、日是否合法 public boolean isLeapYear(int year);//判断year是否为闰年 public DateUtil getNextNDays(int n);//取得year-month-day的下n天日期 public DateUtil getPreviousNDays(int n);//取得year-month-day的前n天日期 public boolean compareDates(DateUtil date);//比较当前日期与date的大小（先后） public boolean equalTwoDates(DateUtil date);//判断两个日期是否相等 public int getDaysofDates(DateUtil date);//求当前日期与date之间相差的天数 public String showDate();//以“year-month-day”格式返回日期值
应用程序共测试三个功能：
- 求下n天
- 求前n天
- 求两个日期相差的天数
注意：严禁使用Java中提供的任何与日期相关的类与方法，并提交完整源码，包括主类及方法（已提供，不需修改）
程序主方法如下：
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int year = 0; int month = 0; int day = 0; int choice = input.nextInt(); if (choice == 1) { // test getNextNDays method int m = 0; year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); DateUtil date = new DateUtil(year, month, day); if (!date.checkInputValidity()) { System.out.println("Wrong Format"); System.exit(0); } m = input.nextInt(); if (m < 0) { System.out.println("Wrong Format"); System.exit(0); } System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:"); System.out.println(date.getNextNDays(m).showDate()); } else if (choice == 2) { // test getPreviousNDays method int n = 0; year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); DateUtil date = new DateUtil(year, month, day); if (!date.checkInputValidity()) { System.out.println("Wrong Format"); System.exit(0); } n = input.nextInt(); if (n < 0) { System.out.println("Wrong Format"); System.exit(0); } System.out.print( date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:"); System.out.println(date.getPreviousNDays(n).showDate()); } else if (choice == 3) { //test getDaysofDates method year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); int anotherYear = Integer.parseInt(input.next()); int anotherMonth = Integer.parseInt(input.next()); int anotherDay = Integer.parseInt(input.next()); DateUtil fromDate = new DateUtil(year, month, day); DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay); if (fromDate.checkInputValidity() && toDate.checkInputValidity()) { System.out.println("The days between " + fromDate.showDate() + " and " + toDate.showDate() + " are:" + fromDate.getDaysofDates(toDate)); } else { System.out.println("Wrong Format"); System.exit(0); } } else{ System.out.println("Wrong Format"); System.exit(0); } } }
输入格式:
有三种输入方式（以输入的第一个数字划分[1,3]）：
- 1 year month day n //测试输入日期的下n天
- 2 year month day n //测试输入日期的前n天
- 3 year1 month1 day1 year2 month2 day2 //测试两个日期之间相差的天数
输出格式:
- 当输入有误时，输出格式如下：
Wrong Format
- 当第一个数字为1且输入均有效，输出格式如下：
year1-month1-day1 next n days is:year2-month2-day2
- 当第一个数字为2且输入均有效，输出格式如下：
year1-month1-day1 previous n days is:year2-month2-day2
- 当第一个数字为3且输入均有效，输出格式如下：
The days between year1-month1-day1 and year2-month2-day2 are:值
输入样例1:
在这里给出一组输入。例如：
3 2014 2 14 2020 6 14
输出样例1:
在这里给出相应的输出。例如：
The days between 2014-2-14 and 2020-6-14 are:2312
输入样例2:
在这里给出一组输入。例如：
2 1834 2 17 7821
输出样例2:
在这里给出相应的输出。例如：
1834-2-17 previous 7821 days is:1812-9-19
输入样例3:
在这里给出一组输入。例如：
1 1999 3 28 6543
输出样例3:
在这里给出相应的输出。例如：
1999-3-28 next 6543 days is:2017-2-24
输入样例4:
在这里给出一组输入。例如：
0 2000 5 12 30
输出样例4:
在这里给出相应的输出。例如：
Wrong Format
代码展示：
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int year = 0; int month = 0; int day = 0; int choice = input.nextInt(); if (choice == 1) { // test getNextNDays method int m = 0; year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); DateUtil date = new DateUtil(year, month, day); if (!date.checkInputValidity()) { System.out.println("Wrong Format"); System.exit(0); } m = input.nextInt(); if (m < 0) { System.out.println("Wrong Format"); System.exit(0); } System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:"); System.out.println(date.getNextNDays(m).showDate()); } else if (choice == 2) { // test getPreviousNDays method int n = 0; year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); DateUtil date = new DateUtil(year, month, day); if (!date.checkInputValidity()) { System.out.println("Wrong Format"); System.exit(0); } n = input.nextInt(); if (n < 0) { System.out.println("Wrong Format"); System.exit(0); } System.out.print( date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:"); System.out.println(date.getPreviousNDays(n).showDate()); } else if (choice == 3) { //test getDaysofDates method year = Integer.parseInt(input.next()); month = Integer.parseInt(input.next()); day = Integer.parseInt(input.next()); int anotherYear = Integer.parseInt(input.next()); int anotherMonth = Integer.parseInt(input.next()); int anotherDay = Integer.parseInt(input.next()); DateUtil fromDate = new DateUtil(year, month, day); DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay); if (fromDate.checkInputValidity() && toDate.checkInputValidity()) { System.out.println("The days between " + fromDate.showDate() + " and " + toDate.showDate() + " are:" + fromDate.getDaysofDates(toDate)); } else { System.out.println("Wrong Format"); System.exit(0); } } else{ System.out.println("Wrong Format"); System.exit(0); } } } class DateUtil{ //私有化 private int year; private int month; private int day; private int [] mon_maxnum = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31}; //构造 public DateUtil() { } public DateUtil(int year,int month,int day) { this.year = year; this.month = month; this.day = day; } public int getYear() { return year; } public void setYear(int year) { this.year = year; } public int getMonth() { return month; } public void setMonth(int month) { this.month = month; } public int getDay() { return day; } public void setDay(int day) { this.day = day; } //判断 public boolean checkInputValidity(){ if(isLeapYear(year)){ mon_maxnum[2]=29; }else{ mon_maxnum[2]=28; } if(this.year<1820||this.year>2020||this.month<1||this.month>12||this.day<1||this.day>mon_maxnum[this.month]){ return false; }else{ return true; } } public boolean isLeapYear(int year){ if(year%400==0||(year%4==0&&year%100!=0)){ return true; }else{ return false; } }//计算 // // // public DateUtil getNextNDays(int n){ if(isLeapYear(year)){ mon_maxnum[2] = 29; }else{ mon_maxnum[2] = 28; } if(n>2100000000){ getNextNDays(2100000000); n -= 2100000000; } day = day + n; //***if或者while 等会测试 while(day>mon_maxnum[month]) { day = day - mon_maxnum[month]; month = month + 1; if (month == 13) { month = month - 12;//测试 year = year + 1; if (isLeapYear(year)) { mon_maxnum[2] = 29; } else { mon_maxnum[2] = 28; } } } return this; } public DateUtil getPreviousNDays(int n){ day = day - n; while(day<1){ if(isLeapYear(year)){ mon_maxnum[2]=29; }else{ mon_maxnum[2]=28; } month = month - 1; if(month==0){ month = month + 12;//测试 year = year -1; } day =day + mon_maxnum[month]; } return this; } public boolean compareDates(DateUtil date){ if(this.year>date.year||(this.year==date.year&&this.month>date.month)||(this.year==date.year&&this.month==date.month&&this.day>date.day)) { return true; }else{ return false; } } public boolean equalTwoDates(DateUtil date){ if(this.year==date.year&&this.month==date.month&&this.day==date.day) { return true; }else{ return false; } } public int getDaysofDates(DateUtil date){ int d = date.day - this.day; if(this.month>date.month){ for(int i = date.month;i<this.month;i++){ if(isLeapYear(date.year)){ mon_maxnum[2]=29; }else{ mon_maxnum[2]=28; } d =d - mon_maxnum[i]; } }else{ for (int j = this.month; j < date.month; j++) { if(isLeapYear(date.year)){ mon_maxnum[2]=29; }else{ mon_maxnum[2]=28; } d =d + mon_maxnum[j]; } } if(this.year > date.year) { int y = date.year; //测试 if(y>this.year){ if(isLeapYear(y)) { d = d - 366; }else{ y = y - 365; } y = y+1; } }else{ int y = this.year; while(date.year>y){ if(isLeapYear(y)) { d =d + 366; }else{ d =d + 365; } y = y+1; } } return d; } public String showDate(){ return year+"-"+month+"-"+day; } }
踩坑心得：前n天以及后n天会不会超过年份范围，月份范围，日期范围的算法运算，以及最大整型的取值范围是否会“爆开”。最大值与最小值的范围运算。在改进的过程中发现int的最大取值范围2147483647会报错，而取到2100000000时不会报错，说明取到日期最大不超过21000000000，
对于测试点的通过还要一次一次的测试，一般数据下对于日期测试调试时都是通过，对于每月最大日期用数组来表示，前提是数组第一个数不为一月，更好表示各个月份所代表的最大日期。其他会踩坑点大体与7-3一致。
改进建议：尽量减少代码繁琐，多加注释，测试数据要考虑极大值的取值，并且注意整型或浮点型是否能取得到，多思考算法考虑情况完全再进行提交，根据Source Monitor图标显示，平均复杂程度（Avg Complexity）与最大复杂度（Max Complexity）较高远超绿色良好范围，但函数嵌套不深，尽量减少函数复杂程度，注释量要达到良好水平。
总结
三次作业有时候会遇到困难，主要方面还是语法积累不足，以及对上课内容并没有完全理解，课下应该多自学语法内容，并且及时预习，上课时就不会茫然不知；对于面向对象程序设计这门课，更多的要学会将问题拆分化，降低类与类之间的耦合性，
增加内聚性，对于代码的优劣判断并不只是通过了测试，更应该是学会如何使代码更具有高效性，可维护性，可发展性，后面的作业学着对自己的代码进行注释，增加可读性。对老师的内容及时进行巩固，在后面的作业中做到一提就对！
