前言
好久不见，本次Blog主要总结这几个月来的大作业情况、期中考试以及学习情况，话不多说，直接开始。
大作业：这两次的大作业仍然是菜单类型的迭代，考点主要还是设计思路，相比于前几次菜单大作业，这两次新增知识点，我个人认为主要有正则表达式的主要使用、继承类的使用。难度而言，在多次迭代后，这两次大作业的难度主体不大，难点在于对于数据的处理然后给出相应的输出、以及对于数据计算的处理。
期中考试：本次期中考试比较简单，也没遇到什么困难点，就主要聊聊考点。本次期中考试考点主要为这段时间学习的知识点，如类的构建以及封装、类的继承以及抽象类的运用、类的接口。本次考试主要难点在于最后一题，本题难点主要在于考察了新的类和方法“Comparable”、“naturOrder()”和“compareTo()”，要发现后两个方法的关联性，但在无敌的IDEA的debug功能面前，比较容易发现，故本次期中考试难度不高。
学习总结：最近学习的东西较多，故这次学习总结很有必要。首先我们主要学习设计思路，了解什么样的设计才是好设计，如要提高代码的复用性、对象之间的联系应该要少、代码的耦合度要降低、设计if等表达语句的时候，要尽量降低代码的复杂度，减少出现bug的概率、类的职责要保持单一、设计过程中要保留代码的可扩展性、程序最好要保持高内聚、低耦合特性......然后我们又学习了类的关系：组合、聚合、关联、依赖。以下解释按照我的个人理解。依赖：指某个类的方法的使用需要传入其他类作为参数，否则无法调用。关联：指某一个类是另一个类的关联变量。聚合：指整体和个体之间的关系，意味着类A的对象包含类B的对象。整体和个体是可以分离的，他们具有各自的生命周期，个体可以属于多个对象，也可以被多个对象共享。组合：相比于聚合，某类中作为属性的类是直接在该类中生成的，与该类同时存在同时消失，具有一样的生命周期。然后学习了继承与接口以及抽象类。继承指子类继承父类的属性与方法，同时一个子类只能有一个父类。接口指子类通过多个接口获得属于自己特性的方法，一个子类可以有多个接口。抽象类主要运用于继承与接口（接口本身即为抽象类），继承了的子类要对其的方法进行覆写。最后初步学习了JAVA的图形化界面，包括如何配置javaFX的环境，以及简单的方法。
前言到这里结束了，接下来是两次大作业的详细分析---
设计与分析
第四次大作业
本体大部分内容与菜单计价程序-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.io.BufferedReader; 2 import java.io.IOException; 3 import java.io.InputStreamReader; 4 import java.time.LocalDate; 5 import java.util.ArrayList; 6 public class Main { 7 public static void main(String[] args) throws IOException { 8 BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); 9 Dish[] dishes = new Dish[10]; 10 SpecialDish[] specialDishes = new SpecialDish[10]; 11 ArrayList<Table> tables = new ArrayList<>(); 12 Table table = new Table(); 13 Record[] records = new Record[10]; 14 Order order = new Order(); 15 Menu menu = new Menu(); 16 lastPrint print = new lastPrint(); 17 int x = 0 , y = 0 , z = 0 , z1 = 0 , tableNum , dishNum , portion , num , unit_price , deleteNum; 18 String menuName , dayTime , hourTime , name; 19 boolean isRightTable = false ,isDish = false , v = false; 20 for(;;){ 21 String input = in.readLine(); 22 if(input.equals("end")){ 23 if(x!=0 && isRightTable){ 24 table.order = order; 25 tables.add(x-1 , table); 26 } 27 print.tables = tables; 28 print.print(); 29 break; 30 } 31 String[] getInput = input.split(" "); 32 if(getInput[0].equals("table")){ 33 if(input.matches("^(table)( )([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})$")) { 34 if(x != 0 && isRightTable) { 35 table.order = order; 36 tables.add(x-1 , table); 37 table = new Table(); 38 y = 0; 39 } 40 isRightTable = true; 41 tableNum = Integer.parseInt(getInput[1]); 42 dayTime = getInput[2]; 43 hourTime = getInput[3]; 44 if(tableNum>55){ 45 isRightTable = false; 46 System.out.println(tableNum +" table num out of range"); 47 continue; 48 } 49 table.tableNum = tableNum; 50 table.mainTime = dayTime; 51 table.remainTime = hourTime; 52 if(!table.timeJudgement()){ 53 isRightTable = false; 54 System.out.println(table.tableNum+" date error"); 55 continue; 56 } 57 if(!table.isRange()){ 58 isRightTable = false; 59 System.out.println("not a valid time period"); 60 continue; 61 } 62 if(!table.timeJudgement1()){ 63 isRightTable = false; 64 System.out.println("table " +table.tableNum + " out of opening hours"); 65 continue; 66 } 67 v = false; 68 order = new Order(); 69 isDish = true; 70 records = new Record[10]; 71 System.out.println("table "+tableNum+": "); 72 x++; 73 } 74 else{ 75 v = true; 76 System.out.println("wrong format"); 77 } 78 } 79 else if(v){ 80 continue; 81 } 82 else if(input.matches("^(\\S+)( )([1-9][0-9]*)$")){ 83 if(isDish){ 84 if(isRightTable){ 85 System.out.println("invalid dish"); 86 } 87 continue; 88 } 89 int i = 0; 90 menuName = getInput[0]; 91 unit_price = Integer.parseInt(getInput[1]); 92 if(unit_price>=300){ 93 System.out.println(menuName+" price out of range "+unit_price); 94 continue; 95 } 96 if(z == 0) { 97 dishes[0] = menu.addDish(menuName , unit_price); 98 z++; 99 } 100 else{ 101 for(;i < z ; i++) { 102 if(menuName.equalsIgnoreCase(dishes[i].name)) { 103 dishes[i].unit_price = unit_price; 104 break; 105 } 106 } 107 } 108 if(i == z){ 109 dishes[z] = menu.addDish(menuName , unit_price); 110 z++; 111 } 112 menu.dishes = dishes; 113 menu.dishNum = z; 114 } 115 else if(input.matches("^(\\S+)( )([1-9][0-9]*)( )(T)$")){ 116 if(isDish){ 117 if(isRightTable){ 118 System.out.println("invalid dish"); 119 } 120 continue; 121 } 122 int i = 0; 123 menuName = getInput[0]; 124 unit_price = Integer.parseInt(getInput[1]); 125 if(unit_price>=300){ 126 System.out.println(menuName+" price out of range "+unit_price); 127 } 128 if(z1 == 0) { 129 specialDishes[0] = menu.addSpecialDish(menuName , unit_price); 130 z1++; 131 } 132 else{ 133 for(;i < z1 ; i++) { 134 if(menuName.equalsIgnoreCase(specialDishes[i].name)) { 135 specialDishes[i].unit_price = unit_price; 136 break; 137 } 138 } 139 } 140 if(i == z1){ 141 specialDishes[z1] = menu.addSpecialDish(menuName , unit_price); 142 z1++; 143 } 144 menu.specialDishes = specialDishes; 145 menu.dishNum1 = z1; 146 } 147 else if(input.matches("^([1-9][0-9]*)( )(\\S+)( )([1-9][0-9]*)( )([1-9][0-9]*)$")){ 148 if(isRightTable){ 149 dishNum = Integer.parseInt(getInput[0]); 150 name = getInput[1]; 151 portion = Integer.parseInt(getInput[2]); 152 num = Integer.parseInt(getInput[3]); 153 if(y>0){ 154 if(records[y-1].orderNum>=dishNum){ 155 System.out.println("record serial number sequence error"); 156 continue; 157 } 158 } 159 if(menu.searthDish(name) != null) { 160 if((portion==1||portion==2||portion==3)&&num<=15){ 161 records[y] = new Record(); 162 records[y] = order.addARecord(dishNum , name , portion , num , menu); 163 records[y].isSpecialDish = false; 164 System.out.println(records[y].orderNum+" "+records[y].d.name+" "+records[y].getPrice()); 165 y++; 166 order.records = records; 167 order.dishNum = y; 168 } 169 } 170 else if(menu.searthSpecialDish(name) != null) { 171 if((portion==1||portion==2||portion==3)&&num<=15){ 172 records[y] = new Record(); 173 records[y] = order.addASpecialRecord(dishNum , name , portion , num , menu); 174 records[y].isSpecialDish = true; 175 System.out.println(records[y].orderNum+" "+records[y].d.name+" "+records[y].getPrice()); 176 y++; 177 order.records = records; 178 order.dishNum = y; 179 } 180 } 181 else{ 182 System.out.println(name+" does not exist"); 183 continue; 184 } 185 if(portion!=1&&portion!=2&&portion!=3){ 186 System.out.println(dishNum+" portion out of range "+portion); 187 continue; 188 } 189 if(num>15){ 190 System.out.println(dishNum+" num out of range "+num); 191 } 192 } 193 } 194 else if(input.matches("([1-9][0-9]*)( )(delete)")) { 195 if(!isRightTable){ 196 continue; 197 } 198 deleteNum = Integer.parseInt(getInput[0]); 199 if(order.findRecordByNum(deleteNum) == 1){ 200 order.delARecordByOrderNum(deleteNum); 201 } 202 else 203 System.out.println("delete error;"); 204 } 205 else if(input.matches("^([1-9][0-9]*)( )([1-9][0-9]*)( )(\\S+)( )([1-9][0-9]*)( )([1-9][0-9]*)$")) { 206 if(!isRightTable){ 207 continue; 208 } 209 int t = Integer.parseInt(getInput[0]); 210 dishNum = Integer.parseInt(getInput[1]); 211 name = getInput[2]; 212 portion = Integer.parseInt(getInput[3]); 213 num = Integer.parseInt(getInput[4]); 214 for(int i = 0;i<x-1;i++){ 215 if(tables.get(i).tableNum == t){ 216 if(menu.searthDish(name) != null) { 217 records[y] = new Record(); 218 records[y] = order.addARecord(dishNum , name , portion , num , menu); 219 records[y].isSpecialDish = false; 220 System.out.println(dishNum+" table "+table.tableNum+" pay for table "+t+" "+records[y].getPrice()); 221 y++; 222 order.records = records; 223 order.dishNum = y; 224 } 225 else if(menu.searthSpecialDish(name) != null) { 226 records[y] = new Record(); 227 records[y] = order.addASpecialRecord(dishNum , name , portion , num , menu); 228 records[y].isSpecialDish = true; 229 System.out.println(dishNum+" table "+table.tableNum+" pay for table "+t+" "+records[y].getPrice()); 230 y++; 231 order.records = records; 232 order.dishNum = y; 233 } 234 235 else{ 236 System.out.println(name+" does not exist"); 237 } 238 break; 239 } 240 if(i == x-2){ 241 System.out.println("Table number ："+t+" does not exist"); 242 } 243 } 244 if(x-1 == 0){ 245 System.out.println("Table number ："+t+" does not exist"); 246 } 247 } 248 else { 249 System.out.println("wrong format"); 250 } 251 } 252 } 253 } 254 class Dish{ 255 String name; 256 int unit_price; 257 public int getPrice(int portion){ 258 double getPrice=0; 259 if(portion==1) 260 getPrice=unit_price; 261 else if(portion==2) 262 getPrice=unit_price*1.5; 263 else if(portion==3) 264 getPrice=unit_price*2; 265 return (int) Math.round(getPrice); 266 } 267 } 268 class SpecialDish extends Dish{ 269 270 } 271 272 class Menu{ 273 Dish[] dishes; 274 SpecialDish[] specialDishes; 275 int dishNum; 276 int dishNum1; 277 public Dish searthDish(String dishName){ 278 for(int k=0;k<dishNum;k++) { 279 if(dishName.equals(dishes[k].name)){ 280 return dishes[k]; 281 } 282 } 283 return null; 284 } 285 public SpecialDish searthSpecialDish(String dishName){ 286 for(int k=0;k<dishNum1;k++) { 287 if(dishName.equals(specialDishes[k].name)){ 288 return specialDishes[k]; 289 } 290 } 291 return null; 292 } 293 public Dish addDish(String dishName,int unit_price){ 294 Dish addDish=new Dish(); 295 addDish.name=dishName; 296 addDish.unit_price=unit_price; 297 return addDish; 298 } 299 public SpecialDish addSpecialDish(String dishName,int unit_price){ 300 SpecialDish addDish=new SpecialDish(); 301 addDish.name=dishName; 302 addDish.unit_price=unit_price; 303 return addDish; 304 } 305 } 306 class Record{ 307 int orderNum; 308 Dish d; 309 int portion; 310 int num; 311 boolean isSpecialDish; 312 public int getPrice() { 313 return d.getPrice(portion)*num; 314 } 315 } 316 class Order { 317 int dishNum; 318 int allCommonPrice; 319 int allSpecialPrice; 320 Record[] records; 321 public void addPortion() { 322 for(int k = 0;k < dishNum-1;k++){ 323 for(int l = k+1;l<dishNum;l++){ 324 if(records[k].d.name.equals(records[l].d.name)&&records[k].portion == records[l].portion){ 325 records[k].num+=records[l].num; 326 records[l].num = 0; 327 } 328 } 329 } 330 } 331 public void getTotalPrice(){ 332 this.addPortion(); 333 for(int k=0;k<dishNum;k++) { 334 if(!records[k].isSpecialDish) 335 allCommonPrice+=records[k].getPrice(); 336 else 337 allSpecialPrice+=records[k].getPrice(); 338 } 339 } 340 public Record addARecord(int orderNum,String dishName,int portion,int num , Menu menu){ 341 Record x=new Record(); 342 x.d=menu.searthDish(dishName); 343 x.orderNum=orderNum; 344 x.portion=portion; 345 x.num=num; 346 return x; 347 } 348 public Record addASpecialRecord(int orderNum,String dishName,int portion,int num , Menu menu){ 349 Record x=new Record(); 350 x.d=menu.searthSpecialDish(dishName); 351 x.orderNum=orderNum; 352 x.portion=portion; 353 x.num=num; 354 return x; 355 } 356 public void delARecordByOrderNum(int orderNum){ 357 for(int k=0;k<dishNum;k++) { 358 if(orderNum==records[k].orderNum) { 359 if(records[k].num == 0) 360 System.out.println("deduplication "+orderNum); 361 else 362 records[k].num=0; 363 } 364 } 365 } 366 public int findRecordByNum(int orderNum){ 367 for(int k = 0; k<dishNum; k++) { 368 if(records[k].orderNum==orderNum) { 369 return 1; 370 } 371 } 372 return 0; 373 } 374 } 375 class Table{ 376 int tableNum; 377 String mainTime; 378 String remainTime; 379 Order order; 380 double commonDiscount; 381 double specialDiscount; 382 int year; 383 int month; 384 int day; 385 double hour; 386 double minute; 387 double second; 388 LocalDate date; 389 public void getTime(){ 390 String[] x = remainTime.split("/"); 391 String[] y = mainTime.split("/"); 392 year = Integer.parseInt(y[0]); 393 month = Integer.parseInt(y[1]); 394 day = Integer.parseInt(y[2]); 395 hour = Double.parseDouble(x[0]); 396 minute = Double.parseDouble(x[1]); 397 second = Double.parseDouble(x[2]); 398 } 399 public boolean isRange(){ 400 this.getTime(); 401 date = LocalDate.of(year , month , day ); 402 LocalDate date1 = LocalDate.of(2022 , 1 , 1 ); 403 LocalDate date2 = LocalDate.of(2023 , 12 , 31 ); 404 return (date.isAfter(date1) && date.isBefore(date2)) || date.isEqual(date1) || date.isEqual(date2); 405 } 406 public boolean timeJudgement() { 407 if(mainTime.matches("^([0-9]{4})(/)(0[1-9]|[1-9]|1[0-2])(/)(0[1-9]|[1-9]|1[0-9]|2[0-9]|3[0-1])$")){ 408 this.getTime(); 409 if(month == 4||month == 6||month == 9||month == 11){ 410 if(day>30){ 411 return false; 412 } 413 } 414 else if(month == 2){ 415 if(day >29) 416 return false; 417 if(!((year%4==0&&year%100!=0)||year%400==0)) 418 if (day > 28) { 419 return false; 420 } 421 } 422 } 423 else{ 424 return false; 425 } 426 return remainTime.matches("^(0[0-9]|[0-9]|1[0-9]|2[0-3])(/)(0[0-9]|[0-9]|[1-5][0-9])(/)(0[0-9]|[0-9]|[1-5][0-9])$"); 427 } 428 public boolean timeJudgement1(){ 429 this.getTime(); 430 int weekOfDay = date.getDayOfWeek().getValue(); 431 if (weekOfDay == 6 || weekOfDay == 7) { 432 if (hour >= 10 && hour < 21 || hour == 9 && minute >= 30 || hour == 21 && minute < 30 ||hour == 21 && minute == 30 && second == 0) { 433 specialDiscount = commonDiscount = 1; 434 return true; 435 } 436 else { 437 return false; 438 } 439 } 440 if (weekOfDay >= 1 && weekOfDay <= 5) { 441 if (hour > 17 && hour < 20 || hour == 17 && minute >= 0 || hour == 20 && minute < 30 || hour == 20 && minute == 30 && second == 0) { 442 commonDiscount = 0.8; 443 specialDiscount = 0.7; 444 return true; 445 } 446 else if (hour > 10 && hour < 14 || hour == 10 && minute >= 30 || hour == 14 && minute < 30 || hour == 14 && minute == 30 && second == 0) { 447 commonDiscount = 0.6; 448 specialDiscount = 0.7; 449 return true; 450 } 451 else { 452 return false; 453 } 454 } 455 return false; 456 } 457 public int tablePrice() { 458 return (int)Math.round(this.order.allCommonPrice*commonDiscount)+(int)Math.round(this.order.allSpecialPrice*specialDiscount); 459 } 460 public boolean isOneTable(Table a){ 461 this.getTime(); 462 a.getTime(); 463 if(this.date.equals(a.date)){ 464 if(date.getDayOfWeek().getValue() >=1&&date.getDayOfWeek().getValue() <=5){ 465 if ((hour >= 17 && hour <= 20)&&(a.hour >= 17 && a.hour <= 20)){ 466 return true; 467 } 468 else return (hour >= 10 && hour <= 14) && (a.hour >= 10 && a.hour <= 14); 469 } 470 else if(date.getDayOfWeek().getValue() ==6||date.getDayOfWeek().getValue() == 7){ 471 return Math.abs((a.hour - hour) * 3600 + (a.minute - minute) * 60 + (a.second - second)) < 3600; 472 } 473 } 474 return false; 475 } 476 } 477 class lastPrint{ 478 ArrayList<Table> tables = new ArrayList<>(); 479 public void print(){ 480 for(int i = 0;i<tables.size();i++){ 481 tables.get(i).order.getTotalPrice(); 482 for(int j = i+1;j<tables.size();j++){ 483 if(tables.get(i).tableNum==tables.get(j).tableNum&&i!=j){ 484 if(tables.get(j).timeJudgement()&&tables.get(j).isRange()&&tables.get(j).timeJudgement1()&&tables.get(j).tableNum<=55&&tables.get(i).isOneTable(tables.get(j))){ 485 tables.get(j).order.getTotalPrice(); 486 tables.get(i).order.allCommonPrice+=tables.get(j).order.allCommonPrice; 487 tables.get(i).order.allSpecialPrice+=tables.get(j).order.allSpecialPrice; 488 tables.remove(j); 489 j--; 490 } 491 } 492 493 } 494 System.out.println("table " + tables.get(i).tableNum + ": " + (tables.get(i).order.allCommonPrice+tables.get(i).order.allSpecialPrice) + " " + tables.get(i).tablePrice()); 495 } 496 } 497 }
Metrics Details For File 'Main.java'
--------------------------------------------------------------------------------------------
Parameter Value
========= =====
Project Directory D:\java\untitled\src\
Project Name 777777
Checkpoint Name Baseline
File Name Main.java
Lines 497
Statements 360
Percent Branch Statements 26.4
Method Call Statements 131
Percent Lines with Comments 0.0
Classes and Interfaces 8
Methods per Class 2.75
Average Statements per Method 13.55
Line Number of Most Complex Method 7
Name of Most Complex Method Main.main()
Maximum Complexity 57
Line Number of Deepest Block 103
Maximum Block Depth 7
Average Block Depth 4.03
Average Complexity 8.20
--------------------------------------------------------------------------------------------
Most Complex Methods in 7 Class(es): Complexity, Statements, Max Depth, Calls
Dish.getPrice() 4, 8, 3, 1
lastPrint.print() 10, 11, 7, 22
Main.main() 57, 51, 7, 24
Menu.addDish() 1, 4, 3, 0
Menu.addSpecialDish() 1, 4, 3, 0
Menu.searthDish() 3, 4, 5, 1
Menu.searthSpecialDish() 3, 4, 5, 1
Order.addARecord() 1, 6, 3, 0
Order.addASpecialRecord() 1, 6, 3, 0
Order.addPortion() 5, 5, 6, 1
Order.delARecordByOrderNum() 5, 6, 5, 1
Order.findRecordByNum() 3, 4, 5, 0
Order.getTotalPrice() 4, 6, 4, 1
Record.getPrice() 1, 1, 3, 1
Table.getTime() 1, 8, 3, 8
Table.isOneTable() 11, 11, 6, 12
Table.isRange() 4, 5, 3, 8
Table.tablePrice() 1, 1, 3, 2
Table.timeJudgement() 14, 14, 7, 3
Table.timeJudgement1() 34, 20, 5, 2
--------------------------------------------------------------------------------------------
Block Depth Statements
0 6
1 8
2 61
3 76
4 62
5 77
6 32
7 38
8 0
9+ 0
--------------------------------------------------------------------------------------------
分析：
本题是菜单三的迭代，相较于上次，新增的内容主要是对于各种数据的处理，这里我的解决方法是用正则表达式排除格式错误的数据，再加入2个布尔参数，用于判断不同情况下的不同输出。同时还增加了特殊菜的订单，合并桌的处理以及计算价格的方式发生了改变。本题主要难点即对于不同数据的处理：首先要通过正则表达式筛选出格式正确的数据，对于格式错误的数据要输出“wrong format”，但是这样操作会出现一个问题，即本题要求当前面是第一个新建桌并且发生错误的时候，后面的数据要全部忽略，直到出现一个新的正确的桌号，我的处理方法为增加一个布尔false类型，当识别到有正确桌号创立后就会变为true类型，通过这个方法来处理数据是否忽略；但题目还要求在创立桌号后，后续创立的菜单数据要全部忽略，并输出“invalid dish”，故对于菜单数据的判断，除了上述布尔数据，我还创建了另一个布尔数据，当创建桌号后，它变为false，意为菜单输入结束；对于第17条要求，我的处理方法是把输入数据按照空格切割，当第一个数据是“table”时，就会进入一个正则表达式判断后续数据是否正确，这样就可以对不同情况进行不同的处理。第二个主要问题在于数据计算处理：此问题解决较为简单，按照题目提供的流程操作即可，主要难点在于相同订单记录的合并以及最后桌的合并，我的解决方法为在Order类中增加合并订单的addPortion方法，以及lastPrint类用于输出总计，其中包含合并桌的操作。本题并没有什么主要卡点，接下来我来分析我的类构建思路。在题目所给的类思路基础上，继承Dish类构建特殊菜specialDish类，在Menu类中聚合SpecialDish[] specialDishes类，方法分别构建关于特殊菜的处理，Order类中增加合并菜addPortion类并增加普通总价commonPrice属性合specialPrice属性，并将计算总价方法改成计算前两属性的方法，再构建Table类，包括对于时间处理的方法，以及2桌是否能合并的判断方法，最后构建lastPrint类，用于计算总价。
第五次大作业
本题在菜单计价程序-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.io.BufferedReader; 2 import java.io.IOException; 3 import java.io.InputStreamReader; 4 import java.time.LocalDate; 5 import java.util.ArrayList; 6 public class Main { 7 public static void main(String[] args) throws IOException { 8 BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); 9 Dish[] dishes = new Dish[20]; 10 SpecialDish[] specialDishes = new SpecialDish[20]; 11 ArrayList<Table> tables = new ArrayList<>(); 12 Table table = new Table(); 13 Record[] records = new Record[20]; 14 PersonPay[] personPays = new PersonPay[10]; 15 Order order = new Order(); 16 Menu menu = new Menu(); 17 lastPrint print = new lastPrint(); 18 int x = 0 , y = 0 , z = 0 , z1 = 0 , p = 0 , tableNum , dishNum , portion , num , unit_price , deleteNum , tasteNum; 19 String menuName , dayTime , hourTime , name , tableName , telephoneNum , taste; 20 boolean isHaveTable = false , forOther = false; 21 for(;;){ 22 String input = in.readLine(); 23 if(input.equals("end")){ 24 if(x!=0){ 25 table.order = order; 26 tables.add(x-1 , table); 27 } 28 print.tables = tables; 29 print.personPays = personPays; 30 print.print(); 31 print.payPrint(); 32 break; 33 } 34 String[] getInput = input.split(" "); 35 if(input.matches("^(table)( )([1-9][0-9]*)( )(:)( )(\\S+)( )((136|133|135|180|181|189)[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})$")) { 36 if(x != 0) { 37 table.order = order; 38 tables.add(x-1 , table); 39 table = new Table(); 40 y = 0; 41 } 42 isHaveTable = true; 43 tableNum = Integer.parseInt(getInput[1]); 44 tableName = getInput[3]; 45 telephoneNum = getInput[4]; 46 dayTime = getInput[5]; 47 hourTime = getInput[6]; 48 table.tableNum = tableNum; 49 table.tableName = tableName; 50 table.telephoneNum = telephoneNum; 51 table.mainTime = dayTime; 52 table.remainTime = hourTime; 53 if(!table.timeJudgement1()){ 54 isHaveTable = false; 55 System.out.println("table " +table.tableNum + " out of opening hours"); 56 continue; 57 } 58 order = new Order(); 59 records = new Record[10]; 60 if(x==0){ 61 personPays[p] = new PersonPay(); 62 personPays[p].name = tableName; 63 personPays[p].telephoneNum = telephoneNum; 64 p++; 65 print.p = p; 66 } 67 else{ 68 for(int i=0;i<p;i++){ 69 if(personPays[i].name.equals(tableName)&&personPays[i].telephoneNum.equals(telephoneNum)) 70 break; 71 if(i==p-1){ 72 personPays[p] = new PersonPay(); 73 personPays[p].name = tableName; 74 personPays[p].telephoneNum = telephoneNum; 75 p++; 76 print.p = p; 77 } 78 } 79 } 80 System.out.println("table "+tableNum+": "); 81 x++; 82 } 83 else if(input.matches("^(\\S+)( )([1-9][0-9]*)$")){ 84 int i = 0; 85 menuName = getInput[0]; 86 unit_price = Integer.parseInt(getInput[1]); 87 if(z == 0) { 88 dishes[0] = menu.addDish(menuName , unit_price); 89 z++; 90 } 91 else{ 92 for(;i < z ; i++) { 93 if(menuName.equalsIgnoreCase(dishes[i].name)) { 94 dishes[i].unit_price = unit_price; 95 break; 96 } 97 } 98 } 99 if(i == z){ 100 dishes[z] = menu.addDish(menuName , unit_price); 101 z++; 102 } 103 menu.dishes = dishes; 104 menu.dishNum = z; 105 } 106 else if(input.matches("^(\\S+)( )(\\S+)( )([1-9][0-9]*)( )(T)$")){ 107 int i = 0; 108 menuName = getInput[0]; 109 taste = getInput[1]; 110 unit_price = Integer.parseInt(getInput[2]); 111 if(z1 == 0) { 112 specialDishes[0] = menu.addSpecialDish(menuName , unit_price , taste); 113 z1++; 114 } 115 else{ 116 for(;i < z1 ; i++) { 117 if(menuName.equalsIgnoreCase(specialDishes[i].name)) { 118 specialDishes[i].unit_price = unit_price; 119 break; 120 } 121 } 122 } 123 if(i == z1){ 124 specialDishes[z1] = menu.addSpecialDish(menuName , unit_price , taste); 125 z1++; 126 } 127 menu.specialDishes = specialDishes; 128 menu.dishNum1 = z1; 129 } 130 else if(input.matches("^([1-9][0-9]*)( )(\\S+)( )([1-9][0-9]*)( )([1-9][0-9]*)$")){ 131 if(!isHaveTable) 132 continue; 133 dishNum = Integer.parseInt(getInput[0]); 134 name = getInput[1]; 135 portion = Integer.parseInt(getInput[2]); 136 num = Integer.parseInt(getInput[3]); 137 if(menu.searthDish(name) != null) { 138 records[y] = new Record(); 139 records[y] = order.addARecord(dishNum , name , portion , num , menu); 140 records[y].isSpecialDish = false; 141 System.out.println(records[y].orderNum+" "+records[y].d.name+" "+records[y].getPrice()); 142 y++; 143 order.records = records; 144 order.dishNum = y; 145 } 146 else{ 147 System.out.println(name+" does not exist"); 148 } 149 } 150 else if(input.matches("^([1-9][0-9]*)( )(\\S+)( )([0-9]+)( )([1-9][0-9]*)( )([1-9][0-9]*)$")){ 151 if(!isHaveTable) 152 continue; 153 dishNum = Integer.parseInt(getInput[0]); 154 name = getInput[1]; 155 tasteNum = Integer.parseInt(getInput[2]); 156 portion = Integer.parseInt(getInput[3]); 157 num = Integer.parseInt(getInput[4]); 158 if(menu.searthSpecialDish(name) != null) { 159 if(((menu.searthSpecialDish(name).taste.equals("川菜") && tasteNum >= 0 && tasteNum <= 5) || (menu.searthSpecialDish(name).taste.equals("晋菜") && tasteNum>=0 && tasteNum <= 4) || (menu.searthSpecialDish(name).taste.equals("浙菜") && tasteNum>=0 && tasteNum <= 3))){ 160 records[y] = new Record(); 161 records[y] = order.addASpecialRecord(dishNum , name , portion , num , menu , tasteNum , forOther); 162 records[y].isSpecialDish = true; 163 System.out.println(records[y].orderNum+" "+records[y].d.name+" "+records[y].getPrice()); 164 y++; 165 order.records = records; 166 order.dishNum = y; 167 } 168 } 169 else{ 170 System.out.println(name+" does not exist"); 171 continue; 172 } 173 if(menu.searthSpecialDish(name).taste.equals("川菜")){ 174 if(tasteNum<0||tasteNum>5) 175 System.out.println("spicy num out of range :"+tasteNum); 176 } 177 if(menu.searthSpecialDish(name).taste.equals("晋菜")){ 178 if(tasteNum<0||tasteNum>4) 179 System.out.println("acidity num out of range :"+tasteNum); 180 } 181 if(menu.searthSpecialDish(name).taste.equals("浙菜")){ 182 if(tasteNum<0||tasteNum>3) 183 System.out.println("sweetness num out of range :"+tasteNum); 184 } 185 } 186 else if(input.matches("([1-9][0-9]*)( )(delete)")) { 187 if(!isHaveTable) 188 continue; 189 deleteNum = Integer.parseInt(getInput[0]); 190 if(order.findRecordByNum(deleteNum) == 1){ 191 order.delARecordByOrderNum(deleteNum); 192 } 193 else 194 System.out.println("delete error;"); 195 } 196 else if(input.matches("^([1-9][0-9]*)( )([1-9][0-9]*)( )(\\S+)( )([1-9][0-9]*)( )([1-9][0-9]*)$")) { 197 if(!isHaveTable) 198 continue; 199 int t = Integer.parseInt(getInput[0]); 200 dishNum = Integer.parseInt(getInput[1]); 201 name = getInput[2]; 202 portion = Integer.parseInt(getInput[3]); 203 num = Integer.parseInt(getInput[4]); 204 for(int i = 0;i<x-1;i++){ 205 if(tables.get(i).tableNum == t){ 206 if(menu.searthDish(name) != null) { 207 records[y] = new Record(); 208 records[y] = order.addARecord(dishNum , name , portion , num , menu); 209 records[y].isSpecialDish = false; 210 System.out.println(dishNum+" table "+table.tableNum+" pay for table "+t+" "+records[y].getPrice()); 211 y++; 212 order.records = records; 213 order.dishNum = y; 214 } 215 break; 216 } 217 } 218 } 219 else if(input.matches("^([1-9][0-9]*)( )([1-9][0-9]*)( )(\\S+)( )([0-9]*)( )([1-9][0-9]*)( )([1-9][0-9]*)$")) { 220 if(!isHaveTable) 221 continue; 222 int t = Integer.parseInt(getInput[0]); 223 dishNum = Integer.parseInt(getInput[1]); 224 name = getInput[2]; 225 tasteNum = Integer.parseInt(getInput[3]); 226 portion = Integer.parseInt(getInput[4]); 227 num = Integer.parseInt(getInput[5]); 228 for(int i = 0;i<x-1;i++){ 229 if(tables.get(i).tableNum == t){ 230 if(menu.searthSpecialDish(name) != null) { 231 if(((menu.searthSpecialDish(name).taste.equals("川菜") && tasteNum >= 1 && tasteNum <= 5) || (menu.searthSpecialDish(name).taste.equals("晋菜") && tasteNum <= 4) || (menu.searthSpecialDish(name).taste.equals("浙菜") && tasteNum <= 3))){ 232 records[y] = new Record(); 233 records[y] = order.addASpecialRecord(dishNum , name , portion , num , menu , tasteNum , !forOther); 234 records[y].isSpecialDish = true; 235 System.out.println(dishNum+" table "+table.tableNum+" pay for table "+t+" "+records[y].getPrice()); 236 tables.get(i).giveTaste(name,num,tasteNum,menu); 237 y++; 238 order.records = records; 239 order.dishNum = y; 240 } 241 } 242 243 break; 244 } 245 } 246 } 247 else { 248 System.out.println("wrong format"); 249 } 250 } 251 } 252 } 253 class Dish{ 254 String name; 255 int unit_price; 256 public int getPrice(int portion){ 257 double getPrice=0; 258 if(portion==1) 259 getPrice=unit_price; 260 else if(portion==2) 261 getPrice=unit_price*1.5; 262 else if(portion==3) 263 getPrice=unit_price*2; 264 return (int) Math.round(getPrice); 265 } 266 } 267 class SpecialDish extends Dish{ 268 String taste; 269 } 270 class Menu{ 271 Dish[] dishes; 272 SpecialDish[] specialDishes; 273 int dishNum; 274 int dishNum1; 275 public Dish searthDish(String dishName){ 276 for(int k=0;k<dishNum;k++) { 277 if(dishName.equals(dishes[k].name)){ 278 return dishes[k]; 279 } 280 } 281 return null; 282 } 283 public SpecialDish searthSpecialDish(String dishName){ 284 for(int k=0;k<dishNum1;k++) { 285 if(dishName.equals(specialDishes[k].name)){ 286 return specialDishes[k]; 287 } 288 } 289 return null; 290 } 291 public Dish addDish(String dishName,int unit_price){ 292 Dish addDish=new Dish(); 293 addDish.name=dishName; 294 addDish.unit_price=unit_price; 295 return addDish; 296 } 297 public SpecialDish addSpecialDish(String dishName,int unit_price,String taste){ 298 SpecialDish addDish=new SpecialDish(); 299 addDish.name=dishName; 300 addDish.unit_price=unit_price; 301 addDish.taste=taste; 302 return addDish; 303 } 304 } 305 class Record{ 306 int orderNum; 307 Dish d; 308 int portion; 309 int num; 310 int spicy; 311 int acidity; 312 int sweetness; 313 boolean isSpecialDish; 314 public int getPrice() { 315 return d.getPrice(portion)*num; 316 } 317 } 318 class Order { 319 int dishNum; 320 int allCommonPrice; 321 int allSpecialPrice; 322 Record[] records; 323 public void addPortion() { 324 for(int k = 0;k < dishNum-1;k++){ 325 for(int l = k+1;l<dishNum;l++){ 326 if(records[k].d.name.equals(records[l].d.name)&&records[k].portion == records[l].portion){ 327 records[k].num+=records[l].num; 328 records[l].num = 0; 329 } 330 } 331 } 332 } 333 public void getTotalPrice(){ 334 for(int k=0;k<dishNum;k++) { 335 if(!records[k].isSpecialDish) 336 allCommonPrice+=records[k].getPrice(); 337 else 338 allSpecialPrice+=records[k].getPrice(); 339 } 340 } 341 public int getTotalPrice(double commonDiscount,double specialDiscount){ 342 int all = 0; 343 for(int k=0;k<dishNum;k++) { 344 if(!records[k].isSpecialDish) 345 all+=Math.round(records[k].getPrice()*commonDiscount); 346 else 347 all+=Math.round(records[k].getPrice()*specialDiscount); 348 } 349 return all; 350 } 351 public Record addARecord(int orderNum,String dishName,int portion,int num , Menu menu){ 352 Record x=new Record(); 353 x.d=menu.searthDish(dishName); 354 x.orderNum=orderNum; 355 x.portion=portion; 356 x.num=num; 357 return x; 358 } 359 public Record addASpecialRecord(int orderNum,String dishName,int portion,int num ,Menu menu,int tasteNum , boolean forOther){ 360 Record x=new Record(); 361 x.d=menu.searthSpecialDish(dishName); 362 x.orderNum=orderNum; 363 x.portion=portion; 364 x.num=num; 365 if(!forOther){ 366 if(menu.searthSpecialDish(dishName).taste.equals("川菜")){ 367 x.spicy = tasteNum; 368 x.acidity = -1; 369 x.sweetness = -1; 370 } 371 if(menu.searthSpecialDish(dishName).taste.equals("晋菜")){ 372 x.spicy = -1; 373 x.acidity = tasteNum; 374 x.sweetness = -1; 375 } 376 if(menu.searthSpecialDish(dishName).taste.equals("浙菜")){ 377 x.spicy = -1; 378 x.acidity = -1; 379 x.sweetness = tasteNum; 380 } 381 } 382 else{ 383 x.spicy = -1; 384 x.acidity = -1; 385 x.sweetness = -1; 386 } 387 return x; 388 } 389 public void delARecordByOrderNum(int orderNum){ 390 for(int k=0;k<dishNum;k++) { 391 if(orderNum==records[k].orderNum) { 392 records[k].num=0; 393 } 394 } 395 } 396 public int findRecordByNum(int orderNum){ 397 for(int k = 0; k<dishNum;k++) { 398 if(records[k].orderNum==orderNum) { 399 return 1; 400 } 401 } 402 return 0; 403 } 404 } 405 class Table{ 406 int tableNum; 407 String tableName; 408 String telephoneNum; 409 String mainTime; 410 String remainTime; 411 Order order; 412 double commonDiscount; 413 double specialDiscount; 414 int averageSpicy; 415 int averageAcidity; 416 int averageSweetness; 417 double spicyNum; 418 double acidityNum; 419 double sweetnessNum; 420 public boolean timeJudgement1(){ 421 String[] x = remainTime.split("/"); 422 String[] y = mainTime.split("/"); 423 int year = Integer.parseInt(y[0]); 424 int month = Integer.parseInt(y[1]); 425 int day = Integer.parseInt(y[2]); 426 double hour = Double.parseDouble(x[0]); 427 double minute = Double.parseDouble(x[1]); 428 double second = Double.parseDouble(x[2]); 429 LocalDate date = LocalDate.of(year,month,day); 430 int weekOfDay = date.getDayOfWeek().getValue(); 431 if (weekOfDay == 6 || weekOfDay == 7) { 432 if (hour >= 10 && hour < 21 || hour == 9 && minute >= 30 || hour == 21 && minute < 30 ||hour == 21 && minute == 30 && second == 0) { 433 specialDiscount = commonDiscount = 1; 434 return true; 435 } 436 else { 437 return false; 438 } 439 } 440 if (weekOfDay >= 1 && weekOfDay <= 5) { 441 if (hour > 17 && hour < 20 || hour == 17 && minute >= 0 || hour == 20 && minute < 30 || hour == 20 && minute == 30 && second == 0) { 442 commonDiscount = 0.8; 443 specialDiscount = 0.7; 444 return true; 445 } 446 else if (hour > 10 && hour < 14 || hour == 10 && minute >= 30 || hour == 14 && minute < 30 || hour == 14 && minute == 30 && second == 0) { 447 commonDiscount = 0.6; 448 specialDiscount = 0.7; 449 return true; 450 } 451 else { 452 return false; 453 } 454 } 455 return false; 456 } 457 public int tablePrice(){ 458 return this.order.getTotalPrice(commonDiscount,specialDiscount); 459 } 460 public void getTaste(){ 461 for(int k = 0;k<this.order.dishNum;k++){ 462 if(order.records[k].isSpecialDish){ 463 if(order.records[k].spicy!=-1){ 464 averageSpicy+=order.records[k].spicy*order.records[k].num; 465 spicyNum=order.records[k].num+spicyNum; 466 } 467 if(order.records[k].acidity!=-1){ 468 averageAcidity+=order.records[k].acidity*order.records[k].num; 469 acidityNum=order.records[k].num+acidityNum; 470 } 471 if(order.records[k].sweetness!=-1){ 472 averageSweetness+=order.records[k].sweetness*order.records[k].num; 473 sweetnessNum=order.records[k].num+sweetnessNum; 474 } 475 } 476 } 477 if(spicyNum!=0){ 478 averageSpicy=(int)Math.round(averageSpicy/spicyNum); 479 } 480 if(acidityNum!=0){ 481 averageAcidity=(int)Math.round(averageAcidity/acidityNum); 482 } 483 if(sweetnessNum!=0){ 484 averageSweetness=(int)Math.round(averageSweetness/sweetnessNum); 485 } 486 } 487 public String spicyLevel(){ 488 if(averageSpicy==0) 489 return "不辣"; 490 if(averageSpicy==1) 491 return "微辣"; 492 if(averageSpicy==2) 493 return "稍辣"; 494 if(averageSpicy==3) 495 return "辣"; 496 if(averageSpicy==4) 497 return "很辣"; 498 if(averageSpicy==5) 499 return "爆辣"; 500 return null; 501 } 502 public String acidityLevel(){ 503 if(averageAcidity==0) 504 return "不酸"; 505 if(averageAcidity==1) 506 return "微酸"; 507 if(averageAcidity==2) 508 return "稍酸"; 509 if(averageAcidity==3) 510 return "酸"; 511 if(averageAcidity==4) 512 return "很酸"; 513 return null; 514 } 515 public String sweetnessLevel(){ 516 if(averageSweetness==0) 517 return "不甜"; 518 if(averageSweetness==1) 519 return "微甜"; 520 if(averageSweetness==2) 521 return "稍甜"; 522 if(averageSweetness==3) 523 return "甜"; 524 return null; 525 } 526 public void giveTaste(String name , int num , int tasteLevel , Menu menu){ 527 if(menu.searthSpecialDish(name).taste.equals("川菜")){ 528 averageSpicy+=tasteLevel*num; 529 spicyNum+=num; 530 } 531 if(menu.searthSpecialDish(name).taste.equals("晋菜")){ 532 averageAcidity+=tasteLevel*num; 533 acidityNum+=num; 534 } 535 if(menu.searthSpecialDish(name).taste.equals("浙菜")){ 536 averageSweetness+=tasteLevel*num; 537 sweetnessNum+=num; 538 } 539 } 540 } 541 class lastPrint{ 542 ArrayList<Table> tables = new ArrayList<>(); 543 PersonPay[] personPays; 544 int p; 545 public void print(){ 546 for (Table table : tables) { 547 table.order.getTotalPrice(); 548 table.getTaste(); 549 if(table.spicyNum==0&&table.acidityNum==0&&table.sweetnessNum==0) 550 System.out.println("table " + table.tableNum + ": " + (table.order.allCommonPrice + table.order.allSpecialPrice) + " " + table.tablePrice()+" "); 551 if(table.spicyNum!=0&&table.acidityNum==0&&table.sweetnessNum==0) 552 System.out.println("table " + table.tableNum + ": " + (table.order.allCommonPrice + table.order.allSpecialPrice) + " " + table.tablePrice() + " 川菜 " +(int)table.spicyNum+" "+table.spicyLevel()); 553 if(table.spicyNum==0&&table.acidityNum!=0&&table.sweetnessNum==0) 554 System.out.println("table " + table.tableNum + ": " + (table.order.allCommonPrice + table.order.allSpecialPrice) + " " + table.tablePrice() + " 晋菜 " +(int)table.acidityNum+" "+table.acidityLevel()); 555 if(table.spicyNum==0&&table.acidityNum==0&&table.sweetnessNum!=0) 556 System.out.println("table " + table.tableNum + ": " + (table.order.allCommonPrice + table.order.allSpecialPrice) + " " + table.tablePrice() + " 浙菜 " +(int)table.sweetnessNum+" "+table.sweetnessLevel()); 557 if(table.spicyNum!=0&&table.acidityNum!=0&&table.sweetnessNum==0) 558 System.out.println("table " + table.tableNum + ": " + (table.order.allCommonPrice + table.order.allSpecialPrice) + " " + table.tablePrice() + " 川菜 " +(int)table.spicyNum+" "+table.spicyLevel()+" 晋菜 "+(int)table.acidityNum+" "+table.acidityLevel()); 559 if(table.spicyNum!=0&&table.acidityNum==0&&table.sweetnessNum!=0) 560 System.out.println("table " + table.tableNum + ": " + (table.order.allCommonPrice + table.order.allSpecialPrice) + " " + table.tablePrice() + " 川菜 " +(int)table.spicyNum+" "+table.spicyLevel()+" 浙菜 "+(int)table.sweetnessNum+" "+table.sweetnessLevel()); 561 if(table.spicyNum==0&&table.acidityNum!=0&&table.sweetnessNum!=0) 562 System.out.println("table " + table.tableNum + ": " + (table.order.allCommonPrice + table.order.allSpecialPrice) + " " + table.tablePrice() + " 晋菜 " +(int)table.acidityNum+" "+table.acidityLevel()+" 浙菜 "+(int)table.sweetnessNum+" "+table.sweetnessLevel()); 563 if(table.spicyNum!=0&&table.acidityNum!=0&&table.sweetnessNum!=0) 564 System.out.println("table " + table.tableNum + ": " + (table.order.allCommonPrice + table.order.allSpecialPrice) + " " + table.tablePrice() + " 川菜 " +(int)table.spicyNum+" "+table.spicyLevel()+" 晋菜 "+(int)table.acidityNum+" "+table.acidityLevel()+" 浙菜 "+(int)table.sweetnessNum+" "+table.sweetnessLevel()); 565 } 566 } 567 public void payPrint(){ 568 for(int k=0;k<p;k++){ 569 for(Table table:tables){ 570 if(table.tableName.equals(personPays[k].name)){ 571 personPays[k].payPrice+=table.tablePrice(); 572 } 573 } 574 } 575 for(int k=0;k<p-1;k++){ 576 for(int l=k+1;l<p;l++){ 577 if(personPays[k].name.toLowerCase().compareTo(personPays[l].name.toLowerCase())>0) { 578 PersonPay x; 579 x=personPays[l]; 580 personPays[l]=personPays[k]; 581 personPays[k]=x; 582 } 583 } 584 } 585 for(int k=0;k<p;k++){ 586 System.out.println(personPays[k].name+" "+personPays[k].telephoneNum+" "+personPays[k].payPrice); 587 } 588 } 589 } 590 class PersonPay{ 591 String name; 592 String telephoneNum; 593 int payPrice; 594 }
Metrics Details For File 'Main.java'
--------------------------------------------------------------------------------------------
Parameter Value
========= =====
Project Directory D:\java\javademo\src\
Project Name 7777
Checkpoint Name Baseline
File Name Main.java
Lines 596
Statements 384
Percent Branch Statements 25.5
Method Call Statements 113
Percent Lines with Comments 0.0
Classes and Interfaces 7
Methods per Class 2.57
Average Statements per Method 17.83
Line Number of Most Complex Method 7
Name of Most Complex Method Main.main()
Maximum Complexity 54
Line Number of Deepest Block 232
Maximum Block Depth 8
Average Block Depth 3.28
Average Complexity 8.12
--------------------------------------------------------------------------------------------
Most Complex Methods in 6 Class(es): Complexity, Statements, Max Depth, Calls
Dish.getPrice() 4, 8, 2, 1
Main.main() 54, 183, 8, 92
Menu.addDish() 1, 4, 2, 0
Menu.addSpecialDish() 1, 5, 2, 0
Menu.searthDish() 3, 4, 4, 1
Menu.searthSpecialDish() 3, 4, 4, 1
Order.addARecord() 1, 6, 2, 0
Order.addASpecialRecord() 6, 23, 4, 6
Order.delARecordByOrderNum() 3, 3, 4, 0
Order.findRecordByNum() 3, 4, 4, 0
Order.getTotalPrice() 4, 7, 3, 0
Order.getTotalPrice() 4, 5, 3, 0
Record.getPrice() 1, 1, 2, 1
Table.getTaste() 9, 17, 5, 0
Table.spicyLevel() 6, 11, 2, 0
Table.tablePrice() 1, 1, 2, 1
Table.timeJudgement1() 34, 28, 4, 10
--------------------------------------------------------------------------------------------
Block Depth Statements
0 12
1 51
2 93
3 39
4 106
5 48
6 13
7 14
8 8
9+ 0
--------------------------------------------------------------------------------------------
期中考试
在测验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.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
ArrayList<Shape> list = new ArrayList<>();
int choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1:
double radium = input.nextDouble();
Shape circle = new Circle(radium);
list.add(circle);
break;
case 2:
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()) + " ");
}
}
}
abstract class Shape implements Comparable<Shape> {
Shape(){
}
abstract double getArea();
public abstract int compareTo(Shape a);
}
class Point {
private double x;
private double y;
Point(){
}
Point(double x , double y){
setX(x);
setY(y);
}
public double getX(){
return x;
}
public double getY(){
return y;
}
public void setX(double x){
this.x = x;
}
public void setY(double y){
this.y = y;
}
}
class Rectangle extends Shape{
Point topLeftPoint;
Point lowerRightPoint;
Rectangle(){
}
Rectangle(Point topLeftPoint , Point lowerRightPoint){
setTopLeftPoint(topLeftPoint);
setLowerRightPoint(lowerRightPoint);
}
public Point getTopLeftPoint(){
return topLeftPoint;
}
public Point getLowerRightPoint() {
return lowerRightPoint;
}
public void setTopLeftPoint(Point topLeftPoint){
this.topLeftPoint = topLeftPoint;
}
public void setLowerRightPoint(Point lowerRightPoint){
this.lowerRightPoint = lowerRightPoint;
}
public double getLength(){
return Math.abs(lowerRightPoint.getX()-topLeftPoint.getX());
}
public double getHeight(){
return Math.abs(lowerRightPoint.getY()-topLeftPoint.getY());
}
public double getArea(){
return getHeight()*getLength();
}
@Override
public int compareTo(Shape a) {
if (a.getArea()<this.getArea()){
return 1;
}
return -1;
}
}
class Circle extends Shape{
private double radium = 0;
Circle(){
}
Circle(double radium){
setRadium(radium);
}
public void setRadium(double radium){
this.radium = radium;
}
public double getRadium(){
return radium;
}
@Override
double getArea() {
return Math.PI*radium*radium;
}
@Override
public int compareTo(Shape a) {
if (a.getArea()<this.getArea()){
return 1;
}
return -1;
}
}
分析：
本题的难度较为简单，主要难点在于Comparator.naturalOrder()方法与Comparable接口的compareTo()方法之间的关系，关系主要通过编译器的debug找到，可以发现Comparator.naturalOrder()是一个排序方法，排序规则则是覆写后的compareTo()方法，compareTo()方法是一个int类型方法，对于符合规则的输出正数，反之输出负数，掌握好这些规则则可以很好的解决该题。
踩坑心得
2. 对于Table桌存在但是后续数据结果出现问题的情况没考虑，修改在table正则表达式前先判断是否存在table即可。
3. 关于桌子的合法处理出现问题，我在处理该情况时，我在判断table格式合法后就将判断条件（用于判断table后续输入是否处理）为false，但忽略了时间不合法也会导致桌号不合法的情况，导致输出出现问题。
4. 关于代点菜的输出数据出现问题，导致卡了很久，因此在处理读数据题目时，要注意输出数据是否正确。
2. 没有考虑特殊菜味道可以为0的情况。
3. 对于错误信息的处理出现问题，当第一个桌号出现错误时，后面直到第二个桌号前的信息要忽略，故我增加了判断语句来处理输出情况。
（3） 期中考试：
7-4：
1. 忘记了compareTo方法的输出规则，导致后续排序出现问题。
2. 对于Compara类作为接口时，没有强制定义为Shape，导致方法传参只能传Object类。
主要困难及改进建议
主要困难：综上所述，个人认为本两次大作业的难点不在于语法，主要在于对于不同数据的处理以及代码的算法设计。如第一次大作业，在对错误信息处理的同时，我要满足错误信息输出"wrong format"，但是还要做到没有正确桌号存在时要忽略点菜信息，同时还要保证菜单输入不受影响，还要保证当正确桌号创建后要忽略后续的菜单输入同时要输出错误语句。后面对于桌号合并以及订单合并也是一个难点，主要问题体现在计价问题上，需要大概计价结果，容易疏忽。第二题难点在于如何处理好桌号订单味道以及在代点特殊菜存在的情况下，如何保证价格计算在当前桌但是味道计算在代点桌同时不能计算在当前桌。我运用了最笨的方法，通过在订单类中加入味道值属性，当点单特殊菜时相应赋值，但在代点特殊菜时，提取数据然后按照普通菜处理，但是不给其订单味道赋值，在用单独的方法把味道赋值给代点桌。再来聊聊关于期中的主要困难，此次期中考试较为简单，难点在最后一题对于Compara类的接口，以及对comePare方法的覆写，难点在于对新知识的不熟悉，解决方法为运用编译器的debug功能查找关系即可。
改进建议：虽然菜单题目可能没有迭代了，但是还是得分析我的代码的改进方向。菜单四：本题在正则表达式识别完数据后，后续对于数据的处理过于冗杂，我个人认为可以新建一个数据类，当识别到不同的操作后相应调用方法进行数据的进一步处理，后续还可增加一个输出类，把输出总和在一起，将代码进一步拆分，再可以把对于普通价格计算和特殊菜价格计算方法合并，避免代码过于冗杂。菜单五：在菜单四的基础上，可以将lastPrint计个人总价的功能放在personPay类中。
总结
本次博客终于接近尾声啦！！！！接下来是第四、第五次大作业以及期中考试的总结。
收获：这两次大作业我在设计的过程中更多的是为了完成测试点而设计代码，导致这两次大作业的设计思路显得过于混乱，如果面对未来的迭代，可能要重新设计，故此次收获主要在后续的反思。这两次设计我犯了一个设计上的错误，代码的可拓展性低、代码耦合度较高，修改思路主要在改进建议中。同时，这两次大作业以及期中考试很好地考察了我对于类的关系的处理，如依赖（大量存在于大作业四和五中，如大作业四判断是否同一桌的方法，大作业五中代点特殊菜赋值味道方法）、聚合（大量存在，如作业四和五中菜单类中聚合Dish类），以及类的继承和接口，以及抽象类的运用。最后，谈谈我个人悟到的设计思路，在进行设计的过程中，要先想好设计的大致方向，在对设计需要的功能进行碎片化设计，尽量降低代码耦合度，最后将代码拼装好。
好了，本次博客到此结束，下次再见，拜拜~
