一.前言
第二次写Blog，相比较上一次初出茅庐而言有了些自己的经验，这次blog的书写相对来说要轻松些。内容上题目较少，但是说容易也并不容易，每一道题都是刺头中的刺头，这一次写博客，不仅仅是以完成任务的目的，更多的，让自己重新对那些打击过自己，折磨过自己的题目进行一次整体性的回顾。对于这次博客，我把它当作对自己过去几星期在JAVA里旅途的回望，对我付出无数心血的pta大作业的再一次审视，对我这段时间学习的一次总结。
第四次作业
1.菜单计价程序-4
题目只有一道题，但是题目难度较大。
第四次大作业主要考察点：
（1）：考察做题人对题目的理解程度和分析程度是否到位。经过几次菜单的迭代，这次大作业的题目文字有了明显的上涨，一个题目中包含了很多的要求。这就需要做题人有清晰的头脑和思想去读题，去分析题目所给的条件和问题。这次大作业中，新增加了很多的错误判断，这些不同错误的不同处理判断对于代码的结构是一次重大的考验，如果你的代码结构不清晰不完整，很有可能被其中一种错误判断钻了空子导致测试点过不去，而且这种逻辑错误很难发现。
（2）：考察做题人对于较高难度题目是否能从多方面进行思考的能力，能否从更全面的方向考虑问题的能力。对于这次大作业，迭代的是对于菜单，table，table旗下订单，删除等一系列的错误考虑，将几种错误排列组合起来，会发现要考虑的东西确实有非常多种情况。像订单里面混入了其他的菜单，错误的table下面的订单归顺上一桌等等。光是table一条语句的判断就有很多种情况，如属于wrongformat旗下的table格式错误，table超出范围的table num out of range等等不同情况，都考察着做题人能否从多方面思考的能力。
（3）：考察做题人对题目要求的简化能力以及对多变量关系的处理能力。随着代码量的上涨，如果正常来进行代码书写，我们需要新增加一些类去进行代码的功能和结构完善，像一些数据计算类和时间，格式的判断类等，能够在很大程度上去简化我们的代码，同时又不影响正常的工作。与此同时，随着多种判断的出现，不可避免的要增加一些语句和变量去适应这些判断，这对于多变量的处理也有一定的考验。
第五次作业
1.菜单计价程序-5
同样只有一道题目，但是难度较大。
第五次大作业主要考察点：
（1）：旨在考察做题人对于数据计算（如四舍五入）的准确把握能力。本次大作业是菜单三的另一种迭代，在菜单三的基础之上增加了多种特色菜，特色菜拥有他们独特的计价方式，因此，如果在计算时四舍五入不规范，就会导致计算出现1的偏差甚至更多。这对于做题人在计算与舍入的顺序上要进行一定的思考和测试，如这次作业的测试样例5，如果你的四舍五入没有设定在菜品价格累加那里，而是整体性四舍五入，就容易出现问题将73的答案算成72。
（2）：旨在考察做题人对于题目的读题能力，考察做题人能否理解题意，按照题目要求来进行代码编写和功能实现。比如这一次的菜单计算不同特色菜的辣度，酸度，甜度值的计算，正常来看，你会觉得没什么难度，直接对相同的特色菜进行度值乘以份数再除以份数就能解决的问题，但是如果你仔细看样例，你会发现在代点菜那个样例上，第一桌的晋菜的菜品数和酸度值都出现了偏差，与你自己计算table1的晋菜的菜品数和酸度值不相同，这是因为table2给table1点了一个晋菜，而这份晋菜的菜品数和酸度值算到了table1上。
（3）：旨在考察做题人对条件判断语句的编写能力，以及对类的合理创建。大作业对于输入语句的是否合理需要有语句去判断，其中用的比较多而实用性强的是正则表达式，而正则表达式的上手门槛不低，需要去仔细研究。同时，新的大作业对于类的需求也发生改变，我们可以通过自行的思考，创建一些新的类使我们更加方便的解题，如对特色菜采取继承，对数据创建类去进行整体性收集，对计算部分创建类去综合起来等等。
期中考试
1.测试1-圆类设计
2.测试2-类结构设计
3.测试3-继承与多态
4.测试4-抽象类与接口
期中考试四个题目同属于一种题型，呈现出按题目顺序进行迭代的方式进行着。
期中考试主要考察点：
（1）：旨在考察做题人对于类的设计是否娴熟。这次考试是几种类之间的组合和迭代，做题人需要根据题意去设计类，丰富类。
（2）：旨在考察做题人对于程序迭代的熟练程度，考察做题人是否能以一种清晰而明确的思路去解决连续性问题。按照题目的要求去解决相应的问题，并在上一步的基础上继续进行深入，这就是迭代所考察的能力。
二.设计与分析
第四次大作业：
这次大作业难度较大，需要进行深入分析。
下面是我这次作业菜单的类图：
Dish类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为4，Branches为0，calls为0，Comments为50，class为1，Method为0，Lines为6。
jisuan类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为54，Branches为31.5，calls为9，Comments为25.9，class为1，Method为3，Lines为85。
Main方法的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为171，Branches为35.1，calls为86，Comments为13.2，class为1，Method为1，Lines为243。
Menu类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为21，Branches为23.8，calls为10，Comments为28.6，class为1，Method为2，Lines为42。
Order类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为32，Branches为34.4，calls为1，Comments为16.9，class为1，Method为2，Lines为59。
Panduan类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为58，Branches为10.3，calls为15，Comments为23.2，class为1，Method为12，Lines为95。
Record类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为28，Branches为17.9，calls为1，Comments为6.3，class为1，Method为1，Lines为32。
Table类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为8，Branches为0，calls为0，Comments为0，class为1，Method为0，Lines为9。
主方法上：我创建了一系列对象（table，menu等）来进行主方法操作。创建了Spring字符串用来接收输入的字符，创建u来判断是否有table的记录输入而不是只有菜单。还有一系列记录table数，菜单菜品数的int变量。
在主要结构上，我采取多个while循环来进行功能的实现。第一个while循环用来处理最先输入的菜单语句。将该while语句与Panduan类中的正则表达式进行联合，如果输入了空语句或者不符合格式的菜品，就输出wrongformat，如果是end则结束程序，如果是table就跳出该while循环。如果输入的语句格式是正确的，则在该循环中进行进一步的判断。
如果输入的语句可能为菜品，进行下一步的判断，如果格式符合非特色菜，则按普通菜进行判断，价格超出范围就输出price out of range，如果都合理则记录该条语句，对于特色菜也是一致的，不同的是在读入特色菜时会将特色菜的special属性设为true，方便以后进行区分。
对于第二个while循环，我用它来处理table语句和普通的订单语句。结合Panduan类中的正则表达式，判断输入的table与正常语句是否符合基本的规则，如果不符合则输出wrongformat。输入的table如果符合基本的规则，则对table语句进行一系列的判断，如序号是否越界，日期是否超时，时间是否合法等。如果有不合理之处，输出相应的错误语句，同时标记该table使之无法输出。判断table的营业时间是否正确，不正确要输出不在营业时间。
对于正常的table将其记录下来，作为正常可以输出的table，输出table的基本信息。对于输入的普通记录，判断其是否合法，不合法输出wrongformat。如果数据合法，判断语句的正确性。如果输入的语句是完整的订单但是序号不是小到大排列，输出record serial number sequence error，如果所点的菜不存在输出菜品不存在，如果份额份数等出现问题也要输出相应的错误提示语句。普通菜和代点菜都有着相应的判断语句。
如果输入的记录是没问题的，再判断输入的记录是否为自己点菜和代点菜亦或者是普通菜和特殊菜的区别。为代点菜输出代点菜的信息，非代点输出非代点菜的信息。将完全合理的点菜记录记录下来，记录到相应的table之中。
还有一些判断如判断是否有菜单混入点菜记录，有删除记录的操作，删除记录中还有判断是否重复删除和错误删除的判断语句，对于每一种可能都进行相应的错误判断处理。
在主方法的最后，通过一个for循环将table的价格等信息输出，相同的table判断时间是否可以相叠加，如果可以将table合并。在输出table之前要进行一系列的判断，比如在不在营业时间等等。一项不符合则不能输出。
对于jisuan类：在该类中我设定了Yinye方法，运用simpleDateFormat，Date，calendar等类进行时间的计算，判断其范围是否合理。
同时，在该类中我设定了discount方法来专门计算table的折扣是多少。当折扣为零代表该table不营业。
在该类中，我设定了timetoTime方法去计算两个table的时间差值，来判断两桌table能否合并。
对于Panduan类：在该类中我设定了很多的正则表达式，如判断menu的格式，价格正确与否。
判断table的格式：
以及判断订单的，桌子时间的，判断删除语句，份额是否合理，份数是否合理，是否为代点菜，时间判断等等各种需求判断我都放在该类之中，进行一波统一。
Dish类：在该类中，我添加了一个属性special来标记该dish是否为特色菜品。
Menu类：在该类中，相比之前，我新增了一个搜寻dish的方法，并且将该方法的返回设定为返回dish，这样便于与我的Main方法进行合作。
Table类：在这次的table类中，我新添加了tablegood作为标记该table是否为合理而健康的table（可正常输出）所用的标记Boolean属性。
Order类：在这次的Order类中的计算价格方面，为了使计算准确没有偏差，我将非特色菜合在一起，特色菜合在一起，分别计算后再相加的方式来计算折扣总价。同时，我在Order中加入了numberJuage去判断序号是否符合从小到大的规则。
Record类：与上次大作业没有什么大的改动，在原有基础上增加了布尔变量判断record是否被删除
第五次大作业：
下面是我第五次大作业的类图：
daiDian类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为5，Branches为0，calls为0，Comments为0，class为1，Method为0，Lines为7。
Dish类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为4，Branches为0，calls为0，Comments为14.3，class为1，Method为0，Lines为7。
jisuan类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为54，Branches为0，calls为0，Comments为14.3，class为1，Method为0，Lines为86。
Juage类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为20，Branches为0，calls为8，Comments为13.9，class为1，Method为6，Lines为36。
Main类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为220，Branches为30，calls为97，Comments为4.7，class为1，Method为57，Lines为274。
Menu类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为21，Branches为23.8，calls为2，Comments为28.9，class为1，Method为4，Lines为38。
Order类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为58，Branches为27.6，calls为8，Comments为13.4，class为1，Method为6，Lines为97。
Record类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为31，Branches为16.1，calls为2，Comments为5.7，class为1，Method为15，Lines为35。
Table类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为12，Branches为0，calls为0，Comments为0，class为1，Method为0，Lines为14。
在Main方法中：我与之前几次大作业一样，在方法初设计了一系列对象以便后面的代码功能实现。不同以往的是，因为这次特色菜的缘故，我设计了DaiDian类用来装代点的菜系。ok整形变量用于检测是否只有菜而无订单，u用来记录table的个数，c用来判断是否有table输出。
在主方法中，我同样使用了两个while循环去实现对输入语句的处理，前者负责处理输入的菜单语句，后者负责输入的table和订单语句。菜单的判断上延续上一版，通过s字符串接收输入的字符串，用分隔符分开，同时对其和s进行判断，若为结束符则直接跳出，若为空语句或其他非法语句则输出wrongformat，若为table则转入下一个while语句之中。配合Juage类中的正则表达式，判断语句是否为菜品，若为菜品，再通过正则判断其是否为特殊菜，从而采取不同的存菜方式。当存入的菜品存在则覆盖，不存在则开辟新的空间去存入新菜。
在主方法中，第二个循环用于处理table语句和他的附属订单，同样的，如果输入结束符则跳出，在juage的正则下判断语句是否符合。另外，如果是第一桌table，则table不用新构建（起始构建过）；在该while循环中，想要存入订单，需要看当前的table是否为正常的table，所以在存入table前需要进行一波判断，这部分阶段同样运用正则表达式进行判断。如果table在营业时间内并且table状态良好，则符合输入订单的条件。
如果输入的订单符合普通订单（非代点菜），则通过普通订单判断存入table，特色菜加上special的处理，度值和数量的存入即可。如果输入的是代点菜的订单，则在存入该订单的基本信息时还要另外将该订单的基本信息存入新创建的类DaiDian类中，在最后计算度以及特色菜数量时带入计算。
在主方法的结尾，我设定了一个大for循环用于输出table以及他们的价格，度值和特色菜数量。
整形变量ta用来判断是否输出的菜系全为普通菜系。变量a为川菜的份数，b为晋菜的份数，d为浙菜的份数，e为川菜的度值，f为晋菜的度值，g为浙菜的度值。通过将他们的度值和份数分开来计算，可以很清晰的计算出每一个输出的结果。因为if，else太过于繁琐，可以用下方的switch语句来输出不同的结果（通过判断上述变量的值）。
在最后的输出用户名，手机号以及价格时，我同样运用for循环实现功能。第一个for循环用于合并符合合并条件的桌子，将他们的总价加在一起，只输出一个语句。后面的双for循环用于输出，排序。里面的for与外面的for一起合作将用户的名字以题目所要求的顺序依次输出。
Record类中：相比之前一代菜单，我在record里面顺应功能需求，增加了新的属性daidain用于判断该订单是否输入代点订单。
Menu类中：在原来的基础之上，我改良了addDish这一方法，以应对当特色菜存入菜单时的情况。如果原菜系中已经有该菜系，我需要一定的判断条件去证明它应该被修改，于是我加入了Lei这一条件，新加了一个addDish方法。
Table类中：相比上一次，我新加入了与table一一对应的PersonName用于存用于的名字，Number存放用户的手机号码，putong变量用来判断该桌是否代点过餐。
Order类中：根据这一次的大作业，对计价的计算进行一波调整，在每一个订单进行累加之前，先对单订单的价格进行四舍五入，再进行累加。
同时，在Order类中加入Du1用于计算该种特色菜类型的数量，Shu2计算该种特色菜类型的度数。
Jisuan类中：在该类中我设定了Yinye方法，运用simpleDateFormat，Date，calendar等类进行时间的计算，判断其范围是否合理。
同时，在该类中我设定了discount方法来专门计算table的折扣是多少。当折扣为零代表该table不营业。
在该类中，我设定了timetoTime方法去计算两个table的时间差值，来判断两桌table能否合并。
Juage类中：我设定了对菜单的（特色，非特色），table的，订单（特色，非特色，普通，代点）各种正则表达式用于判断。
Dish类中，我新加入了String 类型的T用于存入特色菜的类型。
DaiDain类中，该类中专门存放代点的菜，有属性fen用来记录代点菜的数量，有tableNumber用来记录被代点的桌号，Lei用来记录该代点菜的类型，du存放度的值。通过该类，我可以记录下所有代点菜的信息，从而方便我在最后计算table时将其加入计算行列。
期中考试：
期中作业整体难度不高，对四道题都进行一定程度的分析。
下面是我第一题的类图：
circle类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为6，Branches为0，calls为0，Comments为0，class为1，Method为2，Lines为9。
Main方法的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为13，Branches为百分之15.4，calls为6，Comments为0，class为1，Method为1，Lines为17。
对提交源码的分析：
主方法上：我设置了double变量radice来存储半径，写if，else判断语句判断输入的radice是否符合规则，如果radice无法应用于计算则输出错误输入的信息，否则输出圆的面积。
在circle类上：我设置了私有的radice作为该圆类的半径，通过set方法将输入的半径存入，通过output方法将计算出来的圆面积输出。
下面是我第二题的类图：
Main方法的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为12，Branches为0，calls为6，Comments为0，class为1，Method为1，Lines为15。
Point类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为14，Branches为0，calls为0，Comments为0，class为1，Method为5，Lines为20。
Rectangle类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为25，Branches为0，calls为7，Comments为0，class为1，Method为8，Lines为35。
主方法上：我设置了x,y两个double变量用来接收输入的第一个点的x,y坐标，设置相似的x1，y1接收输入的第二个点的x，y坐标。创建Point，Rectangle对象进行正常的程序执行。
Point类上：我设定了两个私有double变量存储该点的x，y值，通过含参构造方法将坐标带入，set方法用来设定坐标值，get方法输出x，y的值。
Rectangle类上：我设定了topLeftPoint和lowerRightPoint两个点来接收输入的上下点，并用他们进行计算面积值。get方法输出点，set方法接收点，getLength，getHeight方法用来输出两点间同一x或y距离，getArea用来计算并输出该长方形面积。
下面是我第三题的类图：
Circle类的的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为12，Branches为0，calls为1，Comments为0，class为1，Method为4，Lines为18。
Rectangle类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为25，Branches为0，calls为7，Comments为0，class为1，Method为8，Lines为34。
Point类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为14，Branches为0，calls为0，Comments为0，class为1，Method为5，Lines为20。
Main方法的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为26，Branches为26.9，calls为11，Comments为8.6，class为1，Method为2，Lines为35。
Shape类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为2，Branches为0，calls为1，Comments为0，class为1，Method为0，Lines为3。
主方法上：我编写了switch语句选择计算的是circle面积还是rectangle的面积，设置了x,y两个double变量用来接收输入的第一个点的x,y坐标，设置相似的x1，y1接收输入的第二个点的x，y坐标。创建Point，Rectangle，Point等对象进行正常的程序执行。设定printArea用来输出面积
Rectangle类上：我用rectangle继承Shape，设定了topLeftPoint和lowerRightPoint两个点来接收输入的上下点，并用他们进行计算面积值。get方法输出点，set方法接收点，getLength，getHeight方法用来输出两点间同一x或y距离，getArea用来计算并输出该长方形面积。
Shape类上：我设定Shape类作为长方形和圆的父类。
在circle类上：我用circle继承Shape，我设置了私有的radium作为该圆类的半径，通过set方法将输入的半径存入，通过output方法将计算出来的圆面积输出。
Point类上：我设定了两个私有double变量存储该点的x，y值，通过含参构造方法将坐标带入，set方法用来设定坐标值，get方法输出x，y的值。
下面是我第四题的类图：
Circle类的的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为12，Branches为0，calls为1，Comments为0，class为1，Method为4，Lines为18。
Rectangle类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为25，Branches为0，calls为7，Comments为0，class为1，Method为8，Lines为26。
Point类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为14，Branches为0，calls为0，Comments为0，class为1，Method为5，Lines为20。
Main方法的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为28，Branches为25.0，calls为16，Comments为11.4，class为1，Method为1，Lines为35。
Shape类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为6，Branches为16.7，calls为3，Comments为0，class为1，Method为1，Lines为8。
Comparable接口的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为2，Branches为0，calls为0，Comments为0，class为1，Method为1，Lines为6。
主方法上：我编写了switch语句选择计算的是circle面积还是rectangle的面积，设置了x,y两个double变量用来接收输入的第一个点的x,y坐标，设置相似的x1，y1接收输入的第二个点的x，y坐标。创建Point，Rectangle，Point等对象进行正常的程序执行。设定printArea用来输出面积。加入了动态数组来收集Shape对象，实现可以输出多个图形面积的功能，同时在主函数中加入可以排序的语句，将计算出的所有的Shape图形的面积进行排序。
Rectangle类上：我用rectangle继承Shape，设定了topLeftPoint和lowerRightPoint两个点来接收输入的上下点，并用他们进行计算面积值。get方法输出点，set方法接收点，getLength，getHeight方法用来输出两点间同一x或y距离，getArea用来计算并输出该长方形面积。
Shape类上：我设定Shape类作为长方形和圆的父类。我用Shape继承了Comparable接口的排序方法，在Shape中将其方法实现化。
在circle类上：我用circle继承Shape，我设置了私有的radium作为该圆类的半径，通过set方法将输入的半径存入，通过output方法将计算出来的圆面积输出。
Point类上：我设定了两个私有double变量存储该点的x，y值，通过含参构造方法将坐标带入，set方法用来设定坐标值，get方法输出x，y的值。
Comparable接口上：我设定了static int类型的CompareTo方法方便Shape去实现。
三.踩坑心得
第四次大作业：
部分原码如下：
if(table[a].tablegood==1)
{
table[a].tableNumber = Integer.valueOf(arr4[1]);
table[a].time1 = new String();
table[a].time2 = new String();
table[a].time1 = arr4[2];//年月日
String[] arr1 = arr4[2].split("/");//分割日期
int year = Integer.valueOf(arr1[0]);
int month = Integer.valueOf(arr1[1]);
int day = Integer.valueOf(arr1[2]);
String[] arr3 = arr4[3].split("/");//分割时间
int hour = Integer.valueOf(arr3[0]);//时
int minute = Integer.valueOf(arr3[1]);//分
int second = Integer.valueOf(arr3[2]);//秒
table[a].time2 = arr4[3];//时分秒
if(arr1[0].length()!=4||arr1[1].length()>2||arr1[1].length()==0||arr1[2].length()>2||arr1[2].length()==0||arr3[0].length()>2||arr3[0].length()==0||arr3[1].length()>2||arr3[1].length()==0||arr3[2].length()>2||arr3[2].length()==0) {
table[a].tablegood = 0;
System.out.println("wrong format");
}
if(year<1000||year>9999||month>12||month<1||day>31||day<0) {
table[a].tableDaterignt = 0;
}
if((year%4==0&&year%100!=0)||(year%400==0)){//闰年
if(month==2&&day>29) {
table[a].tableDaterignt = 0;
}
else if((month==4||month==6||month==9||month==11)&&day>30) {
table[a].tableDaterignt = 0;
}
}
else {//非闰年
if(month==2&&day>28) {
table[a].tableDaterignt = 0;
}
else if((month==4||month==6||month==9||month==11)&&day>30) {
table[a].tableDaterignt = 0;
}
}
if((hour>24||hour<0||minute>59||minute<0||second>59||second<0)) {
table[a].tableDaterignt = 0;
}
time1 = ace1.parse(arr4[2]);
if((time1.compareTo(time01)<0||time1.compareTo(time02)>0)&&table[a].tableDaterignt==1) {
table[a].tableDaterignt = 0;
System.out.println("wrong format");
table[a].tablegood=0;
}
if(table[a].tablegood==1) {
System.out.println("table "+table[a].tableNumber+":");
}
if(table[a].tableDaterignt==0) {
System.out.println(table[a].tableNumber+" date error");
}
1.第四次大作业错误点：
错误点1：在编写程序时没有注意到格式的问题，导致第一次上传分数十分惨淡。在输出语句的table后面加上空格后，很多的格式错误都变成了答案正确。
初始运行：
修改后：
这次错误让我了解到对于程序的编写应该注重对格式的严谨性，多打空格少打空格都应该仔细的检查。
错误点2：在进行while循环的编写过程之中我在while循环中多写了一次输入语句，这就导致我每次想得到运行结果时总是要多敲一下空格才能出答案，而且答案中间有一次空格。经过仔细检查，修改代码后分数来到65。
修改前：
修改后：
通过这次错误，我了解到逻辑错误对代码的致命性，当程序输入的答案正确，但是有个自己打的空格在其中混着，这样的错误难以发现，是非常致命的。我们在编写程序时，应该对如循环语句进行按步走的逻辑性检查，避免这样的事情发生。
错误点3：经过测试发现，当我输入了相同的table，而table的时间不相同时，我仍然将他们计算在一起，这就导致输出的答案错误，过不了测试点。经过修改判断table相加的条件，通过了测试样例。
通过这次错误，我又一次锻炼了自身对于代码逻辑性的敏感程度，了解到代码的逻辑应该与题设紧密联系。
错误点4：经过测试发现，我的table时间超出范围时，我的输出为wrongformat而不是超出范围，了解到自己的判断语句先后顺序上出现了问题，同时我发现自己在输出多个桌子的数据时，会出现时不时的非零返回，意识到自己的程序出现了漏洞，经过修改通过了table超出范围的测试点和多个桌子的情况。
修改前：
修改后：
经过这次错误，我重新强化了自己的代码，使其更加抗打，不容易因为多个数据的测试而出现崩溃的情况。
错误点5：在不停的修改过程中，我发现自己的代点菜测试点一直出现错误，经过测试后发现当给自己table代点菜时，这种情况应是不合理的，该按照错误判断去处理。经过修改后通过了测试点。、
通过这次错误，我了解到思考问题不应该局限，而应该举一反三，多方面的思考才能更加妥当的解决问题，多从出题人的角度去思考问题。
第五次大作业：
部分代码如下：
int ta = 0;
for (int x = 0; x <= tableIndex; x++) {
ta = 0;
if (tables[x].tableGood && tables[x].yinye) {
int a = 0,b=0,d=0,e=0,f=0,g=0;
System.out.print("table " + tables[x].tableNumber + ": " + (tables[x].order.getTotalPrice3() + tables[x].order.getTotalPrice4()) + " " + tables[x].order.getTotalPrice(tables[x].discount));
for(int i=0;i<c;i++) {
if (daiDians[i].tableNumber == tables[x].tableNumber) {
if (daiDians[i].Lei.equals("川菜")) {
e = e + daiDians[i].du;
a = a+daiDians[i].fen;
daiDians[i].Lei="wu";
} else if (daiDians[i].Lei.equals("晋菜")) {
f = f + daiDians[i].du;
b = b+daiDians[i].fen;
daiDians[i].Lei="wu";
} else if (daiDians[i].Lei.equals("浙菜")) {
g = g + daiDians[i].du;
d = d+daiDians[i].fen;
daiDians[i].Lei="wu";
}
}
}
switch (tables[x].order.Shu2("川菜",e,a)){
case 0:System.out.print(" 川菜 " + (tables[x].order.Du1("川菜")+a) + " 不辣");ta=1;break;
case 1:System.out.print(" 川菜 " + (tables[x].order.Du1("川菜") +a) +" 微辣");ta=1;break;
case 2:System.out.print(" 川菜 " + (tables[x].order.Du1("川菜") +a) +" 稍辣");ta=1;break;
case 3:System.out.print(" 川菜 " + (tables[x].order.Du1("川菜") +a) +" 辣");ta=1;break;
case 4:System.out.print(" 川菜 " + (tables[x].order.Du1("川菜") +a)+" 很辣");ta=1;break;
case 5:System.out.print(" 川菜 " + (tables[x].order.Du1("川菜") +a) +" 爆辣");ta=1;break;
case -1:break;
}
switch (tables[x].order.Shu2("晋菜",f,b)){
case 0:System.out.print(" 晋菜 " + (tables[x].order.Du1("晋菜")+ b)+ " 不酸");ta=1;break;
case 1: System.out.print(" 晋菜 " + (tables[x].order.Du1("晋菜")+ b)+ " 微酸");ta=1;break;
case 2: System.out.print(" 晋菜 " + (tables[x].order.Du1("晋菜") +b) +" 稍酸");ta=1;break;
case 3:System.out.print(" 晋菜 " + (tables[x].order.Du1("晋菜") +b)+ " 酸");ta=1;break;
case 4:System.out.print(" 晋菜 " + (tables[x].order.Du1("晋菜") +b)+" 很酸");ta=1;break;
case -1:break;
}
switch (tables[x].order.Shu2("浙菜",g,d)){
case 0:System.out.print(" 浙菜 " + (tables[x].order.Du1("浙菜") +d) +" 不甜");ta=1;break;
case 1:System.out.print(" 浙菜 " + (tables[x].order.Du1("浙菜") +d)+" 微甜");ta=1;break;
case 2: System.out.print(" 浙菜 " + (tables[x].order.Du1("浙菜") +d)+" 稍甜");ta=1;break;
case 3: System.out.print(" 浙菜 " + (tables[x].order.Du1("浙菜") +d)+" 甜");ta = 1;break;
case -1:break;
}
if(ta==0){
System.out.println(" ");
}else{
System.out.println();
}
}
}
for (int i = 0; i <= tableIndex; i++) {
if (tables[i].yinye && tables[i].tableGood) {
tables[i].tableMoney = tables[i].order.getTotalPrice(tables[i].discount);
}
}
for (int x = 0; x <= tableIndex; x++) {
int t = 0;
if (tables[t].tableGood && tables[t].yinye) {
for (int y = 0; y <= tableIndex; y++) {
if (tables[y].tableGood && tables[y].yinye) {
if(tables[y].PersonName.length()>tables[t].PersonName.length()){
t = y;
}
else if(tables[y].PersonName.length()==tables[t].PersonName.length()){
if(tables[y].PersonName.compareTo(tables[t].PersonName)<0) {
t = y;
}
}
if (tables[t].PersonName.equals(tables[y].PersonName) && t != y) {
tables[t].tableMoney = tables[t].tableMoney + tables[y].tableMoney;
tables[y].tableGood = false;
}
}
}
System.out.println(tables[t].PersonName + " " + tables[t].Number + " " + tables[t].tableMoney);
tables[t].tableGood = false;
}
}
}
}
1.第五次大作业错误点：
错误点1：因为读题不仔细错把各菜系的数量看成了度数的平均值，导致第一次提交只有9分（错误低级的我都想吐了，废物本废了属实）。经过修改计算度值，计算各菜系数量的代码后分数来到57。
修改前；
修改后：
经过这次错误，我重洗双眼，了解到读题真的对于编程来说很重要，对于java而言，按照用户要求去实现功能应是常态，如果不仔细读题，就如同不听用户的需求自己乱搞，这是不可取的。
错误点2：在测试样例5上卡住无法动弹，因为样例上的73被我硬生生算成了72（很难想象当时是怎么算多一的）。经过多次更换计算的四舍五入时机，成功的在每一订单相加时运用四舍五入算出了正确的73。（不容易啊！！！）修改后通过了一些测试点和样例5。
经过这次错误，我学习了另一种多方面思考的方式，通过不停的变换方法，改变其结构而达到不同的效果，这样往往能有奇效（瞎猫碰死耗子）。
错误点3：刚过了样例5，但定睛一看，可恶，样例6的特色菜数量和度值与标答出现了一定程度的偏差，在经过一定的交流之后，我了解到被点那桌也要加上特色菜的度值和数量，于是我新建了DaiDain类（就是这么诞生的），用于存放各种数据，在最后输出时将他们吐出，得到正确的结果。
修改前：
修改后：
经过这次错误，我对于供给与需求的理念有了新的认识，同时新学习了一些侧角度思考的技巧。
错误点4：在多次测试过后，我发现当我计算出来的特色菜辣度或其他度值为零时，我不会输出不辣或其他语句，导致我测试点过不去。经过修改switch语句输出了应该输出的平均值。
经过这次错误，我了解到自己不能随意的修改代码（本来我是写了这个switch分支的），更要清楚的了解题目所需，不能一味的按照自己的方式去编程。
错误点5：在多次测试后，发现自己卡在97无法动弹（太痛苦了）。在代点菜那块疯狂的测试，发现当自己给另一桌本来没有那种菜系的桌子点那种菜系，而该菜系还是不辣或其他度值为零的类型，我又不输出不辣或其他语句（服了），经过修改后拿到了满分。
修改前：
修改后：
经过这次错误，我了解到在编程的初期就应该搭好每一个框架，不能等到结尾的时候再来亡羊补牢，这样做会耗费大量的时间和精力，而且很有可能无法测出，得不偿失。
期中考试：
1.第一题较容易，未出现错误。注意java中的Π调用为Math.PI。
原码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
double radice = 0;
Scanner input = new Scanner(System.in);
circle circle = new circle();
radice = input.nextDouble();
if(radice<=0){
System.out.println("Wrong Format");
}else{
circle.set(radice);
double area = circle.output();
System.out.println(String.format("%.2f",area));
}
}
}
class circle{
private double radice;
public void set(double radice){
this.radice = radice;
}
public double output(){
double area = this.radice * this.radice * Math.PI;
return area;
}
}
2.第二题较容易，未出现错误。注意按照题目要求去建立类，根据类图了解类与类之间的关系。
原码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double x = input.nextDouble();
double y = input.nextDouble();
Point point1 = new Point(x,y);
double x1 = input.nextDouble();
double y1 = input.nextDouble();
Point point2 = new Point(x1,y1);
Rectangle rectangle = new Rectangle(point1,point2);
System.out.println(String.format("%.2f",rectangle.getArea()));
}
}
class Rectangle{
private Point topLeftPoint;
private Point lowerRightPoint;
public Point getTopLeftPoint(){
return topLeftPoint;
}
public Rectangle(Point a,Point b){
setLowerRightPoint(b);
setTopLeftPoint(a);
}
public void setTopLeftPoint(Point topLeftPoint){
this.topLeftPoint = topLeftPoint;
}
public Point getLowerRightPoint(){
return lowerRightPoint;
}
public void setLowerRightPoint(Point lowerRightPoint){
this.lowerRightPoint = lowerRightPoint;
}
public double getLength(){
double ping = topLeftPoint.getX()-lowerRightPoint.getX();
double length = Math.abs(ping);
return length;
}
public double getHeight(){
double ping = topLeftPoint.getY()-lowerRightPoint.getY();
double length = Math.abs(ping);
return length;
}
public double getArea(){
double area = this.getLength()*this.getHeight();
return area;
}
}
class Point{
private double x;
private double y;
public Point(double x,double y){
this.x = x;
this.y = y;
}
public void setX(double x){
this.x = x;
}
public void setY(double y){
this.x = x;
}
public double getX(){
return this.x;
}
public double getY(){
return this.y;
}
}
3.第三题出错点为：未考虑题目中要求的半径输出错误时的输出错误半径输入的要求，导致题目第一个测试点过不去。
第一次原码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
int choice = input.nextInt();
switch(choice) {
case 1://Circle
double radiums = input.nextDouble();
Shape circle = new Circle(radiums);
printArea(circle);
break;
case 2://Rectangle
double x1 = input.nextDouble();
double y1 = input.nextDouble();
double x2 = input.nextDouble();
double y2 = input.nextDouble();
Point leftTopPoint = new Point(x1,y1);
Point lowerRightPoint = new Point(x2,y2);
Rectangle rectangle = new Rectangle(leftTopPoint,lowerRightPoint);
printArea(rectangle);
break;
}
}
private static void printArea(Shape circle) {
System.out.println(String.format("%.2f",circle.getArea()));
}
}
abstract class Shape{
public abstract double getArea();
}
class Rectangle extends Shape{
private Point topLeftPoint;
private Point lowerRightPoint;
public Point getTopLeftPoint(){
return topLeftPoint;
}
public Rectangle(Point a,Point b){
setLowerRightPoint(b);
setTopLeftPoint(a);
}
public void setTopLeftPoint(Point topLeftPoint){
this.topLeftPoint = topLeftPoint;
}
public Point getLowerRightPoint(){
return lowerRightPoint;
}
public void setLowerRightPoint(Point lowerRightPoint){
this.lowerRightPoint = lowerRightPoint;
}
public double getLength(){
double ping = topLeftPoint.getX()-lowerRightPoint.getX();
double length = Math.abs(ping);
return length;
}
public double getHeight(){
double ping = topLeftPoint.getY()-lowerRightPoint.getY();
double length = Math.abs(ping);
return length;
}
public double getArea(){
double area = this.getLength()*this.getHeight();
return area;
}
}
class Point{
private double x;
private double y;
public Point(double x,double y){
this.x = x;
this.y = y;
}
public void setX(double x){
this.x = x;
}
public void setY(double y){
this.x = x;
}
public double getX(){
return this.x;
}
public double getY(){
return this.y;
}
}
class Circle extends Shape{
private double radiums = 0;
public Circle(double radiums){
setRadiums(radiums);
}
public double getRadiums(){
return radiums;
}
public void setRadiums(double radiums){
this.radiums = radiums;
}
@Override
public double getArea() {
double area = this.radiums * this.radiums * Math.PI;
return area;
}
}
运行结果：
在原来代码的基础上增加了判断错误半径的输出语句后，提交代码拿到了满分。
修改后的代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
int choice = input.nextInt();
switch(choice) {
case 1://Circle
double radiums = input.nextDouble();
if(radiums<=0){
System.out.println("Wrong Format");
}else{
Shape circle = new Circle(radiums);
printArea(circle);
}
break;
case 2://Rectangle
double x1 = input.nextDouble();
double y1 = input.nextDouble();
double x2 = input.nextDouble();
double y2 = input.nextDouble();
Point leftTopPoint = new Point(x1,y1);
Point lowerRightPoint = new Point(x2,y2);
Rectangle rectangle = new Rectangle(leftTopPoint,lowerRightPoint);
printArea(rectangle);
break;
}
}
private static void printArea(Shape circle) {
System.out.println(String.format("%.2f",circle.getArea()));
}
}
abstract class Shape{
public abstract double getArea();
}
class Rectangle extends Shape{
private Point topLeftPoint;
private Point lowerRightPoint;
public Point getTopLeftPoint(){
return topLeftPoint;
}
public Rectangle(Point a,Point b){
setLowerRightPoint(b);
setTopLeftPoint(a);
}
public void setTopLeftPoint(Point topLeftPoint){
this.topLeftPoint = topLeftPoint;
}
public Point getLowerRightPoint(){
return lowerRightPoint;
}
public void setLowerRightPoint(Point lowerRightPoint){
this.lowerRightPoint = lowerRightPoint;
}
public double getLength(){
double ping = topLeftPoint.getX()-lowerRightPoint.getX();
double length = Math.abs(ping);
return length;
}
public double getHeight(){
double ping = topLeftPoint.getY()-lowerRightPoint.getY();
double length = Math.abs(ping);
return length;
}
public double getArea(){
double area = this.getLength()*this.getHeight();
return area;
}
}
class Point{
private double x;
private double y;
public Point(double x,double y){
this.x = x;
this.y = y;
}
public void setX(double x){
this.x = x;
}
public void setY(double y){
this.x = x;
}
public double getX(){
return this.x;
}
public double getY(){
return this.y;
}
}
class Circle extends Shape{
private double radiums = 0;
public Circle(double radiums){
setRadiums(radiums);
}
public double getRadiums(){
return radiums;
}
public void setRadiums(double radiums){
this.radiums = radiums;
}
@Override
public double getArea() {
double area = this.radiums * this.radiums * Math.PI;
return area;
}
}
运行结果：
通过这次错误，我了解到要仔细的阅读题目，哪怕是一句不起眼的话也应该认真阅读到，不能想当然，要根据题目意思一步步完成目标。
4.第四题未出现错误。注意题目中所要求的在Shape中实现Comparable接口中的排序方法，注意输入不同数字对应switch的不同选择。
原码如下：
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
ArrayList<Shape> list = new ArrayList<>();
int choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1://Circle
double radiums = input.nextDouble();
Shape circle = new Circle(radiums);
list.add(circle);
break;
case 2://Rectangle
double x1 = input.nextDouble();
double y1 = input.nextDouble();
double x2 = input.nextDouble();
double y2 = input.nextDouble();
Point leftTopPoint = new Point(x1,y1);
Point lowerRightPoint = new Point(x2,y2);
Rectangle rectangle = new Rectangle(leftTopPoint,lowerRightPoint);
list.add(rectangle);
break;
}
choice = input.nextInt();
}
list.sort((shape, shape2) -> Shape.compareTo(shape, shape2));//正向排序
for(int i = 0; i < list.size(); i++) {
System.out.print(String.format("%.2f", list.get(i).getArea()) + " ");
}
}
}
abstract class Shape implements Comparable{
public abstract double getArea();
public static int compareTo(Shape shape, Shape shape2) {
if(shape.getArea()<shape2.getArea())
return -1;
return 0;
}
}
interface Comparable{
static int compareTo(Shape shape, Shape shape2) {
return 0;
}
}
class Rectangle extends Shape{
private Point topLeftPoint;
private Point lowerRightPoint;
public Point getTopLeftPoint(){
return topLeftPoint;
}
public Rectangle(Point a,Point b){
setLowerRightPoint(b);
setTopLeftPoint(a);
}
public void setTopLeftPoint(Point topLeftPoint){
this.topLeftPoint = topLeftPoint;
}
public Point getLowerRightPoint(){
return lowerRightPoint;
}
public void setLowerRightPoint(Point lowerRightPoint){
this.lowerRightPoint = lowerRightPoint;
}
public double getLength(){
double ping = topLeftPoint.getX()-lowerRightPoint.getX();
double length = Math.abs(ping);
return length;
}
public double getHeight(){
double ping = topLeftPoint.getY()-lowerRightPoint.getY();
double length = Math.abs(ping);
return length;
}
public double getArea(){
double area = this.getLength()*this.getHeight();
return area;
}
public static int compareTo(Shape shape, Shape shape2) {
if(shape2.getArea()>shape.getArea())
return 1;
return 0;
}
}
class Point{
private double x;
private double y;
public Point(double x,double y){
this.x = x;
this.y = y;
}
public void setX(double x){
this.x = x;
}
public void setY(double y){
this.x = x;
}
public double getX(){
return this.x;
}
public double getY(){
return this.y;
}
}
class Circle extends Shape{
private double radiums = 0;
public Circle(double radiums){
setRadiums(radiums);
}
public double getRadiums(){
return radiums;
}
public void setRadiums(double radiums){
this.radiums = radiums;
}
@Override
public double getArea() {
double area = this.radiums * this.radiums * Math.PI;
return area;
}
public static int compareTo(Shape shape, Shape shape2) {
if(shape2.getArea()>shape.getArea())
return 1;
return 0;
}
}
四.主要困难以及改进建议
困难1.：第四次大作业中，我在处理代码的结构上出现了很大的问题，因为这次大作业有着多层的判断，从菜单到table再到普通点菜记录，中间需要判断很多种情况。要考虑该语句是否合理，再去判断日期，序号等一系列的数据，当他们交叉起来，我需要设置一些Boolean型的变量去辅助判断，这就导致我的代码极其的复杂，当许多个变量混在一起的时候，我就经常弄混，导致错误频繁出现。
改进1：将我所设定的判断型变量放入判断类和相应的类中，如判断table是否合理的变量，我将其放入table类中，使其成为table的一种属性，通过这种方法我简化了Main方法，去掉了很多功能性的辅助变量，我可以直接调用他们而不用再去创建。这样使我后期纠正错误也变得简单了许多。
困难2：第五次大作业中，我在处理特色菜时卡在了代点菜的问题上，因为这次代点的菜如果是特色菜，它的度值和数量要记录到被点的那桌table上，而该记录的价格却还在代点那桌之上，这就导致在功能实现和结构处理上变得十分的困难，难以实现该功能。
改进2：在原来的基础上增加daiDian类，该类中专门存放代点的菜，该类中有属性fen用来记录代点菜的数量，有tableNumber用来记录被代点的桌号，Lei用来记录该代点菜的类型，du存放度的值。通过该类，我可以记录下所有代点菜的信息，从而方便我在最后计算table时将其加入计算行列。
困难3：在期中考试最后一题实现list排序过程中，我在程序编写排序时无法做到按照面积大小进行排序，所写的程序会将所排顺序颠倒，导致每次输出时都会出现面积混乱的情况发生。
改进3：我在Main中写入了 list.sort((shape, shape2) -> Shape.compareTo(shape, shape2));语句，通过Shape实现Comparable接口的排序功能，再由这条语句调用Shape内的接口方法实现Area排序。
五.总结
学习收获
通过这几周的学习，相比前一个月，我的编程能力得到了一定程度的提高，虽然我的编写依旧处于从慢到快的艰难过程，至少在结构编写上我有了更加清晰的思路去编写，在分析需求上和功能要求上比以前更加的准确和自然。学习编程不同于其他科目，对于数学等科目，你可以从目录进行一步一步的学习，有着一定的方向。而对于java的学习，感觉我一直在平行线上运动，遇到困难进行查阅解决，许多的知识都是相平行的，如果你发掘自己在某方面出现了不足，想要实现该功能却没有恰当方法，就会去学习新的编程知识，这种学习习惯的养成很大程度上是java学习所赋予我的。
1.我学习了对判断语句非常有用的正则表达式。正则表达式具有很多的优点：它帮助我匹配我所需要去判断的语句，类似于string类的matches()方法，正则表达式会与匹配语句进行对比，再给出判断的结果返回boolean值。熟练营用正则表达式，在捕获字符串上，匹配纯文本上有具有一定的优势，而且对于代码的节省很有作用。
2.我学习了java语法中的抽象类和接口。通过抽象类，我对于java中所说的面向对象有了更深一层的了解，抽象类的意义在于统领，将其他的相关类所组织起来，这便是抽象类的主要作用。在java语言中，可以用abstract 关键字来修饰一个类，使其成为抽象类。抽象类是它的所有子类的公共属性的集合，是包含一个或多个抽象方法的类。抽象类可以看作是对类的进一步抽象。在面向对象领域，抽象类主要用来进行类型隐藏。比如将animal设为抽象类，使其具有动物所具有的基本特征，具有动物特征的物体都可以成为他的子类，将plant设为抽象类，使其有植物所具有的基本特征，具有植物特征的物体可以成为他的子类。抽象类的概念来源于现实生活之中。这就使我们能在一个更高、更抽象的级别上考虑问题，从而简化了问题的复杂性。在Java程序中用抽象类（abstract class）来实现自然界的抽象概念。抽象类的作用在于将许多有关的类组织在一起，提供一个公共的类，而那些被组织在一起的具体的类作为其子类而派生出来。抽象类刻画了公有行为的特征，并通过继承机制传送给它的派生类。
3.我进一步的了解了关于JAVA中类，方法，属性之间的关系，在运用三者时，我从一开始的主函数功能堆积到现在的开始类与类分工，在结构和功能拆解上学到了很多新东西，这些知识对于我以后编写更长，功能更多，题目更复杂的代码能够保持清晰的思路，在修改代码纠正错误时也更加方便。并且我对于类的构建也越来越专业化和单一化，一个类所具有的功能不应该是多方面而繁琐的，应该是单一而有效的。
学习不足
通过这几周的学习，我虽然一直在学习，但是编程路上要记住的风景实在是太多了，我依然有很多不懂与不足的地方，这些弱点需要我去攻克，去破解。经过自我思考，我发现自己在以下几个方面需要去自我进一步的提升。
1.自己所编写的程序的代码量还是太大，相比其他人而已，编写同一次作业我需要差不多多100多行的代码，我尝试过缩减但是效果并不好，必须从整体上去进行改善，不然无法起到有效的代码删减，太多的代码量很影响自己的修改和维护，过多的代码量也会增加不必要的内存占用。
2.我对于拿到一个问题所产生的解题思路不够清晰，经常会走许多的弯路。我很难想出妥善的解决方法，遇到了问题没有一个清晰的解题思路，没有对题意有明确的认识，不知道怎么入手这个题目。如果自己没有一个好的思路，在解决程序问题方面比有思路的同学要多花很多的时间，而做出来的程序也不比别人的好，浪费了很多的时间。
3.自己没有敢于去尝试的习惯，喜欢安于现状，在编写程序的过程中我一般就使用自己常用的东西没有想过用其它的的方法，是不想去试也是没有用过对其他的方法不熟，导致需要用到其它方法解决问题的时候不知所措，在使用日期编写时没有采用日期类而是自己编写了一个类来计算日期，这就导致我的代码量直接多了两百行，到后面自己再去学日期类又花了很长时间，还要重新写日期方面的内容。
4.自己创建的类应该更具有”高内聚低耦合“这样一种特性，功能及数据的分配上我所创建的类在很多地方有交集，这导致我的代码功能重复较高，有很多代码没有起到实质性的功能，反而复杂了本身的程序，而且占据了一定的空间，使代码在运行上花费了更多的时间。
对其他方面的建议
1.希望大作业测试点能够说明的稍微更加清晰一些，有些测试点的提示太过于模糊而重复，从非偷懒的角度，我认为重复的测试点提示对于自身代码纠正错误的帮助不大。
2.希望在java的部分重要，实用而不易发现的基础知识部分老师能够多教授一些给我们，有些知识靠自己去找有些困难。
3.自己的代码量比别人的总是要多些，但不知道怎样去改正。
标签：语句,JAVA,Point,double,博客,class,table,第二次,public From： https://www.cnblogs.com/8318xwz/p/17397275.html