OOP题目集4-6总结

前言：题目集4-6的题目量不大，但难度比较大，第4次题目集考察的知识点主要是字符串的使用以及数组；第5次题目集考察的知识点主要是正则表达式、类、字符串语法和数组语法的使用和聚合的使用；第6次题目集只有一道题目，但这道题目是由菜单计价程序叠加四次的题目，主要考察类和逻辑，测试点十分的多；

7-1 菜单计价程序-3
分数 30

全屏浏览题目

切换布局
作者 蔡轲
单位 南昌航空大学
设计点菜计价程序，根据输入的信息，计算并输出总价格。

输入内容按先后顺序包括两部分：菜单、订单，最后以"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
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

源代码：

 import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.*;
public class Main{
    public static void main(String[] args) {
        int countOfOrder = 0;
        Menu menu = new Menu();// 创建一个菜单
        Order order = new Order();// 创建集合
        Operator operator = new Operator();// 创建业务类对象
        operator.recordDish(menu);// 记录菜单
        operator.recordOrderNum(order);// 记录桌号
        operator.recordTime(order);// 记录时间
        operator.orderDish(order,menu);// 记录点菜
        // 输出
        operator.output(order);
}

}
class Operator {// 业务类
Scanner input = new Scanner(System.in);
public void output(Order order) {
boolean flag = true;
for (int j = 0; flag; j++) {
    float totalCost = 0;
    if(order.judgeTime(order) == -1){
        System.out.println("table " +  order.getTableNum() + " out of opening hours");
    }else {
        System.out.println("table " + order.getTableNum() + ": ");
        for (int i = 0; ; i++) {
            if (order.records[i].getOrderNum() != -1) {
                if (order.records[i].getIsValue() == 1) {
                    totalCost = totalCost + order.records[i].getPrice();
                }
                System.out.println(order.records[i].orderNum + " " + order.records[i].getD().getName() + " " + order.records[i].getPrice());
            } else {
                totalCost = totalCost * order.judgeTime(order);
                if (totalCost - (int) totalCost >= 0.5) {
                    totalCost = (int) totalCost + 1;// 四舍五入
                }

                System.out.println("table " + order.getTableNum() + ": " + (int) totalCost);
                break;
            }
        }
        // 没设计好，先输出一桌
    }
    flag = false;
}

}
public void recordDish(Menu menu) { //记录菜品
int price;
String name;
    for (int i = 0; ; i++) {
        name = input.next();
        if (name.equals("table")) {
            break;
        }
        price = input.nextInt();
        menu.addDish(name, price);
    }
}

public void recordOrderNum(Order order) {// 记录编号
    order.setTableNum(input.nextInt());
}

public void recordTime(Order order) {// 记录时间
    int year = 0,month = 0,day = 0,hour = 0,min = 0,sec = 0;
    String[] time = input.nextLine().replace("/"," ").split(" ");
    year = Integer.parseInt(time[1]);
    month = Integer.parseInt(time[2]);
    day = Integer.parseInt(time[3]);
    hour = Integer.parseInt(time[4]);
    min = Integer.parseInt(time[5]);
    sec = Integer.parseInt(time[6]);
    order.setYear(year);
    order.setMonth(month);
    order.setDay(day);
    order.setHours(hour);
    order.setMin(min);
    order.setSec(sec);
}

public boolean orderDish(Order order, Menu menu) {// 记录点菜记录
boolean result = true;
    for (int i = 0; result; i++) {
        int num = 0;
        String nums = input.next();
        if (nums.equals("end")){
            result = false;
            break;
        }else{
            num = Integer.parseInt(nums);
        }
        String dish = input.next();
        if(dish.equals("delete")){
            order.delARecordByOrderNum(num);
        } else {
            order.records[i].isValue = 1;
            order.records[i].setOrderNum(num);
            order.records[i].setD(menu.searchDish(dish));
            order.records[i].setPortion(input.nextInt());
            order.records[i].setOrderQuantity(input.nextInt());
        }
    }
    return result;
}

public void deleteRecord(Order order, int recordNum) {// 删除记录
    order.delARecordByOrderNum(recordNum);
}

}
class Dish {// 记录一道菜品的信息
Dish(String name, int unit_price) {
    this.name = name;
    this.unit_price = unit_price;
}

private String name;//菜品名称

private int unit_price; //单价

public int getPrice(int portion) {//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
    double cost = 0;
    if (portion == 1) {
        cost = unit_price;
    } else if (portion == 2) {
        cost = unit_price * 1.5;
    } else if (portion == 3) {
        cost = unit_price * 2;
    }
    int result = 0;
    if (cost - (int) cost >= 0.5) {
        result = (int) cost + 1;
    } else {
        result = (int) cost;
    }
    return result;
}

public String getName() {
    return name;
}

public int getUnit_price() {
    return unit_price;
}

}
class Menu {
public Dish[] dishs = new Dish[1000];//菜品数组，保存所有菜品信息
int dishIndex = 0;

public Dish searchDish(String dishName) {
    boolean existDish = false;// 记录判断结果
    Dish result = new Dish("0", 0);
    for (int i = 0; i < 1000 ; i++) {
        if (this.dishs[i].getName().equals(dishName)) {
            result = dishs[i];
            existDish = true;
            break;
        }
    }
    if (existDish == false) {
        System.out.println(dishName + "does not exist");
    }
    return result;
}//根据菜名在菜谱中查找菜品信息，返回Dish对象。

public void addDish(String dishName, int unit_price) {
    dishs[dishIndex] = new Dish(dishName, unit_price);
    dishIndex++;
}//添加一道菜品信息

}
class Record {
int orderNum;// 序号
Dish d;// 菜品
int orderQuantity;// 份数
int isValue = 0;// 记录是否作数
int portion;// 份额（1/2/3代表小/中/大份）
public int getPrice() {
    return this.orderQuantity * d.getPrice(portion);
}//计价，计算本条记录的价格
Record(){

}
Record(int orderNum, String name, int orderQuantity, int portion) {
    setOrderNum(orderNum);
    setPortion(portion);
    setOrderQuantity(orderQuantity);
}

public int getOrderNum() {
    return orderNum;
}

public void setOrderNum(int orderNum) {
    this.orderNum = orderNum;
}

public int getIsValue() {
    return isValue;
}

public void setIsValue(int isValue) {
    this.isValue = isValue;
}

public Dish getD() {
    return d;
}

public void setD(Dish d) {
    this.d = d;
}

public int getOrderQuantity() {
    return orderQuantity;
}

public void setOrderQuantity(int orderQuantity) {
    this.orderQuantity = orderQuantity;
}

public int getPortion() {
    return portion;
}

public void setPortion(int portion) {
    this.portion = portion;
}

}
class Order {
Record[] records = new Record[100];// 保存订单上每一道的记录

int tableNum;// 桌编号

Order(){
    for(int i = 0 ;i < 100 ;i++){
        this.records[i] = new Record(-1,"1",-1,-1);// 实例化创建内存
    }
}
public float judgeTime(Order order) {// 判断下单时间获得折扣或不营业
    int week = 3;// 星期数
    float discount = 1;
    LocalDate timeStander = LocalDate.of(1898, 12, 19);// 设置参照时间1000年1月1 星期三
    LocalDate time = LocalDate.of(order.getYear(), order.getMonth(), order.getDay());
    week = ((int) timeStander.until(time, ChronoUnit.DAYS) + week) % 7;// 计算当前星期几
    if (week >= 1 && week <= 5) {// 周一到周五
        if (order.getHours() >= 17 && order.getHours() < 20 && order.getMin() < 60 && order.getMin() >= 0 || order.getHours() == 20 && order.getMin() <= 30 && order.getMin() >= 0) {
            discount = 0.8F;
        }//晚上
        else if (order.getHours() > 10 && order.getHours() < 14 && order.getMin() < 60 && order.getMin() >= 0 || order.getHours() == 10 && order.getMin() <= 30 && order.getMin() >= 0 || order.getHours() == 14 && order.getMin() <= 30 && order.getMin() >= 0) {
            discount = 0.6F;
        }//中午
        else {
            discount = -1;
        }// 不营业

    } else {// 周六周日week = 6 或 0
        if (order.getHours() > 9 && order.getHours() < 21 && order.getMin() < 60 && order.getMin() >= 0 || order.getHours() == 9 && order.getMin() <= 30 && order.getMin() >= 0) {
            discount = 1;
        }// 营业
        else {
            discount = -1;
        }// 不营业
    }
    return discount;
}
public int getTableNum() {
    return tableNum;
}

public void setTableNum(int tableNum) {
    this.tableNum = tableNum;
}

int year, month, day, hours, min, sec; // 记录下单时间

public int getYear() {
    return year;
}

public void setYear(int year) {
    this.year = year;
}

public int getMonth() {
    return month;
}

public void setMonth(int month) {
    this.month = month;
}

public int getDay() {
    return day;
}

public void setDay(int day) {
    this.day = day;
}

public int getHours() {
    return hours;
}

public void setHours(int hours) {
    this.hours = hours;
}

public int getMin() {
    return min;
}

public void setMin(int min) {
    this.min = min;
}

public int getSec() {
    return sec;
}

public void setSec(int sec) {
    this.sec = sec;
}

public int getTotalPrice() {
    int sum = 0;
    for (int i = 0; i <= recordIndex; i++) {
        if(records[i].getIsValue() == 1){
            sum = sum + records[i].getPrice();
        }
    }
    return sum;
}//计算订单的总价(不含折扣)

static int recordIndex = 0;// 记录索引

public Record addARecord(int orderNum, String name, int orderQuantity, int portion, Menu menu) {
    this.records[recordIndex] = new Record(orderNum, name, orderQuantity, portion);
    recordIndex++;
    return this.records[recordIndex - 1];
}//添加一条菜品信息到订单中。

public void delARecordByOrderNum(int orderNum) {
    int i = 0;
    for (i = 0; ; i++) {
        if (records[i].orderNum == orderNum) {
            records[i].setIsValue(0);
            break;
        }
    }
}//根据序号删除一条记录

public Record findRecordByNum(int orderNum) {
    int i = 0;
    for (i = 0; ; i++) {
        if (orderNum == records[i].orderNum) {
            records[i].isValue = 0;
            break;
        }
    }
    return records[i];
}//根据序号查找一条记录

}

心得：这道题目对我来说难度很大，在当时做的时候除我以外很多同学都不会做，我也只完成了少数几个测试点，但后面题目集6是这道题的迭代，所以我又花了更多的时间来写这道题。分析题目：每个桌子的属性有桌号、日期和时间，而且菜的折扣和时间有关，所以需要设计一个桌子类来处理这些信息；主类，先要考虑如何输入，用了一个无限循环来处理输入信息，输入一条，处理一条，把输入的每一条字符串都用slip方法处理为数组，然后再根据length来判断是菜单信息还是删除记录以及点菜，最后以"end"结束无限循环当length为2时，并且temp[1]为equals时，就是删除点菜记录；否则就添加到菜单。当length为4，并且temp[0]为tabble时，tabbleAmount加1，因为每个桌子的orderAmount不一样，所以重置orderAmount的数目为0，再新创一个tabble类，再进行有关的信息处理；否则就是点菜，需要添加点菜记录。当length为5时，就是带点菜，需要添加点菜记录。循环结束后，再用一个循环输出。

7-5 日期问题面向对象设计（聚合一）
分数 50

全屏浏览题目

切换布局
作者 段喜龙
单位 南昌航空大学
参考题目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
 
代码长度限制
16 KB
时间限制
10000 ms
内存限制
64 MB

源代码：

import java.util.*;
········int·month·=·this.month;
········int·day·=·this.day;
········for·(int·i·=·0;·i·<·n;·i++)·{
············day--;
············while·(day·<·1)·{
················month--;
················if·(month·<·1)·{
····················month·=·12;
····················year--;
················}
················day·+=·getDayOfMonth(year,·month);
············}
········}
········return·new·DateUtil(year,·month,·day);
····}
····public·boolean·compareDates(DateUtil·date)
····{
········if·(this.year·>·date.year)·return·true;
········if·(this.year·==·date.year)·{
············if·(this.month·>·date.month)·return·true;
············if·(this.month·==·date.month)·{
················if·(this.day·>=·date.day)·return·true;
············}
········}
········return·false;
····}
····public·boolean·equalTwoDates(DateUtil·date)
····{
········if·(date·!=·null)·{
············if·(year·==·date.year·&&·month·==·date.month·&&·day·==·date.day)·{
················return·true;
············}
········}
········return·false;
····}
····private·static·final·int[]·mon·=·{0,·31,·59,·90,·120,·151,·181,·212,·243,·273,·304,·334};
····public·int·getDaysofDates(DateUtil·date)
····{
········DateUtil·dateUtil1·=·this;
········DateUtil·dateUtil2·=·date;
········if·(this.compareDates(date))·{
············dateUtil1·=·date;
············dateUtil2·=·this;
········}
········int·days;
········int·leapYearNum·=·0;
········for·(int·i·=·dateUtil1.getYear();·i·<·dateUtil2.getYear();·i++)·{
············if·(isLeapYear(i))·{
················leapYearNum++;
············}
········}
········days·=·365·*·(dateUtil2.getYear()·-·dateUtil1.getYear())·+·leapYearNum;
········int·d1·=·mon[dateUtil1.getMonth()·-·1]·+·dateUtil1.getDay()·+·(dateUtil1.getMonth()·>·2·&&·isLeapYear(dateUtil1.getYear())·?·1·:·0);
········int·d2·=·mon[dateUtil2.getMonth()·-·1]·+·dateUtil2.getDay()·+·(dateUtil2.getMonth()·>·2·&&·isLeapYear(dateUtil2.getYear())·?·1·:·0);
········return·days·-·d1·+·d2;
····}
····public·String·showDate()
····{
········return·year·+·"-"·+·month·+·"-"·+·day;
····}
}

提交结果：

类图：

 心得：

7-6日期问题面向对象设计（聚合二）

参考题目7-3的要求，设计如下几个类：DateUtil、Year、Month、Day，其中年、月、日的取值范围依然为：year∈[1820,2020] ,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且输入均有效，输出格式如下：
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
代码长度限制
16 KB
时间限制
10000 ms
内存限制
64 MB

源代码：

import java.util.*;
····}
····public·DateUtil·getPreviousNDays(int·n)
····{
········int·year·=·this.year;
········int·month·=·this.month;
········int·day·=·this.day;
········for·(int·i·=·0;·i·<·n;·i++)·{
············day--;
············while·(day·<·1)·{
················month--;
················if·(month·<·1)·{
····················month·=·12;
····················year--;
················}
················day·+=·getDayOfMonth(year,·month);
············}
········}
········return·new·DateUtil(year,·month,·day);
····}
····public·boolean·compareDates(DateUtil·date)//比较当前日期与date的大小（先后）
····{
········if·(this.year·>·date.year)·return·true;
········if·(this.year·==·date.year)·{
············if·(this.month·>·date.month)·return·true;
············if·(this.month·==·date.month)·{
················if·(this.day·>=·date.day)·return·true;
············}
········}
········return·false;
····}
····public·boolean·equalTwoDates(DateUtil·date)
····{
········if·(date·!=·null)·{
············if·(year·==·date.year·&&·month·==·date.month·&&·day·==·date.day)·{
················return·true;
············}
········}
········return·false;
····}
····private·static·final·int[]·mon·=·{0,·31,·59,·90,·120,·151,·181,·212,·243,·273,·304,·334};
····public·int·getDaysofDates(DateUtil·date)//求当前日期与date之间相差的天数
····{
········DateUtil·dateUtil1·=·this;·//·小
········DateUtil·dateUtil2·=·date;·//·大
········if·(this.compareDates(date))·{
············dateUtil1·=·date;
············dateUtil2·=·this;
········}
········int·days;
········int·leapYearNum·=·0;
········for·(int·i·=·dateUtil1.getYear();·i·<·dateUtil2.getYear();·i++)·{
············if·(isLeapYear(i))·{
················leapYearNum++;
············}
········}
········days·=·365·*·(dateUtil2.getYear()·-·dateUtil1.getYear())·+·leapYearNum;
········int·d1·=·mon[dateUtil1.getMonth()·-·1]·+·dateUtil1.getDay()·+·(dateUtil1.getMonth()·>·2·&&·isLeapYear(dateUtil1.getYear())·?·1·:·0);
········int·d2·=·mon[dateUtil2.getMonth()·-·1]·+·dateUtil2.getDay()·+·(dateUtil2.getMonth()·>·2·&&·isLeapYear(dateUtil2.getYear())·?·1·:·0);
········return·days·-·d1·+·d2;
····}
····public·String·showDate()
····{
········return·year·+·"-"·+·month·+·"-"·+·day;
····}
}提交结果：

 类图：

 心得：做完7-5再做这题会比较简单，因为只是类的结构不同，该题目较聚合一的大致算法是一样的，都同为聚合类型，但聚合的方式有所不同。上一题是“一环扣一环”，Year类扣着Month类，Month类扣着Day类，Day类再扣着DateUtil类，而这一题各个类之间是互不影响的。前一题大多关键方法在Day这个类中，而这一道题的关键方法都在DateUtil类中。我认为第二个代码代码结构更好，它的耦合性没有聚合一的那么强。

题目集6

7-1 菜单计价程序-4

麻婆豆腐 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

麻婆豆腐 12
油淋生菜 9 T
table 31 2023/2/1 14/20/00
1 麻婆豆腐 1 16
2 油淋生菜 4 2
end

table 31: 
1 num out of range 16
2 portion out of range 4
table 31: 0 0

麻婆豆腐 12
油淋生菜 9 T
table a 2023/3/15 12/00/00
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end

wrong format

麻婆豆腐 12
油淋生菜 9 T
table 55 2023/3/31 12/000/00
麻辣香锅 15
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end

wrong format

麻婆豆腐 12.0
油淋生菜 9 T
table 55 2023/3/31 12/00/00
麻辣香锅 15
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end

wrong format
table 55: 
invalid dish
麻婆豆腐 does not exist
2 油淋生菜 14
table 55: 14 10

麻婆豆腐 12
油淋生菜 9 T
table a 2023/3/15 12/00/00
1 麻婆 豆腐 1 1
2 油淋生菜 2 1
end

wrong format

麻婆豆腐 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

table 1: 
1 麻婆豆腐 12
2 油淋生菜 14
wrong format
record serial number sequence error
record serial number sequence error
table 1: 26 17