一、前言

目前，我们学期已经过半，在不断的学习和练习中，慢慢的认识了Java这门语言，尝试理解面向对象的编程思想，学习了Java的三大特性：封装、继承、多态，也逐渐体会到了一些在代码编写过程中应该遵循的原则，如单一职责原则、开放-关闭原则等等。话不多说，就让我们来总结以下刚刚结束的期中考试以及作业4和作业5吧~

1. 第四次作业

共一道题目，由于我的菜单计价程序系列前面完成情况并不理想，再加上题目难度较大，涉及异常处理等知识，我只得了十五分（可能还是骗分）。

2. 第五次作业

共一道题目，那两周老师给的时间比较充裕，我终于着手开始写菜单计价程序系列，本次主要总算得了个及格分数，个人觉得这次作业难度中上，但是涉及到的知识点并没有变化，我将在后续设计与分析模块具体分析。

3. 期中考试

共四道题目，主要涉及了类设计，继承与多态，抽象类和接口，难度相较与PTA作业来说并不大，完成情况不错。

二、设计与分析

7-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+英文空格+桌号+“:”+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价

import java.util.Calendar;
····int·delARecordByOrderNum(int·orderNum)·{·//根据序号删除一条记录
········for(int·i·=·0;·i·<·k;·i++)
············if(records[i].orderNum·==·orderNum)·return·records[i].getPrice();
········System.out.println("delete·error;");
········return·0;
····}
}
class·Time{
····Calendar·cal·=·Calendar.getInstance();
····int·year;
····int·month;
····int·day;
····int·hour;
····int·minute;
····int·second;
····int·week;
····Time(String·year,String·month,String·day,String·hour,String·minute,String·second){
········this.year=Integer.parseInt(year);
········this.month=Integer.parseInt(month);
········this.day=Integer.parseInt(day);
········this.hour=Integer.parseInt(hour);
········this.minute=Integer.parseInt(minute);
········this.second=Integer.parseInt(second);
········cal.set(Calendar.YEAR,·this.year);
········cal.set(Calendar.MONTH,·this.month-1);
········cal.set(Calendar.DATE,·this.day);
········cal.set(Calendar.HOUR_OF_DAY,·this.hour);
········cal.set(Calendar.MINUTE,·this.minute);
········cal.set(Calendar.SECOND,·this.second);
········this.week=cal.get(Calendar.DAY_OF_WEEK);
········if(this.week>1)
············this.week=this.week-1;
········else
············this.week=this.week+6;
····}
}
public·class·Main·{
····public·static·void·main(String[]·args)·{
········Scanner·in·=·new·Scanner(System.in);
········Menu·menu·=·new·Menu();
········Order·order·=·new·Order();
········String·input,·dishName;·//dishName为用户输入的菜名
········String[]·parts;
········System.out.println("wrong·format");
········int·orderNum,·delete_Num,·portion,·amount,·k·=·0,·delete_Price·=·0;
········in·.close();
····}
}

辛苦写了半天，测试点都没过，最后只过了输出”wrong format“，后续发现这段代码的问题实在太多了，部分功能也没有实现，就不在这里过多分析了

7-1 菜单计价程序-5

本题在菜单计价程序-3的基础上增加了部分内容，增加的内容用加粗字体标识。

注意不是菜单计价程序-4，本题和菜单计价程序-4同属菜单计价程序-3的两个不同迭代分支。

设计点菜计价程序，根据输入的信息，计算并输出总价格。

输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。

菜单由一条或多条菜品记录组成，每条记录一行

每条菜品记录包含：菜名、基础价格三个信息。

订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。

桌号标识独占一行，包含两个信息：桌号、时间。

桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。

点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。

删除记录格式：序号 delete

标识删除对应序号的那条点菜记录。

如果序号不对，输出"delete error"

代点菜信息包含：桌号序号菜品名称口味度份额份数

代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。

程序最后按输入的先后顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。

每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。

折扣的计算方法（注：以下时间段均按闭区间计算）：

周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。

周末全价，营业时间：9:30-21:30

如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"

参考以下类的模板进行设计：菜品类：对应菜谱上一道菜的信息。

Dish {

String name;//菜品名称

int unit_price; //单价

int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。

Menu {

Dish[] dishs ;//菜品数组，保存所有菜品信息

Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。

Dish addDish(String dishName,int unit_price)//添加一道菜品信息

}

点菜记录类：保存订单上的一道菜品记录

Record {

int orderNum;//序号\\

Dish d;//菜品\\

int portion;//份额（1/2/3代表小/中/大份）\\

int getPrice()//计价，计算本条记录的价格\\

}

订单类：保存用户点的所有菜的信息。

Order {

Record[] records；//保存订单上每一道的记录

int getTotalPrice()//计算订单的总价

Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。

delARecordByOrderNum(int orderNum)//根据序号删除一条记录

findRecordByNum(int orderNum)//根据序号查找一条记录

}

### 输入格式:

桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

菜品记录格式：

菜名+英文空格+基础价格

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。

删除记录格式：序号 +英文空格+delete

代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数

最后一条记录以“end”结束。

### 输出格式:

按输入顺序输出每一桌的订单记录处理信息，包括：

1、桌号，格式：table+英文空格+桌号+”:”

2、按顺序输出当前这一桌每条订单记录的处理信息，

每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名

如果删除记录的序号不存在，则输出“delete error”

最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价

以上为菜单计价系列-3的题目要求，加粗的部分是有调整的内容。本次课题相比菜单计价系列-3新增要求如下：

1、菜单输入时增加特色菜，特色菜的输入格式：菜品名+英文空格+口味类型+英文空格+基础价格+"T"

例如：麻婆豆腐川菜 9 T

菜价的计算方法：

周一至周五 7折，周末全价。

特色菜的口味类型：川菜、晋菜、浙菜

川菜增加辣度值：辣度0-5级；对应辣度水平为：不辣、微辣、稍辣、辣、很辣、爆辣；

晋菜增加酸度值，酸度0-4级；对应酸度水平为：不酸、微酸、稍酸、酸、很酸；

浙菜增加甜度值，甜度0-3级；对应酸度水平为：不甜、微甜、稍甜、甜；

例如：麻婆豆腐川菜 9 T

输入订单记录时如果是特色菜，添加口味度（辣/酸/甜度）值，格式为：序号+英文空格+菜名+英文空格+口味度值+英文空格+份额+英文空格+份数

例如：1 麻婆豆腐 4 1 9

单条信息在处理时，如果口味度超过正常范围，输出"spicy/acidity/sweetness num out of range : "+口味度值，spicy/acidity/sweetness（辣度/酸度/甜度）根据菜品类型择一输出，例如：

acidity num out of range : 5

输出一桌的信息时，按辣、酸、甜度的顺序依次输出本桌菜各种口味的口味度水平，如果没有某个类型的菜，对应的口味（辣/酸/甜）度不输出，只输出已点的菜的口味度。口味度水平由口味度平均值确定，口味度平均值只综合对应口味菜系的菜计算，不做所有菜的平均。比如，某桌菜点了3份川菜，辣度分别是1、3、5；还有4份晋菜，酸度分别是，1、1、2、2，辣度平均值为3、酸度平均值四舍五入为2，甜度没有，不输出。

一桌信息的输出格式：table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格+"川菜"+数量+辣度+英文空格+"晋菜"+数量+酸度+英文空格+"浙菜"+数量+甜度。

如果整桌菜没有特色菜，则只输出table的基本信息，格式如下：

table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格

例如：table 1: 60 36 川菜 2 爆辣浙菜 1 微甜

计算口味度时要累计本桌各类菜系所有记录的口味度总和（每条记录的口味度乘以菜的份数），再除以对应菜系菜的总份数，最后四舍五入。

注：本题要考虑代点菜的情况，当前桌点的菜要加上被其他桌代点的菜综合计算口味度平均值。

2、考虑客户订多桌菜的情况，输入时桌号时，增加用户的信息：

格式：table+英文空格+桌号+英文空格+":"+英文空格+客户姓名+英文空格+手机号+日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

例如：table 1 : tom 13670008181 2023/5/1 21/30/00

约束条件：客户姓名不超过10个字符，手机号11位，前三位必须是180、181、189、133、135、136其中之一。

输出结果时，先按要求输出每一桌的信息，最后按字母顺序依次输出每位客户需要支付的金额。不考虑各桌时间段的问题，同一个客户的所有table金额都要累加。

输出用户支付金额格式：

用户姓名+英文空格+手机号+英文空格+支付金额

注意：不同的四舍五入顺序可能会造成误差，请按以下步骤累计一桌菜的菜价：

将所有记录的菜价累加得到整桌菜的价格。

输入格式:

桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

菜品记录格式：

菜名+口味类型+英文空格+基础价格

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

点菜记录格式：序号+英文空格+菜名+英文空格+辣/酸/甜度值+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。辣/酸/甜度取值范围见题目中说明。

删除记录格式：序号 +英文空格+delete

代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称**+英文空格+辣/酸/甜度值+**英文空格+份额+英文空格+分数

最后一条记录以“end”结束。

输出格式:

按输入顺序输出每一桌的订单记录处理信息，包括：

1、桌号，格式：table+英文空格+桌号+“:”+英文空格

2、按顺序输出当前这一桌每条订单记录的处理信息，

如果删除记录的序号不存在，则输出“delete error”

之后按输入顺序一次输出每一桌所有菜品的价格（整数数值），

格式：table+英文空格+桌号+“:”+英文空格+当前桌的计算折扣后总价+英文空格+辣度平均值+英文空格+酸度平均值+英文空格+甜度平均值+英文空格

最后按拼音顺序输出每位客户(不考虑客户同名或拼音相同的情况)的支付金额，格式：用户姓名+英文空格+手机号+英文空格+支付总金额，按输入顺序排列。

输入样例1:

桌号时间超出营业范围。例如：

麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 21/30/00
1 麻婆豆腐 3 1 2
2 油淋生菜 2 1
3 麻婆豆腐 2 3 2
end

输出样例1:

在这里给出相应的输出。例如：

table 1 out of opening hours

输入样例2:

一种口味的菜品。例如：

麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 20/30/00
1 麻婆豆腐 2 1 2
2 油淋生菜 2 1
3 麻婆豆腐 2 3 2
end

输出样例2:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 24
2 油淋生菜 14
3 麻婆豆腐 48
table 1: 86 62 川菜 4 稍辣
tom 13605054400 62

输入样例3:

辣度值超出范围。例如：

麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 18/30/00
1 麻婆豆腐 6 1 2
2 油淋生菜 1 1
3 麻婆豆腐 5 3 2
end

输出样例3:

在这里给出相应的输出。例如：

table 1: 
spicy num out of range :6
2 油淋生菜 9
3 麻婆豆腐 48
table 1: 57 41 川菜 2 爆辣
tom 13605054400 41

输入样例4:

同一用户对应多桌菜。例如：

麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 18/30/00
1 麻婆豆腐 1 1 2
2 油淋生菜 1 1
3 麻婆豆腐 2 2 2
table 2 : tom 13605054400 2023/5/6 18/30/00
1 麻婆豆腐 2 1 2
2 麻辣鸡丝 2 2
3 麻婆豆腐 2 1 1
end

输出样例4:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 24
2 油淋生菜 9
3 麻婆豆腐 36
table 2: 
1 麻婆豆腐 24
2 麻辣鸡丝 30
3 麻婆豆腐 12
table 1: 69 49 川菜 4 稍辣
table 2: 66 66 川菜 3 稍辣
tom 13605054400 115

输入样例5:

多用户多桌菜。例如：

东坡肉 浙菜 25 T
油淋生菜 9
蜜汁灌藕 浙菜 10 T
刀削面 晋菜 10 T
醋浇羊肉 晋菜 30 T
麻婆豆腐 川菜 12 T
麻辣鸡丝 川菜 15 T
table 1 : tom 13605054400 2023/5/6 12/30/00
1 醋浇羊肉 4 1 1
3 刀削面 1 1 3
2 东坡肉 3 2 1
4 麻辣鸡丝 2 1 1
table 2 : jerry 18100334566 2023/5/1 12/30/00
1 醋浇羊肉 1 1 2
3 麻婆豆腐 2 2 1
4 麻辣鸡丝 2 3 3
table 3 : jerry 18100334566 2023/5/1 12/30/00
1 醋浇羊肉 2 1 1
3 蜜汁灌藕 1 1 2
2 东坡肉 2 2 1
4 麻辣鸡丝 5 1 1
end

输出样例5:

在这里给出相应的输出。例如：

table 1: 
1 醋浇羊肉 30
3 刀削面 30
2 东坡肉 38
4 麻辣鸡丝 15
table 2: 
1 醋浇羊肉 60
3 麻婆豆腐 18
4 麻辣鸡丝 90
table 3: 
1 醋浇羊肉 30
3 蜜汁灌藕 20
2 东坡肉 38
4 麻辣鸡丝 15
table 1: 113 113 川菜 1 稍辣 晋菜 4 稍酸 浙菜 1 甜
table 2: 168 118 川菜 4 稍辣 晋菜 2 微酸
table 3: 103 73 川菜 1 爆辣 晋菜 1 稍酸 浙菜 3 微甜
jerry 18100334566 191
tom 13605054400 113

输入样例6:

多用户多桌菜含代点菜。例如：

东坡肉 浙菜 25 T
油淋生菜 9
蜜汁灌藕 浙菜 10 T
刀削面 晋菜 10 T
醋浇羊肉 晋菜 30 T
麻婆豆腐 川菜 12 T
麻辣鸡丝 川菜 15 T
table 1 : tom 13605054400 2023/5/6 12/30/00
1 醋浇羊肉 4 1 1
3 刀削面 1 1 3
2 东坡肉 3 2 1
4 麻辣鸡丝 2 1 1
table 2 : jerry 18100334566 2023/5/1 12/30/00
1 1 醋浇羊肉 0 1 2
3 麻婆豆腐 2 2 1
4 麻辣鸡丝 2 3 3
table 3 : lucy 18957348763 2023/5/1 12/30/00
1 醋浇羊肉 2 1 1
3 蜜汁灌藕 1 1 2
2 东坡肉 2 2 1
4 麻辣鸡丝 5 1 1
end

输出样例6:

在这里给出相应的输出。例如：

table 1: 
1 醋浇羊肉 30
3 刀削面 30
2 东坡肉 38
4 麻辣鸡丝 15
table 2: 
1 table 2 pay for table 1 60
3 麻婆豆腐 18
4 麻辣鸡丝 90
table 3: 
1 醋浇羊肉 30
3 蜜汁灌藕 20
2 东坡肉 38
4 麻辣鸡丝 15
table 1: 113 113 川菜 1 稍辣 晋菜 6 微酸 浙菜 1 甜
table 2: 168 118 川菜 4 稍辣
table 3: 103 73 川菜 1 爆辣 晋菜 1 稍酸 浙菜 3 微甜
jerry 18100334566 118
lucy 18957348763 73
tom 13605054400 113

输入样例7:

错误的菜品记录和桌号记录，用户丢弃。例如：

东坡肉 25 T
油淋生菜 9
table 1 : tom 136050540 2023/5/1 12/30/00
2 东坡肉 3 2 1
end

输出样例7:

在这里给出相应的输出。例如：

wrong format
wrong format

代码长度限制

50 KB

时间限制

1000 ms

内存限制

64 MB

import java.text.Collator;
import java.text.SimpleDateFormat;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;


public class Main {
    public static void main(String[] args) {while (true) {
            String line = sc.nextLine().trim();
            if (line.equals("end")) {
                break;
            }
            //如果以数字开头
            char firstChar = line.charAt(0);
            String[] arr1 = line.split(" ");
            char secondChar = line.charAt(2);
            if (firstChar >= '0' && firstChar <= '9' && !arr1[1].equals("delete") && !(secondChar >= '0' && secondChar <= '9')) {
                //订单信息
                //1 麻婆豆腐 2 2
                //序号 菜名  份额  份数
                String[] arr = line.split(" ");
                //从菜单中找到菜品
                Dish menuDish = Menu.searchDish(arr[1]);
                if (menuDish != null) {
                    if (menuDish.getT() != null) {
                        //1 麻婆豆腐 6 1 2
                        //特价菜
                        //记录一下点菜的味道是否超过了菜单原本的
                        //如果超过了就需要往order里面添加信息
                        String type = menuDish.getType();
                        switch (type) {
                            case "川菜":
                                String s = Dish.numToTaste(Integer.parseInt(arr[2]));
                                j = getJ(r, j, arr, menuDish, s);
                                break;
                            case "晋菜":
                                String s1 = Dish.numToAcidity(Integer.parseInt(arr[2]));
                                j = getJ(r, j, arr, menuDish, s1);
                                break;
                            case "浙菜":
                                String s2 = Dish.numToSweetness(Integer.parseInt(arr[2]));
                                j = getJ(r, j, arr, menuDish, s2);
                                break;
                            default:
                                break;
                        }
                    } else {
                        //不是特色菜
                        Dish dish = new Dish(arr[1], menuDish.getUnitPrice());
                        Record record = new Record(arr[0], dish, Integer.parseInt(arr[2]), Integer.parseInt(arr[3]), "true"
                                , -1);
                        r[j++] = record;
                    }
                } else {
                    Dish dish = new Dish(arr[1], null);
                    Record record = new Record(arr[0], dish, Integer.parseInt(arr[2]), Integer.parseInt(arr[3]), "true"
                            , -1);
                    r[j++] = record;
                }
                currentTable.setOrders(order1);
                //这是一个订单记录信息，把他加入到订单之中
            } else if (firstChar >= '0' && firstChar <= '9' && secondChar >= '0' && secondChar <= '9') {
                //代点餐，费用算在当前这一桌之中
                //1 4 麻婆豆腐 1 1
                //当前桌为1号桌点了小额1份的编号为4的麻婆豆腐
                String[] arr = line.split(" ");
                //arr[0]代表为哪一桌点菜table桌子
                //arr[1]代表菜品的编号
                //arr[2]代表菜品名称
                //arr[3]代表菜品的份额
                //arr[4]代表菜品的数量
                Dish menuDish = Menu.searchDish(arr[2]);
                if (menuDish != null) {
                    if (menuDish.getT() != null) {
                        //1 1 醋浇羊肉 0 1 2
                        //1 4 麻婆豆腐 1 1
                        String type = menuDish.getType();
                        switch (type) {
                            case "川菜":
                                String s = Dish.numToTaste(Integer.parseInt(arr[3]));
                                j = getJ1(r, j, arr, menuDish, s, tables);
                                break;
                            case "晋菜":
                                //判断是否超过范围
                                String s1 = Dish.numToAcidity(Integer.parseInt(arr[3]));
                                j = getJ1(r, j, arr, menuDish, s1, tables);
                                break;
                            case "浙菜":
                                String s2 = Dish.numToSweetness(Integer.parseInt(arr[3]));
                                j = getJ1(r, j, arr, menuDish, s2, tables);
                                break;
                            default:
                                break;
                        }
                    }
                    //不是特色菜
                    else {
                        //1 麻婆豆腐 6 1 2
                        //特价菜
                        //记录一下点菜的味道是否超过了菜单原本的
                        //如果超过了就需要往order里面添加信息
                        Dish dish = new Dish(arr[2], menuDish.getUnitPrice());
                        //设置一个标记说明谁为谁点的单
                        Record record = new Record(arr[1], dish, Integer.parseInt(arr[3]), Integer.parseInt(arr[4]),
                                "true", Integer.parseInt(arr[0]));
                        r[j++] = record;
                    }
                } else {
                    //不存在的菜
                    Dish dish = new Dish(arr[2], null);
                    //设置一个标记说明谁为谁点的单
                    Record record = new Record(arr[1], dish, Integer.parseInt(arr[3]), Integer.parseInt(arr[4]), "true", Integer.parseInt(arr[0]));
                    r[j++] = record;
                }
                currentTable.setOrders(order1);
            } else if (line.startsWith("table")) {
                //置空record数组
                k = 0;
                r = new Record[10];
                j = 0;
                order1 = new Order(r);//置空一个，换订单信息了
                //桌子置空，换桌子了
                currentTable = null;
                String[] arr = line.split(" ");
                //table 1 : tom 13605054400 2023/5/1 18/30/00
                // table 1 2023/3/22 17/0/0
                //arr[0]代表table桌子
                //arr[1]代表桌子的序号
                //arr[2]代表:
                //arr[3]代表用户名称
                //arr[4]代表用户号码
                //arr[5]代表日期
                //arr[6]代表时间
                //桌子表
                //table 1 : tom 13605054400 2023/5/1 20/30/00
                //table 2 : tom 13605054400 2023/5/1 20/30/00
                //不存在说明需要新建
                currentTable = new Table(arr[1], arr[5], arr[6], order1);
                tables.add(currentTable);
                User targetUser = null;
                for (User user : users) {
                    if (user.getName().equals(arr[3])) {
                        targetUser = user;
                        break;
                    }
                }
                if (targetUser == null) {
                    // 如果找不到该用户，则创建一个新用户并将其添加到用户列表中
                    List<Table> newList = new ArrayList<>();
                    newList.add(currentTable);
                    if (arr[3].length() < 10 && isPhoneNumValid(arr[4])) {
                        users.add(new User(arr[3], arr[4], newList));
                    } else {
                        errorFlag = true;
                    }
                } else {
                    // 如果找到了该用户，则将currentTable添加到其table集合中
                    targetUser.getTable().add(currentTable);
                }


            } else if (firstChar >= '0' && firstChar <= '9' && arr1[1].equals("delete")) {
                //删除record记录，1 delete
                String[] arr = line.split(" ");
                //传的应该是1就是点菜的时候的编号
                deleteNum.add(arr[0]);
                Record record = order1.findRecordByNum(arr[0]);
                String name = record.getD().getName();
                boolean flag = false;
                Dish[] dishes = menu.getDishes();
                for (Dish dish : dishes) {
                    if (dish != null) {
                        if (dish.getName().equals(name)) {
                            flag = true;
                            break;
                        }
                    }
                }
                if (record == null || !flag) {
                    k++;
                    order1.setK(k);
                    //设置一个标记后续遍历
                }
//                orders.stream().map(order -> order.delARecordByOrderNum(arr[1]));
                order1.delARecordByOrderNum(arr[0]);//不应该真的删除，应该是逻辑删除，设置一个flag去记录，是否被删除
            } else {
                if (line.endsWith("T")) {
                    //特价菜
                    //加入菜单
                    String[] arr = line.split(" ");
                    //麻婆豆腐 川菜 12 T
                    try {
                        boolean isDuplicate = false;
                        for (int p = 0; p < 15; p++) {
                            if (d[j] != null) {
                                if (d[j].getName().equals(arr[0])) {
                                    // 菜单中已有该菜，更新信息
                                    d[p].setUnitPrice(Double.parseDouble(arr[2]));
                                    isDuplicate = true;
                                    break;
                                }
                            }
                        }
                        if (!isDuplicate) {
                            d[i++] = new Dish(arr[0], Double.parseDouble(arr[2]), arr[3], arr[1], -1);
                        }
                    } catch (NumberFormatException e) {
                        errorFlag = true;
                    }
                } else {
                    String[] arr = line.split(" ");
                    //arr[0]表示菜品的名称，arr[1]表示菜品的价格
                    try {
                        boolean isDuplicate = false;
                        for (int p = 0; p < 15; p++) {
                            if (d[j] != null) {
                                if (d[j].getName().equals(arr[0])) {
                                    // 菜单中已有该菜，更新信息
                                    d[p].setUnitPrice(Double.parseDouble(arr[1]));
                                    isDuplicate = true;
                                    break;
                                }
                            }
                        }
                        if (!isDuplicate) {
                            d[i++] = new Dish(arr[0], Double.parseDouble(arr[1]));
                        }
                    } catch (NumberFormatException e) {
                        errorFlag = true;
                    }
                }
            }


        }
        if (errorFlag) {
            System.out.println("wrong format");
            System.out.print("wrong format");
            System.exit(0);
        }
        boolean flag = false;
        String output = "";
        for (Table table : tables) {
            //计算价格
            if (!isInOpeningHours(table.getDate(), table.getTime())) {
                //不计算价格,并且标记一下这一桌的情况
                table.setFlag("false");
                output += "table " + table.tableNum + " out of opening hours\n";
//                System.out.println("table " + table.tableNum + " out of opening hours");
                continue;
            }
            //列出当前桌菜品的信息
            System.out.println("table " + table.getTableNum() + ": ");
            Record[] records = table.getOrders().getRecords();
            int k1 = 0, k2 = 0, k3 = 0;
            int num1 = 0, num2 = 0, num3 = 0;//数量
            double totalTaste = 0, totalTaste1 = 0, totalTaste2 = 0;//口味度
            for (Record record : records) {
                if (record != null) {
                    //记录一下当前菜品特价菜的种类的个数方便后续统计平均品味
                    boolean flag1 = Menu.findMenuName(record.getD().getName());//特价菜
                    String type = record.getD().getType();
                    if (flag1 && type.equals("川菜") && record.getD().getFlag() == null && record.getForOrderT1() == null && !record.getFlag().equals("false")) {
                        k1++;
                        num1 += record.getNum();
                        totalTaste += record.getD().getTaste();
                    } else if (flag1 && type.equals("晋菜") && record.getD().getFlag() == null && record.getForOrderT1() == null && !record.getFlag().equals("false")) {
                        k2++;
                        num2 += record.getNum();
                        totalTaste1 += record.getD().getTaste();
                    } else if (flag1 && type.equals("浙菜") && record.getD().getFlag() == null && record.getForOrderT1() == null && !record.getFlag().equals("false")) {
                        k3++;
                        num3 += record.getNum();
                        totalTaste2 += record.getD().getTaste();
                    }
                    //判断品味是否超出了限制
                    if (record != null) {
                        if (record.getD().getFlag() != null) {
                            String over = record.getOver();
                            String[] arr = over.split(" ");
                            //arr[0] spicy
                            //arr[1] 6
                            System.out.println(arr[0] + " num out of range :" + arr[1]);
                        }
                    }
                    //判断本桌子的订单
                    if (record.getD().getUnitPrice() != null && record.getTableNum() == -1 && record.getD().getFlag() == null) {
                        System.out.println(record.getOrderNum() + " " + record.getD().getName() + " " + record.getPrice());
                    } else if (record.getD().getUnitPrice() == null) {
                        //判断是否在菜单中有
                        System.out.println(record.getD().getName() + " does not exist");
                    } else if (record.getTableNum() != -1 && record.getForOrder() == null) {
                        //判断是否是代点
                        System.out.println(record.getOrderNum() + " table " + table.getTableNum() + " pay for table " + record.getTableNum()
                                + " " + record.getPrice());
                    }
                }
            }
            //当前桌子需要打印多少delete error
            Order orders = table.getOrders();
            for (int l = 0; l < orders.getK(); l++) {
                System.out.println("delete error");
            }

            //总价
            double totalPrice = 0.0;
            totalPrice = table.getTotalPrice(table.getDate(), table.getTime());//原价
            double discount = getDiscount(table.getDate(), table.getTime());//特价菜的
            double discountNor = getNormalDiscount(table.getDate(), table.getTime());//普通菜的
            String toutPut = "";
            if (k1 != 0) {
                toutPut += " 川菜 " + num1 + " " + Dish.numToTaste((int) Math.round(totalTaste / k1));
            }
            if (k2 != 0) {
                toutPut += " 晋菜 " + num2 + " " + Dish.numToAcidity((int) Math.floor(totalTaste1 / k2));
            }
            if (k3 != 0) {
                toutPut += " 浙菜 " + num3 + " " + Dish.numToSweetness((int) Math.floor(totalTaste2 / k3));
            }
            int disCountTotalPrice = (int) table.getDisCountTotalPrice(discount, discountNor);
            //判断是否是多用户
//            boolean flag1 = hasDifferentNames(users);
//            //true代表多用户,false代表单用户
//            if (discount == 0.7 && !flag1) {
//                disCountTotalPrice = (int) table.getDisCountTotalPrice(discount) + 1;
//            }
            output += "table " + table.tableNum + ": " + Math.round(totalPrice) + " " + disCountTotalPrice + toutPut + "\n";
        }
        System.out.print(output);
        //输出用户信息
        //给user排个序
        Comparator<User> comparator = new Comparator<User>() {
            private Collator collator = Collator.getInstance(java.util.Locale.CHINA);

            public int compare(User o1, User o2) {
                return collator.compare(o1.getName(), o2.getName());
            }
        };
        Collections.sort(users, comparator);
        for (int i1 = 0; i1 < users.size(); i1++) {
            User user = users.get(i1);
            List<Table> table = user.getTable();
            int pay = 0;
            for (Table table1 : table) {
                //判断当前桌子是否为过期的桌子
                if (table1.getFlag() == null) {
                    double discount = getDiscount(table1.getDate(), table1.getTime());
                    double discount1 = getNormalDiscount(table1.getDate(), table1.getTime());
                    int disCountTotalPrice = (int) table1.getDisCountTotalPrice(discount, discount1);
//                    boolean flag1 = hasDifferentNames(users);
//                    if (!flag1 && discount == 0.7) {
//                        disCountTotalPrice = (int) table1.getDisCountTotalPrice(discount) + 1;
//                    }
                    pay += disCountTotalPrice;
                }
            }
            if (pay != 0) {
                //输出当前用户信息
                System.out.print(user.getName() + " " + user.getPhone() + " " + pay);
                //如果不是最后一个用户，添加换行符
                if (i1 != users.size() - 1) {
                    System.out.print("\n");
                }
            }
        }

    }

    public static boolean hasDifferentNames(List<User> users) {
        List<String> nameList = new ArrayList<String>();
        for (User user : users) {
            nameList.add(user.getName());
        }
        //"tom,jerry"
        if (nameList.size() == 1) {
            //单用户
            return false;
        } else if (nameList.size() > 1) {
            return true;
        }
        return true;
    }

    //判断是否超过菜单上的口味的封装类
    private static int getJ(Record[] r, int j, String[] arr, Dish menuDish, String s1) {
        //1 1 醋浇羊肉 0 1 2
        //如果超过了就需要往over里面添加信息，方便后面输出
        if (s1.equals("")) {
            Dish dish = new Dish(arr[1], menuDish.getUnitPrice(), "T", menuDish.getType(), Integer.parseInt(arr[2]));
            dish.setFlag("over");
            //1 麻婆豆腐 2 3 2
            String typeToEN = "";
            String type = menuDish.getType();
            switch (type) {
                case "川菜":
                    typeToEN = "spicy";
                    break;
                case "晋菜":
                    typeToEN = "acidity";
                    break;
                case "浙菜":
                    typeToEN = "sweetness";
                    break;
            }
            String overInfo = typeToEN + " " + arr[2];
            Record record = new Record(arr[0], dish, Integer.parseInt(arr[3]), Integer.parseInt(arr[4]), "true", -1, overInfo);
            r[j++] = record;
            return j;
        } else {
            //如果没超过就置为”“
            Dish dish = new Dish(arr[1], menuDish.getUnitPrice(), "T", menuDish.getType(), Integer.parseInt(arr[2]));
            Record record = new Record(arr[0], dish, Integer.parseInt(arr[3]), Integer.parseInt(arr[4]), "true", -1, "");
            r[j++] = record;
            return j;
        }

    }

    private static int getJ1(Record[] r, int j, String[] arr, Dish menuDish, String s1, List<Table> tables) {
        //1 1 醋浇羊肉 0 1 2
        //如果超过了就需要往over里面添加信息，方便后面输出
        if (s1.equals("")) {
            Dish dish = new Dish(arr[2], menuDish.getUnitPrice(), "T", menuDish.getType(), Integer.parseInt(arr[3]));
            dish.setFlag("over");
            //1 麻婆豆腐 2 3 2
            String typeToEN = "";
            String type = menuDish.getType();
            switch (type) {
                case "川菜":
                    typeToEN = "spicy";
                    break;
                case "晋菜":
                    typeToEN = "acidity";
                    break;
                case "浙菜":
                    typeToEN = "sweetness";
                    break;
            }
            String overInfo = typeToEN + " " + arr[2];
            Record record = new Record(arr[0], dish, Integer.parseInt(arr[4]), Integer.parseInt(arr[5]), "true", Integer.parseInt(arr[1]), overInfo);
            r[j++] = record;
            return j;
        } else {
            //如果没超过就置为”“
            Dish dish = new Dish(arr[2], menuDish.getUnitPrice(), "T", menuDish.getType(), Integer.parseInt(arr[3]));
            Record newRecord = new Record(arr[0], dish, Integer.parseInt(arr[4]), Integer.parseInt(arr[5]), "true", Integer.parseInt(arr[1]), "", arr[1], null);
            Table table = tables.get(Integer.parseInt(arr[1]) - 1);
            Record[] records = table.getOrder().getRecords();
            records = Arrays.copyOf(records, records.length + 1);
            records[records.length - 1] = newRecord;//往结尾加了
            table.getOrders().setRecords(records);
            //重新赋值，比如说让table2里面的record中的fororder为null，也就是说如果有fororder不为null，说明别人给你点的不算钱。
            //但是必须除掉里面的特色菜，菜照样算，但是不能出现类似川菜这样的
            newRecord = new Record(arr[0], dish, Integer.parseInt(arr[4]), Integer.parseInt(arr[5]), "true", Integer.parseInt(arr[1]), "", null, arr[1]);
            r[j++] = newRecord;
            return j;
        }

    }

    //判断下单是否在营业范围之内
    private static boolean isInOpeningHours(String dateStr, String timeStr) {
        LocalTime time = LocalTime.parse(timeStr, DateTimeFormatter.ofPattern("H/m/s"));
        LocalDate date = LocalDate.parse(dateStr, DateTimeFormatter.ofPattern("yyyy/M/d"));
        DayOfWeek dayOfWeek = date.getDayOfWeek();
        boolean isWeekend = (dayOfWeek == DayOfWeek.SUNDAY || dayOfWeek == DayOfWeek.SATURDAY);
        boolean isWeekend1 = (dayOfWeek == DayOfWeek.MONDAY || dayOfWeek == DayOfWeek.THURSDAY
                || dayOfWeek == DayOfWeek.TUESDAY || dayOfWeek == DayOfWeek.WEDNESDAY || dayOfWeek == DayOfWeek.FRIDAY);
        boolean isOpenTime = (isWeekend && time.isAfter(LocalTime.of(9, 29, 59))
                && time.isBefore(LocalTime.of(21, 30, 01)))
                || (isWeekend1 && time.isAfter(LocalTime.of(16, 59, 59))
                && time.isBefore(LocalTime.of(20, 30, 01)) ||
                (isWeekend1 && time.isAfter(LocalTime.of(10, 29, 59))
                        && time.isBefore(LocalTime.of(14, 30, 01))
                ));
        return isOpenTime;
    }

    //获得普通菜的折扣
    public static double getDiscount(String dateStr, String timeStr) {
        //周一至周五 7折， 周末全价。
        //周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。 普通菜的折扣
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        Calendar calendar = Calendar.getInstance();
        int dayOfWeek = 0;
        //这里的数字4代表星期三，因为Calendar类中星期的编号是从1开始的，星期日为1，星期一为2，以此类推，星期六为7。
        try {
            calendar.setTime(sdf.parse(dateStr));
            dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
        } catch (Exception e) {
            e.printStackTrace();
        }
        double discount = 1.0;
        if (dayOfWeek >= 2 && dayOfWeek <= 6) {
            discount = 0.7;
        } else if (dayOfWeek == 1) {
            discount = 1.0;
        }
        return discount;
    }

    //获得普通菜的折扣
    public static double getNormalDiscount(String dateStr, String timeStr) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        Calendar calendar = Calendar.getInstance();
        int dayOfWeek = 0;
        //这里的数字4代表星期三，因为Calendar类中星期的编号是从1开始的，星期日为1，星期一为2，以此类推，星期六为7。
        try {
            calendar.setTime(sdf.parse(dateStr));
            dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
        } catch (Exception e) {
            e.printStackTrace();
        }
        int hour = Integer.parseInt(timeStr.split("/")[0]);
        int minute = Integer.parseInt(timeStr.split("/")[1]);
        int second = Integer.parseInt(timeStr.split("/")[2]);
        LocalTime orderTime = LocalTime.of(hour, minute, second);

        LocalTime startTime = LocalTime.of(16, 59, 59);
        LocalTime endTime = LocalTime.of(20, 30, 01);

        LocalTime startTime1 = LocalTime.of(10, 29, 59);
        LocalTime endTime1 = LocalTime.of(14, 30, 01);

        LocalTime startTime2 = LocalTime.of(9, 29, 59);
        LocalTime endTime2 = LocalTime.of(21, 30, 01);
        //周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。 普通菜的折扣
        double discount = 1.0;
        if (dayOfWeek >= 2 && dayOfWeek <= 6 && orderTime.isAfter(startTime1) && orderTime.isBefore(endTime1)) {
            discount = 0.6;
        } else if (dayOfWeek >= 2 && dayOfWeek <= 6 && orderTime.isAfter(startTime) && orderTime.isBefore(endTime)) {
            discount = 0.8;
        }
        return discount;
    }

    public static boolean isPhoneNumValid(String phoneNum) {
        return phoneNum.matches("^1(80|81|89|33|35|36)\\d{8}$");
    }


}


class Dish {
    private String name;//菜品名称
    private Double unitPrice;//单价
    private String T; //标记是否是特价菜
    private String type;//标记特价菜的类型
    private int taste;//特价菜的品味等级
    private String flag;

    public String getFlag() {
        return flag;
    }

    public void setFlag(String flag) {
        this.flag = flag;
    }

    public Dish(String name, Double unitPrice) {
        this.name = name;
        this.unitPrice = unitPrice;
    }

    public Dish(String name, Double unitPrice, String t, String type, int taste) {
        this.name = name;
        this.unitPrice = unitPrice;
        this.T = t;
        this.type = type;
        this.taste = taste;
    }

    public static String numToTaste(int num) {
        switch (num) {
            case 0:
                return "不辣";
            case 1:
                return "微辣";
            case 2:
                return "稍辣";
            case 3:
                return "辣";
            case 4:
                return "很辣";
            case 5:
                return "爆辣";
            default:
                return "";
        }
    }

    public static String numToAcidity(int num) {
        switch (num) {
            case 0:
                return "不酸";
            case 1:
                return "微酸";
            case 2:
                return "稍酸";
            case 3:
                return "酸";
            case 4:
                return "很酸";
            default:
                return "";
        }
    }

    public static String numToSweetness(int num) {
        switch (num) {
            case 0:
                return "不甜";
            case 1:
                return "微甜";
            case 2:
                return "稍甜";
            case 3:
                return "甜";
            default:
                return "";
        }
    }

    @Override
    public String toString() {
        return "Dish{" +
                "name='" + name + '\'' +
                ", unitPrice=" + unitPrice +
                ", T='" + T + '\'' +
                ", type='" + type + '\'' +
                ", taste='" + taste + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getUnitPrice() {
        return unitPrice;
    }

    public void setUnitPrice(Double unitPrice) {
        this.unitPrice = unitPrice;
    }

    public String getT() {
        return T;
    }

    public void setT(String t) {
        T = t;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public int getTaste() {
        return taste;
    }

    public void setTaste(int taste) {
        this.taste = taste;
    }

}

class Menu {

    private static Dish[] dishes;//菜品数组，保存所有菜品信息  //只有菜单的名字

    public Menu(Dish[] dishes) {
        this.dishes = dishes;
    }

    //谱中查找菜品信息，返回Dish对象。
    public static Dish searchDish(String dishName) {
        for (Dish dish : dishes) {
            if (dish != null) {
                if (dish.getName().equals(dishName)) {
                    return dish;
                }
            }
        }
        return null;
    }

    //查找特价菜
    public static boolean findMenuName(String dishName) {
        for (Dish dish : dishes) {
            if (dish != null) {
                if (dish.getName().equals(dishName) && dish.getT() != null) {
                    return true;
                }
            }
        }
        return false;
    }

    public Dish[] getDishes() {
        return dishes;
    }

    public void setDishes(Dish[] dishes) {
        this.dishes = dishes;
    }
}

class Order {
    private Record[] records; //保存订单上每一道菜品记录的数组
    private int k; //记录该订单中删除失败的次数

    public int getK() {
        return k;
    }

    public void setK(int k) {
        this.k = k;
    }

    public Order(Record[] records) {
        this.records = records;
    }

    //根据订单号删除一条记录
    public boolean delARecordByOrderNum(String orderNum) {
        //先找到对应的记录
        Record record = findRecordByNum(orderNum);
        if (record == null) { //找不到对应记录，删除失败
            return false; //输出delete error
        }
        record.setFlag("false");
        return true;
    }


    //根据订单号查找一条记录
    public Record findRecordByNum(String orderNum) {
        for (Record record : records) {
            if (record != null) {
                if (record.getOrderNum().equals(orderNum)) {
                    return record;
                }
            }
        }
        return null; //找不到对应记录
    }

    //计算订单的总价
    public double getTotalPrice() {
        double totalPrice = 0.0;
        for (Record record : records) {
            if (record != null && !record.getFlag().equals("false") && record.getD().getFlag() == null && record.getForOrder() == null) {
                totalPrice += record.getPrice();
            }
        }
        return totalPrice;
    }

    public Record[] getRecords() {
        return records;
    }

    public void setRecords(Record[] records) {
        this.records = records;
    }

    //计算折扣之后的总价
    public double getDisCountTotalPrice(Double discount, Double discountN) {
        double totalPrice = 0.0;
        for (Record record : records) {
            if (record != null && !record.getFlag().equals("false") && record.getD().getFlag() == null && record.getForOrder() == null) {
                if (record.getD() != null) {
                    if (record.getD().getT()!=null) {
                        totalPrice += Math.round(record.getPrice() * discount);
                    } else {
                        totalPrice += Math.round(record.getPrice() * discountN);
                    }
                }


            }
        }
        return totalPrice;
    }
}

class Record {
    private String orderNum;  // 序号
    private Dish d;  // 菜品
    private int portion;  // 份额(1/2/3代表小/中/大份)
    private int num;  // 份数
    private String flag;  // 标记是否逻辑删除d
    private int tableNum;//标记谁为谁点的餐
    private String over;//存放输出的信息 spricy   6
    private String forOrderT;
    private String forOrderT1;//用于算除去当前自己的一个菜品

    public String getForOrderT() {
        return forOrderT;
    }

    public void setForOrderT(String forOrderT) {
        this.forOrderT = forOrderT;
    }

    public String getForOrderT1() {
        return forOrderT1;
    }

    public void setForOrderT1(String forOrderT1) {
        this.forOrderT1 = forOrderT1;
    }

    public Record(String orderNum, Dish d, int portion, int num, String flag, int tableNum, String over, String forOrderT
            , String forOrderT1) {
        this.orderNum = orderNum;
        this.d = d;
        this.portion = portion;
        this.num = num;
        this.flag = flag;
        this.tableNum = tableNum;
        this.over = over;
        this.forOrderT = forOrderT;
        this.forOrderT1 = forOrderT1;
    }

    public String getForOrder() {
        return forOrderT;
    }

    public void setForOrder(String forOrder) {
        this.forOrderT = forOrder;
    }

    public String getOver() {
        return over;
    }

    public void setOver(String over) {
        this.over = over;
    }

    @Override
    public String toString() {
        return "Record{" +
                "orderNum='" + orderNum + '\'' +
                ", d=" + d +
                ", portion=" + portion +
                ", num=" + num +
                ", flag=" + flag +
                ", tableNum=" + tableNum +
                '}';
    }

    public int getTableNum() {
        return tableNum;
    }

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

    public String isFlag() {
        return flag;
    }


    public void setFlag(String flag) {
        this.flag = flag;
    }

    public Record(String orderNum, Dish d, int portion, int num, String flag, int tableNum) {
        this.orderNum = orderNum;
        this.d = d;
        this.portion = portion;
        this.num = num;
        this.flag = flag;
        this.tableNum = tableNum;
    }

    public Record(String orderNum, Dish d, int portion, int num, String flag, int tableNum, String over) {
        this.orderNum = orderNum;
        this.d = d;
        this.portion = portion;
        this.num = num;
        this.flag = flag;
        this.tableNum = tableNum;
        this.over = over;
    }

    public int getPrice() {
        double price = 0.0;
        if (d != null) {
            if (d.getUnitPrice() != null) {
                if (portion == 1) {
                    price = d.getUnitPrice();
                } else if (portion == 2) {
                    price = d.getUnitPrice() * 1.5;
                } else if (portion == 3) {
                    price = d.getUnitPrice() * 2;
                }
                return (int) Math.round(price * num);
            }

        }
        return 0;
    }

    public String getOrderNum() {
        return orderNum;
    }

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

    public Dish getD() {
        return d;
    }

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

    public int getPortion() {
        return portion;
    }

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

    public int getNum() {
        return num;
    }

    public String getFlag() {
        return flag;
    }

    public void setNum(int num) {
        this.num = num;
    }

}

class Table {
    String tableNum; //桌号
    String date; //点餐日期
    String time; //点餐日期
    Order order; //该桌子的订单
    String flag;

    public String getFlag() {
        return flag;
    }

    public void setFlag(String flag) {
        this.flag = flag;
    }


    public Order getOrder() {
        return order;
    }

    public void setOrder(Order order) {
        this.order = order;
    }


    public Table(String tableNum, String date, String time, Order order) {
        this.tableNum = tableNum;
        this.date = date;
        this.time = time;
        this.order = order;

    }

    public String getTableNum() {
        return tableNum;
    }

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

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    public String getTime() {
        return time;
    }

    public void setTime(String time) {
        this.time = time;
    }

    public Order getOrders() {
        return order;
    }

    public void setOrders(Order orders) {
        this.order = orders;
    }

    public double getTotalPrice(String dateStr, String timeStr) {
        //计算这一桌的总价
        //根据订单列表中的菜品记录计算总价
        //根据时间判断是否有折扣
        //返回总价
        double totalPrice = order.getTotalPrice();
        return totalPrice;
    }


    public double getDisCountTotalPrice(Double discount, Double discount1) {
        double totalPrice = order.getDisCountTotalPrice(discount, discount1);
        return totalPrice;
    }
}

class User {
    public String getName() {
        return name;
    }

    public User(String name, String phone) {
        this.name = name;
        this.phone = phone;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    private String name;
    private String phone;
    private List<Table> table;


    public List<Table> getTable() {
        return table;
    }

    public User(String name, String phone, List<Table> table) {
        this.name = name;
        this.phone = phone;
        this.table = table;
    }

}

该道题的类图如下：

复杂度分析，如下图所示：

从我该题题目圈复杂度和软件质量的表可以看出我这个题的复杂度是10，是比较高的，说明代码效率低，维护成本高，并且if else语句使用过多，代码执行效率过低。如果要是想要改进的话，应该把if else语句去掉，换成数组或switch，便可以大大提升我们的编程效率。这道题我主要的问题出在”四舍五入“以及和含删除记录的测试样例无法通过，就比如折扣的计算在算总价的时候，应该是对每一个订单乘车折扣，四舍五入，再加入总价，不要全部加起来再乘以折扣然后在四舍五入。另外，有关口味度的计算，我至今都没有通过测试点，按照上面的测试样例，我的辣度是四舍五入的，而酸度和甜度都是向下取整的，但是还是有部分测试点过不去。除此之外，还有一个川菜测试-单用户-辣度值越界的测试点，显示格式错误，我也没有发现哪里有问题。总之，我这道题大体是写出来，但是很多细节上的问题，并没有解决。

7-1 测验1-圆类设计

创建一个圆形类（Circle），私有属性为圆的半径，从控制台输入圆的半径，输出圆的面积

输入格式:
输入圆的半径，取值范围为(0,+∞)，输入数据非法，则程序输出Wrong Format，注意：只考虑从控制台输入数值的情况

输出格式:
输出圆的面积（保留两位小数，可以使用String.format(“%.2f”,输出数值）控制精度）

输入样例:
在这里给出一组输入。例如：

2.35
输出样例:
在这里给出相应的输出。例如：

17.35

import java.util.Scanner;
public class Main {
    private double r;
    public void setRadius(double r) {
        this.r = r;
    }
    public double getArea() {
        return Math.PI * r * r;
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        double r = in.nextDouble();
        if(r <= 0) {
            System.out.println("Wrong Format");
            return;
        }
        Main circle = new Main();
        circle.setRadius(r);
        System.out.println(String.format("%.2f", circle.getArea()));
    }
}

这道题就是简单的类设计，值得一提的是，我开始并没有注意到后面的题目需要用到前面的类设计，所以我开始用的是面向过程的方式写的，这样写固然简单，但是不利于后续的开发。其实，通过这几次作业和实验，也想来谈谈，我对面向对象的理解。面向对象是一种编程思想，把具有某些特征的属性和行为（方法）封装到类中，不关心其具体实现过程，只关心完成功能。当我们在编程过程中使用这种思想时，代码更容易阅读、更容易扩展和维护，就比如说我们的期中考试，同时也提供了更好的数据保护和安全性。当前编程的主流思想就是面向对象思想，我认为我们应该重视这种思想，认真对待我们的面向对象设计这门课。

7-2 测验2-类结构设计

设计一个矩形类，其属性由矩形左上角坐标点（x1，y1）及右下角坐标点（x2，y2）组成，其中，坐标点属性包括该坐标点的X轴及Y轴的坐标值（实型数），求得该矩形的面积。类设计如下图：

输入格式:
分别输入两个坐标点的坐标值x1，y1，x2，y2。

输出格式:
输出该矩形的面积值（保留两位小数）。

输入样例:
在这里给出一组输入。例如：

6 5.8 -7 8.9
输出样例:
在这里给出相应的输出。例如：

40.30

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        double x1 = in.nextDouble();
        double y1 = in.nextDouble();
        double x2 = in.nextDouble();
        double y2 = in.nextDouble();
        Rectangle i = new Rectangle(x1, y1, x2, y2);
        double area = i.getArea();
        System.out.println(String.format("%.2f", area));
    }
}
class Rectangle {
    private double x1, y1, x2, y2;
    public Rectangle(double x1, double y1, double x2, double y2) {
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
    }
    public double getArea() {
        double width = Math.abs(x2 - x1);
        double height = Math.abs(y2 - y1);
        return width * height;
    }
}

主要就是根据上面的类图写，难度不大

7-3 测验3-继承与多态

将测验1与测验2的类设计进行合并设计，抽象出Shape父类（抽象类），Circle及Rectangle作为子类，类图如下所示：

试编程完成如上类图设计，主方法源码如下（可直接拷贝使用）：

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);

int choice = input.nextInt();

switch(choice) {
case 1://Circle
double radiums = input.nextDouble();
Shape circle = new Circle(radiums);
printArea(circle);
break;
case 2://Rectangle
double x1 = input.nextDouble();
double y1 = input.nextDouble();
double x2 = input.nextDouble();
double y2 = input.nextDouble();

Point leftTopPoint = new Point(x1,y1);
Point lowerRightPoint = new Point(x2,y2);

Rectangle rectangle = new Rectangle(leftTopPoint,lowerRightPoint);

printArea(rectangle);
break;
}

}
其中，printArea(Shape shape)方法为定义在Main类中的静态方法，体现程序设计的多态性。

输入格式:
输入类型选择（1或2，不考虑无效输入）
对应图形的参数（圆或矩形）

输出格式:
图形的面积（保留两位小数）

输入样例1:
1
5.6
输出样例1:
在这里给出相应的输出。例如：

98.52
输入样例2:
2
5.6
-32.5
9.4
-5.6
输出样例2:
在这里给出相应的输出。例如：

102.22

import java.util.*;
abstract class Shape {
    public abstract double getArea();
}
class Circle extends Shape {
    private double r;

    public Circle(double r) {
        this.r = r;
    }

    public double getRadius() {
        return r;
    }

    public void setRadius(double r) {
        this.r = r;
    }

    @Override
    public double getArea() {
        return Math.PI * r * r;
    }
}
class Rectangle extends Shape {
    private Point leftTopPoint, lowerRightPoint;

    public Rectangle(Point leftTopPoint, Point lowerRightPoint) {
        this.leftTopPoint = leftTopPoint;
        this.lowerRightPoint = lowerRightPoint;
    }

    public Point getLeftTopPoint() {
        return leftTopPoint;
    }

    public void setLeftTopPoint(Point leftTopPoint) {
        this.leftTopPoint = leftTopPoint;
    }

    public Point getLowerRightPoint() {
        return lowerRightPoint;
    }

    public void setLowerRightPoint(Point lowerRightPoint) {
        this.lowerRightPoint = lowerRightPoint;
    }

    @Override
    public double getArea() {
        return Math.abs((lowerRightPoint.getX() - leftTopPoint.getX())
                * (leftTopPoint.getY() - lowerRightPoint.getY()));
    }
}
class Point {
    private double x, y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        int choice = input.nextInt();

        switch (choice) {
            case 1://Circle
                double r = input.nextDouble();
                if(r <= 0) {
                    System.out.println("Wrong Format");
                }
                else{
                Shape circle = new Circle(r);
                printArea(circle);}
                break;
            case 2://Rectangle
                double x1 = input.nextDouble();
                double y1 = input.nextDouble();
                double x2 = input.nextDouble();
                double y2 = input.nextDouble();

                Point leftTopPoint = new Point(x1, y1);
                Point lowerRightPoint = new Point(x2, y2);

                Rectangle rectangle = new Rectangle(leftTopPoint, lowerRightPoint);

                printArea(rectangle);
                break;
        }

        input.close();
    }

    public static void printArea(Shape shape) {
        System.out.printf("%.2f", shape.getArea());
    }
}

根据类图，我构造了shape的抽象类，然后构造了子类Rectangle和Circle继承父类shape，子类point继承父类Rectangle

7-4 测验4-抽象类与接口

在测验3的题目基础上，重构类设计，实现列表内图形的排序功能（按照图形的面积进行排序）。
提示：题目中Shape类要实现Comparable接口。

其中，Main类源码如下（可直接拷贝使用）：

public class Main {
public static void main(String\[\] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
ArrayList<Shape> list = new ArrayList<>();

int choice = input.nextInt();

while(choice != 0) {
switch(choice) {
case 1://Circle
double radiums = input.nextDouble();
Shape circle = new Circle(radiums);
list.add(circle);
break;
case 2://Rectangle
double x1 = input.nextDouble();
double y1 = input.nextDouble();
double x2 = input.nextDouble();
double y2 = input.nextDouble();
Point leftTopPoint = new Point(x1,y1);
Point lowerRightPoint = new Point(x2,y2);
Rectangle rectangle = new Rectangle(leftTopPoint,lowerRightPoint);
list.add(rectangle);
break;
}
choice = input.nextInt();
}

list.sort(Comparator.naturalOrder());//正向排序

for(int i = 0; i < list.size(); i++) {
System.out.print(String.format("%.2f", list.get(i).getArea()) + " ");
}
}
}

输入格式:
输入图形类型（1:圆形；2：矩形；0：结束输入）

输入图形所需参数

输出格式:
按升序排序输出列表中各图形的面积（保留两位小数），各图形面积之间用空格分隔。

输入样例:
在这里给出一组输入。例如：

1
2.3
2
3.2
3
6
5
1
2.3
0
输出样例:
在这里给出相应的输出。例如：

5.60 16.62 16.62

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
abstract class Shape implements Comparable<Shape> {
    public abstract double getArea();
    @Override
    public int compareTo(Shape i) {
        if (this.getArea() > i.getArea()) {
            return 1;
        } else if (this.getArea() < i.getArea()) {
            return -1;
        } else {
            return 0;
        }
    }
}
class Circle extends Shape {
    private double r;
    public Circle(double r) {
        this.r = r;
    }
    public double getRadius() {
        return r;
    }
    public void setRadius(double r) {
        this.r = r;
    }
    @Override
    public double getArea() {
        return Math.PI * r * r;
    }
}
class Rectangle extends Shape {
    private Point leftTopPoint, lowerRightPoint;
    public Rectangle(Point leftTopPoint, Point lowerRightPoint) {
        this.leftTopPoint = leftTopPoint;
        this.lowerRightPoint = lowerRightPoint;
    }
    public Point getLeftTopPoint() {
        return leftTopPoint;
    }
    public void setLeftTopPoint(Point leftTopPoint) {
        this.leftTopPoint = leftTopPoint;
    }
    public Point getLowerRightPoint() {
        return lowerRightPoint;
    }
    public void setLowerRightPoint(Point lowerRightPoint) {
        this.lowerRightPoint = lowerRightPoint;
    }
    @Override
    public double getArea() {
        return Math.abs((lowerRightPoint.getX() - leftTopPoint.getX())* (leftTopPoint.getY() - lowerRightPoint.getY()));
    }
}
class Point {
    private double x, y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }
    public void setX(double x) {
        this.x = x;
    }
    public double getY() {
        return y;
    }
    public void setY(double y) {
        this.y = y;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        ArrayList<Shape> list = new ArrayList<>();

        int choice = input.nextInt();

        while (choice != 0) {
            switch (choice) {
                case 1:
                    double r = input.nextDouble();
                    if(r <= 0) {
                        System.out.println("Wrong Format");
                    }
                    else{
                    Shape circle = new Circle(r);
                    list.add(circle);}
                    break;
                case 2:
                    double x1 = input.nextDouble();
                    double y1 = input.nextDouble();
                    double x2 = input.nextDouble();
                    double y2 = input.nextDouble();
                    Point leftTopPoint = new Point(x1, y1);
                    Point lowerRightPoint = new Point(x2, y2);
                    Rectangle rectangle = new Rectangle(leftTopPoint, lowerRightPoint);
                    list.add(rectangle);
                    break;
            }
            choice = input.nextInt();
        }
        list.sort(Comparator.naturalOrder());//正向排序

        for(int i = 0; i < list.size(); i++) {
            System.out.print(String.format("%.2f", list.get(i).getArea()) + " ");
        }
    }
}

复杂度分析，如下：

这道主要是重构类设计，实现列表内图形的排序功能，我当时的问题主要在于现场学习Comparable接口，实在能力有限，这是我后续了解到的知识：Comparator是个接口，可重写compare()及equals()这两个方法,用于比价功能；如果是null的话，就是使用元素的默认顺序

当两个对象进行比较的时候：如果Collections.sort(list)只有对象集合这一个参数，会按照队列顺序依次调用对象本身重写的CompareTo()方法。

如果Collections.sort(list, new PriceComparator());第二个传入了Comparator对象，则比较的时候会依次调用Comparator对象的Compare()方法，其内部会调用对象本身实现的Comparable接口中实现的CompareTo()方法来比较，即a.compareTo(b)此时就会根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。进而进行排序。

三、踩坑心得

1.第五次作业中有关折扣得的计算，我开始老算的不对，不是差一块钱就是差两快钱，我开始以为是四舍五入的问题，就不停的实验Java的各种取整函数，比如Math.ceil(double num);Math.round(double num);Math.floor(double num);

结果最后发现是因为特色菜和普通菜的折扣不一样。经过这个事情，我觉得我们在写题的时候，应该认真审题，避免无谓的时间浪费

2.期中考试的第一题开始用的都是面向过程的编程思想，造成后面需要重写代码

四.主要困难和改进建议

1. 代码的复杂度高，我认为要减少选择语句if else，改用switch或者数组，这样可以提高程序运行效率。

2. 对于类的理解不够，一个类里面的属性与方法，应该有单一原则，单一职责原则核心思想是一个类，最好就做一件事。就如老师上课所说的类与类之间的关联性越小越好，而我所写的一些程序，互相关联的太多，导致不太好改。测试对于编码质量是非常重要的，虽然我们pta不对这个做要求，我们也应该对自己所编写的代码持有高度的严谨性，尽可能提高代码质量。

3. 在写作业和实验的代码，我认为我对原有代码的改动过大，可以参考以下办法来减少修改：

首先，我们在设计的时候，一个类只负责完成一个职责或者功能，不要存在多于一种导致类变更的原因。应该遵循单一职责原则通过避免设计大而全的类，避免将不相关的功能耦合在一起，来提高类的内聚性。同时，类职责单一，类依赖的和被依赖的其他类也会变少，减少了代码的耦合性，以此来实现代码的高内聚、松耦合。

其次，我们应遵循开放-关闭原则，在添加一个新的功能，应该是通过在已有代码基础上扩展代码（新增模块、类、方法、属性等），而非修改已有代码（修改模块、类、方法、属性等）的方式来完成。

最后，我们可以通过多态、依赖注入、基于接口来提高代码延展性，从而避免修改原有代码。

五.总结

博客作业对我们来说是一种很重要的总结并反思的机会，以下是我对此次博客的内容进行总结：从我自身的角度，三次作业我掌握了Java语言中继承和抽象类的基本概念及使用方法；以及super关键字的使用方法；理解了继承与组合的区别；理解程序设计中代码复用的重要性。 并且，掌握了Java语言中final关键字的含义及使用方法。学习了Java的三大特性：封装、继承、多态。

从课堂的角度，我个人觉得进度较快。另外，希望PTA作业可以开放测试点，实在太难找了

posted on 2023-05-16 23:36 波浪22206102 阅读(54) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

输入格式:

输出格式:

输入样例1:

输出样例1:

输入样例2:

输出样例2:

输入样例3:

输出样例3:

输入样例4:

输出样例4:

输入样例5:

输出样例5:

输入样例6:

输出样例6:

输入样例7:

输出样例7:

公告