前言：
经过五次大作业的洗礼与折磨，相信大家已经被折磨疯掉了吧，经过上一次的blog总结经验我现在已经学会了blog的总结经验，接下来，我将会从这两次大作业即一次期中考试所涉及的知识点，难度以及题量还有我对这三次作业的看法这四个方面展开，有针对的展开一次总结性blog！
1.题量：
-
(1).第四次大作业：
对于第四次大作业而言，老师已经一改之前的作风了，因为之前除了菜单计价这个核心题目，还有一些大家可以用来保及格的题目，所以在之前题量可能会多一点点，但是老师秉持着为同学负责的态度，这次的题量也从之前的9道甚至更多变成了仅有的1道，题量甚少。
-
(2).第五次大作业：
第五次大作业中和第四次一样因为老师已经改变了之前的计划，不再让大家混分了之后，题量就变成了一道100分的题目，题目比较长，过程比较繁琐难度一下子就上来了。
-
(3).：期中考试
期中考试，一共有四道题，其中第四道题是最难的一道题目，最长的一道，题量中等，并不算太多。
2.难度：
-
(1).第四次大作业：
第四次大作业的难度，我认为说不难的人都是假的，怎么可能会不难，我觉得第四次大作业真的挺难的，差点要了老命，为什么会觉得难呢，其实也有我自己的一部分原因，因为第四次大作业是在第三次大作业的基础上进行改进的，第三次就是纯粹的正确输入，但是，万一输入一个并不是合法的输入呢，后果会怎么样，可想而知我们并不能控制用户的思维和想法，我们能做好的只有自己做到少bug甚至是0bug，这里用到的正则表达式我并没有牢牢地掌握，所以才导致了这次大作业对于我来说是非常的吃力的，我认为难度很大。
-
(2).第次五大作业：
在第五次大作业中，怎么说呢，按照剧情的发展难度应该是随着次数的增加而增加的，但是第五次大作业反而没有第四次大作业难了，当然了，这也仅仅是我个人的看法而已，因为他不是在第四次大作业之后做的叠加，而是在第三次大作业之后，但是呢我也在四舍五入的问题那里卡了好久好久，所以说难度还是有的。
-
(3).期中考试：
期中考试的难度的话应该是不太难的，好像有32个满分据老师所说，但是我没有满分，原因是没有听清老师的原话，就那个需要接口的方法，比较方法我实在是不太会，所以只能最后一题得一半的分数了，希望以后可以多听老师说的话，多去提前预习一些知识，总归是好的。
3.知识点：
-
(1).第四次大作业：
我认为第四次大作业学到的知识点集中起来的五个字正则表达式，的代码如下
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String p=scanner.nextLine();
Pattern pattern1=Pattern.compile("[1-2]");
Pattern pattern2=Pattern.compile("[1-299]+' '+'T'");
//boolean cheak=p.matches("table[ ]([1-9]|[1-9][0-9]+)[ ][0-9]{4}\\/([1-9]|[0-9]{2})\\/([1-9]|[0-9]{2})[ ]([1-9]|[0-9]{2})\\/([1-9]|[0-9]{2})\\/([1-9]|[0-9]{2})");
String []tokens=p.split(" |\\/");
boolean cheak=p.matches("^((\\d{2}(([02468][048])|([13579][26]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][1235679])|([13579][01345789]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))");
}
其中那段特别长的代码是用来判断一个输入的时间类型的字符串用s,spilt分割以后进行一个判断，如果合法日期，那么就输出ture，否则的话就是false了
还有一些就是一些细节上的技巧比如
m.matches(\\d{2})\\表达的意思是0-99的数字其中d就是[0-9]的简写
m.matches(\\d{0-5})\\表达的的意思是0-9组成的五位数字
-
(2).第五次大作业：
我在这次大作业中学到了Arraylist数组的用法
代码如下
ArrayList List = new ArrayList();
List.Add( “string” );
List.Add( 1 );`
向上面这种代码的写法其实并不实用了，以前的老程序员都是这样写的，现在jdk版本更新了可以使用泛化来限制数组的类型，因为菜单计价程序主要储存的就是一个Dish的菜谱信息。
应用泛化以后的代码如下：
ArrayList<String> List = new ArrayList<>();
List.Add( “string” );
List.Add( 1 );`
像经过泛化以后的代码List.add（1）就会报错，因为不是字符串类型。
Set<Integer> set=new HashSet<Integer>();
for(i=0;i<n;i++)
set.add(Integer.parseInt(s[i]));
if(set.size()==n)
System.out.println("NO");
else
System.out.println("YES");
这是HashSet的用法，这叫做哈希集合，他有一个特别强大的功能就是可以实现自动去重，所以只需要判断一下所生成的哈希数集的个数与n相比即可。
-
(3).期中考试：
在期中考试中前面三道题目其实没什么好讲的，重点就在于第四题的那个Comparabe接口代码如下：
class MyComparator implements Comparator<String>{
@Override
public int compare(String o0, String o1) {
if(o0.length()>o1.length())
return -1;
else if(o0.length()==o1.length())
return o0.compareToIgnoreCase(o1);
else
return 1;
}
}
这道题的方法居然是在包里面的直接调用其实就可以了，加个import java.util.*就行了，千万不要和我一样傻乎乎的去重写了个自己的接口。
4.我的看法：
关于我自己的看法，我对于这两次次大作业的看法是，通过这两次大作业，我们从中获得了许许多多的收获，比如对类的概念和语法的使用更加完善，对一些新奇的算法所吸引同时，我们也在一次次的失败中吸取经验，更加的细心，获得成长，在一次次分数积累的过程中，便是我们成长的见证，所以我认为这两次的大作业是对我们非常有益的，所以希望我们以后要一定要更加认真的对待大作业中的每一道题，因为以后大作业一定会越来越难的，所以我们必须要更加努力的学习！我对于期中考试的看法，我其实并不认为这样就能较好的体现对java的掌握情况，不过，也有所帮助吧，至少让我对自己哪里有所欠缺有了一个好的理解，这样在以后的学习生活才可以有更加明确的目标。
以上便是我对这次blog的前言做出的分析。
设计与分析：
我将会以三道菜单计价程序展开着重的分析，另外再对一些第三次作业中出现的新颖算法中出适当分析
-
菜单(1)：
题目如下：
7-1 菜单计价程序-4
分数 100
作者 蔡轲
单位 南昌航空大学
本体大部分内容与菜单计价程序-3相同，增加的部分用加粗文字进行了标注。
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 两个信息。
订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。
桌号标识独占一行，包含两个信息：桌号、时间。
桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。
点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。
不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。
删除记录格式：序号 delete
标识删除对应序号的那条点菜记录。
如果序号不对，输出"delete error"
代点菜信息包含：桌号 序号 菜品名称 份额 分数
代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。
程序最后按输入的桌号从小到大的顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。
每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。
折扣的计算方法（注：以下时间段均按闭区间计算）：
周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。
周末全价，营业时间：9:30-21:30
如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"
参考以下类的模板进行设计（本内容与计价程序之前相同，其他类根据需要自行定义）：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish addDish(String dishName,int unit_price)//添加一道菜品信息
}
点菜记录类：保存订单上的一道菜品记录
Record {
int orderNum;//序号
Dish d;//菜品\
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
delARecordByOrderNum(int orderNum)//根据序号删除一条记录
findRecordByNum(int orderNum)//根据序号查找一条记录
}
本次课题比菜单计价系列-3增加的异常情况：
1、菜谱信息与订单信息混合，应忽略夹在订单信息中的菜谱信息。输出："invalid dish"
2、桌号所带时间格式合法（格式见输入格式部分说明，其中年必须是4位数字，月、日、时、分、秒可以是1位或2位数），数据非法，比如：2023/15/16 ，输出桌号＋" date error"
3、同一桌菜名、份额相同的点菜记录要合并成一条进行计算，否则可能会出现四舍五入的误差。
4、重复删除，重复的删除记录输出"deduplication :"+序号。
5、代点菜时，桌号不存在，输出"Table number ："+被点菜桌号+" does not exist"；本次作业不考虑两桌记录时间不匹配的情况。
6、菜谱信息中出现重复的菜品名，以最后一条记录为准。
7、如果有重复的桌号信息，如果两条信息的时间不在同一时间段，（时段的认定：周一到周五的中午或晚上是同一时段，或者周末时间间隔1小时（不含一小时整，精确到秒）以内算统一时段），此时输出结果按不同的记录分别计价。
8、重复的桌号信息如果两条信息的时间在同一时间段，此时输出结果时合并点菜记录统一计价。前提：两个的桌号信息的时间都在有效时间段以内。计算每一桌总价要先合并符合本条件的饭桌的点菜记录，统一计价输出。
9、份额超出范围（1、2、3）输出：序号+" portion out of range "+份额，份额不能超过1位，否则为非法格式，参照第13条输出。
10、份数超出范围，每桌不超过15份，超出范围输出：序号+" num out of range "+份数。份数必须为数值，最高位不能为0，否则按非法格式参照第16条输出。
11、桌号超出范围[1,55]。输出：桌号 +" table num out of range"，桌号必须为1位或多位数值，最高位不能为0，否则按非法格式参照第16条输出。
12、菜谱信息中菜价超出范围（区间（0,300）），输出：菜品名+" price out of range "+价格，菜价必须为数值，最高位不能为0，否则按非法格式参照第16条输出。
13、时间输入有效但超出范围[2022.1.1-2023.12.31]，输出："not a valid time period"
14、一条点菜记录中若格式正确，但数据出现问题，如：菜名不存在、份额超出范围、份数超出范围，按记录中从左到右的次序优先级由高到低，输出时只提示优先级最高的那个错误。
15、每桌的点菜记录的序号必须按从小到大的顺序排列（可以不连续，也可以不从1开始），未按序排列序号的输出："record serial number sequence error"。当前记录忽略。（代点菜信息的序号除外）
16、所有记录其它非法格式输入，统一输出"wrong format"
17、如果记录以“table”开头，对应记录的格式或者数据不符合桌号的要求，那一桌下面定义的所有信息无论正确或错误均忽略，不做处理。如果记录不是以“table”开头，比如“tab le 55 2023/3/2 12/00/00”，该条记录认为是错误记录，后面所有的信息并入上一桌一起计算。
本次作业比菜单计价系列-3增加的功能：
菜单输入时增加特色菜，特色菜的输入格式：菜品名+英文空格+基础价格+"T"
例如：麻婆豆腐 9 T
菜价的计算方法：
周一至周五 7折， 周末全价。
注意：不同的四舍五入顺序可能会造成误差，请按以下步骤累计一桌菜的菜价：
计算每条记录的菜价：将每份菜的单价按份额进行四舍五入运算后，乘以份数计算多份的价格，然后乘以折扣，再进行四舍五入，得到本条记录的最终支付价格。
最后将所有记录的菜价累加得到整桌菜的价格。
输入格式:
桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数
最后一条记录以“end”结束。
输出格式:
1、桌号，格式：table+英文空格+桌号+”:”+英文空格
2、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价
输入样例1：
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9 T
table 31 2023/2/1 14/20/00
1 麻婆豆腐 1 16
2 油淋生菜 4 2
end
输出样例1:
份数超出范围+份额超出范围。例如：
table 31:
1 num out of range 16
2 portion out of range 4
table 31: 0 0
输入样例2:
桌号信息错误。例如：
麻婆豆腐 12
油淋生菜 9 T
table a 2023/3/15 12/00/00
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end
输出样例2:
在这里给出相应的输出。例如：
wrong format
输入样例3:
错误的菜谱记录。例如：
麻婆豆腐 12.0
油淋生菜 9 T
table 55 2023/3/31 12/00/00
麻辣香锅 15
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end
输出样例3:
在这里给出相应的输出。例如：
wrong format
table 55:
invalid dish
麻婆豆腐 does not exist
2 油淋生菜 14
table 55: 14 10
输入样例4:
桌号格式错误，不以“table”开头。例如：
麻婆豆腐 12
油淋生菜 9 T
table 1 2023/3/15 12/00/00
1 麻婆豆腐 1 1
2 油淋生菜 2 1
tab le 2 2023/3/15 12/00/00
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end
输出样例4:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 12
2 油淋生菜 14
wrong format
record serial number sequence error
record serial number sequence error
table 1: 26 17
我的源码如下：
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*输入：name表示菜品名称;unit_price是菜品价格;
计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）*/
class Main{
public static void main(String[] args){
int j=0,flag=1,i=-1,k=0,m=0,n=0,p=0,q=0,flag3=0;
Scanner scanner=new Scanner(System.in);
Menu menu=new Menu();
Rt rt=new Rt();
Panduan panduan=new Panduan();
while(true) {
String s = scanner.nextLine();//zuopanduan
if (s.equals("end"))
break;
if (s.matches("t(.*)")) {
if(s.matches("table(.*)")) {
if(s.matches("table[ ]([1-9]|[1-9][0-9]+)[ ][0-9]{4}\\/([0-9]|[0-9]{2})\\/([0-9]|[0-9]{2})[ ]([0-9]|[0-9]{2})\\/([0-9]|[0-9]{2})\\/([0-9]|[0-9]{2})")){
String []te=s.split(" |\\/");
LocalDate localDate1=LocalDate.of(2022,1,1);
LocalDate localDate2=LocalDate.of(2023,12,31);
String riqi=te[2]+"-"+te[3]+"-"+te[4];
String shijian=te[5]+"/"+te[6]+"/"+te[7];
if(!(te[1].matches("[1-9]|[1-4][0-9]|5[0-5]"))){
flag=0;
System.out.println(te[1]+" table num out of range");
} else if (!(riqi.matches("^((\\d{2}(([02468][048])|([13579][26]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][1235679])|([13579][01345789]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))"))||!shijian.matches("([0-9]|[0-1][0-9]|20|21|22|23)[/]([0-5][0-9])[/]([0-5][0-9])")) {
flag=0;
System.out.println(te[1]+" date error");
}else{
LocalDate localDate=LocalDate.of(Integer.parseInt(te[2]), Integer.parseInt(te[3]), Integer.parseInt(te[4]));
LocalDateTime localDateTime=LocalDateTime.of(Integer.parseInt(te[2]), Integer.parseInt(te[3]), Integer.parseInt(te[4]), Integer.parseInt(te[5]), Integer.parseInt(te[6]), Integer.parseInt(te[7]));
if(localDate.isBefore(localDate1)||localDate.isAfter(localDate2)){
flag=0;
System.out.println("not a valid time period");}
else if (panduan.panduan2(localDateTime)==0) {
flag=0;
System.out.println("table " + te[1] + " out of opening hours");
} else{
i++;
flag=1;
rt.tables[i] = new Table();
rt.tables[i].tablenum = Integer.parseInt(te[1]);
rt.tables[i].localDateTime=localDateTime;
System.out.println("table"+' '+te[1]+": ");
}
}
}
else{
flag=0;
System.out.println("wrong format");
}
}
else{
System.out.println("wrong format");}
//这里进行i不加对上一个桌的继承。
} else {
if (flag == 1) {
if (s.matches("([1-9]|[1-9][0-9]+)[ ]delete")) {
String[] dd = s.split(" ");//后续可能会有bug
if ((rt.tables[i].findRecordByNum(rt.tables[i], Integer.parseInt(dd[0]), rt.tables[i].i) != 1) && (rt.tables[i].findRecorddByNum(rt.tables[i], Integer.parseInt(dd[0]), rt.tables[i].j) != 1))
System.out.println("delete error;");
} else if (s.matches("([1-9]|[1-9][0-9]+)[ ]([1-9]|[1-9][0-9]+)[ ][\u4E00-\u9FA5]+[ ][0-9][ ]([1-9]|[1-9][0-9]+)")) {
String[] dd = s.split(" ");
flag3=0;
for (j = 0; j <= i; j++) {//判断自己给自己点菜
if (rt.tables[j].tablenum == Integer.parseInt(dd[0])){
flag3=1;
break;}
}
if(flag3==1){
if(rt.tables[j].tablenum==rt.tables[i].tablenum){
System.out.println("Table number ：" + dd[0] + " does not exist");
}
else if (menu.searthDish(dd[2]) == null)
System.out.println(dd[2] + " " + "does not exist");
else{
rt.tables[i].recordsd[rt.tables[i].j] = rt.tables[i].addaRecordd(menu, Integer.parseInt(dd[0]), Integer.parseInt(dd[1]), dd[2], Integer.parseInt(dd[3]), Integer.parseInt(dd[4]));
System.out.println(rt.tables[i].recordsd[rt.tables[i].j].orderNum + " table " + rt.tables[i].tablenum + " pay for table " + dd[0] + " " + rt.tables[i].recordsd[rt.tables[i].j].getPrice);
rt.tables[i].j++;}
} else
System.out.println("Table number ：" + dd[0] + " does not exist");
}//
else if (s.matches("([1-9]|[1-9][0-9]+)[ ][\u4E00-\u9FA5]+[ ][0-9][ ]([1-9]|[1-9][0-9]+)")) {
String[] bz = s.split(" ");
if (rt.tables[i].i!=0){
if(Integer.parseInt(bz[0])<= rt.tables[i].records[rt.tables[i].i-1].orderNum){
System.out.println("record serial number sequence error");
continue;}
}
if (menu.searthDish(bz[1])== null)
System.out.println(bz[1] + " " + "does not exist");
else if (!bz[2].matches("[1-3]") && menu.searthDish(bz[1]).flag == 1)
System.out.println(bz[0] + " portion out of range " + bz[2]);
else if (!bz[2].matches("[1-3]") && menu.searthDish(bz[1]).flag == 0) {
System.out.println(bz[0] + " portion out of range " + bz[2]);
} else if (!bz[3].matches("[1-9]|1[0-5]")) {
System.out.println(bz[0] + " num out of range " + bz[3]);
} else{
rt.tables[i].records[rt.tables[i].i] = rt.tables[i].addaRecord(menu, Integer.parseInt(bz[0]), bz[1], Integer.parseInt(bz[2]), Integer.parseInt(bz[3]));
System.out.println(bz[0] + " " + bz[1] + " " + rt.tables[i].records[rt.tables[i].i].getPrice);
rt.tables[i].i++;}
}
else if (s.matches("[\u4E00-\u9FA5]+[ ]([1-9]|[1-9][0-9]+)") || s.matches("[\u4E00-\u9FA5]+[ ]([1-9]|[1-9][0-9]+)[ ][T]")) {//进入菜单
if (i == -1) {
int flag1 = 0, flag2 = 1;
boolean cheak1 = s.matches("[\u4E00-\u9FA5]+[ ]([1-9]|[1-9][0-9]+)");
boolean cheak2 = s.matches("[\u4E00-\u9FA5]+[ ]([1-9]|[1-9][0-9]+)[ ][T]");
String[] tokens = s.split(" ");
if (cheak1) {
if (s.matches("[\u4E00-\u9FA5]+[ ]([1-9][0-9]?|[1-2][0-9]{2})"))
menu.addDish(tokens[0], Integer.parseInt(tokens[1]), flag1);
else
System.out.println(tokens[0] + " price out of range " + tokens[1]);
}
if (cheak2) {
if (s.matches("[\u4E00-\u9FA5]+[ ]([1-9][0-9]?|[1-2][0-9]{2})[ ][T]"))
menu.addDish(tokens[0], Integer.parseInt(tokens[1]), flag2);
else
System.out.println(tokens[0] + " price out of range " + tokens[1]);
}
} else
System.out.println("invalid dish");
} else {
System.out.println("wrong format");
}
}
}
}
for(j=0;j<=i;j++) {
if(rt.tables[j].flag==1){
for(k=j+1;k<=i;k++) {
if(rt.tables[k].tablenum==rt.tables[j].tablenum){
//rt.tables[k].flag=0;
if(panduan.panduan(rt.tables[k].localDateTime,rt.tables[j].localDateTime)!=0||panduan.panduan1(rt.tables[k].localDateTime,rt.tables[j].localDateTime)!=0){
rt.tables[k].flag=0;
for(m=0;m<rt.tables[j].i;m++){
if(rt.tables[j].records[m].flag==1){
for(n=m+1;n<rt.tables[j].i;n++){
if(rt.tables[j].records[n].portion==rt.tables[j].records[m].portion&&rt.tables[j].records[n].d.name==rt.tables[j].records[m].d.name){
rt.tables[j].records[n].flag=0;
rt.tables[j].records[m].num+=rt.tables[j].records[n].num;
}
}
}
for (p=0; p< rt.tables[k].i; p++) {
if (rt.tables[k].records[p].portion == rt.tables[j].records[m].portion && rt.tables[k].records[p].d.name == rt.tables[j].records[m].d.name) {
rt.tables[k].records[p].flag = 0;
rt.tables[j].records[m].num += rt.tables[k].records[p].num;
}
}
}
}//if
}
else{
for(m=0;m<rt.tables[j].i;m++){
if(rt.tables[j].records[m].flag==1){
for(n=m+1;n<rt.tables[j].i;n++){
if(rt.tables[j].records[n].portion==rt.tables[j].records[m].portion&&rt.tables[j].records[n].d.name==rt.tables[j].records[m].d.name){
rt.tables[j].records[n].flag=0;
rt.tables[j].records[m].num+=rt.tables[j].records[n].num;
}
}
}
for (p=0; p< rt.tables[j].j; p++) {
if (rt.tables[j].recordsd[p].portion == rt.tables[j].records[m].portion && rt.tables[j].records[p].d.name == rt.tables[j].records[m].d.name) {
rt.tables[j].recordsd[p].flag = 0;
rt.tables[j].records[m].num += rt.tables[j].recordsd[p].num;
}
}
}
}
}
}
}
for(j=0;j<=i;j++){
for(k=0;k<rt.tables[j].i;k++)
rt.tables[j].TotalPrice+=rt.tables[j].records[k].d.getPrice(rt.tables[j].records[k].portion)*rt.tables[j].records[k].num;
for(k=0;k<rt.tables[j].j;k++)
rt.tables[j].TotalPrice+=rt.tables[j].recordsd[k].d.getPrice(rt.tables[j].recordsd[k].portion)*rt.tables[j].recordsd[k].num;
for(k=0;k<rt.tables[j].i;k++)
rt.tables[j].TotalPricez+=panduan.jisuan(rt.tables[j],rt.tables[j].records[k]);
for(k=0;k<rt.tables[j].j;k++)
rt.tables[j].TotalPricez+=panduan.jisuan(rt.tables[j],rt.tables[j].recordsd[k]);
if(rt.tables[j].flag==1)
System.out.println("table"+" "+rt.tables[j].tablenum+": "+ rt.tables[j].TotalPrice+" "+rt.tables[j].TotalPricez);
}
/* for(int jj=0;jj<rt.tables[j].j;jj++)
rt.tables[j].TotalPrice+=rt.tables[j].recordsd[jj].getPrice;
for(int ii=0;ii<rt.tables[j].i;ii++)
rt.tables[j].TotalPrice+=rt.tables[j].records[ii].getPrice;
if(rt.tables[j].localDateTime.getDayOfWeek().getValue()>=1&&rt.tables[j].localDateTime.getDayOfWeek().getValue()<=5){
if()
/*if(rt.tables[j].localDateTime.getHour()*3600+rt.tables[j].localDateTime.getMinute()*60+rt.tables[j].localDateTime.getSecond()>=17*3600&&rt.tables[j].localDateTime.getHour()*3600+rt.tables[j].localDateTime.getMinute()*60+rt.tables[j].localDateTime.getSecond()<=20.5*3600){
rt.tables[j].TotalPricez=(int)Math.round(rt.tables[j].TotalPrice*0.8);
System.out.println("table "+rt.tables[j].tablenum+": "+rt.tables[j].TotalPrice+" "+rt.tables[j].TotalPricez);
}
else if (rt.tables[j].localDateTime.getHour()*3600+rt.tables[j].localDateTime.getMinute()*60+rt.tables[j].localDateTime.getSecond()>=10.5*3600&&rt.tables[j].localDateTime.getHour()*3600+rt.tables[j].localDateTime.getMinute()*60+rt.tables[j].localDateTime.getSecond()<=14.5*3600){
rt.tables[j].TotalPricez=(int)Math.round(rt.tables[j].TotalPrice*0.6);
System.out.println("table "+rt.tables[j].tablenum+": "+rt.tables[j].TotalPrice+" "+rt.tables[j].TotalPricez);
}
}
else{
if(rt.tables[j].localDateTime.getHour()*3600+rt.tables[j].localDateTime.getMinute()*60+rt.tables[j].localDateTime.getSecond()>=9.5*3600&&rt.tables[j].localDateTime.getHour()*3600+rt.tables[j].localDateTime.getMinute()*60+rt.tables[j].localDateTime.getSecond()<=21*3600)
System.out.println("table "+rt.tables[j].tablenum+": "+rt.tables[j].TotalPrice+" "+rt.tables[j].TotalPricez);
}
}*/
}
}
class Dish {
String name;
int flag=0;
int unit_price;
public Dish(String name,int unit_price){
this.name = name;
this.unit_price = unit_price;
}
public Dish(){
}
public int getPrice(int portion){
double unit_price1=unit_price;
if(portion==2)
unit_price1=1.5*unit_price;
if(portion==3)
unit_price1=2*unit_price;
return (int) Math.round(unit_price1);
}
}
/*输入：dishs菜品数组，用来保存所有菜品信息;
searthDish(String dishName)根据菜名在菜谱中查找菜品信息，返回Dish对象;参数类型为String，名称为dishName;
*/
class Menu {
public Dish[] dishs=new Dish[20];
int f=0;
Dish searthDish(String dishName){
int i;
int flag=0;
for(i=f-1;i>=0;i--){
flag=0;
if(dishs[i].name.equals(dishName)){
flag=1;break;
}
}
if(!(flag != 1))
return dishs[i];
else
return null;
}
public void addDish(String dishName,int unit_price,int flag){
dishs[f]=new Dish(dishName,unit_price);
dishs[f].flag=flag;
f++;
}
}
/*输入：d Dish类型的菜品;portion份额（1/2/3代表小/中/大份）getPrice()函数计价，计算本条记录的价格*/
class Record {
int tableNum;
int orderNum;//序号\
Dish d;//菜品\
int portion;//份额（1/2/3代表小/中/大份）\
int getPrice;
int num;
int flag=1;
}
class Table {
Record[] records = new Record[20];
Record[] recordsd = new Record[20];
int flag=1;
int TotalPrice;
int TotalPricez;
int i = 0;
int j = 0;
int tablenum;
LocalDateTime localDateTime;
/*public void setTablenum(int tablenum){
this.tablenum=tablenum;
}*/
public Record addaRecord(Menu menu, int orderNum, String dishName, int portion, int num) {
Record record = new Record();
record.orderNum = orderNum;
record.num = num;
record.d = menu.searthDish(dishName);
record.portion = portion;
if ((record.d != null))
record.getPrice = record.d.getPrice(portion) * num;
return record;
}
public Record addaRecordd(Menu menu, int tablenum, int orderNum, String dishName, int portion, int num) {
Record record = new Record();
record.tableNum = tablenum;
record.orderNum = orderNum;
record.num = num;
record.d = menu.searthDish(dishName);
record.portion = portion;
if ((record.d != null))
record.getPrice = record.d.getPrice(portion) * num;
return record;
}
public int findRecordByNum(Table table, int orderNum, int i) {
for (int k = 0; k < i; k++)
if (!(table.records[k].orderNum != orderNum)) {
if(table.records[k].num ==0){
System.out.println("deduplication "+orderNum);
return 1;
}else{
table.records[k].num = 0; //这里做删除；
return 1;}
}
return 0;
}//根据序号查找一条记录
public int findRecorddByNum(Table table, int orderNum, int j) {
for (int m = 0; m < j; m++)
if(table.records[m].num ==0){
System.out.println("deduplication "+orderNum);
return 1;
}else{
table.records[m].num= 0; //这里做删除；
return 1;}
return 0;
}//根据序号查找一条记录
}
class Rt{
Table tables[]=new Table[20];
}
class Panduan{
int panduan(LocalDateTime localDateTime1,LocalDateTime localDateTime2) {
if (localDateTime1.getDayOfWeek().getValue() <= 5 && localDateTime1.getDayOfWeek().getValue() >= 1 && localDateTime1.getDayOfWeek().getValue() == localDateTime2.getDayOfWeek().getValue()) {
if ((localDateTime1.getHour() * 3600 + localDateTime1.getMinute() * 60 + localDateTime1.getSecond() >= 17 * 3600 && localDateTime1.getHour() * 3600 + localDateTime1.getMinute() * 60 + localDateTime1.getSecond() <= 20.5 * 3600)&&(localDateTime2.getHour() * 3600 + localDateTime2.getMinute() * 60 + localDateTime2.getSecond() >= 17 * 3600 && localDateTime2.getHour() * 3600 + localDateTime2.getMinute() * 60 + localDateTime2.getSecond() <= 20.5 * 3600))
return 1;
if ((localDateTime1.getHour() * 3600 + localDateTime1.getMinute() * 60 + localDateTime1.getSecond() >= 10.5 * 3600 && localDateTime1.getHour() * 3600 + localDateTime1.getMinute() * 60 + localDateTime1.getSecond() <= 14.5 * 3600)&&(localDateTime2.getHour() * 3600 + localDateTime2.getMinute() * 60 + localDateTime2.getSecond() >= 10.5 * 3600 && localDateTime2.getHour() * 3600 + localDateTime2.getMinute() * 60 + localDateTime2.getSecond() <= 14.5 * 3600))
return 1;
}
return 0;
}
int panduan1(LocalDateTime localDateTime1,LocalDateTime localDateTime2){
if(localDateTime1.getDayOfWeek().getValue()<=7&&localDateTime1.getDayOfWeek().getValue()>=6&&localDateTime1.getDayOfWeek().getValue()==localDateTime2.getDayOfWeek().getValue()) {
if (Math.abs(localDateTime1.getHour() * 3600 + localDateTime1.getMinute() * 60 + localDateTime1.getSecond() - localDateTime2.getHour() * 3600 + localDateTime2.getMinute() * 60 + localDateTime2.getSecond()) < 3600)
return 1;
}
return 0;
}
int panduan2(LocalDateTime localDateTime){
if(localDateTime.getDayOfWeek().getValue()<=5&&localDateTime.getDayOfWeek().getValue()>=1){
if((localDateTime.getHour() * 3600 + localDateTime.getMinute() * 60 + localDateTime.getSecond() >= 17 * 3600 && localDateTime.getHour() * 3600 + localDateTime.getMinute() * 60 + localDateTime.getSecond() <= 20.5 * 3600)||(localDateTime.getHour() * 3600 + localDateTime.getMinute() * 60 + localDateTime.getSecond() >= 10.5 * 3600 && localDateTime.getHour() * 3600 + localDateTime.getMinute() * 60 + localDateTime.getSecond() <= 14.5 * 3600))
return 1;}
if(localDateTime.getDayOfWeek().getValue()<=7&&localDateTime.getDayOfWeek().getValue()>=6){
if(localDateTime.getHour() * 3600 + localDateTime.getMinute() * 60 + localDateTime.getSecond() >= 9.5 * 3600 && localDateTime.getHour() * 3600 + localDateTime.getMinute() * 60 + localDateTime.getSecond() <= 21.5*3600)
return 1;
}
return 0;
}
int jisuan(Table table,Record record){
if(record.d.flag==0){
if(table.localDateTime.getDayOfWeek().getValue()<=5&&table.localDateTime.getDayOfWeek().getValue()>=1){
if(table.localDateTime.getHour() * 3600 + table.localDateTime.getMinute() * 60 + table.localDateTime.getSecond() >= 17 * 3600 && table.localDateTime.getHour() * 3600 + table.localDateTime.getMinute() * 60 + table.localDateTime.getSecond() <= 20.5 * 3600)
return (int)Math.round(record.d.getPrice(record.portion)*record.num*0.8);
else if (table.localDateTime.getHour() * 3600 + table.localDateTime.getMinute() * 60 + table.localDateTime.getSecond() >= 10.5 * 3600 && table.localDateTime.getHour() * 3600 + table.localDateTime.getMinute() * 60 + table.localDateTime.getSecond() <= 14.5 * 3600){
return (int)Math.round(record.d.getPrice(record.portion)*record.num*0.6);
}
}
else{
return record.d.getPrice(record.portion)*record.num;
}
}
else{
if(table.localDateTime.getDayOfWeek().getValue()<=5&&table.localDateTime.getDayOfWeek().getValue()>=1)
return (int)Math.round(record.d.getPrice(record.portion)*record.num*0.7);
else
return record.d.getPrice(record.portion)*record.num;
}
return 1;
}
}
设计思路：
我的设计思路是，由于这次的错误输入比较的多，所以在开始写代码前必须有一个十分清晰的思路
首先需要明确的分析究竟有几种类别的正则表达式，比如下面这行代码就是用来判断含有table行的代码是否符合正确输入的格式：
if(s.matches("table[ ]([1-9]|[1-9][0-9]+)[ ][0-9]{4}\\/([0-9]|[0-9]{2})\\/([0-9]|[0-9]{2})[ ]([0-9]|[0-9]{2})\\/([0-9]|[0-9]{2})\\/([0-9]|[0-9]{2})"))
再比如这个是用来判断是否是输入菜谱的判断：
else if (s.matches("[\u4E00-\u9FA5]+[ ]([1-9]|[1-9][0-9]+)") || s.matches("[\u4E00-\u9FA5]+[ ]([1-9]|[1-9][0-9]+)[ ][T]"))
还有许许多多类似的判断，其实都大同小异，这里便不再赘述。
然后呢分好类之后，就要根据不同的部分进行相应的操作，输入菜谱这块的话，需要先用split方法将字符串以空格分隔，然后将分好的存进一个数组当中，接着把菜名和菜价存进已经new好的dish数组当中，这就是菜谱的存储方法，接着就是像订单啊之类的操作。其实和这个都有所相似，细节不同而已。
然后将代点菜的操作完成之后，删除的代码也补上，就到了最后的计算总价的环节了，这里要注意时间不同打的折扣也不同，所以还要进行四舍五入的操作，然后根据tables数组的顺序，依次输出每桌的折扣前的价格和折扣后的价格，就大功告成了。
类图如下：
关系报表图如下：
对类图报表及代码的分析与解释：
类图分析：
可以从类图看出，此题我使用了六个类，分别是record类，Dish类，Main类，Menu类和Table类，还有一个时间判断的类。
报表分析
Lines： 指的是代码总行数
Statements：语句的行数，语句是以分号结尾的。这个C中有所不同。
Percent Branch Statement：分支数占总语句数的百分比
Method Call Statement：方法调用语句数
Percent Lines with Comments：注释语句占总语句数的百分比
Classes and Interfaces：类和接口数
Methods per Class：每个类平均包含函数个数
Average Statements per Method：每个函数平均包含的语句个数
函数复杂度（Function Complexity）复杂
所以从图中不难看出，在这几个方面中，达到绿色的是比较良好的代码，而红色超出绿色范围的则是不太良好的代码，我的这个大部分在范围内，只有class类可能不太妥当，然后红色的范围是比较不合格的，另外圈复杂度也控制在了平均6.62的一个数据，最高的圈复杂度是13，比较高，总体的话还行，以后写代码的时候要尽可能地去降低自己代码的复杂度才可以实现代码更好的可维护性和可移植性。
-
菜单5：
题目的话我就不写了太长了，其实和上次的差不多就多了几个特色菜而已，下面只给出我的源代码吧。
我的源码如下：
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*输入：name表示菜品名称;unit_price是菜品价格;
计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）*/
class Main{
public static void main(String[] args){
int j=0,flag=1,i=-1,k=0,m=0,n=0,p=0,q=0,g=0;
Scanner scanner=new Scanner(System.in);
Menu menu=new Menu();
Rt rt=new Rt();
Panduan panduan=new Panduan();
Kouwd kouwd=new Kouwd();
while(true) {
String s = scanner.nextLine();//zuopanduan
if (s.equals("end"))
break;
if(s.matches("table(.*)")) {
if(s.matches("table[ ]([1-9]|[1-9][0-9]+)[ ][:][ ]([a-z]|[A-Z]){1,10}[ ](180|181|189|133|135|136)[0-9]{8}[ ][0-9]{4}\\/([0-9]|[0-9]{2})\\/([0-9]|[0-9]{2})[ ]([0-9]|[0-9]{2})\\/([0-9]|[0-9]{2})\\/([0-9]|[0-9]{2})")){
String []te=s.split(" |\\/");
LocalDateTime localDateTime=LocalDateTime.of(Integer.parseInt(te[5]), Integer.parseInt(te[6]), Integer.parseInt(te[7]), Integer.parseInt(te[8]), Integer.parseInt(te[9]), Integer.parseInt(te[10]));
if (panduan.panduan2(localDateTime)==0) {
flag=0;
System.out.println("table " + te[1] + " out of opening hours");
} else{
i++;
flag=1;
rt.tables[i] = new Table();
rt.tables[i].tablenum = Integer.parseInt(te[1]);
rt.tables[i].name = te[3];
rt.tables[i].code = te[4];
rt.tables[i].localDateTime=localDateTime;
System.out.println("table"+' '+te[1]+": ");
}
}
else{
flag=0;
System.out.println("wrong format");
}
}
else {
if (flag == 1) {
/*1删除*/ if (s.matches("([1-9]|[1-9][0-9]+)[ ]delete")) {
String[] dd = s.split(" ");//后续可能会有bug
if ((rt.tables[i].findRecordByNum(rt.tables[i], Integer.parseInt(dd[0]), rt.tables[i].i) != 1) && (rt.tables[i].findRecorddByNum(rt.tables[i], Integer.parseInt(dd[0]), rt.tables[i].j) != 1))
System.out.println("delete error;");
} /*2带点菜订单*/else if (s.matches("([1-9]|[1-9][0-9]+)[ ]([1-9]|[1-9][0-9]+)[ ][\u4E00-\u9FA5]+[ ][0-9][ ]([1-9]|[1-9][0-9]+)")) {
String[] dd = s.split(" ");
if (menu.searthDish(dd[2]) == null)
System.out.println(dd[2] + " " + "does not exist");
else{
rt.tables[i].recordsd[rt.tables[i].j] = rt.tables[i].addaRecordd(menu, Integer.parseInt(dd[0]), Integer.parseInt(dd[1]), dd[2],-1, Integer.parseInt(dd[3]), Integer.parseInt(dd[4]));
System.out.println(rt.tables[i].recordsd[rt.tables[i].j].orderNum + " table " + rt.tables[i].tablenum + " pay for table " + dd[0] + " " + rt.tables[i].recordsd[rt.tables[i].j].getPrice);
rt.tables[i].j++;}
}//
/*3订单*/ else if (s.matches("([1-9]|[1-9][0-9]+)[ ][\u4E00-\u9FA5]+[ ][0-9][ ]([1-9]|[1-9][0-9]+)")) {
String[] bz = s.split(" ");
if (menu.searthDish(bz[1])== null)
System.out.println(bz[1] + " " + "does not exist");
else{
rt.tables[i].records[rt.tables[i].i] = rt.tables[i].addaRecord(menu, Integer.parseInt(bz[0]), bz[1],-1, Integer.parseInt(bz[2]), Integer.parseInt(bz[3]));
System.out.println(bz[0] + " " + bz[1] + " " + rt.tables[i].records[rt.tables[i].i].getPrice);
rt.tables[i].i++;}
} /*4特色带点*/else if (s.matches("([1-9]|[1-9][0-9]+)[ ]([1-9]|[1-9][0-9]+)[ ][\u4E00-\u9FA5]+[ ]([0-9]|[1-9][0-9]+)[ ][0-9][ ]([1-9]|[1-9][0-9]+)")) {
String []td=s.split(" ");
if (menu.searthDish(td[2]) == null)
System.out.println(td[2] + " " + "does not exist");
else if (menu.searthDish(td[2]).flag==1) {
if(Integer.parseInt(td[3])>5||Integer.parseInt(td[3])<0)
System.out.println("spicy num out of range :"+td[3]);
else{
rt.tables[i].recordsd[rt.tables[i].j] = rt.tables[i].addaRecordd(menu, Integer.parseInt(td[0]), Integer.parseInt(td[1]), td[2],Integer.parseInt(td[3]), Integer.parseInt(td[4]), Integer.parseInt(td[5]));
//rt.tables[Integer.parseInt(td[0])].recordtd[rt.tables[Integer.parseInt(td[0])].k]=rt.tables[Integer.parseInt(td[0])].addaRecortd(menu, Integer.parseInt(td[0]), Integer.parseInt(td[1]), td[2],Integer.parseInt(td[3]), Integer.parseInt(td[4]), Integer.parseInt(td[5]));
System.out.println(rt.tables[i].recordsd[rt.tables[i].j].orderNum + " table " + rt.tables[i].tablenum + " pay for table " + td[0] + " " + rt.tables[i].recordsd[rt.tables[i].j].getPrice);
rt.tables[i].j++;}
}
else if(menu.searthDish(td[2]).flag==2){
if(Integer.parseInt(td[3])>4||Integer.parseInt(td[3])<0)
System.out.println("acidity num out of range :"+td[3]);
else{
rt.tables[i].recordsd[rt.tables[i].j] = rt.tables[i].addaRecordd(menu, Integer.parseInt(td[0]), Integer.parseInt(td[1]), td[2],Integer.parseInt(td[3]), Integer.parseInt(td[4]), Integer.parseInt(td[5]));
//rt.tables[Integer.parseInt(td[0])].recordtd[rt.tables[Integer.parseInt(td[0])].k]=rt.tables[Integer.parseInt(td[0])].addaRecortd(menu, Integer.parseInt(td[0]), Integer.parseInt(td[1]), td[2],Integer.parseInt(td[3]), Integer.parseInt(td[4]), Integer.parseInt(td[5]));
System.out.println(rt.tables[i].recordsd[rt.tables[i].j].orderNum + " table " + rt.tables[i].tablenum + " pay for table " + td[0] + " " + rt.tables[i].recordsd[rt.tables[i].j].getPrice);
rt.tables[i].j++;}
}
else if(menu.searthDish(td[2]).flag==3){
if(Integer.parseInt(td[3])>3||Integer.parseInt(td[3])<0)
System.out.println("sweetness num out of range :"+td[3]);
else{
rt.tables[i].recordsd[rt.tables[i].j] = rt.tables[i].addaRecordd(menu, Integer.parseInt(td[0]), Integer.parseInt(td[1]), td[2],Integer.parseInt(td[3]), Integer.parseInt(td[4]), Integer.parseInt(td[5]));
// rt.tables[Integer.parseInt(td[0])].recordtd[rt.tables[Integer.parseInt(td[0])].k]=rt.tables[Integer.parseInt(td[0])].addaRecortd(menu, Integer.parseInt(td[0]), Integer.parseInt(td[1]), td[2],Integer.parseInt(td[3]), Integer.parseInt(td[4]), Integer.parseInt(td[5]));
System.out.println(rt.tables[i].recordsd[rt.tables[i].j].orderNum + " table " + rt.tables[i].tablenum + " pay for table " + td[0] + " " + rt.tables[i].recordsd[rt.tables[i].j].getPrice);
rt.tables[i].j++;}
}
}/*5特色菜自己输入*/ else if (s.matches("([1-9]|[1-9][0-9]+)[ ][\u4E00-\u9FA5]+[ ]([0-9]|[1-9][0-9]+)[ ][0-9][ ]([1-9]|[1-9][0-9]+)")) {
String []tz=s.split(" ");
if (menu.searthDish(tz[1])== null)
System.out.println(tz[1] + " " + "does not exist");
else if (menu.searthDish(tz[1]).flag==1) {
if(Integer.parseInt(tz[2])>5||Integer.parseInt(tz[2])<0)
System.out.println("spicy num out of range :"+tz[2]);
else{
rt.tables[i].records[rt.tables[i].i] = rt.tables[i].addaRecord(menu, Integer.parseInt(tz[0]), tz[1],Integer.parseInt(tz[2]), Integer.parseInt(tz[3]), Integer.parseInt(tz[4]));
System.out.println(tz[0] + " " + tz[1] + " " + rt.tables[i].records[rt.tables[i].i].getPrice);
rt.tables[i].i++;}
}
else if(menu.searthDish(tz[1]).flag==2){
if(Integer.parseInt(tz[2])>4||Integer.parseInt(tz[2])<0)
System.out.println("acidity num out of range :"+tz[2]);
else{
rt.tables[i].records[rt.tables[i].i] = rt.tables[i].addaRecord(menu, Integer.parseInt(tz[0]), tz[1],Integer.parseInt(tz[2]), Integer.parseInt(tz[3]), Integer.parseInt(tz[4]));
System.out.println(tz[0] + " " + tz[1] + " " + rt.tables[i].records[rt.tables[i].i].getPrice);
rt.tables[i].i++;}
}
else if(menu.searthDish(tz[1]).flag==3){
if(Integer.parseInt(tz[2])>3||Integer.parseInt(tz[2])<0)
System.out.println("sweetness num out of range :"+tz[2]);
else{
rt.tables[i].records[rt.tables[i].i] = rt.tables[i].addaRecord(menu, Integer.parseInt(tz[0]), tz[1],Integer.parseInt(tz[2]), Integer.parseInt(tz[3]), Integer.parseInt(tz[4]));
System.out.println(tz[0] + " " + tz[1] + " " + rt.tables[i].records[rt.tables[i].i].getPrice);
rt.tables[i].i++;}
}}
/*6菜谱输入*/ else if (s.matches("[\u4E00-\u9FA5]+[ ]([1-9]|[1-9][0-9]+)")) {//进入菜单
String[] tokens = s.split(" ");
menu.addDish(tokens[0], Integer.parseInt(tokens[1]), 0);
}
else if (s.matches("[\u4E00-\u9FA5]+[ ](川菜|晋菜|浙菜)[ ]([1-9]|[1-9][0-9]+)[ ][T]")) {
String[] tokens1 = s.split(" ");
if(tokens1[1].equals("川菜")){
menu.addDish(tokens1[0], Integer.parseInt(tokens1[2]), 1);}
else if (tokens1[1].equals("晋菜")){
menu.addDish(tokens1[0], Integer.parseInt(tokens1[2]), 2);}
else if(tokens1[1].equals("浙菜")){
menu.addDish(tokens1[0], Integer.parseInt(tokens1[2]), 3);}
}
else {
System.out.println("wrong format");
}
}
}
}
for(j=0;j<=i;j++){
for(k=0;k<rt.tables[j].j;k++){
if(rt.tables[j].recordsd[k].d.flag!=0&&rt.tables[j].recordsd[k].num!=0){
for(p=0;p<=i;p++) {
if (rt.tables[p].tablenum == rt.tables[j].recordsd[k].tableNum) {
rt.tables[p].recordtd[rt.tables[p].k] = rt.tables[p].addaRecortd(menu,rt.tables[j].recordsd[k].tableNum , rt.tables[j].recordsd[k].orderNum,rt.tables[j].recordsd[k].d.name, rt.tables[j].recordsd[k].feel, rt.tables[j].recordsd[k].portion, rt.tables[j].recordsd[k].num);
rt.tables[p].k++;
}
}
}
}
}
for(j=0;j<=i;j++){
for(k=0;k<rt.tables[j].i;k++)
rt.tables[j].TotalPrice+=rt.tables[j].records[k].d.getPrice(rt.tables[j].records[k].portion)*rt.tables[j].records[k].num;
for(k=0;k<rt.tables[j].j;k++)
rt.tables[j].TotalPrice+=rt.tables[j].recordsd[k].d.getPrice(rt.tables[j].recordsd[k].portion)*rt.tables[j].recordsd[k].num;
for(k=0;k<rt.tables[j].i;k++)
rt.tables[j].TotalPricez+=panduan.jisuan(rt.tables[j],rt.tables[j].records[k]);
for(k=0;k<rt.tables[j].j;k++)
rt.tables[j].TotalPricez+=panduan.jisuan(rt.tables[j],rt.tables[j].recordsd[k]);
if(rt.tables[j].flag==1)
System.out.print("table"+" "+rt.tables[j].tablenum+": "+ rt.tables[j].TotalPrice+" "+rt.tables[j].TotalPricez);
for(m=0;m<rt.tables[j].i;m++){
if(rt.tables[j].records[m].d.flag==1&&rt.tables[j].records[m].num!=0){
rt.tables[j].cfeel+=rt.tables[j].records[m].feel*rt.tables[j].records[m].num;
rt.tables[j].cnum+=rt.tables[j].records[m].num;
}
if(rt.tables[j].records[m].d.flag==2&&rt.tables[j].records[m].num!=0){
rt.tables[j].jfeel+=rt.tables[j].records[m].feel*rt.tables[j].records[m].num;
rt.tables[j].jnum+=rt.tables[j].records[m].num;
}
if(rt.tables[j].records[m].d.flag==3&&rt.tables[j].records[m].num!=0){
rt.tables[j].zfeel+=rt.tables[j].records[m].feel*rt.tables[j].records[m].num;
rt.tables[j].znum+=rt.tables[j].records[m].num;
}
}
for(n=0;n<rt.tables[j].k;n++){
if(rt.tables[j].recordtd[n].d.flag==1){
rt.tables[j].cfeel+=rt.tables[j].recordtd[n].feel*rt.tables[j].recordtd[n].num;
rt.tables[j].cnum+=rt.tables[j].recordtd[n].num;
}
if(rt.tables[j].recordtd[n].d.flag==2){
rt.tables[j].jfeel+=rt.tables[j].recordtd[n].feel*rt.tables[j].recordtd[n].num;
rt.tables[j].jnum+=rt.tables[j].recordtd[n].num;
}
if(rt.tables[j].recordtd[n].d.flag==3){
rt.tables[j].zfeel+=rt.tables[j].recordtd[n].feel*rt.tables[j].recordtd[n].num;
rt.tables[j].znum+=rt.tables[j].recordtd[n].num;
}
}
g=0;
if(rt.tables[j].cnum>0){
System.out.print(" 川菜 "+rt.tables[j].cnum+" "+kouwd.cpanduan(Math.round(1.0*rt.tables[j].cfeel/rt.tables[j].cnum)));
g++;}
if(rt.tables[j].jnum>0){
System.out.print(" 晋菜 "+rt.tables[j].jnum+" "+kouwd.jpanduan(Math.round(1.0*rt.tables[j].jfeel/rt.tables[j].jnum)));
g++;}
if(rt.tables[j].znum>0){
System.out.print(" 浙菜 "+rt.tables[j].znum+" "+kouwd.zpanduan(Math.round(1.0*rt.tables[j].zfeel/rt.tables[j].znum)));
g++;}
if(g==0)
System.out.print(" ");
System.out.println();
}
for(q=0;q<=i;q++){
if(rt.tables[q].flag==1){
for(j=q+1;j<=i;j++){
if(rt.tables[q].name.equals(rt.tables[j].name)){
rt.tables[q].TotalPricez+=rt.tables[j].TotalPricez;
rt.tables[j].flag=0;
}
}
}
}
String temp1=null;
String temp2=null;
int temp3=0;
for(p=0;p<i;p++){
for(q=0;q<i-p;q++){
if( rt.tables[q].name.charAt(0)-'0'>rt.tables[q+1].name.charAt(0)-'0'&&rt.tables[q].flag==1&&rt.tables[q+1].flag==1){
temp1=rt.tables[q].name;temp2=rt.tables[q].code;temp3=rt.tables[q].TotalPricez;
rt.tables[q].name=rt.tables[q+1].name;rt.tables[q].code=rt.tables[q+1].code;rt.tables[q].TotalPricez=rt.tables[q+1].TotalPricez;
rt.tables[q+1].name=temp1;rt.tables[q+1].code=temp2;rt.tables[q+1].TotalPricez=temp3;
}
}
}
for(j=0;j<=i;j++){
if(rt.tables[j].flag==1)
System.out.println(rt.tables[j].name+" "+rt.tables[j].code+" "+rt.tables[j].TotalPricez);
}
}
}
class Dish {
String name;
int flag=0;
int unit_price;
public Dish(String name,int unit_price){
this.name = name;
this.unit_price = unit_price;
}
public Dish(){
}
public int getPrice(int portion){
double unit_price1=unit_price;
if(portion==2)
unit_price1=1.5*unit_price;
if(portion==3)
unit_price1=2*unit_price;
return (int) Math.round(unit_price1);
}
}
/*输入：dishs菜品数组，用来保存所有菜品信息;
searthDish(String dishName)根据菜名在菜谱中查找菜品信息，返回Dish对象;参数类型为String，名称为dishName;
*/
class Menu {
public Dish[] dishs=new Dish[20];
int f=0;
Dish searthDish(String dishName){
int i;
int flag=0;
for(i=f-1;i>=0;i--){
flag=0;
if(dishs[i].name.equals(dishName)){
flag=1;break;
}
}
if(!(flag != 1))
return dishs[i];
else
return null;
}
public void addDish(String dishName,int unit_price,int flag){
dishs[f]=new Dish(dishName,unit_price);
dishs[f].flag=flag;
f++;
}
}
/*输入：d Dish类型的菜品;portion份额（1/2/3代表小/中/大份）getPrice()函数计价，计算本条记录的价格*/
class Record {
int tableNum;
int orderNum;//序号\
Dish d;//菜品\
int portion;//份额（1/2/3代表小/中/大份）\
int getPrice;
int num;
int flag=1;
int feel;
}
class Table {
Record[] records = new Record[20];
Record[] recordsd = new Record[20];
Record[] recordtd =new Record[20];
int flag=1;
String name;
String code;
int cfeel;
int jfeel;
int zfeel;
int cnum=0;
int jnum=0;
int znum=0;
int TotalPrice;
int TotalPricez;
int i = 0;
int j = 0;
int k = 0;
int tablenum;
LocalDateTime localDateTime;
/*public void setTablenum(int tablenum){
this.tablenum=tablenum;
}*/
public Record addaRecord(Menu menu, int orderNum, String dishName, int feel,int portion, int num) {
Record record = new Record();
record.orderNum = orderNum;
record.num = num;
record.feel=feel;
record.d = menu.searthDish(dishName);
record.portion = portion;
if ((record.d != null))
record.getPrice = record.d.getPrice(portion) * num;
return record;
}
public Record addaRecordd(Menu menu, int tablenum, int orderNum, String dishName,int feel, int portion, int num) {
Record record = new Record();
record.tableNum = tablenum;
record.orderNum = orderNum;
record.num = num;
record.feel=feel;
record.d = menu.searthDish(dishName);
record.portion = portion;
if ((record.d != null))
record.getPrice = record.d.getPrice(portion) * num;
return record;
}
public Record addaRecortd(Menu menu, int tablenum, int orderNum, String dishName,int feel, int portion, int num) {
Record record = new Record();
record.tableNum = tablenum;
record.orderNum = orderNum;
record.num = num;
record.feel=feel;
record.d = menu.searthDish(dishName);
record.portion = portion;
if ((record.d != null))
record.getPrice = record.d.getPrice(portion) * num;
return record;
}
public int findRecordByNum(Table table, int orderNum, int i) {
for (int k = 0; k < i; k++)
if (!(table.records[k].orderNum != orderNum)) {
table.records[k].num = 0; //这里做删除；
table.records[k].feel=0;
return 1;
}
return 0;
}//根据序号查找一条记录
public int findRecorddByNum(Table table, int orderNum, int j) {
for (int m = 0; m < j; m++)
if (!(table.recordsd[m].orderNum != orderNum)) {
table.recordsd[m].num= 0; //这里做删除；
table.recordsd[m].feel=0;
return 1;}
return 0;
}
}
设计与分析如下：
嗯，这一题的输入方面的处理其实和菜单计价4没什么太大的差距，都是使用正则表达式来控制区分输入的是哪一种处理，但是菜单计价5多了一个新的功能，就是增加了川菜浙菜等菜系的特色，在菜单的增加方面，其实和菜单4是一样的，只不过我加了一个record的新属性，就是flag，我把普通菜的glag当作0，而特色菜分别flag为1，2，3，这样我认为是不改变源代码的最为简便的方法了。然后，在进行完所有的操作之后，还需要对口味度进行一个计算，我用来计算口味度的代码如下：
for(j=0;j<=i;j++){
for(k=0;k<rt.tables[j].i;k++)
rt.tables[j].TotalPrice+=rt.tables[j].records[k].d.getPrice(rt.tables[j].records[k].portion)*rt.tables[j].records[k].num;
for(k=0;k<rt.tables[j].j;k++)
rt.tables[j].TotalPrice+=rt.tables[j].recordsd[k].d.getPrice(rt.tables[j].recordsd[k].portion)*rt.tables[j].recordsd[k].num;
for(k=0;k<rt.tables[j].i;k++)
rt.tables[j].TotalPricez+=panduan.jisuan(rt.tables[j],rt.tables[j].records[k]);
for(k=0;k<rt.tables[j].j;k++)
rt.tables[j].TotalPricez+=panduan.jisuan(rt.tables[j],rt.tables[j].recordsd[k]);
if(rt.tables[j].flag==1)
System.out.print("table"+" "+rt.tables[j].tablenum+": "+ rt.tables[j].TotalPrice+" "+rt.tables[j].TotalPricez);
for(m=0;m<rt.tables[j].i;m++){
if(rt.tables[j].records[m].d.flag==1&&rt.tables[j].records[m].num!=0){
rt.tables[j].cfeel+=rt.tables[j].records[m].feel*rt.tables[j].records[m].num;
rt.tables[j].cnum+=rt.tables[j].records[m].num;
}
if(rt.tables[j].records[m].d.flag==2&&rt.tables[j].records[m].num!=0){
rt.tables[j].jfeel+=rt.tables[j].records[m].feel*rt.tables[j].records[m].num;
rt.tables[j].jnum+=rt.tables[j].records[m].num;
}
if(rt.tables[j].records[m].d.flag==3&&rt.tables[j].records[m].num!=0){
rt.tables[j].zfeel+=rt.tables[j].records[m].feel*rt.tables[j].records[m].num;
rt.tables[j].znum+=rt.tables[j].records[m].num;
}
}
for(n=0;n<rt.tables[j].k;n++){
if(rt.tables[j].recordtd[n].d.flag==1){
rt.tables[j].cfeel+=rt.tables[j].recordtd[n].feel*rt.tables[j].recordtd[n].num;
rt.tables[j].cnum+=rt.tables[j].recordtd[n].num;
}
if(rt.tables[j].recordtd[n].d.flag==2){
rt.tables[j].jfeel+=rt.tables[j].recordtd[n].feel*rt.tables[j].recordtd[n].num;
rt.tables[j].jnum+=rt.tables[j].recordtd[n].num;
}
if(rt.tables[j].recordtd[n].d.flag==3){
rt.tables[j].zfeel+=rt.tables[j].recordtd[n].feel*rt.tables[j].recordtd[n].num;
rt.tables[j].znum+=rt.tables[j].recordtd[n].num;
}
}
这里的四舍五入算法十分的重要，大家以后一定要小心小心再小心，然后就是最后把每一桌的信息输出即可，包括每一桌的原价，打折后的价格等等。以上便是我的大概设计与分析。
类图如下：
关系报表图如下：
对类图报表及代码的分析与解释：
类图分析：
可以从类图看出，此题我使用了除了Main类的七个类，分别是record类，Dish类，Panduan类，Menu类和Table类，Rt类及Kouwd类用来判断口味度，因为是对菜单3的拓展，与菜单4不同的是，在菜单5里，增加了计算不同菜系口味度的方面的要求，其他在价格的计算上与第一题无差别，仍然是不同的时间对应不同的折扣。
报表分析
还是那几个数据
Lines： 指的是代码总行数
Statements：语句的行数，语句是以分号结尾的。这个C中有所不同。
Percent Branch Statement：分支数占总语句数的百分比
Method Call Statement：方法调用语句数
Percent Lines with Comments：注释语句占总语句数的百分比
Classes and Interfaces：类和接口数
Methods per Class：每个类平均包含函数个数
Average Statements per Method：每个函数平均包含的语句个数
函数复杂度（Function Complexity）复杂
还是老样子，在这几个方面中，达到绿色的是比较良好的代码，而红色超出绿色范围的则是不太良好的代码，我的这个大部分在范围内，相比于上次来讲，这次的平均圈复杂度是7.25，比菜单4又上升了一个点，最大圈复杂度是仍然是13，唯一的超出了绿色的范围，这说明我可能使用了比较累赘的语法或重复语法，希望下次可以有所改进或者学习一些可以用来降低圈复杂度的方法。
-
期中考试4题：
题目如下：
7-4 测验4-抽象类与接口
分数 40
作者 段喜龙
单位 南昌航空大学
在测验3的题目基础上，重构类设计，实现列表内图形的排序功能（按照图形的面积进行排序）。
提示：题目中Shape类要实现Comparable接口。
其中，Main类源码如下（可直接拷贝使用）：
可拷贝的代码如下
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(Comparator.naturalOrder());//正向排序
for(int i = 0; i < list.size(); i++) {
System.out.print(String.format("%.2f", list.get(i).getArea()) + " ");
}
}
}
输入格式:
输入图形类型（1:圆形；2：矩形；0：结束输入）
输入图形所需参数
输出格式:
按升序排序输出列表中各图形的面积（保留两位小数），各图形面积之间用空格分隔。
输入样例:
在这里给出一组输入。例如：
1
2.3
2
3.2
3
6
5
1
2.3
0
输出样例:
在这里给出相应的输出。例如：
5.60 16.62 16.62
源码：由于我当时没做出来，这是后来改进的代码
import java.util.Scanner;
import java.util.*;
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(Comparator.naturalOrder());//正向排序
for(int i = 0; i < list.size(); i++) {
System.out.print(String.format("%.2f", list.get(i).getArea()) + " ");
}
}
}
class Shape implements Comparable{
Shape(){
}
public double getArea(){
return 0;
}
@Override
public int compareTo(Object o){
if(this.getArea()>((Shape)o).getArea())
return 1;
if(this.getArea()<((Shape)o).getArea())
return -1;
return 0;
}
}
class Circle extends Shape{
double radiums;
Circle(Double radiums){
if(radiums<=0){
System.out.println("Wrong format");
}
this.radiums=radiums;
}
@Override
public double getArea(){
double a=Math.PI*this.radiums*this.radiums;
return a;
}
}
class Rectangle extends Shape{
Point leftTopPoint;
Point lowerRightPoint;
Rectangle(Point leftTopPoint,Point lowerRightPoint){
this.leftTopPoint=leftTopPoint;
this.lowerRightPoint=lowerRightPoint;
}
@Override
public double getArea(){
double a=Math.abs(this.leftTopPoint.x-this.lowerRightPoint.x)*Math.abs(this.leftTopPoint.y-this.lowerRightPoint.y);
return a;
}
}
class Point{
double x;
double y;
Point(double x,double y){
this.x=x;
this.y=y;
}
}
类图如下：由于是按照老师的要求来设计的，所以就是老师的类图
对类图报表及代码的分析与解释：
类图分析：
可以从类图看出，老师设计了圆圈类和矩形类，还有他们的父类，是一个比较抽象的类Sheep类，另外的话还有一个Point点类，关系也比较简单，这里就不做说明了。
踩坑心得：
其实对于这两道系列题和期中考试，刚开始做的时候我踩得坑还不少，以下便是我在做这些道题的时候所踩得坑，希望以后可以不再犯，也希望对大家有所帮助。
-
1：
我始终认为java中传参是非常重要的，如图在添加菜谱的时候
上面我就踩了许许多多的坑，忘记传参导致菜谱数组一直为空，所以说像以上这几种情况，大家更应该多多注意，以后尽量杜绝这些情况
想用实例变量却在main函数外定义了变量：
关于这个情况就需要大家对实例变量和静态变量以及静态方法有一个较为清晰的认知。
-
2:
除去比较低级的错误以后，我认为有一个错误是大家在学习java时都会遇到的，就是null，无论何时何地，想必大家都被null所深深的折磨吧，接下来我就说说自己对null情况的分析。 如图所示：
我们可能会经常遇到这种情况，其实这种多是我们没有new一个对象出来，我们只需要new一个就行了，如图所示
如图，代码便可以正常运行了
-
3:
期中考试的时候，最后死活一直报错，原来是，Comparable是java库函数里面的，我自己去写了一个，怪不得不行
以上就是我的踩坑心得。
主要困难及改进建议
通过这两次的的大作业来看，我认为菜单系列题还是有难度的，这两次作业的话，每一次都特别的做的特别的时间之长，才勉强拿到分数
，差不多基本到了后面一道题基本要花一天甚至两天的时间才有可能写完，并且还可能得不到全部的分数，另外就是我觉得在一些算法之类的题，也有一些难度，这也可能是做题少的原因吧！然后就我个人代码改进建议的话，我觉得我的代码行数还是有一点多的，这其中可能就是有一些地方做的不太周到，还可以减少更多的if else嵌套句的循环之类的，另外一点就是要多多的写累，这样的话可以做到自己代码更加的可持续性和可维护性，希望在下次大作业的时候可能更好的提前着手思考写什么样的框架，因为框架就像是一座房子的基石，基石搭不好，再多的努力也是白费，所以一定要先想好具体的框架，这样可以使自己在之后的代码之路上走的更远更轻松。
总结
历经了两三天之久，终于终于终于来到了最后的总结环节，可把我累坏了，接下来就让我对此次博客进行一个总结，首先，这次博客是进行在两次大作业加一次期中考试之后的，也就是说，每进行三次大作业，就要进行一次博客的总结，如果让我比较这个博客和大作业的话，我觉得这个博客总结会比较更加的累，因为他需要打的字非常非常的多，需要了解一些新的东西，也非常非常非常的多，但是意义上来讲，这个博客要比大作业的意义更加的好。
1：在第6到9周的时间里，主要大作业上的话就是对菜单进行不断的改进和整合，然后还有实验课的话，就是对农夫过河不断的利用新的方法，比如说继承或者接口来改进之前的代码，让游戏都变得更加完善，这些的话是自己在课余时间学到的东西，当然也不排除一直在学习通上听网课里面讲的这些重要的知识点，然后就是在上课的时候学到的东西上课，我觉得老师偏重于讲解怎样设计类画出类图理解清楚关系，而不是一味的只会让学生们写代码，注重提高学生们的思维通过课上的学习，我不再是就只会单纯的敲写代码，而是更多的会理解的要首先在一开始就要有一个清晰的框架，然后有了大框架之后去写代码，才会更加的流畅和顺利。
2在一方面的话，如果是自己，哪一方面没有学习好，或者需要更加进一步探究的话，我认为我在继承组合和聚集以及依赖这几个关系当中模糊不清，不能理解他们的真正界限，我觉得这是我接下来需要改进和完善的地方，其他方面的话还是要多多自己下功夫才行
3至于对老师课程实验，线上线下作业以及组织方式方面的建议，我觉得有时候可能老师太忙了吧，有时候回复不了，但是有些问题又得不到解决的话就会很无助，或者老师可以在大作业结束之后，开放一些测试点给没有通过的同学看看，可以让他们更加的完善自己的代码质量，这样我觉得可能有助于同学们的成长
总之拥有一颗谦卑的态度和积极上进的决心可以帮助我们在程序员这条道路上走的更远，希望大家有问题就要多去探索自己的问题，只有这样，我们每个人才会变得更加的优秀，所以我们仍然在路上，我们每个人都需要更加的努力，努力吧！以上的全部内容就是我对此次博客的全部分析，如果有写的不周到的地方，敬请谅解，以后我会学的更加多的知识来写出更好的作品，谢谢阅读。