一、前言
距离第一次做题目集总结已经过去了一个月，在这一个月里，我通过写题目又学到了许多新的知识。这一次题目集的难度比上一次的要难，考察的知识更多，也很考察设计能力与逻辑思维能力。
题目集4总共7道题，题量适中，除了第一题外难度也适中。考察的内容主要有基础的语法、算法，还有部分容器的使用，以及Java中部分库类的使用，还考察了类的封装。
题目集5总共六道题，前几道考察的是正则表达式的使用，后面两道考察了类的设计中聚合关系的运用，让我了解到同一个题目，同一种功能，可以有多种不同的写法。
题目集6只有一道题，但却是这几个题目集中最为重量级的一道，难度相比于之前的题目直线上升，考察的是类的设计，只是题目描述就有近三千字，有45个测试点，狠狠地烧了我的cpu??
二、设计与分析
题目集4：
1.菜单计价程序-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+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
输入样例：
在这里给出一组输入。例如：
麻婆豆腐 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
代码长度限制 16kb
时间限制 400ms
内存限制 64MB
解释和心得：
打开题目集的时候，本来想着题目难度都是根据顺序递增的，但是我看到这第一题的时候就有点傻眼了，长长的题目描述和比较复杂的设计让我望而却步，还没开始写就已经打退堂鼓，先写了后面的几道题，等到回过头来想做这道题的时候，题目集已经快关闭了，于是就放弃了这道题，但是做了题目集6的迭代版本之后，发现这一版本的难度其实还好，具体思路和详细做法放到迭代版本中讲解。
题目集4中剩下的几道题值得讲解的就是对运行时间的处理。比如说数组和字符串的排序，一开始单纯用for循环来写，然后就会出现运行时间超出限定时间的情况：
所以我就去学习了使代码运行更高效快速的方法，一个是库里面的快排Arrays.sort,还有一个就是LinkedHashSet这一容器，前者不用多介绍，就是一个快速排序的方法，后者则比较复杂。
LinkedHashSet是一个基于LinkedHashMap实现的有序去重集合列表。它的特性之一是元素没有重复，因此在写去掉重复数据这道题的时候，我用到了这一容器。
题目集5：
1.日期问题面向对象设计（聚合一）
参考题目7-2的要求，设计如下几个类：DateUtil、Year、Month、Day，其中年、月、日的取值范围依然为：year∈[1900,2050] ,month∈[1,12] ,day∈[1,31]。
应用程序共测试三个功能：
求下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
代码长度限制 12kb
时间限制 10000ms
内存限制 64MB
我的源码如下:
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int year = 0;
int month = 0;
int day = 0;
int choice = input.nextInt();
if (choice == 1) { // test getNextNDays method
int m = 0;
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
DateUtil date = new DateUtil(year, month, day);
if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}
m = input.nextInt();
if (m < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.println(date.getNextNDays(m).showDate());
} else if (choice == 2) { // test getPreviousNDays method
int n = 0;
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
DateUtil date = new DateUtil(year, month, day);
if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}
n = input.nextInt();
if (n < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.println(date.getPreviousNDays(n).showDate());
} else if (choice == 3) { //test getDaysofDates method
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
int anotherYear = Integer.parseInt(input.next());
int anotherMonth = Integer.parseInt(input.next());
int anotherDay = Integer.parseInt(input.next());
DateUtil fromDate = new DateUtil(year, month, day);
DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);
if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
System.out.println(fromDate.getDaysofDates(toDate));
} else {
System.out.println("Wrong Format");
System.exit(0);
}
}
else{
System.out.println("Wrong Format");
System.exit(0);
}
}
}
class DateUtil {
private Day day;
public DateUtil() {
}
public DateUtil(int year, int month, int day) {
this.day = new Day(year,month,day);
}
public void setDay(Day day) {
this.day = day;
}
public Day getDay(){
return day;
}
public boolean checkInputValidity() {
if(day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear())){
day.mon_maxnum[2]=29;
}
if (day.getMonth().getYear().validate() && day.getMonth().validate() && day.validate()) {
return true;
}else {
return false;
}
}
public boolean compareDates(DateUtil date) {
if (day.getMonth().getYear().getYear()<date.day.getMonth().getYear().getYear()){
return false;
} else if (day.getMonth().getYear().getYear()==date.day.getMonth().getYear().getYear()) {
if (day.getMonth().getMonth()<date.day.getMonth().getMonth()){
return false;
} else if (day.getMonth().getMonth()==date.day.getMonth().getMonth()) {
if (day.getDay()<date.day.getDay()){
return false;
}
}
}
return true;
}
public boolean equalTwoDates(DateUtil date) {
if (day.getMonth().getYear().getYear() == date.day.getMonth().getYear().getYear() && day.getMonth().getMonth() == date.day.getMonth().getMonth() && day.getDay() == date.day.getDay()) {
return true;
}
return false;
}
public DateUtil getNextNDays(int n) {
int i;
for (i=0;i<n;i++){
if(day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear())) {
day.mon_maxnum[2] = 29;
}else{
day.mon_maxnum[2] = 28;
}
if (day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getMonth().getMonth() != 12 && day.getDay() == day.mon_maxnum[day.getMonth().getMonth()]){//闰年跨月不跨年
day.getMonth().monthIncrement();
day.restMin();
} else if (day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getMonth().getMonth() == 12 && day.getDay() == day.mon_maxnum[day.getMonth().getMonth()]) {//闰年跨年
day.getMonth().getYear().yearIncrement();
day.getMonth().restMin();
day.restMin();
} else if (day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getDay() != day.mon_maxnum[day.getMonth().getMonth()]) {//闰年不跨月
day.dayIncrement();
}
else if (!day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getMonth().getMonth()!=12 && day.getDay() == day.mon_maxnum[day.getMonth().getMonth()]) {//非闰年跨月不跨年
day.getMonth().monthIncrement();
day.restMin();
}else if (!day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getMonth().getMonth() == 12 && day.getDay() == day.mon_maxnum[day.getMonth().getMonth()]) {//非闰年跨年
day.getMonth().getYear().yearIncrement();
day.getMonth().restMin();
day.restMin();
} else if (!day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getDay() != day.mon_maxnum[day.getMonth().getMonth()]) {//非闰年不跨月
day.dayIncrement();
}
}
return this;
}
public DateUtil getPreviousNDays(int n) {
int i;
for (i=0;i<n;i++) {
if(day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear())) {
day.mon_maxnum[2] = 29;
}else {
day.mon_maxnum[2] = 28;
}
if (day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getMonth().getMonth() != 1 && day.getDay() == 1){//闰年退月不退年
day.getMonth().monthReduction();
day.setDay(day.mon_maxnum[day.getMonth().getMonth()]);
} else if (day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getMonth().getMonth() == 1 && day.getDay() == 1) {//闰年退年
day.getMonth().getYear().yearReduction();
day.getMonth().restMax();
day.restMax();
} else if (day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getDay() != 1) {//闰年不退月
day.dayReduction();
} else if (!day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getMonth().getMonth() != 1 && day.getDay() == 1) {//非闰年退月不退年
day.getMonth().monthReduction();
day.setDay(day.mon_maxnum[day.getMonth().getMonth()]);
}else if (!day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getMonth().getMonth() == 1 && day.getDay() == 1) {//非闰年退年
day.getMonth().getYear().yearReduction();
day.getMonth().restMax();
day.restMax();
} else if (!day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear()) && day.getDay() != 1) {//非闰年不跨月
day.dayReduction();
}
}
return this;
}
public int getDaysofDates(DateUtil date) {
if(day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear())) {
day.mon_maxnum[2] = 29;
}else{
day.mon_maxnum[2] = 28;
}
if(date.day.getMonth().getYear().isLeapYear(date.day.getMonth().getYear().getYear())) {
date.day.mon_maxnum1[2] = 29;
}else{
date.day.mon_maxnum1[2] = 28;
}
int i,sum=0,day1=0,day2=0;
if (equalTwoDates(date)) {
return sum;
} else {
if (compareDates(date)){//前大于后
if (day.getMonth().getYear().getYear() == date.day.getMonth().getYear().getYear()){// 同一年
if (day.getMonth().getMonth() == date.day.getMonth().getMonth()) {// 同一个月
day1 = day.getDay() - date.day.getDay();
} else {// 不同一个月
day1 = day.mon_maxnum[date.day.getMonth().getMonth()] - date.day.getDay();//小月剩余的天数
for (i = date.day.getMonth().getMonth() + 1; i < day.getMonth().getMonth(); i++) {
day2 += day.mon_maxnum[date.day.getMonth().getMonth()];
}
day2 += day.getDay();//整月以及大月当月已走过天数之和
}
} else if (day.getMonth().getYear().getYear()>date.day.getMonth().getYear().getYear()) {//非同一年
for (i = date.day.getMonth().getYear().getYear() + 1; i < day.getMonth().getYear().getYear(); i++) {//计算相隔的完整年的天数
if (day.getMonth().getYear().isLeapYear(i)) {
sum += 366;
} else {
sum += 365;
}
}
for (i = 1; i < date.day.getMonth().getMonth(); i++) {
day1 += date.day.mon_maxnum[i];//已走过的整月的天数
}
for (i = 1; i < day.getMonth().getMonth(); i++) {
day2 += day.mon_maxnum[i];//同上
}
if (day.getMonth().getYear().isLeapYear(date.day.getMonth().getYear().getYear())) {
day1 = 366 - day1 - date.day.getDay();//小年当年剩余的天数
} else {
day1 = 365 - day1 - date.day.getDay();
}
day2 += day.getDay();//大年当年已走过的天数
}
} else {//后大于前
if (date.day.getMonth().getYear().getYear() == day.getMonth().getYear().getYear()) {//同一年
if (date.day.getMonth().getMonth() == day.getMonth().getMonth()) {// 同一个月
day2 = date.day.getDay() - day.getDay();
} else {// 不同一个月
day2 = day.mon_maxnum[day.getMonth().getMonth()] - day.getDay();//小月剩余的天数
for (i = day.getMonth().getMonth() + 1; i < date.day.getMonth().getMonth(); i++) {
day1 += day.mon_maxnum[day.getMonth().getMonth()];
}
day1 += date.day.getDay();//整月以及大月当月已走过天数之和
}
} else if (day.getMonth().getYear().getYear() < date.day.getMonth().getYear().getYear()) {//非同一年
for (i = day.getMonth().getYear().getYear() + 1; i < date.day.getMonth().getYear().getYear(); i++) {//计算相隔的完整年的天数
if (day.getMonth().getYear().isLeapYear(i)) {
sum += 366;
} else {
sum += 365;
}
}
for (i = 1; i < date.day.getMonth().getMonth(); i++) {
day1 += date.day.mon_maxnum1[i];//已走过的整月的天数
}
for (i = 1; i < day.getMonth().getMonth(); i++) {
day2 += day.mon_maxnum[i];//同上
}
if (day.getMonth().getYear().isLeapYear(day.getMonth().getYear().getYear())) {
day2 = 366 - day2 - day.getDay();//小年当年剩余的天数
} else {
day2 = 365 - day2 - day.getDay();
}
day1 += date.day.getDay();//大年当年已走过的天数
}
}
}
return sum+day1+day2;
}
public String showDate(){
return (day.getMonth().getYear().getYear() + "-" + day.getMonth().getMonth() + "-" + day.getDay());
}
}
class Year {
private int year;
public Year() {
}
public Year(int year) {
this.year = year;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public boolean isLeapYear(int year) {
if(year%4 == 0 && year%100 != 0 || year%400 == 0){
return true;
}
else{
return false;
}
}
public boolean validate() {
if (year >= 1900 && year <= 2050) {
return true;
} else {
return false;
}
}
public void yearIncrement() {
year++;
}
public void yearReduction() {
year--;
}
}
class Month {
private Year year;
private int month;
public Month() {
}
public Month(int year,int month) {
this.year = new Year(year);
this.month = month;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public Year getYear() {
return year;
}
public void setYear(Year year) {
this.year = year;
}
public void restMin() {
month = 1;
}
public void restMax() {
month = 12;
}
public boolean validate() {
if (month>=1 && month<=12) {
return true;
} else {
return false;
}
}
public void monthIncrement() {
month++;
}
public void monthReduction() {
month--;
}
}
class Day {
private Month month;
private int day;
int[] mon_maxnum = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
int[] mon_maxnum1 = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
public Day() {
}
public Day(int year,int month,int day) {
this.month = new Month(year,month);
this.day = day;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
public Month getMonth() {
return month;
}
public void setMonth(Month month) {
this.month = month;
}
public void restMin() {
day = 1;
}
public void restMax() {
day = mon_maxnum[month.getMonth()];
}
public boolean validate() {
if (day>0 && day <= mon_maxnum[month.getMonth()]) {
return true;
} else {
return false;
}
}
public void dayIncrement() {
day++;
}
public void dayReduction() {
day--;
}
}
解释和心得
本题的代码方法相较于之前的版本没有改变多少，新增的Year、Month和Day的Increment、Reduction、restMin和restMax等方法比较简易。
但是这个迭代版本的类的设计与之前设计的版本差别很大，因为这里利用了代码的聚合关系。在聚合关系中，成员对象是整体的一部分，但是成员对象可以脱离整体对象独立存在，类与类之间的关系在不同层次上，是整体与个体/部分的关系。
本题难度不大，根据给出的类图来设计对应的类便可。
整体体现的是良好的面向对象程序的设计思维，将日期相关的类和方法进行了合理的分离和封装。定义Year，Month，Day类来进行基础的日期操作，DateUtil类里则封装了日期的计算方法，这样的设计使代码更简洁易懂，可读性更强，更好修改，而不是像之前那样把所有方法都在同一个类里实现。
以下是两个版本的类图对比：
最初版本：
聚合一版本：
2.日期问题面向对象设计（聚合二）
这一题与聚合一版本差别不大，改变了代码的聚合关系，类的设计有所更改。
类图如下：
源代码：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int year = 0;
int month = 0;
int day = 0;
int choice = input.nextInt();
if (choice == 1) { // test getNextNDays method
int m = 0;
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
DateUtil date = new DateUtil(year, month, day);
if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}
m = input.nextInt();
if (m < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.print(date.getYear().getYear() + "-" + date.getMonth().getMonth() + "-" + date.getDay().getDay() + " next " + m + " days is:");
System.out.println(date.getNextNDays(m).showDate());
} else if (choice == 2) { // test getPreviousNDays method
int n = 0;
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
DateUtil date = new DateUtil(year, month, day);
if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}
n = input.nextInt();
if (n < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.print(
date.getYear().getYear() + "-" + date.getMonth().getMonth() + "-" + date.getDay().getDay() + " previous " + n + " days is:");
System.out.println(date.getPreviousNDays(n).showDate());
} else if (choice == 3) { //test getDaysofDates method
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
int anotherYear = Integer.parseInt(input.next());
int anotherMonth = Integer.parseInt(input.next());
int anotherDay = Integer.parseInt(input.next());
DateUtil fromDate = new DateUtil(year, month, day);
DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);
if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
System.out.println("The days between " + fromDate.showDate() +
" and " + toDate.showDate() + " are:"
+ fromDate.getDaysofDates(toDate));
} else {
System.out.println("Wrong Format");
System.exit(0);
}
}
else{
System.out.println("Wrong Format");
System.exit(0);
}
}
}
class DateUtil {
private Year year;
private Month month;
private Day day;
int[] mon_maxnum = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
int[] mon_maxnum1 = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
public DateUtil() {
}
public DateUtil(int year, int month, int day) {
this.day = new Day(day);
this.month = new Month(month);
this.year = new Year(year);
}
public Year getYear() {
return year;
}
public void setYear(Year year) {
this.year = year;
}
public Month getMonth() {
return month;
}
public void setMonth(Month month) {
this.month = month;
}
public Day getDay(){
return day;
}
public void setDay(Day day) {
this.day = day;
}
public void setDayMin() {
day.setDay(1);
}
public void setDayMax() {
day.setDay(mon_maxnum[month.getMonth()]);
}
public boolean checkInputValidity() {
if(year.isLeapYear(year.getYear())){
mon_maxnum[2]=29;
}
if (month.validate() && year.validate() && day.getDay()>=1 && day.getDay() <= mon_maxnum[month.getMonth()]) {
return true;
}else {
return false;
}
}
public boolean compareDates(DateUtil date) {
if (year.getYear()<date.year.getYear()){
return false;
} else if (year.getYear()==date.year.getYear()) {
if (month.getMonth()<date.month.getMonth()){
return false;
} else if (month.getMonth()==date.month.getMonth()) {
if (day.getDay()<date.day.getDay()){
return false;
}
}
}
return true;
}
public boolean equalTwoDates(DateUtil date) {
if (year.getYear() == date.year.getYear() && month.getMonth() == date.month.getMonth() && day.getDay() == date.day.getDay()) {
return true;
}
return false;
}
public DateUtil getNextNDays(int n) {
int i;
for (i=0;i<n;i++){
if (year.isLeapYear(year.getYear())) {
mon_maxnum[2] = 29;
if (month.getMonth() != 12 && day.getDay() == mon_maxnum[month.getMonth()]) {//闰年跨月不跨年
month.monthIncrement();
setDayMin();
} else if (month.getMonth() == 12 && day.getDay() == mon_maxnum[month.getMonth()]) {//闰年跨年
year.yearIncrement();
month.restMin();
setDayMin();
} else if (day.getDay() != mon_maxnum[month.getMonth()]) {//闰年不跨月
day.dayIncrement();
}
} else {
mon_maxnum[2] = 28;
if (month.getMonth() != 12 && day.getDay() == mon_maxnum[month.getMonth()]) {//非闰年跨月不跨年
month.monthIncrement();
setDayMin();
} else if (month.getMonth() == 12 && day.getDay() == mon_maxnum[month.getMonth()]) {//非闰年跨年
year.yearIncrement();
month.restMin();
setDayMin();
} else if (day.getDay() != mon_maxnum[month.getMonth()]) {//非闰年不跨月
day.dayIncrement();
}
}
}
return this;
}
public DateUtil getPreviousNDays(int n) {
int i;
for (i=0;i<n;i++) {
if (year.isLeapYear(year.getYear())) {
mon_maxnum[2] = 29;
if (month.getMonth() != 1 && day.getDay() == 1) {//闰年退月不退年
month.monthReduction();
day.setDay(mon_maxnum[month.getMonth()]);
} else if (month.getMonth() == 1 && day.getDay() == 1) {//闰年退年
year.yearReduction();
month.restMax();
setDayMax();
} else if (day.getDay() != 1) {//闰年不退月
day.dayReduction();
}
} else {
mon_maxnum[2] = 28;
if (month.getMonth() != 1 && day.getDay() == 1) {//非闰年退月不退年
month.monthReduction();
day.setDay(mon_maxnum[month.getMonth()]);
} else if (month.getMonth() == 1 && day.getDay() == 1) {//非闰年退年
year.yearReduction();
month.restMax();
setDayMax();
} else if (day.getDay() != 1) {//非闰年不跨月
day.dayReduction();
}
}
}
return this;
}
public int getDaysofDates(DateUtil date) {
if(year.isLeapYear(year.getYear())) {
mon_maxnum[2] = 29;
}else{
mon_maxnum[2] = 28;
}
if(date.year.isLeapYear(date.year.getYear())) {
date.mon_maxnum1[2] = 29;
}else{
date.mon_maxnum1[2] = 28;
}
int i,sum=0,day1=0,day2=0;
if (equalTwoDates(date)) {
return sum;
} else {
if (compareDates(date)){//前大于后
if (year.getYear() == date.year.getYear()){// 同一年
if (month.getMonth() == date.month.getMonth()) {// 同一个月
day1 = day.getDay() - date.day.getDay();
} else {// 不同一个月
day1 = mon_maxnum[date.month.getMonth()] - date.day.getDay();//小月剩余的天数
for (i = date.month.getMonth() + 1; i < month.getMonth(); i++) {
day2 += mon_maxnum[date.month.getMonth()];
}
day2 += day.getDay();//整月以及大月当月已走过天数之和
}
} else if (year.getYear()>date.year.getYear()) {//非同一年
for (i = date.year.getYear() + 1; i < year.getYear(); i++) {//计算相隔的完整年的天数
if (year.isLeapYear(i)) {
sum += 366;
} else {
sum += 365;
}
}
for (i = 1; i < date.month.getMonth(); i++) {
day1 += date.mon_maxnum[i];//已走过的整月的天数
}
for (i = 1; i < month.getMonth(); i++) {
day2 += mon_maxnum[i];//同上
}
if (year.isLeapYear(date.year.getYear())) {
day1 = 366 - day1 - date.day.getDay();//小年当年剩余的天数
} else {
day1 = 365 - day1 - date.day.getDay();
}
day2 += day.getDay();//大年当年已走过的天数
}
} else {//后大于前
if (date.year.getYear() == year.getYear()) {//同一年
if (date.month.getMonth() == month.getMonth()) {// 同一个月
day2 = date.day.getDay() - day.getDay();
} else {// 不同一个月
day2 = mon_maxnum[month.getMonth()] - day.getDay();//小月剩余的天数
for (i = month.getMonth() + 1; i < date.month.getMonth(); i++) {
day1 += mon_maxnum[month.getMonth()];
}
day1 += date.day.getDay();//整月以及大月当月已走过天数之和
}
} else if (year.getYear() < date.year.getYear()) {//非同一年
for (i = year.getYear() + 1; i < date.year.getYear(); i++) {//计算相隔的完整年的天数
if (year.isLeapYear(i)) {
sum += 366;
} else {
sum += 365;
}
}
for (i = 1; i < date.month.getMonth(); i++) {
day1 += date.mon_maxnum1[i];//已走过的整月的天数
}
for (i = 1; i < month.getMonth(); i++) {
day2 += mon_maxnum[i];//同上
}
if (year.isLeapYear(year.getYear())) {
day2 = 366 - day2 - day.getDay();//小年当年剩余的天数
} else {
day2 = 365 - day2 - day.getDay();
}
day1 += date.day.getDay();//大年当年已走过的天数
}
}
}
return sum+day1+day2;
}
public String showDate(){
return (year.getYear() + "-" + month.getMonth() + "-" + day.getDay());
}
}
class Year {
private int year;
public Year() {
}
public Year(int year) {
this.year = year;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public boolean isLeapYear(int year) {
if(year%4 == 0 && year%100 != 0 || year%400 == 0){
return true;
}
else{
return false;
}
}
public boolean validate() {
if (year >= 1820 && year <= 2020) {
return true;
} else {
return false;
}
}
public void yearIncrement() {
year++;
}
public void yearReduction() {
year--;
}
}
class Month {
private int month;
public Month() {
}
public Month(int month) {
this.month = month;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public void restMin() {
month = 1;
}
public void restMax() {
month = 12;
}
public boolean validate() {
if (month >= 1 && month <= 12) {
return true;
} else {
return false;
}
}
public void monthIncrement() {
month++;
}
public void monthReduction() {
month--;
}
}
class Day {
private int day;
public Day() {
}
public Day(int day) {
this.day = day;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
public void dayIncrement() {
day++;
}
public void dayReduction() {
day--;
}
}
聚合二中的关系是一对多的聚合关系，这使得DateUtil类中的方法更复杂，但是却使数据更加容易管理，个人觉得聚合二比聚合一更方便易懂。
题目集6：
1.菜单计价程序-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
其他用例请参考公开的测试用例
代码长度限制 50kb
时间限制 1000ms
内存限制 64MB
源代码：
import java.sql.SQLOutput;
import java.time.LocalDateTime;
import java.util.*;
public class Main {
static int cnt1 = 0;
static int cnt2 = -1;
static int cnt3 = 0;
public static void main(String args[]) {
int[] mon_maxnum = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
Scanner s = new Scanner(System.in);
Menu menu = new Menu();
Table[] tables = new Table[10];
for (int i=0;i<10;i++) {
tables[i] = new Table();
}
String input = s.nextLine();
while (!input.equals("end")) {
String[] a = input.split(" ");//以空格为分隔符分离输入的字符串
if (input.matches("[\\u4e00-\\u9fa5]+ \\d+(\\.\\d+)?( T)?") ) { //输入的是菜谱信息
if (!a[1].matches("^[1-9]|[1-9]\\d*$")) {//菜价
System.out.println("wrong format");
} else if (Integer.parseInt(a[1]) > 300 || Integer.parseInt(a[1]) < 0) {
System.out.println(a[0] + " price out of range " + a[1]);
} else{
menu.dishes[cnt1] = menu.addDish(a[0], Integer.parseInt(a[1]));//类型不匹配，使用Integer包装
cnt1++;
}
} else if (a.length == 3 && input.matches("[\\u4e00-\\u9fa5]+ \\d+(\\.\\d+)?( T)?")) {//特价菜
if (!a[1].matches("^[1-9]|[1-9]\\d*$")) {
System.out.println("wrong format");
} else if (Integer.parseInt(a[1]) > 300 || Integer.parseInt(a[1]) < 0) {
System.out.println(a[0] + " price out of range " + a[1]);
} else{
menu.dishes[cnt1] = menu.addDish(a[0], Integer.parseInt(a[1]));//类型不匹配，使用Integer包装
menu.dishes[cnt1].T = 1;
cnt1++;
}
} else if (a.length == 4 && a[0].equals("table")) {//桌与时间
String[] da = a[2].split("/");//年月日
String[] ti = a[3].split("/");//具体时间
if (!a[1].matches("^[1-9]|[1-9]\\d*$")) {
System.out.println("wrong format");
} else if (Integer.parseInt(a[1]) > 55) {
System.out.println(a[1] + " table num out of range");
}
else if (!a[2].matches("\\d{4,}/\\d{1,2}/\\d{1,2}") || !a[3].matches("\\d{1,2}/\\d{1,2}/\\d{1,2}")) {
System.out.println("wrong format");
} else if (Integer.parseInt(da[0]) < 2022 || Integer.parseInt(da[0]) > 2023 ) {
System.out.println("not a valid time period");
} else if (Integer.parseInt(da[1]) < 1 || Integer.parseInt(da[1]) > 12) {
System.out.println(a[1] + " date error");
} else if (Integer.parseInt(da[2]) < 1 || Integer.parseInt(da[2]) > mon_maxnum[Integer.parseInt(da[1])]) {
System.out.println(a[1] + " date error");
} else if (Integer.parseInt(ti[0]) > 23 || Integer.parseInt(ti[0]) < 0) {
System.out.println(a[1] + " date error");
} else if (Integer.parseInt(ti[1]) > 59 || Integer.parseInt(ti[1]) < 0) {
System.out.println(a[1] + " date error");
} else if (Integer.parseInt(ti[2]) > 59 || Integer.parseInt(ti[2]) < 0) {
System.out.println(a[1] + " date error");
} else {
cnt2++;
tables[cnt2] = new Table();
tables[cnt2].time = new Time();
tables[cnt2].tableNum = Integer.parseInt(a[1]);
tables[cnt2].time.date = a[2];//年月日
tables[cnt2].time.times = a[3];//具体时间
System.out.println("table " + a[1] + ": ");
}
} else if (input.matches("\\d+ [\\u4e00-\\u9fa5a-zA-Z]+ \\d+ \\d+")) {//点菜
if (cnt2 > -1) {
if (!tables[cnt2].order.checkOrdernum(Integer.parseInt(a[0]))) {
System.out.println("record serial number sequence error");
} else if (menu.searchDish(a[1]) == null) {
System.out.println(a[1] + " does not exist");
} else {
Dish dish = new Dish();
dish = menu.searchDish(a[1]);
if (dish.T == 1) {//特价菜份额份数判断
if (!a[3].matches("^[1-9]|[1-9]\\d*$")) {
System.out.println("wrong format");
} else if (Integer.parseInt(a[2]) > 9) {
System.out.println("wrong format");
} else if (Integer.parseInt(a[2]) != 1 && Integer.parseInt(a[2]) != 3) {
System.out.println(a[0] + " portion out of range " + a[2]);
} else if (Integer.parseInt(a[3]) > 15) {
System.out.println(a[0] + " num out of range " + a[3]);
} else {
Record record = new Record();
record.orderNum = Integer.parseInt(a[0]);
record.portion = Integer.parseInt(a[2]);
record.num = Integer.parseInt(a[3]);
record.d = menu.searchDish(a[1]);
tables[cnt2].order.records[cnt3] = record;
cnt3++;
System.out.println(record.orderNum + " " + record.d.name + " " + record.getPriceA());
}
} else {//非特价菜份额份数判断
if (!a[3].matches("^[1-9]|[1-9]\\d*$")) {
System.out.println("wrong format");
} else if (Integer.parseInt(a[2]) > 9) {
System.out.println("wrong format");
} else if (Integer.parseInt(a[2]) > 3) {
System.out.println(a[0] + " portion out of range " + a[2]);
} else if (Integer.parseInt(a[3]) > 15) {
System.out.println(a[0] + " num out of range " + a[3]);
} else {
Record record = new Record();
record.orderNum = Integer.parseInt(a[0]);
record.portion = Integer.parseInt(a[2]);
record.num = Integer.parseInt(a[3]);
record.d = menu.searchDish(a[1]);
tables[cnt2].order.records[cnt3] = record;
cnt3++;
System.out.println(record.orderNum + " " + record.d.name + " " + record.getPriceA());
}
}
}
}
}else if (a.length == 2 && a[1].equals("delete")) {
for (int i = 0;i <= cnt2;i++) {
tables[i].order.delARecordByOrderNum(Integer.parseInt(a[0]));
}
} else{
System.out.println("wrong format");
}
input = s.nextLine();
}
for (int i=0;i <= Main.cnt2;i++) {
tables[i].getPrice();
}
}
}
class Dish {
String name;
int unit_price;
int T = 0;
public int getPrice(int portion) {
int p = 0;
if (portion == 1) {
p = unit_price;
} else if (portion == 2) {
p = (int)(Math.round(unit_price*1.5));
} else if (portion == 3) {
p = unit_price * 2;
}
return p;
}
}
class Menu {
Dish[] dishes;
public Menu() {
this.dishes = new Dish[100];
}
public Dish searchDish(String dishName) {
for (int i = 0; i < Main.cnt1; i++) {
if (dishName.equals(dishes[i].name)) {
return dishes[i];
}
}
return null;
}//根据菜名在菜谱中查找菜品信息，返回Dish对象。
public Dish addDish(String dishName,int unit_price) {
Dish dish = new Dish();
dish.name = dishName;
dish.unit_price = unit_price;
return dish;
}//添加一道菜品信息
}
class Record {
Dish d;
int orderNum;
int flag = 1;//判断是否删除
int portion;
int num;
public Record (){
d = new Dish();
}
public int getPrice() {
return d.getPrice(portion) * num * flag;
}
public int getPriceA() {
return d.getPrice(portion) * num;
}
}
class Order {
Record[] records;
public Order() {
this.records = new Record[100];
for (int i = 0; i < 100; i++) {
records[i] = new Record();
}
}
public int getTotalPrice() {//计算订单的总价
int totalprice = 0;
for (int i=0;i < Main.cnt3;i++) {
totalprice += records[i].getPrice();
}
return totalprice;
}
public Record addARecord(int orderNum,String dishName,int portion,int num) {//添加一条菜品信息到订单中
Record record = new Record();
record.orderNum = orderNum;
record.d.name = dishName;
record.portion = portion;
record.num = num;
return record;
}
public void delARecordByOrderNum(int orderNum) {
int i;
i = findRecordByNum(orderNum);
if (i == -1) {
System.out.println("delete error");
} else {
if (records[i].flag == 1) {
records[i].flag = 0;
} else{
System.out.println("deduplication " + orderNum);
}
}
}
public int findRecordByNum(int orderNum) {
int i;
for (i=0;i < Main.cnt3;i++) {
if (records[i].orderNum == orderNum) {
return i;
}
}
return -1;
}
Boolean checkOrdernum(int j) {
for (int i=0;i< Main.cnt3;i++) {
if (j <= records[i].orderNum) {
return false;
}
}
return true;
}
}
class Time {
String date;
String times;
int weekday;
int year;
int month;
int day;
int hour;
int minutes;
public void getDate() {
String[] da = date.split("/");
String[] ti = times.split("/");
this.year = Integer.parseInt(da[0]);
this.month = Integer.parseInt(da[1]);
this.day = Integer.parseInt(da[2]);
this.hour = Integer.parseInt(ti[0]);
this.minutes = Integer.parseInt(ti[1]);
LocalDateTime d = LocalDateTime.of(year,month,day,hour,minutes);
this.weekday = d.getDayOfWeek().getValue();//getValue得到值，否则DayOfWeek类型不能直接用
}
}
class Table {
Time time;
Order order;
int tableNum;
int tablePrice;
public Table() {
time = new Time();
order = new Order();
}
public void getPrice() {
int sum1 = 0;//特价菜
int sum2 = 0;//非特价菜
time.getDate();
if (time.weekday >= 1 && time.weekday <= 5) {//周一到周五
for (int i=0;i <= Main.cnt3;i++) {
if (order.records[i].d.T == 1) {//是特价菜
sum1 += (int)(Math.round(order.records[i].getPrice()*0.7));
} else if (order.records[i].d.T == 0) {//不是特价菜
sum2 += order.records[i].getPrice();
}
}
if ((time.hour >= 10 && time.minutes >= 30 && time.hour < 14) || (time.hour <= 14 && time.minutes <= 30 && time.hour > 10)) {//中午
tablePrice = (int)(Math.round(sum2 * 0.6)) + sum1;
System.out.println("table " + tableNum + ": " + order.getTotalPrice() + " " + tablePrice);
} else if ((time.hour >= 17 && time.hour < 20) || time.hour == 20 && time.minutes <= 30) {//晚上
tablePrice = (int)(Math.round(sum2 * 0.8)) + sum1;
System.out.println("table " + tableNum + ": " + order.getTotalPrice() + " " + tablePrice);
} else{ //非营业时间
System.out.println("table " + tableNum + " out of opening hours");
}
} else if (time.weekday == 6 || time.weekday == 7) {//周末
if ((time.hour >= 9 && time.minutes >= 30 && time.hour < 21) || (time.hour <= 21 && time.minutes <=30 && time.hour > 9)) {
tablePrice = order.getTotalPrice();
System.out.println("table " + tableNum + ": " + order.getTotalPrice() + " " + tablePrice);
} else{ //非营业时间
System.out.println("table " + tableNum + " out of opening hours");
}
}
}
}
本题类图如下：
解释和心得
在老师布置完这道题，并在群里说本题预计时间20h+，代码量1000+的时候，我就意识到这是一块难啃的骨头了。
首先分析题目可以知道，代码运行大致可以分为输入菜品信息、输入点菜信息、得出价格三个主要模块。其中可以有选择地进行已点菜品的删除、代点菜等额外功能。
我的思路是先根据已给的类来设计，最后才写的主方法。
首先是菜品类Dish，这个类比较简单，包含的是菜品的属性，只用写一个getPrice方法来返回当前菜品的单价，那么就根据题目给的要求，根据不同的份额在基础单价之上进行提价，再返回该值。在这一类里面我增加了一个标志T，用来标记添加的菜品是否是特价菜，标记会在后续方法中用到。
然后设计菜谱类Menu。在该类里面有一个Dish数组，用来存放已有的菜品。我首先写了一个构造方法，给Dish类数组开辟了空间，然后设计searchDish方法和addDish方法。前者只用for循环就可实现，循环条件后续写主方法时才有具体值，找到了就返回当前数组信息，没找到就返回null。后者的设计则是每次都创建一个对象Dish，将传进来的菜品属性赋值给Dish，然后返回整个Dish数据。
再设计点菜记录类Record，该类的功能是保存订单上的一道菜品记录。仅有的一个方法是计算当前一条菜品的总价，我增加了一个成员num，代表这一菜品的份数，还增加了一个标记flag，用来判断是否删除当前这一条菜品记录，默认值为1不删除，当顾客做出了删除选择时，将flag赋值为0，在计算当前一条菜品总价时乘上flag，就可实现不计价，这样的删除是伪删除，虽然做法不是特别正确，但是目前这一功能还没有碰到bug。
然后设计订单类Order，该类的功能是保存用户的所有点菜信息，计算当前桌的总价。有一个成员Record数组，然后是四个方法。第一个方法是计算订单总价，定义一个局部变量totalprice，用for循环让该变量每次都加上Record类里的每条菜品的价格便可得到总价。addRecord方法与前面的addDish方法一样，不再赘述。然后是查找菜品的操作，这里也是直接用for循环便可实现。最后是已点菜品的删除操作，调用查找函数，找到要删除的菜品之后，判断其成员属性flag是否为0，不为0则赋值为0，为0则说明已经进行过删除，输出“deduplication” + orderNum，没找到则输出“delete error”。
除此之外，我还设计了Time类和Table类。Time类用来得到当前的点餐具体时间。Table类用来进行最后的价格折扣计算。
Table类的设计有点小复杂，我修改了很多遍才大致正确，首先就是判断当前的星期，来确定折扣，再判断具体时间，再进行折扣，特价菜的折扣我也是放到了Table类里面来进行计算，这一个类就是单纯用来计算的。
然后就是主方法的设计。主方法的设计比较繁琐，大致思路是运用正则表达式来判断输入的数据类型，再对该数据进行处理。正则表达式判断的那一块代码我修改了很多次，但都达不到满意的效果，除非全部删除进行重写，但由于开始的比较晚，已经来不及重写了，只能在原有的基础上增加判定条件，使数据判断更精确。
我定义了三个全局变量，cnt1对应菜品数量，每添加一个菜品信息，cnt1进行自增；cnt2对应订单菜品数量，增加一道订单，cnt2++；cnt3对应桌子数量，增加一张桌子，cnt3++。上文提到的for循环条件就是用的这几个计数器变量来进行判断。
写了大概的框架之后，就根据测试点来一个个完成功能。例如份额、份数的范围，菜价的范围，订单时间的范围等，都要一步步地进行修改，并且每次修改完都要测试一下数据，看是否会影响其他功能。（实际上经常都是牵一发而动全身，改的人都傻了?）