第二次PTA总结
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"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
import java.util.*; public class Main { static Scanner scanner = new Scanner(System.in); public static void main(String[] args) { Menu menu = new Menu(); String input; // 读取菜单信息 while (!"end".equals(input = scanner.nextLine())) { String[] data = input.split(" "); menu.addDish(data[0], Integer.parseInt(data[1])); } Map<Integer, Table> tableMap = new HashMap<>(); // 读取订单信息 while(true) { input = scanner.nextLine(); if("end".equals(input)) { break; } String[] data = input.split(" "); String[] tableHeadData = data[0].split(" "); long timeStamp = Table.timeStamp(tableHeadData[2], tableHeadData[3]); Table table = tableMap.getOrDefault(Integer.parseInt(tableHeadData[1]), new Table(timeStamp)); if(!table.validateTimeStamp(timeStamp)) { System.out.printf("table %d out of opening hours\n", table.tableNum); continue; } tableMap.put(table.tableNum, table); if("delete".equals(data[1])) { Record record = table.order.findRecordByNum(Integer.parseInt(data[0])); if(record != null) { table.order.delARecordByOrderNum(Integer.parseInt(data[0])); }else { System.out.println("delete error"); } }else { Dish dish = menu.searchDish(data[1]); if(dish == null) { System.out.printf("** %s does not exist\n", data[1]); continue; } int totalPrice = dish.getPrice(Integer.parseInt(data[2])); totalPrice = totalPrice * Integer.parseInt(data[3]); Record record = table.order.addARecord(Integer.parseInt(data[0]), data[1], Integer.parseInt(data[2]), Integer.parseInt(data[3])); record.totalPrice = totalPrice; } } for(int i = 1; i <= tableMap.size(); i++) { Table table = tableMap.get(i); if(table == null) { continue; } int totalPrice = Math.round(table.order.getTotalPrice() * table.getDiscount()); System.out.printf("table %d: \n", table.tableNum); for (Record record : table.order.records) { Dish dish = menu.searchDish(record.d.name); System.out.printf("%d %s ", record.orderNum, record.d.name); if(dish == null) { System.out.println(); continue; } System.out.println(record.totalPrice); } System.out.printf("table %d: %d\n", table.tableNum, totalPrice); } } public static class Dish { String name; int unit_Price; public Dish(String name, int unit_Price) { this.name = name; this.unit_Price = unit_Price; } public int getPrice(int portion) { switch (portion) { case 1: return unit_Price; case 2: return Math.round(unit_Price * 1.5f); case 3: return unit_Price * 2; default: return 0; } } } public static class Menu { List<Dish> dishes = new ArrayList<>(); Map<String, Dish> dishMap = new HashMap<>(); public Menu() { } public Dish addDish(String name, int unit_Price) { Dish dish = dishMap.get(name); if(dish != null) { dish.unit_Price = unit_Price; return dish; } dish = new Dish(name, unit_Price); dishes.add(dish); dishMap.put(name, dish); return dish; } public Dish searchDish(String name) { return dishMap.get(name); } } public static class Order { List<Record> records = new ArrayList<>(); public Record addARecord(int orderNum, String dishName, int portion, int num) { Record record = new Record(orderNum, new Dish(dishName, 0), portion, num, 0); records.add(record); return record; }
分析：
本质是对一堆字符串的处理，但字符串类型及数量较多，故先规整一下需要使用的常量与对象。主要分为四个：
Dish：每道菜相关的信息。 Order：每张订单相关的信息。 TableInfo：桌子相关的信息。 Menu：所有菜的信息。
Menu 的实现将简单，好处也好体现。在其上实现其他三个对象需要注意许多事项，下文将具体讲解。
核心思路是拆解出相关信息并处理它，再按要求进行输出。
踩坑心得：
注一：价格保留整点，看样例输出就行。 注二：testcase 中至少一个查询无结果，是判断菜单中不存在当前记录。（是否输出这个信息不要紧，但注意其不影响程序，实测90分版本可以） 注三：小数处理，按小数点后第一位做约定，即等于 5 便向前取整，大于 5 便向后取整。所以（1.5）应该是 2 。
- 菜品类&Dish类
包含两个成员变量name和unit_price，对应菜名和基础价格。
有方法getPrice(int portion)，根据输入的份量portion计算出价格。
- 菜谱类&Menu类
保持所有菜品信息。
提供方法searchDish(String dishName)根据菜名查找菜品信息。
提供方法addDish(String dishName, int unit_price)添加菜品信息。
- 点菜记录类&Record类
包含三个成员变量orderNum，Dish类型的引用d和portion。通过调用Dish的getPrice()方法，实现获取单条记录的价格。
- 订单类
包含一个Record类型的数组变量records，代表一个用户点餐的全部记录。实现获取总价和添加记录等方法。
- 代点菜信息类&ShareData类
包含桌号、点菜序号和其余需要信息。对于当前的餐桌，计算代点餐品的价格并将其添加到它的订单中。
- Main类
使用Scanner处理输入，逐行输入并赋值给响应的变量。在处理完一张餐桌的订单后，计算总价，并在终端输出。
每张餐桌的订单信息都应包含桌号以及所有点菜记录，输出功能应分别调用Dish、Record和Order中的函数。
应用程序共测试三个功能：
- 求下n天
- 求前n天
- 求两个日期相差的天数
注意：严禁使用Java中提供的任何与日期相关的类与方法，并提交完整源码，包括主类及方法（已提供，不需修改）
输入格式:
有三种输入方式（以输入的第一个数字划分[1,3]）：
- 1 year month day n //测试输入日期的下n天
- 2 year month day n //测试输入日期的前n天
- 3 year1 month1 day1 year2 month2 day2 //测试两个日期之间相差的天数
输出格式:
- 当输入有误时，输出格式如下：
Wrong Format - 当第一个数字为1且输入均有效，输出格式如下：
year-month-day - 当第一个数字为2且输入均有效，输出格式如下：
year-month-day - 当第一个数字为3且输入均有效，输出格式如下：
天数值
输入样例1:
在这里给出一组输入。例如：
3 2014 2 14 2020 6 14
输出样例1:
在这里给出相应的输出。例如：
2312
输入样例2:
在这里给出一组输入。例如：
2 1935 2 17 125340
输出样例2:
在这里给出相应的输出。例如：
1591-12-17
输入样例3:
在这里给出一组输入。例如：
1 1999 3 28 6543
输出样例3:
在这里给出相应的输出。例如：
2017-2-24
输入样例4:
在这里给出一组输入。例如：
0 2000 5 12 30
输出样例4:
在这里给出相应的输出。例如：
Wrong Format
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int type = sc.nextInt(); switch (type) { case 1: int year1 = sc.nextInt(); int month1 = sc.nextInt(); int day1 = sc.nextInt(); int n1 = sc.nextInt(); if (isValidDate(year1, month1, day1)) { int[] result = getNextNDate(year1, month1, day1, n1); System.out.printf("%s-%s-%s", result[0], result[1], result[2]); } else { System.out.println("Wrong Format"); } break; case 2: int year2 = sc.nextInt(); int month2 = sc.nextInt(); int day2 = sc.nextInt(); int n2 = sc.nextInt(); if (isValidDate(year2, month2, day2)) { int[] result = getPrevNDate(year2, month2, day2, n2); System.out.printf("%s-%s-%s", result[0], result[1], result[2]); } else { System.out.println("Wrong Format"); } break; case 3: int year3 = sc.nextInt(); int month3 = sc.nextInt(); int day3 = sc.nextInt(); int year4 = sc.nextInt(); int month4 = sc.nextInt(); int day4 = sc.nextInt(); if (isValidDate(year3, month3, day3) && isValidDate(year4, month4, day4)) { int result = getDaysofDates(year3, month3, day3, year4, month4, day4); System.out.println(result); } else { System.out.println("Wrong Format"); } break; default: System.out.println("Wrong Format"); break; } } // 判断日期是否合法 public static boolean isValidDate(int year, int month, int day) { if (year < 1900 || year > 2050 || month < 1 || month > 12 || day < 1 || day > 31) { return false; } // 判断月份对应的天数是否合法 if (day > getDaysOfMonth(year, month)) { return false; } return true; } // 获取指定年月的天数 public static int getDaysOfMonth(int year, int month) { switch (month) { case 2: if (isLeapYear(year)) { return 29; } else { return 28; } case 4: return 30; case 6: return 30; case 9: return 30; case 11: return 30; default: return 31; } } // 判断是否为闰年 public static boolean isLeapYear(int year) { if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) { return true; } else { return false; } } // 获取下n天的日期 public static int[] getNextNDate(int year, int month, int day, int n) { while (n > 0) { day++; if (day > getDaysOfMonth(year, month)) { month++; day = 1; } if (month > 12) { year++; month = 1; } n--; } int[] result = {year, month, day}; return result; } // 获取前n天的日期 public static int[] getPrevNDate(int year, int month, int day, int n) { while (n > 0) { day--; if (day < 1) { month--; if (month < 1) { year--; month = 12; } day = getDaysOfMonth(year, month); } n--; } int[] result = {year, month, day}; return result; } // 获取两个日期之间相差的天数 public static int getDaysofDates(int year1, int month1, int day1, int year2, int month2, int day2) { int days1 = compareDates(year1, month1, day1); int days2 = compareDates(year2, month2, day2); return Math.abs(days1 - days2); } // 从1900年1月1日开始计算到指定日期的天数 public static int compareDates(int year, int month, int day) { int days = 0; // 计算年份之间的天数 for (int i = 1900; i < year; i++) { days += isLeapYear(i) ? 366 : 365; } // 计算月份之间的天数 for (int i = 1; i < month; i++) { days += getDaysOfMonth(year, i); } // 加上当前月份的天数 days += day - 1; return days; } }
这道题主要考察了对年月日做字符串处理的能力和算法思路。需要判断输入的格式是否正确。同时，由于题目中要求禁止使用 Java 提供的任何与日期相关的类与方法，因此需要自己设计时间计算的算法。
算法思路方面，我们可以采用“暴力”的方法，即：遍历时间，计算间隔天数或新日期。在本题中，日期只是一串数字，新日期的计算较为简单，主要的问题在于计算两个日期间隔的天数。我们可以先判断两个日期是不是同一年，然后再判断它们是否处于闰年。如果判断出它们在不同年中，那么就要对于它们所在的年份分别计算前一部分和后一部分的天数。计算方法较为繁琐，需要细心计算。
踩坑心得：
1.题目规定的年月日的范围是[1900,2050]，需要注意。需要使用switch语句进行日期错误的输出。
2.注意闰年的处理，如果是闰年，则2月份有29天，否则该月份不是29天。
3.在DateUtil类中，我们需要添加一个需要在某年之前的天数(本年已过去的天数的累加)，设计如下：
totalDays = count >= leap_year ? (leap_yearDays[month-1] + day) : (yearDays[month-1] + day);
for(int i=leap_year; i<year; i++){
if(isLeapYear(i)){
totalDays += 366;
}
else{
totalDays += 365;
}
}
4.求下n天与求前n天：这两个功能类似，在DateUtil.java中将计算当前日期与n的差后，通过for循环遍历日期。在每个月份的末尾更新日期。在Month和Year类中，分别定义一个getNthMonth，和getNthYear来进行日期的更新，遇到2月份还要考虑闰年的情况。
class Year{ private int year; Year(int year){ this.year = year; } boolean isLeapYear(){ return (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0); } int getNthYear(int n){ if((year + n) > 2050 || (year + n) < 1900){//year没有在1900~2050之间 return 0; } if((isLeapYear())&&(n>=60)){//(注，是大于等于60天)如果都在这一年范围内，直接计算 return year + n; } int leap_years = getLeapYears(); int diff; if(isLeapYear() && (n + yearDays[1] > leap_yearDays[1]) || (!isLeapYear() && (n + yearDays[1] > normal_yearDays[1]))){//如果跨越二月份 int sum = 1; diff = dayDiff(1,1,year + n); Year tempYear = new Year(year); while((diff--)>=0){ tempYear.update(); if(tempYear.isLeapYear()){ sum += 366; } else{ sum += 365; } } diff = n - (sum - totalDays);//计算剩余的天数 } else{//不跨越二月份 diff = n; } if(diff <= 0){//年份不变 return year; } else{//年份变化 int res = year + 1; while((diff--) > 0){ if(new Year(res).isLeapYear()){ diff-=366; } else{ diff-=365; } res++; } return res - 1; } } private int getLeapYears(){ int result = 0; for(int i=1900;i<year;i++){ if(new Year(i).isLeapYear()){ result++; } } return result; } } class Month{ private Year year; private int month; Month(Year y, int m){ year = y; month = m; day = 1; } int getNthMonth(int n){ if(n == 0){//不更新 return month; } if(year.year == 2050 && month+n>12){//直接代入就好了 month = month + n - 12; return month; } if(year.year == 1900 && month - n <= 0){//直接代入 month = month - n + 12; return month; } int leaps = 0; for(int i=1;i<=n;i++){ update(); if(month == 1 && i<n && (!year.isLeapYear() || (year.isLeapYear() && i + yearDays[0] <= leap_yearDays[0]))){//到达下一年，但是不跨越二月份，跨越的情况在下面的for循环处理 leaps++; } } if(leaps == 0){//不跨越二月份 return month; } else{//跨越二月份 int countDiff = (n + leaps) - (totalDays - year.yearDays[month-1]); //统计过2月之后还多出的时间 for(int i=month+1; i<=12; i++){//尝试往后找合适的月份 countDiff -= getDayOfMonth(i,year.isLeapYear()); if(countDiff <= 0){ return i; } } Year yearTemp = new Year(year.year+1);//此时还没找到，需要更换年份 int res = countDiff; int tempMonth = 1; while(res > 0){ res -= getDayOfMonth(tempMonth,yearTemp.isLeapYear()); if(res <= 0){ return tempMonth; } else{ tempMonth++; } } return -1; } } }
应用程序共测试三个功能：
- 求下n天
- 求前n天
- 求两个日期相差的天数
注意：严禁使用Java中提供的任何与日期相关的类与方法，并提交完整源码，包括主类及方法（已提供，不需修改）
输入格式:
有三种输入方式（以输入的第一个数字划分[1,3]）：
- 1 year month day n //测试输入日期的下n天
- 2 year month day n //测试输入日期的前n天
- 3 year1 month1 day1 year2 month2 day2 //测试两个日期之间相差的天数
输出格式:
- 当输入有误时，输出格式如下：
Wrong Format - 当第一个数字为1且输入均有效，输出格式如下：
year1-month1-day1 next n days is:year2-month2-day2 - 当第一个数字为2且输入均有效，输出格式如下：
year1-month1-day1 previous n days is:year2-month2-day2 - 当第一个数字为3且输入均有效，输出格式如下：
The days between year1-month1-day1 and year2-month2-day2 are:值
输入样例1:
在这里给出一组输入。例如：
3 2014 2 14 2020 6 14
输出样例1:
在这里给出相应的输出。例如：
The days between 2014-2-14 and 2020-6-14 are:2312
输入样例2:
在这里给出一组输入。例如：
2 1834 2 17 7821
输出样例2:
在这里给出相应的输出。例如：
1834-2-17 previous 7821 days is:1812-9-19
输入样例3:
在这里给出一组输入。例如：
1 1999 3 28 6543
输出样例3:
在这里给出相应的输出。例如：
1999-3-28 next 6543 days is:2017-2-24
输入样例4:
在这里给出一组输入。例如：
0 2000 5 12 30
输出样例4:
在这里给出相应的输出。例如：
Wrong Format
分析：题目要求建立DateUtil、Year、Month、Day类来重现时间类，在所有方法中都要用到。方法较多，如：isLeapYear、dayOfMonth、toDate等，需要较多时间来写。粗略统计有42个方法，还有一堆计算方法。
此题对时差等相关的细节要求较高，因为输出已经规定格式，必须保证每一个细节都是符合格式的。
踩坑心得：
1.输入输出的格式要注意，空格和“-”都会直接影响最终输出
2.将类设计得尽量完善，可以写不少方法以增加程序的灵活性。
3.用数组（或列表）来存储天数，每个月份对应存储它自己的天数数列。如
Month.months = {31, 28, 31, ..., 31}; 可根据平闰年来修改：
Month.months = is_leap(year) ? {31, 29, ..., 31} : {31, 28, ..., 31}
4.计算完日期之后要特别注意它的有效性，需做一定的判断。
5.判断月份的时候，把12特判即可。
6.在DateUtil类中还可以写关于根据当前日期获取年月日的方法，便于在别的地方使用。如：
// 通过当前日期获取年月日 public static void getCurrentYearMonthDay(int[] ymd) { Date date = new Date(); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); String str = df.format(date); String[] ss = str.split("-"); assert(ss.length == 3); for (int i = 0; i < 3; i++) ymd[i] = Integer.parseInt(ss[i]); }
本体大部分内容与菜单计价程序-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
其他用例请参考公开的测试用例
import java.util.*; public class Main { public static Map<String, Dish> dishes = new HashMap<>(); // 菜谱信息 public static Map<String, Table> tables = new HashMap<>(); // 桌子信息 public static void main(String[] args) { Scanner sc = new Scanner(System.in); // 读入菜谱信息 while (sc.hasNext()) { String dishInfo = sc.nextLine(); if (dishInfo.equals("end")) break; String[] dish = dishInfo.split(" "); String name = dish[0]; double price; try { price = Double.parseDouble(dish[1]); } catch (NumberFormatException e) { System.out.println("wrong format"); return; } dishes.put(name, new Dish(name, price)); } // 读入订单信息 while (sc.hasNext()) { String orderInfo = sc.nextLine(); if (orderInfo.equals("end")) break; if (!orderInfo.startsWith("table")) { // 订单信息以“table”开头 System.out.println("wrong format"); return; } String[] tableInfo = orderInfo.split(" "); String id = tableInfo[1]; if (tableInfo.length != 4 || !isValidDate(tableInfo[2]) || !isValidTime(tableInfo[3])) { // 桌号信息格式正确 System.out.println("wrong format"); return; } String time = tableInfo[2] + " " + tableInfo[3]; if (!tables.containsKey(id)) tables.put(id, new Table(id, time)); else if (!time.equals(tables.get(id).time)) { // 更新桌子时间 System.out.println("wrong format"); return; } while (sc.hasNextLine()) { String record = sc.nextLine(); if (record.equals("end")) break; String[] order = record.split(" "); int serialNumber = Integer.parseInt(order[0]); if (serialNumber != tables.get(id).records.size() + 1) { // 订单编号必须紧密连续递增 System.out.println("record serial number sequence error"); return; } switch (order.length) { case 2: // 根据订单编号删除记录 if (!tables.get(id).remove(serialNumber)) System.out.println("invalid operation"); break; case 4: // 添加记录 String dishName = order[1]; if (!dishes.containsKey(dishName) || !isInteger(order[2])) { // 菜名必须存在，份数必须是整数 System.out.println("table " + id + ":"); System.out.println("invalid dish"); System.out.println(dishName + " does not exist"); tables.get(id).print(); return; } int num = Integer.parseInt(order[2]); double portion = Double.parseDouble(order[3]); Dish dish = dishes.get(dishName); Order newOrder = new Order(serialNumber, dish, num, portion); if (!tables.get(id).add(newOrder)) { // 份数和份额必须在范围内 System.out.println("table " + id + ":"); tables.get(id).print(); return; } break; default: System.out.println("wrong format"); return; } } } for (Table table : tables.values()) table.print(); } // 判断字符串是否为日期格式，yyyy/MM/dd public static boolean isValidDate(String dateString) { if (dateString == null || dateString.isEmpty()) return false; String[] dateParts = dateString.split("/"); if (dateParts.length != 3) return false; try { int yyyy = Integer.parseInt(dateParts[0]); int MM = Integer.parseInt(dateParts[1]); int dd = Integer.parseInt(dateParts[2]); if (yyyy < 0 || MM < 1 || MM > 12 || dd < 1 || dd > 31) return false; } catch (NumberFormatException e) { return false; } return true; } // 判断字符串是否为时间格式，HH/mm/ss public static boolean isValidTime(String timeString) { if (timeString == null || timeString.isEmpty()) return false; String[] timeParts = timeString.split("/"); if (timeParts.length != 3) return false; try { int HH = Integer.parseInt(timeParts[0]); int mm = Integer.parseInt(timeParts[1]); int ss = Integer.parseInt(timeParts[2]); if (HH < 0 || HH > 23 || mm < 0 || mm > 59 || ss < 0 || ss > 59) return false; } catch (NumberFormatException e) { return false; } return true; } // 判断字符串是否为整数 public static boolean isInteger(String str) { try { Integer.parseInt(str); return true; } catch (NumberFormatException e) { return false; } } } // 菜品类 class Dish { public String name; // 菜名 public double price; // 价格 public Dish(String name, double price) { this.name = name; this.price = price; } } // 菜单类 class Order { public int serialNumber; // 订单编号 public Dish dish; // 菜品 public int num; // 数量 public double portion; // 份额 public Order(int serialNumber, Dish dish, int num, double portion) { this.serialNumber = serialNumber; this.dish = dish; this.num = num; this.portion = portion; } // 计算本菜品的总价 public double getTotalPrice() { return dish.price * num * portion / 100; } } // 桌子类 class Table { private static final Map<String, Dish> dishes = null; public String id; // 桌号 public String time; // 时间 public List<Order> records; // 订单记录 public Table(String id, String time) { this.id = id; this.time = time; records = new ArrayList<Order>(); } // 添加订单记录 public boolean add(Order order) { if (order.num <= 0 || order.num > 100 || order.portion <= 0 || order.portion > 100) { // 份数和份额必须在范围内 System.out.println("table " + id + ":"); System.out.println(order.serialNumber + " num out of range " + order.num); return false; } records.add(order); return true; } // 删除订单记录 public boolean remove(int serialNumber) { if (serialNumber < 1 || serialNumber > records.size()) { // 订单编号必须在范围内 System.out.println("invalid operation"); return false; } records.remove(serialNumber - 1); return true; } // 输出表格信息 public void print() { double totalPrice = 0; Map<String, Integer> dishesCount = new HashMap<>(); for (Order order : records) { totalPrice += order.getTotalPrice(); String name = order.dish.name; dishesCount.put(name, dishesCount.getOrDefault(name, 0) + order.num); } System.out.print("table " + id + ":"); if (records.isEmpty()) { System.out.println(" 0 0"); return; } System.out.printf(" %.0f %.0f\n", totalPrice, totalPrice + 5); // 总价和小费 for (String name : dishesCount.keySet()) System.out.println(dishes.get(name).name + " " + dishesCount.get(name)); // 检查重复点菜 Set<String> distinctDishes = new HashSet<>(); List<Order> deduplicatedRecords = new ArrayList<>(); for (Order order : records) { String name = order.dish.name; if (!distinctDishes.contains(name)) { deduplicatedRecords.add(order); distinctDishes.add(name); } } int duplicatedCount = records.size() - deduplicatedRecords.size(); if (duplicatedCount > 0) System.out.println("deduplication " + duplicatedCount); System.out.printf("table %s: %.0f %.0f\n", id, totalPrice, totalPrice + 5); } }
类图：
分析：
本次作业设计的难点之一是处理各种异常情况。在设计程序时，需要考虑到各种不合法的输入格式和数据，对其进行逐个判断和处理，输出对应的异常提示信息。另外，菜价计算的过程也需要注意精度问题，例如四舍五入的实现方式、累加时的精度控制等。
在本次作业的实现过程中，我的思路是先定义好各种类的属性和方法，并且按照输入信息的顺序逐个处理，然后统一输出结果。在处理输入信息时，要细心、严谨，对于每一个不合法的输入都要及时输出提示信息，同时记录错误信息，以便修改和调试程序。
在编写代码时，我还使用了一些代码规范和优化的技巧，例如使用try-catch捕获异常，采用命名规范和代码注释规范等。通过这次作业的设计和实现，我加深了对Java程序设计的理解和应用，提高了自己的编程能力和实践经验。
踩坑心得：
-
注意输出格式，需要按照题目规定的格式输出，特别是空格和符号。
-
在读取代点菜信息时，要先找到代点菜的桌号对应的Order对象，再在该Order对象中添加对应的记录。
-
在删除订单记录时，先根据序号找到对应的Record对象，再从Order对象的records数组中删除该记录。
-
在计算菜品价格时，务必进行四舍五入，保留整数，否则得到的结果可能不准确。
-
在计算折扣时，要注意判断时间是否在营业时间范围内，输出相应的提示信息。
-
处理重复的记录、错误格式的输入等异常情况时，需要按照题目要求输出相应的提示信息。
-
如果输入的桌号超出范围，要输出相应的提示信息；同时还要注意桌号必须为整数，最高位不能为零，否则按非法格式处理。
-
注意需按照序号从小到大的顺序输出每个订单记录的处理信息，否则输出"record serial number sequence error"。
-
合并同一桌重复的点菜记录时，需要对份数进行累加，而不是简单地保留最后一条记录。
-
特别注意可能存在菜品名相同但基础价格不同的情况，需要按照题目要求处理。
-
对于特色菜的处理，按照题目要求计算菜品价格，注意四舍五入顺序。
改进建议：
1、对于部分输入格式不合法的情况，建议输出具体的出错信息，便于排查问题。
2、对于代点菜的功能，建议增加输出代点菜的桌号和被代点菜的桌号，以便进行核对。
3、计价时建议将每一条记录的小计输出，方便核对。
4、对于同一桌重复的点菜记录，建议在添加新记录时进行合并，而不是在计价时进行合并。
5、建议在输入订单记录时对序号进行校验，确保序号的连续性和正确性。
6、计算菜价时建议使用BigDecimal类进行精确计算，避免浮点数计算误差。
总结：
通过这道作业，我了解了Java中异常处理的方法，并运用到了实际项目中。
在此过程中，我发现了自己对于异常处理的不熟练程度，需要更多的实践进行加强。
同时，作为一道相对复杂的作业，也让我更深刻地认识到了良好的代码设计和规范的重要性，代码的可读性和可维护性对于一个项目的成功实现有着至关重要的作用。
对于教师、课程、作业、实验、课上及课下组织方式等方面，我认为除了能够掌握更多的知识之外，更为重要的是能够培养我们独立思考和解决问题的能力，这才是我们未来发展所必须的能力。同时，我也希望有更多的实践机会来加强自己的能力，并更好地掌握所学知识。
浙公网安备 33010602011771号