一.前言
在进行题目集4-6的练习时，老师课堂上讲的内容一般都会围绕在这次题目集需要用到的新内容上。对于题目集代码的完成有很大的帮助，如课堂讲的封装、继承、多态等内容，简化了代码修改的难度，正则表达式则在一定程度上减少了代码量。但是就我个人认为，这几次的题目集除了期中考试外都有一定的难度。除了代码量较大外，需要检测的点也增加了很多。运用新学习的知识完成题目集的代码是很有难度的。所以这几次我的目标就成了尽可能地多拿分。
知识点总结：
封装：封装是指将数据和操作数据的方法封装在一个类中，通过对外提供公共的方法来访问和操作数据，隐藏了内部的实现细节，提高了安全性和可维护性。
继承：继承是指一个类可以继承另一个类的属性和方法，从而可以重用父类的代码，并且可以在子类中添加新的属性和方法，实现代码的复用和扩展。
多态：多态是指同一个方法调用，可以根据对象的不同而表现出不同的行为，实现了统一的接口，不同的实现。
接口：接口是一种抽象的数据类型，它定义了一组方法的签名，但没有具体的实现。类可以实现接口，并且必须实现接口中定义的所有方法，从而实现了代码的解耦和扩展。
正则表达式：正则表达式是一种用于匹配和搜索文本模式的强大工具。它由一些特殊字符和文本组成，可以用来定义字符串的模式。通过使用正则表达式，可以进行字符串的搜索、替换、验证等操作。
8项基本原则：
-
用接口来定义类型：通过接口定义类型，而不是类，可以增加代码的灵活性，降低耦合性。
-
避免创建不必要的对象：尽量重用对象，避免频繁创建对象，以提高性能。
-
消除过时的对象引用：及时清理不再需要的对象引用，以避免内存泄漏。
-
使用泛型：通过使用泛型，可以提高代码的类型安全性和可读性。
-
优先考虑接口而不是类：尽量使用接口来定义类型，而不是具体的实现类，以提高代码的灵活性和可扩展性。
-
优先考虑复合而不是继承：通过组合多个类的功能，而不是继承类的功能，可以降低耦合性，提高灵活性。
-
考虑使用注解来代替标记接口：注解提供了一种更灵活的方式来定义和使用元数据。
-
谨慎使用序列化：对于类的序列化和反序列化操作要谨慎小心，以避免安全漏洞和兼容性问题。
二.设计与分析
题目集4：
菜单计价程序-2、菜单计价程序-3难度相对较大，且和后面的题目集相关，在这里详细介绍：
菜单计价程序-2：
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 两个信息。
订单分：点菜记录和删除信息。每一类信息都可包含一条或多条记录，每条记录一行。
点菜记录包含：序号、菜名、份额、份数。
份额可选项包括：1、2、3，分别代表小、中、大份。
删除记录格式：序号 delete
标识删除对应序号的那条点菜记录。
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
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)//根据序号查找一条记录
}
输入格式:
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：
序号+英文空格+菜名+英文空格+份额+英文空格+份数
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
最后一条记录以“end”结束。
输出格式:
按顺序输出每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。
如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后输出订单上所有菜品的总价（整数数值），
本次题目不考虑其他错误情况，如：菜单订单顺序颠倒、不符合格式的输入、序号重复等。
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end
输出样例:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
63
输入样例1:
订单中包含删除记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例1:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
27
输入样例2:
订单中包含不存在的菜品记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
end
输出样例2:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
63
输入样例3:
订单中包含删除信息以及不存在的菜品记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 delete
7 delete
end
输出样例3:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
27
输入样例4:
订单中包含删除信息以及不存在的菜品记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
5 delete
7 delete
end
输出样例4:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
delete error;
63
实验代码如下：
1 import java.util.*;
2
3 public class Main{
4 public static void main(String []args){
5 Scanner scanner = new Scanner(System.in);
6 Dish[] dishname=new Dish[500];
7 Menu menu=new Menu();
8 Record[] record=new Record[500];
9 Order order=new Order();
10 int item=0,lengt=0;
11 while(true)
12 {
13 String string=scanner.nextLine();
14 String[] strings=string.split(" ");
15 if(string.equals("end"))
16 {
17 if(lengt==0) //输入菜单
18 {
19 System.out.println("0");
20 return ;
21 }
22 else
23 break;
24 }
25 else
26 {
27 if(strings.length==2)
28 {
29 char result=strings[0].charAt(0);
30 if(result>='0'&&result<='9')
31 {
32 order.records=record; //删除序号
33 order.delARecordByOrderNum(strings[0],lengt);
34 }
35 else
36 {
37 for(int i=0;i<item;i++) //重复的菜品输入
38 {
39 if(strings[0].equals(dishname[i].name))
40 dishname[i].unit_price=Integer.parseInt(strings[1]);
41 }
42 dishname[item]=new Dish();//添加一道菜品信息
43 dishname[item].name=strings[0];
44 dishname[item].unit_price=Integer.parseInt(strings[1]);
45 item++;
46 }
47 }
48 if(strings.length==4)
49 {
50 if(lengt==0) //输入菜单菜品
51 {
52 menu.dishes =dishname;
53 menu.count=item;
54 }
55 if(menu.searchDish(strings[1])!=null)
56 {
57 record[lengt]=new Record();
58 record[lengt].d=menu.searchDish(strings[1]); //输入菜品
59 }
60 else
61 {
62 System.out.println(strings[1]+" does not exist"); //记录错误菜品名
63 continue;
64 }
65 record[lengt].orderNum=strings[0]; //输入序号
66 record[lengt].portion=Integer.parseInt(strings[2]); //输入份额
67 record[lengt].dishnum=Integer.parseInt(strings[3]); //输入份数
68 System.out.println(record[lengt].orderNum+" "+record[lengt].d.name+" "+record[lengt].getprice());
69 lengt++;
70 }
71 }
72 }
73 order.records=record;
74 System.out.print(order.getTotalPrice(lengt)); //输出总金额
75 }
76 //菜品类
77 public static class Dish
78 {
79 String name; //菜品名
80 int unit_price; //单价
81 public int getPrice(int portion)
82 {
83 double price=unit_price;
84 switch (portion)
85 {
86 case 1:
87 price=unit_price;
88 break;
89 case 2:
90 price=(int) Math.round(unit_price*1.5);
91 break;
92 case 3:
93 price=unit_price*2;
94 break;
95 default:
96 break;
97 }
98 return (int) price;
99 }
100 }
101 //菜单类
102 public static class Menu
103 {
104 Dish[] dishes; //菜品数组
105 int count;
106 public Dish searchDish(String dishName)
107 {
108 for(int i=0;i<count;i++)
109 {
110 if(dishName.equals(dishes[i].name))
111 {
112 return dishes[i];
113 }
114 }
115 return null;
116 }
117 Dish addDish(String dishName,int unit_price){
118 Dish dh = new Dish();
119 dh.name = dishName;
120 dh.unit_price = unit_price;
121 count++;
122 return dh;
123 }//添加一道菜品信息
124 }
125 //记录类
126 public static class Record
127 {
128 Dish d; //菜品
129 int portion,dishnum; //份额
130 String orderNum; //序号
131 boolean bool;
132 public int getprice()
133 {
134 int price=d.getPrice(portion)*dishnum;
135 return price;
136 }
137 }
138 //订单类
139 public static class Order
140 {
141 Record[] records; //菜品数组
142 public void delARecordByOrderNum(String orderNum1,int count)
143 {
144 int flag=0,i;
145 for(i=0;i<count;i++)
146 {
147 if(records[i].orderNum.equals(orderNum1))
148 {
149 records[i].bool=true;
150 flag=1;
151 }
152 }
153 if(flag==0)
154 {
155 System.out.println("delete error;");
156 }
157 }
158 public int getTotalPrice(int count)
159 {
160 int totalPrice=0;
161 for(int i=0;i<count;i++)
162 if(!records[i].bool)
163 totalPrice+=records[i].getprice();
164 return totalPrice;
165 }
166 }
167 }
难点：增加了删除点菜的功能，代码量较第一次有了一定的提升。难度适中。
菜单计价程序-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)//根据序号查找一条记录
}
### 输入格式:
桌号标识格式：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+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
输入格式:
桌号标识格式：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+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 12/2/3
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end
输出样例:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 38
输入样例1:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 17/0/0
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例1:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 22
输入样例2:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 16/59/59
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例2:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
table 1 out of opening hours
输入样例3:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2022/12/5 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
5 delete
7 delete
table 2 2022/12/3 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
7 delete
end
输出样例3:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
delete error;
table 2:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
table 1 out of opening hours
table 2: 63
输入样例4:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2022/12/3 19/5/12
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
table 2 2022/12/3 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 4 麻婆豆腐 1 1
7 delete
end
输出样例4:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
table 2:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
4 table 2 pay for table 1 12
delete error;
table 1: 63
table 2: 75
题目代码：
1 import java.util.*;
2
3 public class Main {
4 public static void main(String[] args) {
5 Scanner scanner = new Scanner(System.in);
6 Menu munus = new Menu();
7 Table[] tables = new Table[10];
8 int menunum = 0;//菜单数
9 int ordernum = 0;//订单数
10 Dish words;
11 int cntTable = 0;//桌号
12 int counts;
13 String[] temp;
14 int Len1,Len2,Len3,Len4,Len5;
15
16 while (true) {
17 String strings = scanner.nextLine();
18 temp = strings.split(" ");
19 if(strings.equals("end"))
20 break;
21 counts = temp.length;
22 if (counts == 2) {//一个空格
23 if (temp[1].equals("delete")) {//第二个为delete
24 Len1 = Integer.parseInt(temp[0]);
25 int c = tables[cntTable].odt.delARecordByOrderNum(Len1);
26 tables[cntTable].sum-=c;
27 } else {
28 Len2 = Integer.parseInt(temp[1]);
29 munus.dishs[menunum] = munus.addDish(temp[0], Len2);
30 menunum++;
31 }
32 }
33 else if (counts == 4) {//三个空格
34 if (temp[0].equals("table")) {//桌号
35 cntTable++;
36 ordernum = 0;
37 tables[cntTable] = new Table();
38 tables[cntTable].AheadProceseconds(strings);
39 System.out.println("table " + cntTable + ": ");
40 } else {//增加订单的情况；
41 Len3 =Integer.parseInt(temp[0]);
42 Len4 = Integer.parseInt(temp[2]);
43 Len5=Integer.parseInt(temp[3]);
44 tables[cntTable].odt.addARecord(Len3, temp[1],Len4 , Len5);
45 words = munus.searthDish(temp[1]);
46 if (words != null) {
47 tables[cntTable].odt.records[ordernum].d = words;
48 int a = tables[cntTable].odt.records[ordernum].getPrice();
49 System.out.println(tables[cntTable].odt.records[ordernum].orderNum + " " + words.name + " " +a );
50 tables[cntTable].sum +=a;
51 }
52 ordernum++;
53 }
54 }
55
56 else if (counts == 5) {//代点菜
57 Len1 = Integer.parseInt(temp[1]);
58 Len2 = Integer.parseInt(temp[3]);
59 Len3 = Integer.parseInt(temp[4]);
60 tables[cntTable].odt.addARecord( Len1, temp[2], Len2, Len3);
61 words = munus.searthDish(temp[2]);
62 if (words != null) {
63 tables[cntTable].odt.records[ordernum].d.unit_price = words.unit_price;
64 int b = tables[cntTable].odt.records[ordernum].getPrice();
65 System.out.println(temp[1] + " table " + tables[cntTable].tableNum + " pay for table " + temp[0] + " " + b);
66 tables[cntTable].sum += b;
67 }
68 ordernum++;
69 }
70
71 }
72 for (int i = 1; i < cntTable + 1; i++) {
73 tables[i].Gettottalprice();
74 }
75 }
76 }
77
78 class Dish {
79 String name;//菜品名称
80 int unit_price;
81
82 int getPrice(int portion) {
83 int dishprice = 0;
84 if (portion == 1) {
85 dishprice = unit_price ;
86 } else if (portion == 2) {
87 dishprice = Math.round((float) (unit_price * 1.5)) ;
88 } else if (portion == 3) {
89 dishprice = (unit_price * 2) ;
90 }
91 return dishprice;//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
92 }
93 }
94 class Menu {
95 Dish[] dishs = new Dish[10];
96 int count = 0;
97 Dish searthDish(String dishName){
98 Dish temd = null;
99 for(int i=count-1;i>=0;i--){
100 if(dishName.equals(dishs[i].name)){
101 temd = dishs[i];
102 break;
103 }
104 }
105 if(temd==null){
106 System.out.println(dishName+" does not exist");
107 }
108 return temd;
109 }
110 Dish addDish(String dishName,int unit_price){
111 Dish dh = new Dish();
112 dh.name = dishName;
113 dh.unit_price = unit_price;
114 count++;
115 return dh;
116 }//添加一道菜品信息
117 }
118 class Order {
119
120 Record[] records = new Record[10];
121 int count = 0;//订单数量
122 void addARecord(int orderNum,String dishName,int portion,int num){
123 records[count] = new Record();
124 records[count].d.name = dishName;
125 records[count].orderNum = orderNum;
126 records[count].portion = portion;
127 records[count].num = num;
128 count++;
129 }//添加一条菜品信息到订单中。
130 int delARecordByOrderNum(int orderNum){
131 if(orderNum>count||orderNum<=0){
132 System.out.println("delete error;");
133 return 0;
134 }else {
135 return records[orderNum - 1].getPrice();
136 }
137 }//根据序号删除一条记录
138 }
139 class Record
140 {
141 int orderNum;//序号
142 Dish d = new Dish();//菜品
143 int num = 0;
144 int portion;//份额（1/2/3代表小/中/大份）\
145 //int exist = 1;
146 int getPrice(){
147 return d.getPrice(portion) * num;
148 }//计价，计算本条记录的价格\
149 }
150 class Table
151 {
152 int tableNum;
153 String tableordertime;
154 int year,month,day,week,hours,minutes,seconds;
155 int mounts;
156 int sum = 0;//一桌价格 ；
157 Order odt = new Order();
158 double discnt = -1;
159 void Gettottalprice(){
160 if(discnt>0){
161 sum = (int) Math.round(sum*discnt);
162 System.out.println("table " + tableNum + ": " + sum);
163 }else {
164 System.out.println("table " + tableNum + " out of opening hours");
165 }
166 }
167 void AheadProceseconds(String tableDtime){
168 this.tableordertime = tableDtime;
169 procesecondsTime();
170 discount();
171 }
172
173
174 void procesecondsTime(){//处理时间
175 String[] temp = tableordertime.split(" ");
176 tableNum = Integer.parseInt(temp[1]);
177 String[] temp1 = temp[2].split("/");
178 String[] temp2 = temp[3].split("/");
179
180 year = Integer.parseInt(temp1[0]);
181 month = Integer.parseInt(temp1[1]);
182 day = Integer.parseInt(temp1[2]);
183 mounts = month-1;
184
185 Calendar calen = Calendar.getInstance();
186 calen.set(year, (mounts), day);
187 week = calen.get(Calendar.DAY_OF_WEEK);
188 if(week==1)
189 week = 7;
190 else
191 week--;
192 hours = Integer.parseInt(temp2[0]);
193 minutes = Integer.parseInt(temp2[1]);
194 seconds = Integer.parseInt(temp2[2]);
195
196 }
197
198 void discount(){
199 if(week>=1&&week<=5)
200 {
201
202 if(hours==20&&minutes<30)
203 discnt=0.8;
204 else if(hours==20&&minutes==30&&seconds==0)
205 discnt=0.8;
206 else if(hours==14&&minutes<30)
207 discnt=0.6;
208 else if(hours>=17&&hours<20)
209 discnt=0.8;
210 else if(hours>=11&&hours<=13||hours==10&&minutes>=30)
211 discnt=0.6;
212 else if(hours==14&&minutes==30&&seconds==0)
213 discnt=0.6;
214 }
215 else
216 {
217 if(hours>=10&&hours<=20)
218 discnt= 1.0;
219 else if(hours==9&&minutes>=30)
220 discnt= 1.0;
221 else if(hours==21&&minutes<30||hours==21&&minutes==30&&seconds==0)
222 discnt= 1.0;
223 }
224 }
225 }
主要难点：加入了新的类，桌号table，点单、删除需要和table相关联。出现了时间计算，只在规定时间内营业，并且存在折扣问题。这一题耗费了我大量的时间进行时间计算。
题目集五
题目集5虽然只有一道题但是代码量和难度和之前相比直线上升，做到最后我也没能够通过所有测试点。
菜单计价程序-4：
本体大部分内容与菜单计价程序-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+英文空格+桌号+“:”+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9 T
table 31 2023/2/1 14/20/00
1 麻婆豆腐 1 16
2 油淋生菜 1 2
2 delete
2 delete
end
输出样例:
在这里给出相应的输出。例如：
table 31:
1 num out of range 16
2 油淋生菜 18
deduplication 2
table 31: 0 0
输入样例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
油淋生菜 9 T
table 55 2023/3/31 12/000/00
麻辣香锅 15
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end
输出样例3:
在这里给出相应的输出。例如：
wrong format
输入样例4:
错误的菜谱记录。例如：
麻婆豆腐 12.0
油淋生菜 9 T
table 55 2023/3/31 12/00/00
麻辣香锅 15
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end
输出样例4:
在这里给出相应的输出。例如：
wrong format
table 55:
invalid dish
麻婆豆腐 does not exist
2 油淋生菜 14
table 55: 14 10
输入样例5:
桌号格式错误（以“table”开头）+订单格式错误（忽略）。例如：
麻婆豆腐 12
油淋生菜 9 T
table a 2023/3/15 12/00/00
1 麻婆 豆腐 1 1
2 油淋生菜 2 1
end
输出样例5:
在这里给出相应的输出。例如：
wrong format
输入样例6:
桌号格式错误，不以“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
输出样例6:
在这里给出相应的输出。例如：
table 1: 1 麻婆豆腐 12 2 油淋生菜 14 wrong format record serial number sequence error record serial number sequence error table 1: 26 17
1 import java.time.LocalTime;
2 import java.util.*;
3
4 public class Main {
5 public static void main(String[] args) {
6 Menu menu = new Menu();
7 Scanner input = new Scanner(System.in);
8 Order[] orders = new Order[200];
9 Table[] tables = new Table[200];
10 int i = 0;
11 String nextLine = input.nextLine();
12 while (!nextLine.equals("end")) {
13
14 String[] lineArray = nextLine.split(" ");
15
16 if ("table".equals(lineArray[0])) {
17 orders[i] = new Order(menu);
18 int[] delete = new int[10];
19 int del = 0;
20 int orderDish = 0;
21 if (lineArray.length != 4) {
22 System.out.println("wrong format");
23 nextLine = input.nextLine();
24 while (!nextLine.equals("end")) {
25 String[] lineArray1 = nextLine.split(" ");
26 if ("table".equals(lineArray1[0])) {
27 break;
28 }else {
29 nextLine = input.nextLine();
30 }
31 }
32 continue;
33 }
34 if (!lineArray[0].equals("table")) {
35 System.out.println("wrong format");
36 nextLine = input.nextLine();
37 while (!nextLine.equals("end")) {
38 String[] lineArray1 = nextLine.split(" ");
39 if ("table".equals(lineArray1[0])) {
40 break;
41 }else {
42 nextLine = input.nextLine();
43 }
44 }
45 continue;
46 }
47 if (!(lineArray[1].matches("[1-9]|[1-4][0-9]|5[0-5]"))) {
48 System.out.println("wrong format");
49 nextLine = input.nextLine();
50 while (!nextLine.equals("end")) {
51 String[] lineArray1 = nextLine.split(" ");
52 if ("table".equals(lineArray1[0])) {
53 break;
54 }else {
55 nextLine = input.nextLine();
56 }
57 }
58 continue;
59 }
60 int tableNum= Integer.parseInt(lineArray[1]);
61 String[] date = lineArray[2].split("/");
62 String[] time = lineArray[3].split("/");
63 if (!(date[0].matches("[0-9]{4}") &&
64 date[1].matches("[0-9]{1,2}") &&
65 date[2].matches("[0-9]{1,2}") &&
66 time[0].matches("[0-9]{1,2}") &&
67 time[1].matches("[0-9]{1,2}") &&
68 time[2].matches("[0-9]{1,2}"))) {
69 System.out.println("wrong format");
70 nextLine = input.nextLine();
71 while (!nextLine.equals("end")) {
72 String[] lineArray1 = nextLine.split(" ");
73 if ("table".equals(lineArray1[0])) {
74 break;
75 }else {
76 nextLine = input.nextLine();
77 }
78 }
79 continue;
80 }
81 if (!(date[1].matches("[1-9]|1[0-2]|0[1-9]") &&
82 time[0].matches("[0-9]|0[0-9]|1[0-9]|2[0-4]") &&
83 time[1].matches("[0-9]|0[0-9]|[1-5][0-9]") &&
84 time[2].matches("[0-9]|0[0-9]|[1-5][0-9]"))) {
85 System.out.println(tableNum + " date error");
86 nextLine = input.nextLine();
87 while (!nextLine.equals("end")) {
88 String[] lineArray1 = nextLine.split(" ");
89 if ("table".equals(lineArray1[0])) {
90 break;
91 }else {
92 nextLine = input.nextLine();
93 }
94 }
95 continue;
96 }
97 Calendar calendar= Calendar.getInstance();
98 calendar.set(Integer.parseInt(date[0]),
99 Integer.parseInt(date[1]),
100 Integer.parseInt(date[2]));;
101 LocalTime localTime = LocalTime.of(Integer.parseInt(time[0]),
102 Integer.parseInt(time[1]),
103 Integer.parseInt(time[2]));
104
105 if (!isDate(calendar)) {
106 System.out.println("not a valid time period");
107 nextLine = input.nextLine();
108 while (!nextLine.equals("end")) {
109 String[] lineArray1 = nextLine.split(" ");
110 if ("table".equals(lineArray1[0])) {
111 break;
112 }else {
113 nextLine = input.nextLine();
114 }
115 }
116 continue;
117 }
118 System.out.println("table " + tableNum + ": ");
119 nextLine = input.nextLine();
120 while (!nextLine.equals("end")) {
121 String[] lineArray1 = nextLine.split(" ");
122 if ("table".equals(lineArray1[0])) {
123 break;
124 } else if ("table".equals(lineArray1[0] + lineArray1[1])) {
125 System.out.println("wrong format");
126 } else if (lineArray1.length == 5) {
127 Dish dish = new Dish();
128 dish = menu.searthDish(lineArray1[2]);
129 orderDish = dish.getPrice(Integer.parseInt(lineArray1[3])) *
130 Integer.parseInt(lineArray1[4]);
131 System.out.println(lineArray1[1] + " table " + tableNum +
132 " pay for table " + lineArray1[0] + " " + orderDish);
133 } else if (lineArray1.length == 4) {
134
135 int orderNum;
136 String dishName = lineArray1[1];
137 int portion;
138 int num;
139 if (lineArray1[0].matches("[1-9]|[1-9][0-9]")) {
140 orderNum = Integer.parseInt(lineArray1[0]);
141 }else {
142 orderNum = 0;
143 }
144 if (lineArray1[2].matches("[1-9]")) {
145 portion = Integer.parseInt(lineArray1[2]);
146 }else {
147 portion = 0;
148 }
149 if (lineArray1[3].matches("[1-9]|[1-9][0-9]")) {
150 num = Integer.parseInt(lineArray1[3]);
151 }else {
152 num = 0;
153 }
154
155 orders[i].addARecord(orderNum,dishName,portion,num);
156 } else if ("delete".equals(lineArray1[1])) {
157 int flag = 0;
158 delete[del] = Integer.parseInt(lineArray1[0]);
159 for (int j = del;j >= 1;j --) {
160 if (delete[j] == delete[j-1]) {
161 System.out.println("deduplication " + delete[del]);
162 flag = 1;
163 }
164 }
165 if (flag == 0) {
166 orders[i].delARecordByOrderNum(Integer.parseInt(lineArray1[0]));
167 }
168 del ++;
169 } else if (lineArray1.length == 2) {
170 System.out.println("invalid dish");
171 }else {
172 System.out.println("wrong format");
173 }
174 nextLine = input.nextLine();
175 }
176 tables[i] = new Table(orders[i],tableNum,calendar,localTime);
177 tables[i].setOrderDish(orderDish);
178
179 i ++;
180 } else if (lineArray.length == 2) {
181 if (lineArray[1].matches("[1-9]|[1-2][0-9]{1,2}")) {
182 menu.addDish(lineArray[0], Integer.parseInt(lineArray[1]));
183 } else if (lineArray[1].matches("0|[3-9][0-9]{1,2}")) {
184 System.out.println(lineArray[0] + " price out of range " +
185 Integer.parseInt(lineArray[1]));
186 }else {
187 System.out.println("wrong format");
188 }
189 nextLine = input.nextLine();
190 } else if (lineArray.length == 3) {
191 if (lineArray[1].matches("[1-9]|[1-2][0-9]{2}")) {
192 menu.addDish(lineArray[0],Integer.parseInt(lineArray[1]),lineArray[2]);
193
194 } else if (lineArray[1].matches("0|[3-9][0-9]{2}")) {
195 System.out.println(lineArray[0] + " price out of range " +
196 Integer.parseInt(lineArray[1]));
197 }else {
198 System.out.println("wrong format");
199 }
200 nextLine = input.nextLine();
201 }else {
202 System.out.println("wrong format");
203 nextLine =input.nextLine();
204 }
205 }
206 for (int j = 0;j < i;j ++) {
207 tables[j].getTotalPrice();
208 }
209 }
210 public static boolean isDate(Calendar calendar) {
211 int[] maxNum = {0,31,28,31,30,31,30,31,31,30,31,30,31};
212 if ((calendar.get(Calendar.YEAR) == 2022 ||
213 calendar.get(Calendar.YEAR) == 2023) &&
214 (calendar.get(Calendar.MONTH) >=1 &&
215 calendar.get(Calendar.MONTH) <= 12) &&
216 (calendar.get(Calendar.DATE) >= 1 &&
217 calendar.get(Calendar.DATE) <= maxNum[calendar.get(Calendar.MONTH)])) {
218 return true;
219 }else {
220 return false;
221 }
222 }
223 }
224
225 class Table {
226 int num;
227 Calendar calendar = Calendar.getInstance();
228 LocalTime localTime = LocalTime.now(); ;
229 Order order;
230 private int orderDish = 0;
231
232 public int getOrderDish() {
233 return orderDish;
234 }
235
236 public void setOrderDish(int orderDish) {
237 this.orderDish = orderDish;
238 }
239
240 public Table() {
241
242 }
243 public Table (int num) {
244 this.num = num;
245 }
246 public Table(Order order,int num,Calendar calendar,LocalTime localTime) {
247 this.order = order;
248 this.num = num;
249 this.calendar = calendar;
250 this.localTime = localTime;
251 }
252 public boolean isOpeningHours() {
253 if (this.calendar.get(Calendar.DAY_OF_WEEK) == 3 ||
254 this.calendar.get(Calendar.DAY_OF_WEEK) == 4) {
255 if (localTime.getHour() >9 &&
256 localTime.getHour() <= 21) {
257 return true;
258 } else if ((localTime.getHour() == 9 &&
259 localTime.getMinute() >= 30) ||
260 (localTime.getHour() == 21 &&
261 localTime.getMinute() < 30)) {
262 return true;
263 } else if (localTime.getHour() == 21 &&
264 localTime.getMinute() == 30 &&
265 localTime.getSecond() == 0) {
266 return true;
267 }else {
268 return false;
269 }
270 }else {
271 if ((localTime.getHour() > 10 &&
272 localTime.getHour() <= 14) ||
273 (localTime.getHour() >= 17 &&
274 localTime.getHour() <= 20)) {
275 return true;
276 } else if ((localTime.getHour() == 10 &&
277 localTime.getMinute() >= 30) ||
278 (localTime.getHour() == 14 &&
279 localTime.getMinute() < 30) ||
280 (localTime.getHour() == 20 &&
281 localTime.getSecond() < 30)) {
282 return true;
283 } else if ((localTime.getHour() == 10 &&
284 localTime.getMinute() == 30 &&
285 localTime.getSecond() == 0) ||
286 (localTime.getHour() == 20 &&
287 localTime.getMinute() == 30 &&
288 localTime.getSecond() == 0)) {
289 return true;
290 }else {
291 return false;
292 }
293 }
294 }
295 public double discount() {
296 if (this.calendar.get(Calendar.DAY_OF_WEEK) == 3 ||
297 this.calendar.get(Calendar.DAY_OF_WEEK) == 4) {
298 return 1;
299 }else {
300 if (localTime.getHour() >= 17 &&
301 localTime.getHour() <= 20) {
302 return 0.8;
303 } else if (localTime.getHour() == 20 &&
304 localTime.getSecond() < 30) {
305 return 0.8;
306 } else if (localTime.getHour() == 20 &&
307 localTime.getMinute() == 30 &&
308 localTime.getSecond() == 0) {
309 return 0.8;
310 } else if ((localTime.getHour() > 10 &&
311 localTime.getHour() <= 14)) {
312 return 0.6;
313 } else if ((localTime.getHour() == 10 &&
314 localTime.getMinute() >= 30) ||
315 (localTime.getHour() == 14 &&
316 localTime.getMinute() < 30)) {
317 return 0.6;
318 } else if ((localTime.getHour() == 10 &&
319 localTime.getMinute() == 30 &&
320 localTime.getSecond() == 0)) {
321 return 0.6;
322 }
323 }
324 return 0;
325 }
326 public double discountNew() {
327 if (this.calendar.get(Calendar.DAY_OF_WEEK) == 3 ||
328 this.calendar.get(Calendar.DAY_OF_WEEK) == 4) {
329 return 1;
330 }else {
331 return 0.7;
332 }
333 }
334 public void getTotalPrice() {
335 double sum = 0;
336 if (isOpeningHours()) {
337 for (Record record:this.order.getRecords()
338 ) {
339 int price = record.getPrice();
340 if (record.getD().specialDish.equals("T")) {
341 if (!record.isDelete()) {
342 sum += Math.round(price) * discountNew();
343 }
344 }else {
345 if (!record.isDelete()) {
346 sum += Math.round(price) * discount();
347 }
348 }
349 }
350 System.out.println("table " + this.num + ": " +
351 order.getTotalPrice() + " " +
352 Math.round(sum));
353 }else {
354 System.out.println("table " + this.num + " out of opening hours");
355 }
356 }
357 }
358 class Menu {
359 private List<Dish> dishes = new ArrayList<>();//菜品数组，保存所有菜品信息
360
361 public List<Dish> getDishes() {
362 return dishes;
363 }
364
365 Dish searthDish(String dishName) {
366 for (Dish dish : dishes) {
367 if (dish.getDishName().equals(dishName)) {
368 return dish;
369 }
370 }
371 return null;
372 }
373
374 //添加一道菜品信息
375 Dish addDish(String dishName, int unit_price) {
376 for (Dish dish : dishes) {
377 if (dish.getDishName().equals(dishName)) {
378 dish.setUnit_price(unit_price);
379 return dish;
380 }
381 }
382 Dish dish = new Dish(dishName, unit_price);
383 dishes.add(dish);
384 return dish;
385 }
386 Dish addDish(String dishName,int unit_price,String orderDish) {
387 for (Dish dish : dishes) {
388 if (dish.getDishName().equals(dishName)) {
389 dish.setUnit_price(unit_price);
390 return dish;
391 }
392 }
393 Dish dish = new Dish(dishName,unit_price,orderDish);
394 dishes.add(dish);
395 return dish;
396 }
397 }
398
399 class Dish {
400 String dishName;//菜品名称
401 int unit_price; //单价
402 String specialDish;
403
404 public String getDishName() {
405 return dishName;
406 }
407 public int getUnit_price() {
408 return unit_price;
409 }
410 public void setDishName(String dishName) {
411 this.dishName = dishName;
412 }
413
414 public void setUnit_price(int unit_price) {
415 this.unit_price = unit_price;
416 }
417
418 public Dish(String name, int unit_price) {
419 this.dishName = name;
420 this.unit_price = unit_price;
421 this.specialDish = "F";
422 }
423
424 public Dish(String dishName, int unit_price, String specialDish) {
425 this.dishName = dishName;
426 this.unit_price = unit_price;
427 this.specialDish = specialDish;
428 }
429
430 public Dish() {
431 }
432
433 //计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
434 int getPrice(int portion) {
435 float botSum[] = {1, 1.5f, 2};
436 return Math.round((unit_price * botSum[portion - 1]));
437 }
438 }
439
440 class Record {
441 private int numOrder;//序号\
442 private Dish d;//菜品\
443 private int portion;//份额（1/2/3代表小/中/大份）\
444 private int num;
445 private boolean isDelete = false;
446
447 public boolean isNotFound() {
448 return notFound;
449 }
450
451 public void setNotFound(boolean notFound) {
452 this.notFound = notFound;
453 }
454
455 private boolean notFound = false;
456
457 public Record(int orderNum, Dish d, int portion, int num) {
458 this.numOrder = orderNum;
459 this.d = d;
460 this.portion = portion;
461 this.num = num;
462 }
463 public Record(Dish d, int portion) {
464 this.d = d;
465 this.portion = portion;
466 }
467
468 //计价，计算本条记录的价格
469 int getPrice() {
470 return d.getPrice(portion) * this.num;
471 }
472
473 public void setNumOrder(int numOrder) {
474 this.numOrder = numOrder;
475 }
476 public int getNumOrder() {
477 return numOrder;
478 }
479
480 public Dish getD() {
481 return d;
482 }
483
484 public void setD(Dish d) {
485 this.d = d;
486 }
487
488
489 public void setPortion(int portion) {
490 this.portion = portion;
491 }
492
493 public int getPortion() {
494 return portion;
495 }
496
497
498 public void setDelete(boolean delete) {
499 isDelete = delete;
500 }
501 public boolean isDelete() {
502 return isDelete;
503 }
504
505 public void setNum(int num) {
506 this.num = num;
507 }
508 public int getNum() {
509 return num;
510 }
511 }
512
513 class Order {
514 private Menu menu;
515 private List<Record> records = new ArrayList<>();//保存订单上每一道的记录
516 public Order(Menu menu) {
517 this.menu = menu;
518 }
519
520 public List<Record> getRecords() {
521 return records;
522 }
523
524 public Menu getMenu() {
525 return menu;
526 }
527
528 //计算订单的总价
529 int getTotalPrice() {
530 int sum = 0;
531 for (Record record : records) {
532 int price = record.getPrice();
533 if (!record.isDelete()) {
534 sum += price;
535 }
536 }
537 return sum;
538 }
539 //添加一条菜品信息到订单中
540 Record addARecord(int orderNum, String dishName, int portion, int num) {
541 if (orderNum == 0) {
542 System.out.println("wrong format");
543 return null;
544 }
545 Dish dish = menu.searthDish(dishName);
546 if (dish == null) {
547 System.out.println(dishName + " does not exist");
548 return null;
549 }
550 if (portion == 0) {
551 System.out.println("wrong format");
552 return null;
553 }
554 if (dish.specialDish.equals("T")) {
555 if (portion != 1 && portion != 2 && portion != 3) {
556 System.out.println(orderNum + " portion out of range " + portion);
557 return null;
558 }
559 } else if (dish.specialDish.equals("F")) {
560 if (portion != 1 && portion !=2 && portion != 3) {
561 System.out.println(orderNum + " portion out of range " + portion);
562 return null;
563 }
564 }
565 if (num > 15) {
566 System.out.println(orderNum + " num out of range " + num);
567 return null;
568 } else if (num == 0) {
569 System.out.println("wrong format");
570 return null;
571 }
572 Record record = new Record(orderNum, dish, portion, num);
573
574 for (int i = 0;i < records.size();i ++) {
575 if (records.get(i).getNumOrder() >= record.getNumOrder()) {
576 System.out.println("record serial number sequence error");
577 return null;
578 }
579 }
580 records.add(record);
581 int price = record.getPrice();
582 System.out.println(record.getNumOrder() + " " + record.getD().getDishName() + " " + price);
583 return record;
584 }
585 public boolean delARecordByOrderNum(int orderNum) {
586 for (Record record : records) {
587 if (!record.isNotFound() && !record.isDelete() && record.getNumOrder() == orderNum) {
588 record.setDelete(true);
589 return true;
590 }
591 }
592 System.out.println("delete error");
593 return false;
594 }
595 }
主要难点：输入有所改变，需要判别是否为特色菜。加入了带点菜功能，这一步的难度很大。同时需要对错误的输入进行相应的判断输出，我使用正则表达式、try-catch语句进行了一部分简单的判断，更多的错误没能解决。
题目集6
同样的难度非常大。新增了菜系和品味。
菜单计价程序-5：
本题在菜单计价程序-3的基础上增加了部分内容，增加的内容用加粗字体标识。
注意不是菜单计价程序-4，本题和菜单计价程序-4同属菜单计价程序-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)//根据序号查找一条记录
}
### 输入格式:
桌号标识格式：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+英文空格+桌号+“:”+英文空格+当前桌的总价
以上为菜单计价系列-3的题目要求，加粗的部分是有调整的内容。本次课题相比菜单计价系列-3新增要求如下：
1、菜单输入时增加特色菜，特色菜的输入格式：菜品名+英文空格+口味类型+英文空格+基础价格+"T"
例如：麻婆豆腐 川菜 9 T
菜价的计算方法：
周一至周五 7折， 周末全价。
特色菜的口味类型：川菜、晋菜、浙菜
川菜增加辣度值：辣度0-5级；对应辣度水平为：不辣、微辣、稍辣、辣、很辣、爆辣；
晋菜增加酸度值，酸度0-4级；对应酸度水平为：不酸、微酸、稍酸、酸、很酸；
浙菜增加甜度值，甜度0-3级；对应酸度水平为：不甜、微甜、稍甜、甜；
例如：麻婆豆腐 川菜 9 T
输入订单记录时如果是特色菜，添加口味度（辣/酸/甜度）值，格式为：序号+英文空格+菜名+英文空格+口味度值+英文空格+份额+英文空格+份数
例如：1 麻婆豆腐 4 1 9
单条信息在处理时，如果口味度超过正常范围，输出"spicy/acidity/sweetness num out of range : "+口味度值，spicy/acidity/sweetness（辣度/酸度/甜度）根据菜品类型择一输出，例如：
acidity num out of range : 5
输出一桌的信息时，按辣、酸、甜度的顺序依次输出本桌菜各种口味的口味度水平，如果没有某个类型的菜，对应的口味（辣/酸/甜）度不输出，只输出已点的菜的口味度。口味度水平由口味度平均值确定，口味度平均值只综合对应口味菜系的菜计算，不做所有菜的平均。比如，某桌菜点了3份川菜，辣度分别是1、3、5；还有4份晋菜，酸度分别是，1、1、2、2，辣度平均值为3、酸度平均值四舍五入为2，甜度没有，不输出。
一桌信息的输出格式：table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格+"川菜"+数量+辣度+英文空格+"晋菜"+数量+酸度+英文空格+"浙菜"+数量+甜度。
如果整桌菜没有特色菜，则只输出table的基本信息，格式如下，注意最后加一个英文空格：
table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格
例如：table 1: 60 36 川菜 2 爆辣 浙菜 1 微甜
计算口味度时要累计本桌各类菜系所有记录的口味度总和（每条记录的口味度乘以菜的份数），再除以对应菜系菜的总份数，最后四舍五入。
注：本题要考虑代点菜的情况，当前桌点的菜要加上被其他桌代点的菜综合计算口味度平均值。
2、考虑客户订多桌菜的情况，输入时桌号时，增加用户的信息：
格式：table+英文空格+桌号+英文空格+":"+英文空格+客户姓名+英文空格+手机号+日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
例如：table 1 : tom 13670008181 2023/5/1 21/30/00
约束条件：客户姓名不超过10个字符，手机号11位，前三位必须是180、181、189、133、135、136其中之一。
输出结果时，先按要求输出每一桌的信息，最后按字母顺序依次输出每位客户需要支付的金额。不考虑各桌时间段的问题，同一个客户的所有table金额都要累加。
输出用户支付金额格式：
用户姓名+英文空格+手机号+英文空格+支付金额
注意：不同的四舍五入顺序可能会造成误差，请按以下步骤累计一桌菜的菜价：
计算每条记录的菜价：将每份菜的单价按份额进行四舍五入运算后，乘以份数计算多份的价格，然后乘以折扣，再进行四舍五入，得到本条记录的最终支付价格。
将所有记录的菜价累加得到整桌菜的价格。
输入格式:
桌号标识格式：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 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 21/30/00
1 麻婆豆腐 3 1 2
2 油淋生菜 2 1
3 麻婆豆腐 2 3 2
end
输出样例1:
在这里给出相应的输出。例如：
table 1 out of opening hours
输入样例2:
一种口味的菜品。例如：
麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 20/30/00
1 麻婆豆腐 2 1 2
2 油淋生菜 2 1
3 麻婆豆腐 2 3 2
end
输出样例2:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 24
2 油淋生菜 14
3 麻婆豆腐 48
table 1: 86 62 川菜 4 稍辣
tom 13605054400 62
输入样例3:
辣度值超出范围。例如：
麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 18/30/00
1 麻婆豆腐 6 1 2
2 油淋生菜 1 1
3 麻婆豆腐 5 3 2
end
输出样例3:
在这里给出相应的输出。例如：
table 1:
spicy num out of range :6
2 油淋生菜 9
3 麻婆豆腐 48
table 1: 57 41 川菜 2 爆辣
tom 13605054400 41
输入样例4:
同一用户对应多桌菜。例如：
麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 18/30/00
1 麻婆豆腐 1 1 2
2 油淋生菜 1 1
3 麻婆豆腐 2 2 2
table 2 : tom 13605054400 2023/5/6 18/30/00
1 麻婆豆腐 2 1 2
2 麻辣鸡丝 2 2
3 麻婆豆腐 2 1 1
end
输出样例4:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 24
2 油淋生菜 9
3 麻婆豆腐 36
table 2:
1 麻婆豆腐 24
2 麻辣鸡丝 30
3 麻婆豆腐 12
table 1: 69 49 川菜 4 稍辣
table 2: 66 66 川菜 3 稍辣
tom 13605054400 115
输入样例5:
多用户多桌菜。例如：
东坡肉 浙菜 25 T
油淋生菜 9
蜜汁灌藕 浙菜 10 T
刀削面 晋菜 10 T
醋浇羊肉 晋菜 30 T
麻婆豆腐 川菜 12 T
麻辣鸡丝 川菜 15 T
table 1 : tom 13605054400 2023/5/6 12/30/00
1 醋浇羊肉 4 1 1
3 刀削面 1 1 3
2 东坡肉 3 2 1
4 麻辣鸡丝 2 1 1
table 2 : jerry 18100334566 2023/5/1 12/30/00
1 醋浇羊肉 1 1 2
3 麻婆豆腐 2 2 1
4 麻辣鸡丝 2 3 3
table 3 : jerry 18100334566 2023/5/1 12/30/00
1 醋浇羊肉 2 1 1
3 蜜汁灌藕 1 1 2
2 东坡肉 2 2 1
4 麻辣鸡丝 5 1 1
end
输出样例5:
在这里给出相应的输出。例如：
table 1:
1 醋浇羊肉 30
3 刀削面 30
2 东坡肉 38
4 麻辣鸡丝 15
table 2:
1 醋浇羊肉 60
3 麻婆豆腐 18
4 麻辣鸡丝 90
table 3:
1 醋浇羊肉 30
3 蜜汁灌藕 20
2 东坡肉 38
4 麻辣鸡丝 15
table 1: 113 113 川菜 1 稍辣 晋菜 4 稍酸 浙菜 1 甜
table 2: 168 118 川菜 4 稍辣 晋菜 2 微酸
table 3: 103 73 川菜 1 爆辣 晋菜 1 稍酸 浙菜 3 微甜
jerry 18100334566 191
tom 13605054400 113
输入样例6:
多用户多桌菜含代点菜。例如：
东坡肉 浙菜 25 T
油淋生菜 9
蜜汁灌藕 浙菜 10 T
刀削面 晋菜 10 T
醋浇羊肉 晋菜 30 T
麻婆豆腐 川菜 12 T
麻辣鸡丝 川菜 15 T
table 1 : tom 13605054400 2023/5/6 12/30/00
1 醋浇羊肉 4 1 1
3 刀削面 1 1 3
2 东坡肉 3 2 1
4 麻辣鸡丝 2 1 1
table 2 : jerry 18100334566 2023/5/1 12/30/00
1 1 醋浇羊肉 0 1 2
3 麻婆豆腐 2 2 1
4 麻辣鸡丝 2 3 3
table 3 : lucy 18957348763 2023/5/1 12/30/00
1 醋浇羊肉 2 1 1
3 蜜汁灌藕 1 1 2
2 东坡肉 2 2 1
4 麻辣鸡丝 5 1 1
end
输出样例6:
在这里给出相应的输出。例如：
table 1:
1 醋浇羊肉 30
3 刀削面 30
2 东坡肉 38
4 麻辣鸡丝 15
table 2:
1 table 2 pay for table 1 60
3 麻婆豆腐 18
4 麻辣鸡丝 90
table 3:
1 醋浇羊肉 30
3 蜜汁灌藕 20
2 东坡肉 38
4 麻辣鸡丝 15
table 1: 113 113 川菜 1 稍辣 晋菜 6 微酸 浙菜 1 甜
table 2: 168 118 川菜 4 稍辣
table 3: 103 73 川菜 1 爆辣 晋菜 1 稍酸 浙菜 3 微甜
jerry 18100334566 118
lucy 18957348763 73
tom 13605054400 113
输入样例7:
错误的菜品记录和桌号记录，用户丢弃。例如：
东坡肉 25 T
油淋生菜 9
table 1 : tom 136050540 2023/5/1 12/30/00
2 东坡肉 3 2 1
end
输出样例7:
在这里给出相应的输出。例如：
wrong format wrong format
1 import java.util.Scanner;
2 import java.time.LocalDate;
3
4
5 public class Main {
6 public static void main(String[] args) {
7 Scanner input = new Scanner(System.in);
8 Menu menu = new Menu();
9 Table[] tablemes = new Table[10];
10 String dishName; //dishName为用户输入的菜名
11 String[] temp;
12 int orderNum=0, portion, amount;
13 int i=0;
14 int tablenum=0;
15 int onum = 0;
16 int dengji = 0;
17 String type = "普通";
18 Dish dish;
19 while (true) {
20 String st = input.nextLine();
21 temp = st.split(" ");
22 if(st.equals("end"))
23 break;
24 int count = temp.length;
25 if (count == 2) {
26 if (temp[1].equals("delete")) {//第二个为delete
27 onum = Integer.parseInt(temp[0]);
28 int c = tablemes[tablenum].torder.delARecordByOrderNum(onum);
29 if(tablemes[tablenum].torder.findRecordByNum(onum)!=null) {//删除的菜品记录存在
30 if(tablemes[tablenum].torder.findRecordByNum(onum).d.type.equals("普通")) {//删除菜品为普通菜
31 tablemes[tablenum].sumprice -= c;
32 tablemes[tablenum].disprice -= Math.round( c*tablemes[tablenum].discount);
33 }
34 else {//删除菜品为特色菜
35 tablemes[tablenum].sumTprice -= c;
36 tablemes[tablenum].disprice -= Math.round( c*tablemes[tablenum].Tdiscount);
37 if(tablemes[tablenum].torder.findRecordByNum(onum).d.type.equals("川菜")) {
38 tablemes[tablenum].torder.avspicy =
39 (tablemes[tablenum].torder.avspicy * tablemes[tablenum].torder.chuancai -
40 tablemes[tablenum].torder.findRecordByNum(onum).level * tablemes[tablenum].torder.findRecordByNum(onum).amount) /
41 (tablemes[tablenum].torder.chuancai - tablemes[tablenum].torder.findRecordByNum(onum).amount);
42 tablemes[tablenum].torder.chuancai -= tablemes[tablenum].torder.findRecordByNum(onum).amount;
43 }
44 else if(tablemes[tablenum].torder.findRecordByNum(onum).d.type.equals("晋菜")) {
45 tablemes[tablenum].torder.avsour =
46 (tablemes[tablenum].torder.avsour * tablemes[tablenum].torder.jincai -
47 tablemes[tablenum].torder.findRecordByNum(onum).level * tablemes[tablenum].torder.findRecordByNum(onum).amount) /
48 (tablemes[tablenum].torder.jincai - tablemes[tablenum].torder.findRecordByNum(onum).amount);
49 tablemes[tablenum].torder.jincai -= tablemes[tablenum].torder.findRecordByNum(onum).amount;
50 }
51 else if(tablemes[tablenum].torder.findRecordByNum(onum).d.type.equals("浙菜")) {
52 tablemes[tablenum].torder.avsweet =
53 (tablemes[tablenum].torder.avsweet * tablemes[tablenum].torder.zhecai -
54 tablemes[tablenum].torder.findRecordByNum(onum).level * tablemes[tablenum].torder.findRecordByNum(onum).amount) /
55 (tablemes[tablenum].torder.zhecai - tablemes[tablenum].torder.findRecordByNum(onum).amount);
56 tablemes[tablenum].torder.zhecai -= tablemes[tablenum].torder.findRecordByNum(onum).amount;
57 }
58 }
59 }
60
61 }
62 else {//普通菜增加
63 menu.addDish(temp[0], Integer.parseInt(temp[1]),"普通");
64 }
65 }
66
67 else if (count == 4) {
68 if(temp[3].equals("T")) {//特色菜增加
69 menu.addDish(temp[0], Integer.parseInt(temp[2]), temp[1]);
70 }
71 else {
72 //普通菜点单//增加订单的情况；
73 onum =Integer.parseInt(temp[0]);
74 dishName =temp[1];
75 portion = Integer.parseInt(temp[2]);
76 amount = Integer.parseInt(temp[3]);
77 tablemes[tablenum].torder.addARecord(onum,dishName,-1,portion,amount,"普通");
78 dish = menu.searchDish(dishName);
79 if (dish != null) {
80 tablemes[tablenum].torder.records[orderNum].d = dish;
81 int a = tablemes[tablenum].torder.records[orderNum].getPrice();
82 if(tablemes[tablenum].discount>0)
83 System.out.println(tablemes[tablenum].torder.records[orderNum].orderNum + " " + dish.name + " " +a );
84 tablemes[tablenum].sumprice +=a;
85 tablemes[tablenum].disprice += Math.round( a*tablemes[tablenum].discount);
86 }
87 orderNum++;
88 }
89 }
90
91 else if(count == 5){//特色菜点单//增加订单
92 onum =Integer.parseInt(temp[0]);
93 dishName =temp[1];
94 dengji = Integer.parseInt(temp[2]);
95 portion = Integer.parseInt(temp[3]);
96 amount = Integer.parseInt(temp[4]);
97 dish = menu.searchDish(dishName);
98 type = dish.type;
99 if(!dish.validengji(type, dengji)) { // type的辣度等级不合法
100 if(type.equals("川菜")) {
101 System.out.println("spicy num out of range :"+dengji);
102 }
103 else if(type.equals("晋菜")) {
104 System.out.println("acidity num out of range :"+dengji);
105 }
106 else if(type.equals("浙菜")) {
107 System.out.println("sweetness num out of range :"+dengji);
108 }
109 }
110 else {
111 tablemes[tablenum].torder.addARecord(onum,dishName,dengji,portion,amount,type);
112 type = "普通";
113 dish = menu.searchDish(dishName);
114 if (dish != null) {
115 tablemes[tablenum].torder.records[orderNum].d = dish;
116 int a = tablemes[tablenum].torder.records[orderNum].getPrice();
117 if(tablemes[tablenum].discount>0)
118 System.out.println(tablemes[tablenum].torder.records[orderNum].orderNum + " " + dish.name + " " +a );
119 tablemes[tablenum].sumTprice += a;
120 tablemes[tablenum].disprice += Math.round( a*tablemes[tablenum].Tdiscount);
121 }
122 orderNum++;
123 }
124 }
125
126 else if(count == 6) {//代点特色菜
127 onum =Integer.parseInt(temp[0]);
128 int daitable = Integer.parseInt(temp[1]);
129 dishName =temp[2];
130 dengji = Integer.parseInt(temp[3]);
131 portion = Integer.parseInt(temp[4]);
132 amount = Integer.parseInt(temp[5]);
133 dish = menu.searchDish(dishName);
134 type = dish.type;
135 tablemes[daitable].torder.addARecord(onum,dishName,dengji,portion,amount,type);
136 type = "普通";
137 dish = menu.searchDish(dishName);
138 if (dish != null) {
139 tablemes[daitable].torder.records[orderNum].d = dish;
140 int a = tablemes[daitable].torder.records[orderNum].getPrice() * amount;
141 if(tablemes[daitable].discount>0)
142 System.out.println(tablemes[daitable].torder.records[orderNum].orderNum + " table " +tablenum+" pay for table "+daitable+ " " +a );
143 tablemes[tablenum].sumTprice += a;
144 tablemes[tablenum].disprice += Math.round( a*tablemes[tablenum].Tdiscount);
145 }
146 }
147
148 else if (count == 7) {//三个空格 ///桌子信息
149 if (temp[0].equals("table")) {//桌号
150 tablenum++;//跳过0;
151 orderNum = 0;
152 tablemes[tablenum] = new Table(tablenum,temp[3],temp[4]);
153 tablemes[tablenum].time.setTenDate(temp[5]);
154 tablemes[tablenum].time.setTenTime(temp[6]);
155 tablemes[tablenum].discount(tablemes[tablenum].time.getTimeofDay(), tablemes[tablenum].time.getDayOfWeek());
156 tablemes[tablenum].Tdiscount(tablemes[tablenum].time.getDayOfWeek());
157 if(tablemes[tablenum].discount>0)
158 System.out.println("table " + tablenum + ": ");
159 }
160 }
161 else {
162 System.out.println("wrong format");
163 System.exit(0);
164 }
165
166 }
167 for (i = 1; i <= tablenum; i++) {
168 if (tablemes[i].Gettottalprice() == 0)//输出价格等信息
169 System.exit(0);
170 //输出 川菜+份数+辣度 等等等等等信息..............
171 if (tablemes[i].discount > 0) {
172 if (tablemes[i].torder.chuancai != 0) {
173 System.out.println("川菜 " + tablemes[i].torder.chuancai + " " + tablemes[i].torder.word("川菜"));
174 }
175 if (tablemes[i].torder.jincai != 0) {
176 if (tablemes[i].torder.chuancai != 0) {
177 System.out.println(" 晋菜 " + tablemes[i].torder.jincai + " " + tablemes[i].torder.word("晋菜"));
178 } else
179 System.out.println("晋菜 " + tablemes[i].torder.jincai + " " + tablemes[i].torder.word("晋菜"));
180 }
181 if (tablemes[i].torder.zhecai != 0) {
182 if (tablemes[i].torder.chuancai != 0 || tablemes[i].torder.jincai != 0) {
183 System.out.println(" 浙菜 " + tablemes[i].torder.zhecai + " " + tablemes[i].torder.word("浙菜"));
184 } else
185 System.out.println("浙菜 " + tablemes[i].torder.zhecai + " " + tablemes[i].torder.word("浙菜"));
186 }
187 }
188 }
189 Customer customer = new Customer();
190 for(i = 1; i<=tablenum; i++) {
191 customer.Setcustomer(tablemes[i].name,tablemes[i].telnum,tablemes[i].disprice);
192 }
193 customer.paixu();
194 for(i = 0;i<30;i++) {
195 if(customer.name[i]!=null) {
196 System.out.println(customer.name[i]+" "+customer.telnum[i]+" "+customer.sumprice[i]);
197 }
198 }
199 }
200 }
201
202 class Customer{
203 String[] name = new String[30];
204 String[] telnum = new String[30];
205 int[] sumprice = new int[30];
206 int i = 0;//保存用户个数
207 int j = 0;
208 int k = 1;//k=0时，用户重复；k=1时，新名字
209 public void Setcustomer(String name, String telnum,int sumprice) {
210 if(i==0) {//保存第一位用户
211 this.name[i] = name;
212 this.telnum[i] = telnum;
213 this.sumprice[i] = sumprice;
214 i++;
215 }
216 else {//
217 for(j=0; j<i ;j++) {
218 if(this.name[j].equals(name)) {//同一个用户
219 this.sumprice[j] += sumprice;//更改用户支付总价
220 k = 0;
221 }
222 }
223 if(k == 1){//新用户
224 this.name[i] = name;
225 this.telnum[i] = telnum;
226 this.sumprice[i] = sumprice;
227 i++;
228 }
229 }
230 }
231
232 public void paixu() {
233 int n = 0;
234 int m = 0;
235 String temp;
236 int t = 0;
237 for(n=0;n<i-1;n++) {
238 for(m=n;m<i-1;m++) {
239 if(this.name[m].charAt(0)>this.name[m+1].charAt(0)) {
240 temp=name[m];
241 name[m]=name[m+1];
242 name[m+1]=temp;
243 temp=telnum[m];
244 telnum[m]=telnum[m+1];
245 telnum[m+1]=temp;
246 t=sumprice[m];
247 sumprice[m]=sumprice[m+1];
248 sumprice[m+1]=t;
249 }
250 }
251 }
252 }
253 }
254
255
256 class Dish {//菜品类：对应菜谱上一道菜的信息。
257 String name = "";//菜品名称
258 int unit_price;//单价
259 String type = "普通";//
260
261 public Dish() {
262 super();
263 }
264
265 public Dish(String name, int unit_price, String type) {
266 super();
267 this.name = name;
268 this.unit_price = unit_price;
269 this.type = type;
270 }
271
272 public Dish(String name, int unit_price) {
273 super();
274 this.name = name;
275 this.unit_price = unit_price;
276 }
277
278 public void resetDish(String name, int unit_price, String type) {
279 this.name = name;
280 this.unit_price = unit_price;
281 this.type = type;
282 }
283
284 public int getPrice(int portion) {
285 //计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份)
286 int price = 0;
287 if(portion == 1) {
288 price = unit_price;
289 }
290 else if(portion == 2) {
291 price = (int)(unit_price * 1.5 + 0.5);
292 }
293 else if(portion == 3) {
294 price = (int)(unit_price * 2 + 0.5);
295 }
296 else System.out.println("portion out of range " + portion);
297 return price;
298 }
299 public boolean validengji(String type, int dengji) {
300 if(type.equals("川菜")&&dengji>=0&&dengji<=5) {
301 return true;
302 }
303 else if(type.equals("晋菜")&&dengji>=0&&dengji<=4){
304 return true;
305 }
306 else if(type.equals("浙菜")&&dengji>=0&&dengji<=3){
307 return true;
308 }
309 return false;
310 }
311 }
312
313 class Menu {//菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
314 Dish[] dishs = new Dish[30];//普通菜品数组，保存所有非特价菜菜品信息
315 static int i = 0;//dish个数
316 public Dish searchDish(String dishName){
317 //根据菜名在菜谱中查找菜品信息，返回Dish对象.
318 int j;
319 for(j=0;j<i;j++) {
320 if(dishs[j]==null)
321 System.out.println(dishName+" does not exist");
322 if(dishs[j].name.equals(dishName)) {
323 return dishs[j];//找到菜
324 }
325 }
326 System.out.println(dishName+" does not exist");
327 return null;//没找到，返回空
328 }
329
330 public void addDish(String dishName,int unit_price,String type){
331 //添加一道菜品信息
332 int m = 0;
333 for(int j = 0; j<i ;j++) {
334 if(dishs[j].name.equals(dishName)) {
335 dishs[j].resetDish(dishName, unit_price, type);
336 m++;
337 }
338 }
339 if(m==0) {
340 dishs[i] = new Dish(dishName, unit_price, type);
341 i++;
342 }
343
344 }
345 }
346
347 class Order {//订单类：保存用户点的所有菜的信息。
348 Record[] records = new Record[30];//保存订单上每一道的记录
349 int k = 0;//records数组的元素个数
350 //平均 口味（辣/酸/甜）度
351 double avspicy = 0;
352 double avsour = 0;
353 double avsweet = 0;
354 int chuancai = 0;
355 int jincai = 0;
356 int zhecai = 0;
357 public Order() {
358 super();
359 }
360
361 public String word(String type) {
362 if(type.equals("川菜")) {
363 int n = (int)Math.round(avspicy);
364 switch(n) {
365 case 0: return "不辣";
366 case 1: return "微辣";
367 case 2: return "稍辣";
368 case 3: return "辣";
369 case 4: return "很辣";
370 case 5: return "爆辣";
371 }
372 }
373 else if(type.equals("晋菜")) {
374 int n = (int)Math.round(avsour);
375 switch(n) {
376 case 0: return "不酸";
377 case 1: return "微酸";
378 case 2: return "稍酸";
379 case 3: return "酸";
380 case 4: return "很酸";
381 }
382 }
383 else if(type.equals("浙菜")) {
384 int n = (int)Math.round(avsweet);
385 switch(n) {
386 case 0: return "不甜";
387 case 1: return "微甜";
388 case 2: return "稍甜";
389 case 3: return "甜";
390 }
391 }
392 return null;
393 }
394
395 public void addARecord(int orderNum,String dishName,int dengji,int portion,int amount, String type){
396 //添加一条菜品信息到订单中。
397 records[k] = new Record();
398 records[k].d.name=dishName;
399 records[k].orderNum=orderNum;
400 records[k].level=dengji;
401 records[k].portion=portion;
402 records[k].amount=amount;
403 k++;
404 if(type.equals("川菜")) {
405 if(avspicy == 0) {
406 avspicy = dengji;
407 chuancai = chuancai + amount ;
408 }
409 else {
410 avspicy = (dengji*amount + avspicy * chuancai)/(amount+chuancai);
411 chuancai = chuancai + amount;
412 }
413 }
414 else if(type.equals("晋菜")) {
415 if(avsour == 0) {
416 avsour =dengji;
417 jincai = jincai + amount ;
418 }
419 else {
420 avsour = (dengji*amount + avsour * jincai)/(amount + jincai);
421 jincai = jincai + amount;
422 }
423 }
424 else if(type.equals("浙菜")){
425 if(avsweet == 0) {
426 avsweet =dengji;
427 zhecai = zhecai + amount ;
428 }
429 else {
430 avsweet = (dengji*amount + avsweet * zhecai)/(amount + zhecai);
431 zhecai = zhecai + amount;
432 }
433
434 }
435 }
436
437 public int delARecordByOrderNum(int orderNum){
438 //根据序号删除一条记录
439 for(int i = 0; i < k; i++)
440 if(records[i].orderNum == orderNum)
441 return records[i].getPrice();
442 System.out.println("delete error;");
443 return 0;
444 }
445
446
447 public Record findRecordByNum(int orderNum){
448 //根据序号查找一条记录
449 for(int j=0;j<k;j++) {
450 if(records[j].orderNum==orderNum) {
451 return records[j];
452 }
453 }
454 return null;//没找到，返回空
455 }
456 }
457
458 class Record {//点菜记录类：保存订单上的一道菜品记录
459 int orderNum = 0;//序号
460 Dish d = new Dish(" ",0);//菜品
461 int level = 0; //辣度/酸度/甜度
462 int portion = 1; //份额（1/2/3代表小/中/大份）
463 int amount = 1; //菜品数量
464 public int getPrice(){
465 //计价，计算本条记录的价格
466 return d.getPrice(portion)*amount;
467 }
468 public void setOrderNum(int orderNum) {
469 this.orderNum = orderNum;
470 }
471 }
472
473 class Table {
474 int tableNum = 0;//桌号
475 int sumprice = 0;//一桌价格原价
476 int sumTprice = 0;
477 int disprice = 0;//一桌折扣价
478 float discount = -1;
479 float Tdiscount = -1;
480 String name;//名字
481 String telnum;//电话号码
482 public Table(int tableNum,String name,String telnum) {
483 this.tableNum=tableNum;
484 this.name = name;
485 this.telnum = telnum;
486 }
487 Order torder = new Order();
488 Time time = new Time();
489 int Gettottalprice(){
490 if(discount>0){
491 System.out.print("table " + tableNum + ": " + (sumprice+sumTprice) +" "+ disprice + " ");
492 return 1;
493 }else {
494 System.out.println("table " + tableNum + " out of opening hours");
495 return 0;
496 }
497 }
498 void Tdiscount(int dayofweek){
499 if(dayofweek>=1&&dayofweek<=5)
500 Tdiscount =0.7F;
501 else if(dayofweek==6||dayofweek==7)
502 Tdiscount =1.0F;
503 }
504 void discount(int timeofday,int dayofweek){
505 if((timeofday>=10.5*3600&&timeofday<=14.5*3600)&&(dayofweek>=1&&dayofweek<=5))
506 discount =0.6F;
507 else if((timeofday>=17*3600&&timeofday<=20.5*3600)&&(dayofweek>=1&&dayofweek<=5))
508 discount =0.8F;
509 else if((timeofday>=9.5*3600&&timeofday<=21.5*3600)&&(dayofweek==6||dayofweek==7))
510 discount =1.0F;
511 }
512 }
513
514
515 class Time {
516 int [] TenTime;
517 int [] TenDate;
518 public void setTenDate(String DATE) {
519 String[] strings=DATE.split("/");//字符型
520 int[] TenDate=new int [3];
521 for(int i=0;i<3;i++)
522 TenDate[i]=Integer.parseInt(strings[i]);//Int
523 this.TenDate = TenDate;
524 }
525 public void setTenTime(String TIME) {
526 String[] strings=TIME.split("/");//字符型
527 int[] TenTime=new int [3];
528 for(int i=0;i<3;i++)
529 TenTime[i]=Integer.parseInt(strings[i]);//Int
530 this.TenTime = TenTime;
531 }
532 public int getDayOfWeek(){// 获取周第几天
533 LocalDate date = LocalDate.of(TenDate[0],TenDate[1],TenDate[2]);//LocalDate
534 return (date.getDayOfWeek().getValue());//调用LocalDate类中的getDayOfWeek方法，获取周第几天
535 }
536
537 public int getTimeofDay(){
538 int tentime;
539 tentime=TenTime[0]*3600+TenTime[1]*60+TenTime[2];
540 return tentime;
541 }
542 }
主要难点：菜系的判断、划分，菜品品味的判断。这一题我同样没能完全做对。
期中考试
我个人认为难度适中，从简单到复杂，具有一定的区分度。主要考察了课堂讲的内容。
继承与多态：
将测验1与测验2的类设计进行合并设计，抽象出Shape父类（抽象类），Circle及Rectangle作为子类，类图如下所示：
试编程完成如上类图设计，主方法源码如下（可直接拷贝使用）：
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;
}
}
其中，printArea(Shape shape)方法为定义在Main类中的静态方法，体现程序设计的多态性。
输入格式:
输入类型选择（1或2，不考虑无效输入）
对应图形的参数（圆或矩形）
输出格式:
图形的面积（保留两位小数）
输入样例1:
1
5.6
输出样例1:
在这里给出相应的输出。例如：
98.52
输入样例2:
2
5.6
-32.5
9.4
-5.6
输出样例2:
在这里给出相应的输出。例如：
102.22
1 import java.util.Scanner;
2
3 public class Main {
4 public static void main(String[] args) {
5 // TODO Auto-generated method stub
6 Scanner input = new Scanner(System.in);
7
8 int choice = input.nextInt();
9
10 switch(choice) {
11 case 1://Circle
12 double radiums = input.nextDouble();
13 Shape circle = new Circle(radiums);
14 if(radiums <= 0)
15 {
16 System.out.println("Wrong Format");
17 }
18 else
19 printArea(circle);
20 break;
21 case 2://Rectangle
22 double x1 = input.nextDouble();
23 double y1 = input.nextDouble();
24 double x2 = input.nextDouble();
25 double y2 = input.nextDouble();
26
27 Point leftTopPoint = new Point(x1,y1);
28 Point lowerRightPoint = new Point(x2,y2);
29
30 Rectangle rectangle = new Rectangle(leftTopPoint,lowerRightPoint);
31
32 printArea(rectangle);
33 break;
34 }
35
36 }
37 public static void printArea(Shape shape){
38 System.out.printf("%.2f\n",shape.getArea());
39 }
40 }
41 class Shape{
42 Shape(){
43
44 }
45 public double getArea()
46 {
47 return getArea();
48 }
49 }
50
51 class Circle extends Shape{
52 private double radiums = 0;
53 Circle(){
54 }
55 Circle(double radiums)
56 {
57 this.radiums=radiums;
58 }
59 public double getRadiums()
60 {
61 return radiums;
62 }
63 public void setRadiums(double radiums)
64 {
65 this.radiums=radiums;
66 }
67 public double getArea()
68 {
69 return radiums*radiums*3.1415926535;
70 }
71 }
72
73 class Rectangle extends Shape{
74 Point topLeftPoint;
75 Point lowerRightPoint;
76 Rectangle(){
77 }
78 Rectangle(Point topLeftPoint,Point lowerRightPoint)
79 {
80 this.topLeftPoint=topLeftPoint;
81 this.lowerRightPoint=lowerRightPoint;
82 }
83 public Point getTopLeftPoint(){
84 return topLeftPoint;
85 }
86 public void setTopLeftPoint(Point topLeftPoint){
87 this.topLeftPoint=topLeftPoint;
88 }
89 public Point getLowerRightPoint(){
90 return lowerRightPoint;
91 }
92 public void setLowerRightPoint(Point lowerRightPoint){
93 this.lowerRightPoint=lowerRightPoint;
94 }
95 public double getLength(){
96 return Math.abs(topLeftPoint.x-lowerRightPoint.x);
97 }
98 public double getHeight(){
99 return Math.abs(topLeftPoint.y-lowerRightPoint.y);
100 }
101 public double getArea(){
102 return getHeight()*getLength();
103 }
104 }
105
106 class Point{
107 double x,y;
108
109 Point(){
110 }
111 Point(double x,double y)
112 {
113 this.x=x;
114 this.y=y;
115 }
116 public double getX(){
117 return x;
118 }
119 public void setX(double x){
120 this.x=x;
121 }
122 public double getY(){
123 return y;
124 }
125 public void setY(double y){
126 this.y=y;
127 }
128 }
三.踩坑心得
在进行有关时间运算的题目集的编写时，我耗费了大量的时间编写代码用于日期的判断，包括输入输出的转换时间（24小时制格式： HH/MM/SS）和有时侯输入输出时间不是这个模式时的匹配。后来使用java自带的时间间隔计算方法，变换了计算方式：
import·java.time.LocalDate;
import·java.time.temporal.ChronoUnit;
import·java.time.temporal.ChronoField;
long·monthinterval·=·secondday.getMonthValue()-firstday.getMonthValue();
long·yearinterval·=·secondday.getYear()-firstday.getYear();
四.主要困难与改进意见
我在这段时间的学习过程中，遇到的最大的问题就是对JAVA基本功能的不了解和对类中操作的不熟悉，在进行作业时，经常碰到一个本来可以通过JAVA8自带的库解决的问题，但我根本不知道有这个功能，导致自己尝试写函数，花费了大量的时间。再就是对类中操作的不熟悉，碰到需要一段较长代码才能实现功能时，在类中我不知道应该从何开始下手，导致较长代码无从下手。遇到的主要困难是在进行题目集5、6的100分大题目时，我甚至不知道应该从哪一步开始编写代码。
在系统地学习了java编码的八大原则后略微有了一定的思路与想法，但还需习题来练习。
五.总结
我自认为这段时间的学习算是比较认真了，但是在完成题目集的过程中还是碰到了很多的困难，面对动则数百行的代码，我一度不知从何下手，也曾因为写了两三天的代码碰到一堆error而苦恼心烦，但还好我始终没有放弃。做不到全对就尽自己最大的能力争取去多拿一点分。在系统的学了封装、继承、多态接口、正则表达式、8项基本原则等内容后，我不清楚我的编码能力得到了多大的提升，但是我对于java语言的理解、编码的规范性无疑是有了新层次的理解。
标签：空格,JAVA,记录,期中考试,Blog,int,菜品,table,tablemes From： https://www.cnblogs.com/nchu212072lyt/p/17842545.html