#面向对象程序设计PTA作业# 第4、5、6次作业总结（一）

一、前言

本次总结涉及题目集4的7-1、题目集5的7-5、7-6，题目集6的7-1、7-4、7-5。

1. 三次题目集涉及的的知识点：

• 面向对象技术特性之封装性、字符串处理（4：7-1）
• 面向对象程序设计方法之聚合（5：7-5，7-6）
• 面向对象程序设计之继承（6：7-4，7-5）

2. 题量、难度情况

这三次题目集的题量和难度对于我来说比较大，是我第一次真真切切感受到，软件工程专业的作业不熬几个大夜根本写不完。难度有高有低，跨度还是很明显的，简单题一拿到手里就有思路可以着手来写，但是复杂题往往拿到手里没有什么思路，一方面复杂题（比如6：7-4）的需求就很复杂，阅读量也比较大，需要多读几遍题才能理解需求，另一方面复杂题代码量比较大，编码过程本身就比较耗时，在长达五六个小时的编码过程中还需要时刻注意遵循需求，因此复杂题对我而言还是比较困难。

---

二、设计与分析

（一）题目集4：7-1

原题

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];
}//根据序号查找一条记录

}

（二）设计思路

• 功能需求：这道题的功能需求十分复杂，需要应对多种输入情况，同时需要考虑各种输入格式或因输入错误导致的异常。
• 性能方面：本题基本不会涉及到代码性能问题，不作为考虑的终点
• 可扩展性：本题没有要求可扩展，但考虑到本题隶属于菜单类系列题，还是尽量保证扩展性
• 可测试性：测试数据将由平台给出，无需过多关注
• 安全性：需要特别注意各种输入异常导致的空指针问题

程序类图如下：

该类图暂时不能完成题目全部要求，需要进行大量的改进

---

三、踩坑心得

提交结果：

这道题目对我来说确实是难度很大，在有限的时间内我也尽力尝试去完成了，即便只完成了很少的测试点，但在此次作业中，我还是有很多收获，下面列举一些我在本题中踩过的坑与收获心得。

1. 在面对复杂程序时，务必要先花时间进行类设计，不论是实体类还是业务类，都要根据需求进行相应的设计，不得边写边设计，最后耗费时间且代码质量低。
2. 编码应当遵守编码规范，尤其是空格和缩进，对于这种长代码，往往一时半会难以完成，隔天再看时代码的结构非常影响阅读，合理的编码方式不仅提高效率，也提高代码质量，反之则会导致低效低质。

---

四、改进建议

1. 命名规范：变量名、函数名、类名等要使用有意义的名称，遵循命名规范，使代码易于理解和维护。

2. 注释：在关键地方添加注释，解释代码的作用、实现方法等，便于阅读和维护。

3. 异常处理：由于本题输入比较复杂，对字符串的处理难以面面俱到，这对依赖文字输入的程序来说是十分致命的，可以使用异常处理机制来规避不恰当的输入引发的程序崩溃问题

---

五、总结

这道题目非常侧重考察设计，对于细节的处理都是学过并且经常用的知识，但是怎么把这些细节有机的组合起来是非常考人的一点。