1.前言
1.知识点总结：
第四次PTA作业集
7-1 菜单计价程序-3 分数 40 作者 蔡轲 单位 南昌航空大学设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 两个信息。
订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。
桌号标识独占一行，包含两个信息：桌号、时间。
桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。
点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。
不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。
删除记录格式：序号 delete
标识删除对应序号的那条点菜记录。
如果序号不对，输出"delete error"
代点菜信息包含：桌号 序号 菜品名称 份额 分数
代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。
程序最后按输入的先后顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。
每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。
折扣的计算方法（注：以下时间段均按闭区间计算）：
周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。
周末全价，营业时间：9:30-21:30
如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"
参考以下类的模板进行设计：菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish\[\] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish addDish(String dishName,int unit_price)//添加一道菜品信息
}
点菜记录类：保存订单上的一道菜品记录
Record {
int orderNum;//序号\\
Dish d;//菜品\\
int portion;//份额（1/2/3代表小/中/大份）\\
int getPrice()//计价，计算本条记录的价格\\
}
订单类：保存用户点的所有菜的信息。
Order {
Record\[\] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
delARecordByOrderNum(int orderNum)//根据序号删除一条记录
findRecordByNum(int orderNum)//根据序号查找一条记录
}
### 输入格式:
桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数
最后一条记录以“end”结束。
### 输出格式:
按输入顺序输出每一桌的订单记录处理信息，包括：
1、桌号，格式：table+英文空格+桌号+”:”
2、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
输入格式:
桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数
最后一条记录以“end”结束。
输出格式:
按输入顺序输出每一桌的订单记录处理信息，包括：
1、桌号，格式：table+英文空格+桌号+“:”+英文空格
2、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 12/2/3
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end
输出样例:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 38
输入样例1:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 17/0/0
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例1:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 22
输入样例2:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 16/59/59
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例2:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
table 1 out of opening hours
输入样例3:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2022/12/5 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
5 delete
7 delete
table 2 2022/12/3 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
7 delete
end
输出样例3:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
delete error;
table 2:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
table 1 out of opening hours
table 2: 63
输入样例4:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2022/12/3 19/5/12
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
table 2 2022/12/3 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 4 麻婆豆腐 1 1
7 delete
end
输出样例4:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
table 2:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
4 table 2 pay for table 1 12
delete error;
table 1: 63
table 2: 75
我的代码：
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws ParseException {
Scanner scanner = new Scanner(System.in);
Menu menu = new Menu();
Dish dish = new Dish();
Table table = new Table();
Table[] tables = new Table[20];
Dish[] dishes = new Dish[20];
Order []orders = new Order[20];
Record records = new Record();
int[] num = new int[20];
num[0] = 0;
int i=0;
int j=0;
int tableNum=0;
int n=0;
String line;
while(true) {
line = scanner.nextLine();
String[] part = line.split(" ");
if(line.equals("end"))
break;
else if(part.length == 2) {
if(part[1].equals("delete")) {
num[0] = Integer.parseInt(part[0]);
if(orders[tableNum-1].delARecordByOrderNum(num[0],orders[tableNum-1].findorderlength())!= null) {
j--;
}
else {
System.out.println("delete error;");
}
}
else {
if(dish.getI(dishes,part[0],i)!= -1) {
dishes[dish.getI(dishes,part[0],i)].setUnit_price(Integer.parseInt(part[1]));
}
else {
dish.setName(part[0]);
dish.setUnit_price(Integer.parseInt(part[1]));
dishes[i] = new Dish();
dishes[i].setName(dish.getName());
dishes[i].setUnit_price(dish.getUnit_price());
menu.setDishes(dishes);
i++;
}
}
}
lableB:
if(part.length == 4) {
if(part[0].equals("table")) {
table.setName(part[0]);
table.setTablenum(part[1]);
table.setDate(part[2]);
table.setTime(part[3]);
tables[n] = new Table();
tables[n].setName(table.getName());
tables[n].setTablenum(table.getTablenum());
tables[n].setDate(table.getDate());
tables[n].setTime(table.getTime());
System.out.println("table "+tables[n].getTablenum()+": ");
n++;
j=0;
tableNum = Integer.parseInt(part[1]);
}
else {
if(menu.searthDish(part[1],i)!= null) {
records.setD(menu.searthDish(part[1],i));
}
else {
System.out.println(part[1]+" does not exist");
break lableB;
}
records.setOrderNum(Integer.parseInt(part[0]));
records.setPortion(Integer.parseInt(part[2]));
records.setNum(Integer.parseInt(part[3]));
if(j==0) {
orders[tableNum-1] = new Order();
orders[tableNum-1].space( orders[tableNum-1].records);
}
orders[tableNum-1].records[j] = new Record();
orders[tableNum-1].records[j].setOrderNum(records.getOrderNum());
orders[tableNum-1].records[j].setD(records.getD());
orders[tableNum-1].records[j].setPortion(records.getPortion());
orders[tableNum-1].records[j].setNum(records.getNum());
System.out.println(orders[tableNum-1].records[j].getOrderNum()+" "+orders[tableNum-1].records[j].getD().getName()+" "+orders[tableNum-1].records[j].getPrice());
j++;
}
}
lableA:
if(part.length == 5) {
if(menu.searthDish(part[2],i)!= null) {
records.setD(menu.searthDish(part[2],i));
}
else {
System.out.println(part[2]+" does not exist");
break lableA;
}
records.setOrderNum(Integer.parseInt(part[1]));
records.setPortion(Integer.parseInt(part[3]));
records.setNum(Integer.parseInt(part[4]));
if(j==0) {
orders[tableNum-1] = new Order();
orders[tableNum-1].space( orders[tableNum-1].records);
}
orders[tableNum-1].records[j] = new Record();
orders[tableNum-1].records[j].setOrderNum(records.getOrderNum());
orders[tableNum-1].records[j].setD(records.getD());
orders[tableNum-1].records[j].setPortion(records.getPortion());
orders[tableNum-1].records[j].setNum(records.getNum());
System.out.println(part[1]+" table "+tableNum+" pay for table "+part[0]+" "+orders[tableNum-1].records[j].getPrice());
j++;
}
}
for(int t=0;t<n;t++) {
if(num[0] == 0) {
orders[t].getTotalPrice(j,judgetime(tables[t].getTime(),judgedate(tables[t].getDate())),tables[t].getTablenum());
}
else{
orders[t].getTotalPrice(orders[t].findorderlength(),judgetime(tables[t].getTime(),judgedate(tables[t].getDate())),tables[t].getTablenum());
}
if(t<n-1) {
System.out.print("\n");
}
}
}
public static boolean isValidDate(String dateStr) {//判断日期是否合法
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
dateFormat.setLenient(false);
try {
dateFormat.parse(dateStr);
return true;
} catch (ParseException e) {
return false;
}
}
public static int judgedate(String dateStr) throws ParseException {//判断日期是周几
String inputdate = dateStr;
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
Date inputDate;
if (!isValidDate(inputdate)) {
System.out.println(inputdate+"无效!");
}
else if(isValidDate(inputdate)) {
inputDate = dateFormat.parse(inputdate);
Calendar calendar = Calendar.getInstance();
calendar.setTime(inputDate);
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK)-1;
if(dayOfWeek==0)
dayOfWeek=7;
return dayOfWeek;
}
return 0;
}
public static int judgetime(String timeStr,int dayOfWeek) {//判断时间是上午还是下午还是晚上
String[] time = timeStr.split("/");
int hour = Integer.parseInt(time[0]);
int minutes = Integer.parseInt(time[1]);
if(dayOfWeek>=1&&dayOfWeek<=5) {
if((hour == 17 && minutes >= 0 && minutes <= 59) ||
(hour > 17 && hour < 20) ||
(hour == 20 && minutes >= 0 && minutes <= 30)){
return 1;
}
else if((hour == 10 && minutes >= 30 && minutes <= 59) ||
(hour > 10 && hour < 14) ||
(hour == 14 && minutes >= 0 && minutes <= 30)){
return 2;
}
else
return 0;
}
else {
if((hour == 9 && minutes >= 30 && minutes <= 59) ||
(hour > 9 && hour < 21) ||
(hour == 21 && minutes >= 0 && minutes <= 30)) {
return 3;
}
else
return 0;
}
}
}
class Dish{//菜品类:对应菜谱上一道菜的名称
private String name;//菜品名称
private int unit_price;//单价
public Dish(String name,int unit_price){//构造器
this.name = name;
this.unit_price = unit_price;
}
public Dish(){
}
public void setName(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setUnit_price(int unit_price){
this.unit_price = unit_price;
}
public int getUnit_price() {
return unit_price;
}
public int getPrice(int n){//计算菜品价格的方法
double []portion = new double[3];
portion[0] = 1;
portion[1] = 1.5;
portion[2] = 2;
return Math.round((float)(unit_price*portion[n-1]));
}
public int getI(Dish dishes[],String part,int num){//找到菜单中重复菜名的下标
if(num==0)
return -1;
for(int i=0;;i++) {
if(dishes[i].getName().equals(part))
return i;
else if(i==num-1)
return -1;
}
}
}
class Menu {//菜单类：对应菜谱，包含饭店提供的所有菜的信息。
Dish[] dishes;//菜品数组，保存所有菜品信息
public Menu(Dish[] dishes){//构造器
this.dishes = new Dish[20];
}
public Menu(){
}
public void setDishes(Dish[] dishes) {
this.dishes = dishes;
}
public Dish searthDish(String dishName,int i){
int n=0;
while(n<i)
{
if(dishes[n].getName().equals(dishName))
return dishes[n];
n++;
}
return null;
}
public Dish[] addDish(String dishName,int unit_price){//添加一道菜品信息
int i=0;
while(true)
{
if(dishes[i].getName()== null) {
dishes[i].setName(dishName);
dishes[i].setUnit_price(unit_price);
return dishes;}
i++;
}
}
}
class Record {//记录类：保存订单上的一道菜品记录
private Integer orderNum;//序号
private Dish d;//菜品
private int portion;//份额（1/2/3代表小/中/大份）
private int num;//份数
public Record(){
}
public Record(Integer orderNum,Dish d,int portion,int num) {
this.orderNum = orderNum;
this.d = d;
this.portion = portion;
this.num = num;
}
public Integer getOrderNum() {
return orderNum;
}
public void setOrderNum(Integer 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 void setNum(int num) {
this.num = num;
}
public int getPrice(){//计价
return d.getPrice(portion)*num;
}
}
class Order {//订单类：保存用户点的所有菜的信息
Record[] records;//保存订单上每一道的记录
public Order() {
}
public void space(Record[] records) {
this.records = new Record[20];
}
public void setRecords(Record[] records) {
this.records = records;
}
public void getTotalPrice(int n,int discount,String tableNum){//计算订单的总价
int i = 0;
int totalprice = 0;
while(i<n) {
totalprice = totalprice+records[i].getPrice();
i++;
}
if(discount==1)
System.out.print("table "+tableNum+": "+Math.round((float)(totalprice*0.8)));
else if(discount==2)
System.out.print("table "+tableNum+": "+Math.round((float)(totalprice*0.6)));
else if(discount==3)
System.out.print("table "+tableNum+": "+totalprice);
else if(discount==0)
System.out.print("table "+tableNum+" out of opening hours");
}
public Record[] addARecord(Integer orderNum,String dishName,int portion,int num){//添加一条菜品信息到订单中
int i=0;
while(true)
{
if(records[i].getOrderNum()== null) {
records[i].setOrderNum(orderNum);
records[i].getD().setName(dishName);
records[i].setPortion(portion);
records[i].setNum(num);
return records;}
i++;
}
}
public Record[] delARecordByOrderNum(Integer orderNum,int n){//根据序号删除一条记录
int t=n;
for(int i=0;i<n;i++)
{
if(records[i].getOrderNum()== orderNum) {
for(int j=i;;j++) {
if(j == t-1) {
records[j] = null;
t--;
i=0;
return records;
}
else {
records[j].setOrderNum(records[j+1].getOrderNum());
records[j].setD(records[j+1].getD());
records[j].setPortion(records[j+1].getPortion());
records[j].setNum(records[j+1].getNum());
}
}
}
if(t==n&&i==n-1)
return null;
}
return records;
}
public void findRecordByNum(Integer orderNum){//根据序号查找一条记录
int i =0;
while(records[i].getOrderNum()!= null) {
if(records[i].getOrderNum()== orderNum) {
System.out.println(records[i].getOrderNum()+" "+records[i].getD().getName()+" "+records[i].getPortion()+" "+records[i].getNum());
}
}
}
public int findorderlength() {
int i=0;
while(records[i] != null) {
i++;
}
return i;
}
}
class Table{//桌号类
private String name;//table
private String tablenum;//桌号
private String date;//年月日
private String time;//时分秒
public Table(String name,String tablenum,String date,String time){//构造器
this.name = name;
this.tablenum = tablenum;
this.date = date;
this.time = time;
}
public Table(){
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
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;
}
}
分析：针对这一题，题目及其题目要求并不算太难，只需按照题目要求严格的创建类和类方法中的输入输出
7-2 成绩计算-2-关联类 分数 10 作者 蔡轲 单位 南昌航空大学创建成绩类，包含：
属性：平时成绩（int）、期末成绩（int）
方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）
创建学生类，包含：
属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）
方法：计算总分、计算平均分
输入3个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365
注意：未用学生类对象封装数据的，本题计0分
输入格式:
依次输入3个学生的每门课成绩，每个学生成绩信息格式：
学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致
例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出格式:
3个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 242 80.67
22201312 黄昊 234 78.00
22201313 李少辰 236 78.67
输入样例:
在这里给出一组输入。例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 242 76.67 84.00 80.67
22201312 黄昊 234 75.00 80.67 78.00
22201313 李少辰 236 83.67 76.00 78.67import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Student[] stus = new Student[3];
Score []stur = new Score[3];
String course;
for(int i=0;i<3;i++){
for(int j=0;j<3;j++) {
stus[i] =new Student();
stus[i].setStudentnum(input.next());
stus[i].setStudentname(input.next());
course = input.next();
Score grades = new Score(input.nextInt(),input.nextInt());
stur[j] = grades;
stus[i].setChinese(stur[0]);
stus[i].setMath(stur[1]);
stus[i].setPhysics(stur[2]);
}
}
for(int j=0;j<3;j++)
System.out.println(stus[j].getStudentnum()+" "+stus[j].getStudentname()+" "+(int)stus[j].figure1()+" "+String.format("%.2f",stus[j].figure2(0))+" "+String.format("%.2f",stus[j].figure2(1))+" "+String.format("%.2f",stus[j].figure2(2)));
}
}
class Student{//将学生信息封装在一个学生对象中
private String studentnum;//学号
private String studentname;//姓名
private Score chinese;//语文成绩
private Score math;//数学成绩
private Score physics;//物理成绩
public Student(String studentnum,String studentname,Score chinese,Score math,Score physics){//构造器
this.studentnum = studentnum;
this.studentname = studentname;
this.chinese = chinese;
this.math = math;
this.physics = physics;
}
public Student(){
}
public void setStudentnum(String studentnum){
this.studentnum = studentnum;
}
public String getStudentnum() {
return studentnum;
}
public void setStudentname(String studentname){
this.studentname = studentname;
}
public String getStudentname() {
return studentname;
}
public void setChinese(Score chinese){
this.chinese = chinese;
}
public Score getChinese() {
return chinese;
}
public Score getMath() {
return math;
}
public void setMath(Score math){
this.math = math;
}
public Score getPhysics() {
return physics;
}
public void setPhysics(Score physics){
this.physics =physics;
}
public double figure1(){
return chinese.figure3()+math.figure3()+physics.figure3();
}
public double figure2(int t){
double overall1 = chinese.getUgrades()+math.getUgrades()+physics.getUgrades();
double overall2 = chinese.getFgrades()+math.getFgrades()+physics.getFgrades();
double overall3 = chinese.figure3()+math.figure3()+physics.figure3();
double pj = 0;
if(t==0) {
pj = (double)(overall1/(double)3);
return pj;
}
else if(t==1) {
pj = (double)(overall2/(double)3);
return pj;
}
else {
pj = (double)(overall3/(double)3);
return pj;
}
}
}
class Score{
int ugrades;//平时成绩
int fgrades;//期末成绩
public Score(int ugrades,int fgrades){//构造器
this.ugrades = ugrades;
this.fgrades = fgrades;
}
public Score(){
}
public int getUgrades() {
return ugrades;
}
public int getFgrades() {
return fgrades;
}
public double figure3() {
return (int)(ugrades*0.4+fgrades*0.6);
}
}
分析：题目难度中等，题量也不算太多，主要在于练习类的构造方法、方法的调用、参数传递、对象的构造与使用；练习循环结构；练习数据的输入与输出；理解抽象类与子类的关系，代码聚合性的调试。
7-2 单词统计与排序 分数 10 作者 张峰 单位 山东科技大学
从键盘录入一段英文文本（句子之间的标点符号只包括“,”或“.”，单词之间、单词与标点之间都以" "分割。
要求：按照每个单词的长度由高到低输出各个单词（重复单词只输出一次），如果单词长度相同，则按照单词的首字母顺序（不区分大小写，首字母相同的比较第二个字母，以此类推）升序输出。
输入格式:
一段英文文本。
输出格式:
按照题目要求输出的各个单词（每个单词一行）。
输入样例:
Hello, I am a student from China.
输出样例:
student
China
Hello
from
am
a
I
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String line = scanner.nextLine();
line=purgeline(line);
Sortbylength(line);
}
public static String purgeline(String line) {//清除字符串中的，和.
String deleteString = "";
for(int i=0;i<line.length();i++) {
if(line.charAt(i)!=','&&line.charAt(i)!='.') {
deleteString += line.charAt(i);
}
}
return deleteString;
}
public static void Sortbylength(String line) {
String[] part = line.split(" ");
String s;
int t=0;
for (int i=0;i<part.length-1;i++) {
for (int j=i+1;j<=part.length-1; j++) {
if (part[i].length()<part[j].length()) {
s = part[i];
part[i] = part[j];
part[j] = s;
}
if(part[i].length()==part[j].length()) {
if(judgsamelen(part[i],part[j])>0) {
s = part[i];
part[i] = part[j];
part[j] = s;
}
}
}
}
for(int i=0;i<part.length-1;i++) {
if(!part[i].equals(part[i+1])) {
System.out.println(part[i]);
t=0;
}
if(part[i].equals(part[i+1])) {
if(t==0) {
System.out.println(part[i]);
t++;
i++;
}
else if(t>0)
i++;
}
if(i==part.length-2&&!part[part.length-2].equals(part[part.length-1])) {
System.out.print(part[part.length-1]);
}
}
}
public static int judgsamelen(String l,String d) {//判断两个长度相同的字符串排序
String s=l.toLowerCase();
String t=d.toLowerCase();
return s.compareTo(t);
}
}
分析：题目简单，题量不大，重点是如何对字符串进行分割还有排序
7-3 判断两个日期的先后，计算间隔天数、周数 分数 10 作者 吴光生 单位 新余学院从键盘输入两个日期，格式如：2022-06-18。判断两个日期的先后，并输出它们之间间隔的天数、周数（不足一周按0计算）。
预备知识：通过查询Java API文档，了解Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法，了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则，了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法。
输入格式:
输入两行，每行输入一个日期，日期格式如：2022-06-18
输出格式:
第一行输出：第一个日期比第二个日期更早（晚）
第二行输出：两个日期间隔XX天
第三行输出：两个日期间隔XX周
输入样例1:
2000-02-18
2000-03-15
输出样例1:
第一个日期比第二个日期更早
两个日期间隔26天
两个日期间隔3周
输入样例2:
2022-6-18
2022-6-1
输出样例2:
第一个日期比第二个日期更晚
两个日期间隔17天
两个日期间隔2周
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws ParseException {
Scanner scanner = new Scanner(System.in);
String startdate = scanner.nextLine();//开始日期
String enddate = scanner.nextLine();//结束日期
scanner.close();
// 解析日期字符串为Date对象
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date startDate;//开始时间
Date endDate;//结束时间
long diffMillis = 0;
long diffDays = 0;
long diffWeeks = 0;
if (!isValidDate(startdate)||!isValidDate(enddate)) {
//System.out.print(startdate+"或"+enddate+"中有不合法的日期.");
return;
}
else {
startDate = dateFormat.parse(startdate);
endDate = dateFormat.parse(enddate);
if (startDate.before(endDate)){
System.out.println("第一个日期比第二个日期更早");
// 计算日期差距
diffMillis = endDate.getTime() - startDate.getTime();
diffDays = diffMillis / (24 * 60 * 60 * 1000);
diffWeeks = diffDays / (7);
}
else {
System.out.println("第一个日期比第二个日期更晚");
// 计算日期差距
diffMillis = startDate.getTime() - endDate.getTime();
diffDays = diffMillis / (24 * 60 * 60 * 1000);
diffWeeks = diffDays / (7);
}
System.out.println("两个日期间隔"+diffDays+"天");
System.out.print("两个日期间隔"+diffWeeks+"周");
}
}
// 判断日期是否合法
public static boolean isValidDate(String dateStr) {
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
dateFormat.setLenient(false);
try {
dateFormat.parse(dateStr);
return true;
} catch (ParseException e) {
return false;
}
}
}
分析：题目简单，题量不大，其主要是沿用上几次练习中日期类的使用
7-4 菜单计价程序-2 分数 40 作者 蔡轲 单位 南昌航空大学
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 两个信息。
订单分：点菜记录和删除信息。每一类信息都可包含一条或多条记录，每条记录一行。
点菜记录包含：序号、菜名、份额、份数。
份额可选项包括：1、2、3，分别代表小、中、大份。
删除记录格式：序号 delete
标识删除对应序号的那条点菜记录。
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
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)//根据序号查找一条记录
}
输入格式:
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：
序号+英文空格+菜名+英文空格+份额+英文空格+份数
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
最后一条记录以“end”结束。
输出格式:
按顺序输出每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。
如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后输出订单上所有菜品的总价（整数数值），
本次题目不考虑其他错误情况，如：菜单订单顺序颠倒、不符合格式的输入、序号重复等。
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end
输出样例:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
63
输入样例1:
订单中包含删除记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例1:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
27
输入样例2:
订单中包含不存在的菜品记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
end
输出样例2:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
63
输入样例3:
订单中包含删除信息以及不存在的菜品记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 delete
7 delete
end
输出样例3:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
27
输入样例4:
订单中包含删除信息以及不存在的菜品记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
5 delete
7 delete
end
输出样例4:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
delete error;
63
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Menu menu = new Menu();
Dish dish = new Dish();
Dish[] dishes = new Dish[20];
Order order = new Order();
Record records = new Record();
Record[] record_array = new Record[20];
int[] num = new int[20];
num[0] = 0;
int i=0;
int j=0;
String line;
while(true) {
line = scanner.nextLine();
String[] part = line.split(" ");
if(line.equals("end"))
break;
else if(part.length == 2) {
if(part[1].equals("delete")) {
num[0] = Integer.parseInt(part[0]);
if(order.delARecordByOrderNum(num[0],order.findorderlength())!= null) {
j--;
}
else {
System.out.println("delete error;");
}
}
else {
if(dish.getI(dishes,part[0],i)!= -1) {
dishes[dish.getI(dishes,part[0],i)].setUnit_price(Integer.parseInt(part[1]));
}
else {
dish.setName(part[0]);
dish.setUnit_price(Integer.parseInt(part[1]));
dishes[i] = new Dish();
dishes[i].setName(dish.getName());
dishes[i].setUnit_price(dish.getUnit_price());
menu.setDishes(dishes);
i++;
}
}
}
lableB:
if(part.length == 4) {
if(menu.searthDish(part[1],i)!= null) {
records.setD(menu.searthDish(part[1],i));
}
else {
System.out.println(part[1]+" does not exist");
break lableB;
}
records.setOrderNum(Integer.parseInt(part[0]));
records.setPortion(Integer.parseInt(part[2]));
records.setNum(Integer.parseInt(part[3]));
record_array[j] = new Record();
record_array[j].setOrderNum(records.getOrderNum());
record_array[j].setD(records.getD());
record_array[j].setPortion(records.getPortion());
record_array[j].setNum(records.getNum());
order.setRecords(record_array);
System.out.println(order.records[j].getOrderNum()+" "+order.records[j].getD().getName()+" "+order.records[j].getPrice());
j++;
}
}
if(num[0] == 0) {
System.out.print(order.getTotalPrice(j));
}
else {
System.out.print(order.getTotalPrice(order.findorderlength()));
}
}
}
class Dish{//菜品类:对应菜谱上一道菜的名称
private String name;//菜品名称
private int unit_price;//单价
public Dish(String name,int unit_price){//构造器
this.name = name;
this.unit_price = unit_price;
}
public Dish(){
}
public void setName(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setUnit_price(int unit_price){
this.unit_price = unit_price;
}
public int getUnit_price() {
return unit_price;
}
public int getPrice(int n){//计算菜品价格的方法
double []portion = new double[3];
portion[0] = 1;
portion[1] = 1.5;
portion[2] = 2;
return Math.round((float)(unit_price*portion[n-1]));
}
public int getI(Dish dishes[],String part,int num){//找到菜单中重复菜名的下标
if(num==0)
return -1;
for(int i=0;;i++) {
if(dishes[i].getName().equals(part))
return i;
else if(i==num-1)
return -1;
}
}
}
class Menu {//菜单类：对应菜谱，包含饭店提供的所有菜的信息。
Dish[] dishes;//菜品数组，保存所有菜品信息
public Menu(Dish[] dishes){//构造器
this.dishes = new Dish[20];
}
public Menu(){
}
public void setDishes(Dish[] dishes) {
this.dishes = dishes;
}
public Dish searthDish(String dishName,int i){
int n=0;
while(n<i)
{
if(dishes[n].getName().equals(dishName))
return dishes[n];
n++;
}
return null;
}
public Dish[] addDish(String dishName,int unit_price){//添加一道菜品信息
int i=0;
while(true)
{
if(dishes[i].getName()== null) {
dishes[i].setName(dishName);
dishes[i].setUnit_price(unit_price);
return dishes;}
i++;
}
}
}
class Record {//记录类：保存订单上的一道菜品记录
private Integer orderNum;//序号
private Dish d;//菜品
private int portion;//份额（1/2/3代表小/中/大份）
private int num;//份数
public Record(){
}
public Record(Integer orderNum,Dish d,int portion,int num) {
this.orderNum = orderNum;
this.d = d;
this.portion = portion;
this.num = num;
}
public Integer getOrderNum() {
return orderNum;
}
public void setOrderNum(Integer 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 void setNum(int num) {
this.num = num;
}
public int getPrice(){//计价
return d.getPrice(portion)*num;
}
}
class Order {//订单类：保存用户点的所有菜的信息
Record[] records;//保存订单上每一道的记录
public Order() {
}
public Order(Record[] records) {
this.records = new Record[20];
}
public void setRecords(Record[] records) {
this.records = records;
}
public int getTotalPrice(int n){//计算订单的总价
int i = 0;
int totalprice = 0;
while(i<n) {
totalprice = totalprice+records[i].getPrice();
i++;
}
return totalprice;
}
public Record[] addARecord(Integer orderNum,String dishName,int portion,int num){//添加一条菜品信息到订单中
int i=0;
while(true)
{
if(records[i].getOrderNum()== null) {
records[i].setOrderNum(orderNum);
records[i].getD().setName(dishName);
records[i].setPortion(portion);
records[i].setNum(num);
return records;}
i++;
}
}
public Record[] delARecordByOrderNum(Integer orderNum,int n){//根据序号删除一条记录
int t=n;
for(int i=0;;i++)
{
if(records[i].getOrderNum()== orderNum) {
for(int j=i;;j++) {
if(j == t-1) {
records[j] = null;
t--;
i=0;
return records;
}
else {
records[j].setOrderNum(records[j+1].getOrderNum());
records[j].setD(records[j+1].getD());
records[j].setPortion(records[j+1].getPortion());
records[j].setNum(records[j+1].getNum());
}
}
}
if(t==n&&i==n-1)
return null;
}
}
public void findRecordByNum(Integer orderNum){//根据序号查找一条记录
int i =0;
while(records[i].getOrderNum()!= null) {
if(records[i].getOrderNum()== orderNum) {
System.out.println(records[i].getOrderNum()+" "+records[i].getD().getName()+" "+records[i].getPortion()+" "+records[i].getNum());
}
}
}
public int findorderlength() {
int i=0;
while(records[i] != null) {
i++;
}
return i;
}
}
题目简单，题量不大，主要是在菜单1的基础上进行迭代
第五次PTA作业集
7-1 菜单计价程序-4 分数 100 作者 蔡轲 单位 南昌航空大学本体大部分内容与菜单计价程序-3相同，增加的部分用加粗文字进行了标注。
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 两个信息。
订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。
桌号标识独占一行，包含两个信息：桌号、时间。
桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。
点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。
不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。
删除记录格式：序号 delete
标识删除对应序号的那条点菜记录。
如果序号不对，输出"delete error"
代点菜信息包含：桌号 序号 菜品名称 份额 分数
代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。
程序最后按输入的桌号从小到大的顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。
每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。
折扣的计算方法（注：以下时间段均按闭区间计算）：
周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。
周末全价，营业时间：9:30-21:30
如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"
参考以下类的模板进行设计（本内容与计价程序之前相同，其他类根据需要自行定义）：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish addDish(String dishName,int unit_price)//添加一道菜品信息
}
点菜记录类：保存订单上的一道菜品记录
Record {
int orderNum;//序号
Dish d;//菜品\\
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
delARecordByOrderNum(int orderNum)//根据序号删除一条记录
findRecordByNum(int orderNum)//根据序号查找一条记录
}
本次课题比菜单计价系列-3增加的异常情况：
1、菜谱信息与订单信息混合，应忽略夹在订单信息中的菜谱信息。输出："invalid dish"
2、桌号所带时间格式合法（格式见输入格式部分说明，其中年必须是4位数字，月、日、时、分、秒可以是1位或2位数），数据非法，比如：2023/15/16 ，输出桌号＋" date error"
3、同一桌菜名、份额相同的点菜记录要合并成一条进行计算，否则可能会出现四舍五入的误差。
4、重复删除，重复的删除记录输出"deduplication :"+序号。
5、代点菜时，桌号不存在，输出"Table number ："+被点菜桌号+" does not exist"；本次作业不考虑两桌记录时间不匹配的情况。
6、菜谱信息中出现重复的菜品名，以最后一条记录为准。
7、如果有重复的桌号信息，如果两条信息的时间不在同一时间段，（时段的认定：周一到周五的中午或晚上是同一时段，或者周末时间间隔1小时（不含一小时整，精确到秒）以内算统一时段），此时输出结果按不同的记录分别计价。
8、重复的桌号信息如果两条信息的时间在同一时间段，此时输出结果时合并点菜记录统一计价。前提：两个的桌号信息的时间都在有效时间段以内。计算每一桌总价要先合并符合本条件的饭桌的点菜记录，统一计价输出。
9、份额超出范围（1、2、3）输出：序号+" portion out of range "+份额，份额不能超过1位，否则为非法格式，参照第13条输出。
10、份数超出范围，每桌不超过15份，超出范围输出：序号+" num out of range "+份数。份数必须为数值，最高位不能为0，否则按非法格式参照第16条输出。
11、桌号超出范围[1,55]。输出：桌号 +" table num out of range"，桌号必须为1位或多位数值，最高位不能为0，否则按非法格式参照第16条输出。
12、菜谱信息中菜价超出范围（区间（0,300）），输出：菜品名+" price out of range "+价格，菜价必须为数值，最高位不能为0，否则按非法格式参照第16条输出。
13、时间输入有效但超出范围[2022.1.1-2023.12.31]，输出："not a valid time period"
14、一条点菜记录中若格式正确，但数据出现问题，如：菜名不存在、份额超出范围、份数超出范围，按记录中从左到右的次序优先级由高到低，输出时只提示优先级最高的那个错误。
15、每桌的点菜记录的序号必须按从小到大的顺序排列（可以不连续，也可以不从1开始），未按序排列序号的输出："record serial number sequence error"。当前记录忽略。（代点菜信息的序号除外）
16、所有记录其它非法格式输入，统一输出"wrong format"
17、如果记录以“table”开头，对应记录的格式或者数据不符合桌号的要求，那一桌下面定义的所有信息无论正确或错误均忽略，不做处理。如果记录不是以“table”开头，比如“tab le 55 2023/3/2 12/00/00”，该条记录认为是错误记录，后面所有的信息并入上一桌一起计算。
本次作业比菜单计价系列-3增加的功能：
菜单输入时增加特色菜，特色菜的输入格式：菜品名+英文空格+基础价格+"T"
例如：麻婆豆腐 9 T
菜价的计算方法：
周一至周五 7折， 周末全价。
注意：不同的四舍五入顺序可能会造成误差，请按以下步骤累计一桌菜的菜价：
计算每条记录的菜价：将每份菜的单价按份额进行四舍五入运算后，乘以份数计算多份的价格，然后乘以折扣，再进行四舍五入，得到本条记录的最终支付价格。
最后将所有记录的菜价累加得到整桌菜的价格。
输入格式:
桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数
最后一条记录以“end”结束。
输出格式:
按输入顺序输出每一桌的订单记录处理信息，包括：
1、桌号，格式：table+英文空格+桌号+”:”+英文空格
2、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9 T
table 31 2023/2/1 14/20/00
1 麻婆豆腐 1 16
2 油淋生菜 1 2
2 delete
2 delete
end
输出样例:
在这里给出相应的输出。例如：
table 31:
1 num out of range 16
2 油淋生菜 18
deduplication 2
table 31: 0 0
输入样例1:
份数超出范围+份额超出范围。例如：
麻婆豆腐 12
油淋生菜 9 T
table 31 2023/2/1 14/20/00
1 麻婆豆腐 1 16
2 油淋生菜 4 2
end
输出样例1:
份数超出范围+份额超出范围。例如：
table 31:
1 num out of range 16
2 portion out of range 4
table 31: 0 0
输入样例2:
桌号信息错误。例如：
麻婆豆腐 12
油淋生菜 9 T
table a 2023/3/15 12/00/00
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end
输出样例2:
在这里给出相应的输出。例如：
wrong format
输入样例3:
混合错误：桌号信息格式错误+混合的菜谱信息（菜谱信息忽略）。例如：
麻婆豆腐 12
油淋生菜 9 T
table 55 2023/3/31 12/000/00
麻辣香锅 15
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end
输出样例3:
在这里给出相应的输出。例如：
wrong format
输入样例4:
错误的菜谱记录。例如：
麻婆豆腐 12.0
油淋生菜 9 T
table 55 2023/3/31 12/00/00
麻辣香锅 15
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end
输出样例4:
在这里给出相应的输出。例如：
wrong format
table 55:
invalid dish
麻婆豆腐 does not exist
2 油淋生菜 14
table 55: 14 10
输入样例5:
桌号格式错误（以“table”开头）+订单格式错误（忽略）。例如：
麻婆豆腐 12
油淋生菜 9 T
table a 2023/3/15 12/00/00
1 麻婆 豆腐 1 1
2 油淋生菜 2 1
end
输出样例5:
在这里给出相应的输出。例如：
wrong format
输入样例6:
桌号格式错误，不以“table”开头。例如：
麻婆豆腐 12
油淋生菜 9 T
table 1 2023/3/15 12/00/00
1 麻婆豆腐 1 1
2 油淋生菜 2 1
tab le 2 2023/3/15 12/00/00
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end
输出样例6:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 12
2 油淋生菜 14
wrong format
record serial number sequence error
record serial number sequence error
table 1: 26 17
其他用例请参考公开的测试用例
代码长度限制 50 KB 时间限制 1000 ms 内存限制 64 MBimport java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws ParseException {
Scanner scanner = new Scanner(System.in);
Menu menu = new Menu();
Dish dish = new Dish();
Enter_correction input = new Enter_correction();
Dish[] dishes = new Dish[20];
Order []orders = new Order[20];
Record records = new Record();
int[] num = new int[20];
num[0] = 0;
int i=0;
int j=0;
int n=0;
int m=0;
int s=0;
int d=0;
int y=1;
int x=0;
String line;
while(true) {
line = scanner.nextLine();
String[] part = line.split(" ");
if(line.equals("end"))
break;
lableD:
try {
if(part[1].equals("delete")) {
if(y==1)
break lableD;
m = Integer.parseInt(part[0]);
if(orders[n-1].delARecordByOrderNum(m,orders[n-1].findorderlength())!= null) {
j--;
num[s]=m;
s++;
}
else if(judgedelete(m,num)==1) {
System.out.println("deduplication "+part[0]);
}
else {
System.out.println("delete error;");
}
}
}
catch(ArrayIndexOutOfBoundsException e){
//System.out.println("wrong format");
break lableD;
}
lableC:
try {
if(part[0].matches("([\\u4E00-\\u9FA5]+)")) {
if(n>0) {
System.out.println("invalid dish");
break lableC;
}
if(input.enter_correction(line,2)==false&&input.enter_correction(line,5)==false) {
System.out.println("wrong format");
break lableC;
}
try {
check(Integer.parseInt(part[1]),1);
}
catch(DataException e) {
System.out.println(part[0]+" price out of range "+part[1]);
break lableC;
}
if(dish.getI(dishes,part[0],i)!= -1) {
dishes[dish.getI(dishes,part[0],i)].setUnit_price(Integer.parseInt(part[1]));
}
else {
dish.setName(part[0]);
dish.setUnit_price(Integer.parseInt(part[1]));
if(part.length == 3)
dish.setT(1);
else
dish.setT(0);
dishes[i] = new Dish();
dishes[i].setName(dish.getName());
dishes[i].setUnit_price(dish.getUnit_price());
dishes[i].setT(dish.getT());
menu.setDishes(dishes);
i++;
}
}
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("wrong format");
break lableC;
}
lableB:
try {
if(part[0].equals("table")) {
if(input.enter_correction(line,1)==false) {
System.out.println("wrong format");
y=1;
x=1;
break lableB;
}
if(!isValidDate(part[2])) {
System.out.println(part[1]+" date error");
y=1;
x=1;
break lableB;
}
if(judgetime(part[3],judgedate(part[2]))==0) {
System.out.println("table "+part[1]+" out of opening hours");
y=1;
x=1;
break lableB;
}
try {
inspect(part[2]);
}
catch(DateException e) {
System.out.println("not a valid time period");
y=1;
x=1;
break lableB;
}
try {
check(Integer.parseInt(part[1]),2);
}
catch(DataException e) {
System.out.println(part[1]+" table num out of range");
y=1;
x=1;
break lableB;
}
y=0;
x=0;
orders[n] = new Order();
orders[n].space( orders[n].records);
orders[n].table = new Table();
orders[n].table.setTablenum(Integer.parseInt(part[1]));
orders[n].table.setDate(part[2]);
orders[n].table.setTime(part[3]);
System.out.println("table "+orders[n].table.getTablenum()+": ");
n++;
j=0;
d=0;
}
else if(line.matches("\\d+\\s[\\u4e00-\\u9fa5]+\\s\\d+\\s\\d+")) {
if(y==1)
break lableB;
if(input.enter_correction(line,3)==false) {
System.out.println("wrong format");
break lableB;
}
if(menu.searthDish(part[1],i)!= null) {
records.setD(menu.searthDish(part[1],i));
}
else {
System.out.println(part[1]+" does not exist");
break lableB;
}
try {
check(Integer.parseInt(part[2]),3);
}
catch(DataException e) {
System.out.println(part[0]+" portion out of range "+part[2]);
break lableB;
}
try {
check(Integer.parseInt(part[3]),4);
}
catch(DataException e) {
System.out.println(part[0]+" num out of range "+part[3]);
break lableB;
}
if(Integer.parseInt(part[0])<=d) {
System.out.println("record serial number sequence error");
break lableB;
}
records.setOrderNum(Integer.parseInt(part[0]));
d=Integer.parseInt(part[0]);
records.setPortion(Integer.parseInt(part[2]));
records.setNum(Integer.parseInt(part[3]));
orders[n-1].records[j] = new Record();
orders[n-1].records[j].setOrderNum(records.getOrderNum());
orders[n-1].records[j].setD(records.getD());
orders[n-1].records[j].setPortion(records.getPortion());
orders[n-1].records[j].setNum(records.getNum());
System.out.println(orders[n-1].records[j].getOrderNum()+" "+orders[n-1].records[j].getD().getName()+" "+orders[n-1].records[j].getPrice());
j++;
}
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("wrong format");
break lableB;
}
lableA:
try {
if(line.matches("\\d+\\s\\d+\\s[\\u4e00-\\u9fa5]+\\s\\d+\\s\\d+")) {
if(y==1)
break lableA;
if(input.enter_correction(line,4)==false) {
System.out.println("wrong format");
break lableA;
}
if(judgetablenum(Integer.parseInt(part[0]),orders)==1||Integer.parseInt(part[0])==orders[n-1].table.getTablenum()) {
System.out.println("Table number ："+part[0]+" does not exist");
break lableA;
}
if(menu.searthDish(part[2],i)!= null) {
records.setD(menu.searthDish(part[2],i));
}
else {
System.out.println(part[2]+" does not exist");
break lableA;
}
try {
check(Integer.parseInt(part[3]),3);
}
catch(DataException e) {
System.out.println(part[0]+" portion out of range "+part[2]);
break lableA;
}
try {
check(Integer.parseInt(part[4]),4);
}
catch(DataException e) {
System.out.println(part[0]+" num out of range "+part[3]);
break lableA;
}
records.setOrderNum(Integer.parseInt(part[1]));
records.setPortion(Integer.parseInt(part[3]));
records.setNum(Integer.parseInt(part[4]));
if(j==0) {
orders[n-1] = new Order();
orders[n-1].space( orders[n-1].records);
}
orders[n-1].records[j] = new Record();
orders[n-1].records[j].setOrderNum(records.getOrderNum());
orders[n-1].records[j].setD(records.getD());
orders[n-1].records[j].setPortion(records.getPortion());
orders[n-1].records[j].setNum(records.getNum());
System.out.println(part[1]+" table "+orders[n-1].table.getTablenum()+" pay for table "+part[0]+" "+orders[n-1].records[j].getPrice());
j++;
}
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("wrong format");
break lableA;
}
if(judgeline(line)==1) {
if(x==0)
System.out.println("wrong format");
}
}
if(n>1&&judgeistime(orders)==1) {
for(int e=0;e<orders[0].findorderlength();e++) {
for(int k=0;k<orders[1].findorderlength();k++) {
if(orders[0].records[e].getD().getName()==orders[1].records[k].getD().getName()
&&orders[0].records[e].getPortion()==orders[1].records[k].getPortion()) {
orders[0].records[e].setNum(orders[0].records[e].getNum()+orders[1].records[k].getNum());
}
}
}
orders[0].getTotalPrice(orders[0].findorderlength(),judgetime(orders[0].table.getTime(),judgedate(orders[0].table.getDate())));
return;
}
else {
for(int t=0;t<n;t++) {
orders[t].getTotalPrice(orders[t].findorderlength(),judgetime(orders[t].table.getTime(),judgedate(orders[t].table.getDate())));
if(t<n-1) {
System.out.print("\n");
}
}
}
}
public static int judgedate(String dateStr) throws ParseException {//判断日期是周几
String inputdate = dateStr;
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
Date inputDate;
inputDate = dateFormat.parse(inputdate);
Calendar calendar = Calendar.getInstance();
calendar.setTime(inputDate);
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK)-1;
if(dayOfWeek==0)
dayOfWeek=7;
return dayOfWeek;
}
public static int judgetime(String timeStr,int dayOfWeek) {//判断时间是上午还是下午还是晚上
String[] time = timeStr.split("/");
int hour = Integer.parseInt(time[0]);
int minutes = Integer.parseInt(time[1]);
if(dayOfWeek>=1&&dayOfWeek<=5) {
if((hour == 17 && minutes >= 0 && minutes <= 59) ||
(hour > 17 && hour < 20) ||
(hour == 20 && minutes >= 0 && minutes <= 30)){
return 1;
}
else if((hour == 10 && minutes >= 30 && minutes <= 59) ||
(hour > 10 && hour < 14) ||
(hour == 14 && minutes >= 0 && minutes <= 30)){
return 2;
}
else
return 0;
}
else {
if((hour == 9 && minutes >= 30 && minutes <= 59) ||
(hour > 9 && hour < 21) ||
(hour == 21 && minutes >= 0 && minutes <= 30)) {
return 3;
}
else
return 0;
}
}
public static void check(int n,int m)throws DataException{
if(!(n>0&&n<300)&&(m==1))
throw new DataException();
else if(!(n>0&&n<56)&&(m==2))
throw new DataException();
else if(!(n>0&&n<4)&&(m==3))
throw new DataException();
else if(!(n<=15)&&(m==4))
throw new DataException();
}
public static int judgedelete(int m,int num[]) {
for(int i=0;i<num.length;i++) {
if(num[i]==m) {
return 1;
}
}
return 0;
}
public static int judgetablenum(int m,Order orders[]) {
int i=0;
while(orders[i] != null) {
if(orders[i].table.getTablenum()==m) {
return 0;
}
i++;
}
return 1;
}
public static int judgeline(String line) {
String[] part = line.split(" ");
try {
if(!part[1].equals("delete")&&!part[0].matches("([\\u4E00-\\u9FA5]+)")&&!part[0].equals("table")&&!line.matches("\\d+\\s[\\u4e00-\\u9fa5]+\\s\\d+\\s\\d+")&&!line.matches("\\d+\\s\\d+\\s[\\u4e00-\\u9fa5]+\\s\\d+\\s\\d+"))
return 1;
else
return 0;}
catch(ArrayIndexOutOfBoundsException e) {
return 1;
}
}
public static int judgeistime(Order orders[]) throws ParseException {
int date1=judgedate(orders[0].table.getDate());
int date2=judgedate(orders[1].table.getDate());
int time1=judgetime(orders[0].table.getTime(),date1);
int time2=judgetime(orders[1].table.getTime(),date2);
int gap=0;
String t1 = orders[0].table.getTime();
String t2 = orders[1].table.getTime();
SimpleDateFormat format = new SimpleDateFormat("HH/mm/ss");
try {
Date d1 = format.parse(t1);
Date d2 = format.parse(t2);
long duration = d2.getTime() - d1.getTime();
if(duration<0)
duration = d1.getTime() - d2.getTime();
long hours = duration / (60 * 60 * 1000);
long minutes = (duration % (60 * 60 * 1000)) / (60 * 1000);
long seconds = ((duration % (60 * 60 * 1000)) % (60 * 1000)) / 1000;
gap=(int)(hours*3600+minutes*60+seconds);
} catch (ParseException e) {
e.printStackTrace();
}
if(orders[0].table.getDate().equals(orders[1].table.getDate())) {
if(date1==date2&&time1==time2&&time1==3&&(gap>0&&gap<3600)) {
return 1;
}
if(date1==date2&&time1==time2&&time1!=3) {
return 1;
}
}
return 0;
}
public static void inspect(String inputdate)throws DateException{
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
Date inputDate;
try {
inputDate = dateFormat.parse(inputdate);
Date startTime = dateFormat.parse("2022/1/1");
Date endTime = dateFormat.parse("2023/12/31");
if (inputDate.before(startTime) || inputDate.after(endTime)) {
throw new DateException();
}
} catch (ParseException e) {
return;
}
}
public static boolean isValidDate(String dateStr) {//判断日期是否合法
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
dateFormat.setLenient(false);
try {
dateFormat.parse(dateStr);
return true;
} catch (ParseException e) {
return false;
}
}
}
class Dish{//菜品类:对应菜谱上一道菜的名称
private String name;//菜品名称
private int unit_price;//单价
private int t;//是否是特色菜
public Dish(String name,int unit_price,int t){//构造器
this.name = name;
this.unit_price = unit_price;
this.t = t;
}
public Dish(){
}
public void setName(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setUnit_price(int unit_price){
this.unit_price = unit_price;
}
public int getUnit_price() {
return unit_price;
}
public void setT(int t){
this.t = t;
}
public int getT() {
return t;
}
public int getPrice(int n){//计算菜品价格的方法
double []portion = new double[3];
portion[0] = 1;
portion[1] = 1.5;
portion[2] = 2;
return Math.round((float)(unit_price*portion[n-1]));
}
public int getI(Dish dishes[],String part,int num){//找到菜单中重复菜名的下标
if(num==0)
return -1;
for(int i=0;;i++) {
if(dishes[i].getName().equals(part))
return i;
else if(i==num-1)
return -1;
}
}
}
class Menu {//菜单类：对应菜谱，包含饭店提供的所有菜的信息。
Dish[] dishes;//菜品数组，保存所有菜品信息
public Menu(Dish[] dishes){//构造器
this.dishes = new Dish[20];
}
public Menu(){
}
public void setDishes(Dish[] dishes) {
this.dishes = dishes;
}
public Dish searthDish(String dishName,int i){
int n=0;
while(n<i)
{
if(dishes[n].getName().equals(dishName))
return dishes[n];
n++;
}
return null;
}
public Dish[] addDish(String dishName,int unit_price){//添加一道菜品信息
int i=0;
while(true)
{
if(dishes[i].getName()== null) {
dishes[i].setName(dishName);
dishes[i].setUnit_price(unit_price);
return dishes;}
i++;
}
}
}
class Record {//记录类：保存订单上的一道菜品记录
private Integer orderNum;//序号
private Dish d;//菜品
private int portion;//份额（1/2/3代表小/中/大份）
private int num;//份数
public Record(){
}
public Record(Integer orderNum,Dish d,int portion,int num) {
this.orderNum = orderNum;
this.d = d;
this.portion = portion;
this.num = num;
}
public Integer getOrderNum() {
return orderNum;
}
public void setOrderNum(Integer 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 void setNum(int num) {
this.num = num;
}
public int getPrice(){//计价
return d.getPrice(portion)*num;
}
}
class Order {//订单类：保存用户点的所有菜的信息
Record[] records;//保存订单上每一道的记录
Table table;//桌号
public Order() {
}
public void space(Record[] records) {
this.records = new Record[20];
}
public void setRecords(Record[] records) {
this.records = records;
}
public void getTotalPrice(int n,int discount){//计算订单的总价
int i = 0;
int j = 0;
int init_totalprice = 0;
int ulti_totalprice = 0;
int price=0;
while(i<n) {
init_totalprice = init_totalprice+records[i].getPrice();
i++;
}
while(j<n) {
if(discount==1&&records[j].getD().getT()==0) {
price=Math.round((float)(records[j].getPrice()*0.8));
}
else if(discount==1&&records[j].getD().getT()==1) {
price=Math.round((float)(records[j].getPrice()*0.7));
}
else if(discount==2&&records[j].getD().getT()==0) {
price=Math.round((float)(records[j].getPrice()*0.6));
}
else if(discount==2&&records[j].getD().getT()==1) {
price=Math.round((float)(records[j].getPrice()*0.7));
}
else if(discount==3) {
price=records[j].getPrice();
}
ulti_totalprice = ulti_totalprice+price;
j++;
}
System.out.print("table "+table.getTablenum()+": "+init_totalprice+" "+ulti_totalprice);
}
public Record[] delARecordByOrderNum(Integer orderNum,int n){//根据序号删除一条记录
if(n==0)
return null;
int t=n;
for(int i=0;i<n;i++)
{
if(records[i].getOrderNum()== orderNum) {
for(int j=i;;j++) {
if(j == t-1) {
records[j] = null;
t--;
i=0;
return records;
}
else {
records[j].setOrderNum(records[j+1].getOrderNum());
records[j].setD(records[j+1].getD());
records[j].setPortion(records[j+1].getPortion());
records[j].setNum(records[j+1].getNum());
}
}
}
if(t==n&&i==n-1)
return null;
}
return records;
}
public Record[] addARecord(Integer orderNum,Dish D,int portion,int num){//添加一条菜品信息到订单中
int t=findorderlength();
records[t] = new Record();
records[t].setOrderNum(orderNum);
records[t].setD(D);
records[t].setPortion(portion);
records[t].setNum(num);
return records;
}
public void findRecordByNum(Integer orderNum){//根据序号查找一条记录
int i =0;
while(records[i].getOrderNum()!= null) {
if(records[i].getOrderNum()== orderNum) {
System.out.println(records[i].getOrderNum()+" "+records[i].getD().getName()+" "+records[i].getPortion()+" "+records[i].getNum());
}
}
}
public int findorderlength() {
int i=0;
while(records[i] != null) {
i++;
}
return i;
}
}
class Table{//桌号类
private int tablenum;//桌号
private String date;//年月日
private String time;//时分秒
public Table(int tablenum,String date,String time){//构造器
this.tablenum = tablenum;
this.date = date;
this.time = time;
}
public Table(){
}
public int getTablenum() {
return tablenum;
}
public void setTablenum(int 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;
}
}
class Enter_correction{//输入校正类
public Boolean enter_correction(String line,int n) {
if(n==1)
return line.matches("table\\s[1-9]\\d*\\s\\d{4}/\\d{1,2}/\\d{1,2}\\s\\d{1,2}/\\d{1,2}/\\d{1,2}");
else if(n==2)
return line.matches("[\\u4e00-\\u9fa5]+ [1-9]\\d*");
else if(n==3)
return line.matches("[1-9]\\d*\\s[\\u4e00-\\u9fa5a-zA-Z]++\\s[1-9]\\s[1-9]\\d*");
else if(n==4)
return line.matches("[1-9]\\d*\\s\\d+\\s[\\u4e00-\\u9fa5]+\\s\\d+\\s\\d+");
else if(n==5)
return line.matches("[\\u4e00-\\u9fa5]+ [1-9]\\d* T");
else
return true;
}
}
class DataException extends Exception{
}
class DateException extends Exception{
}
题目难度偏难，题量也偏大，其主要是在菜单三的基础上进行了迭代，最为重要的是正确地使用正则表达式排除输出数据异常，其次是使用try-catch语句进行捕获异常，处理异常。
第六次PTA作业集
7-1 菜单计价程序-5 分数 100 作者 蔡轲 单位 南昌航空大学本题在菜单计价程序-3的基础上增加了部分内容，增加的内容用加粗字体标识。
注意不是菜单计价程序-4，本题和菜单计价程序-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)//根据序号查找一条记录
}
### 输入格式:
桌号标识格式：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、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名
如果删除记录的序号不存在，则输出“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
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws ParseException {
Scanner scanner = new Scanner(System.in);
Menu menu = new Menu();
Dish dish = new Dish();
Enter_correction input = new Enter_correction();
Dish[] dishes = new Dish[20];
T[] Specialties = new T[20];
Order []orders = new Order[20];
Customer []customer = new Customer[20];
Record records = new Record();
int[] num = new int[20];
num[0] = 0;
int i=0;
int j=0;
int n=0;
int m=0;
int s=0;
int y=1;
int x=0;
int a=-1;
int b=0;
int c=0;
int d=0;
String line;
while(true) {
line = scanner.nextLine();
String[] part = line.split(" ");
if(line.equals("end"))
break;
lableD:
if(part[1].equals("delete")) {
if(y==1)
break lableD;
m = Integer.parseInt(part[0]);
if(orders[n-1].delARecordByOrderNum(m,orders[n-1].findorderlength())!= null) {
j--;
num[s]=m;
s++;
}
else {
System.out.println("delete error;");
}
}
lableC:
if(part[0].matches("([\\u4E00-\\u9FA5]+)")) {
if(input.enter_correction(line,2)==false&&input.enter_correction(line,5)==false) {
System.out.println("wrong format");
break lableC;
}
if(dish.getI(dishes,part[0],i)!= -1) {
dishes[dish.getI(dishes,part[0],i)].setUnit_price(Integer.parseInt(part[2]));
}
else {
if(part.length == 4) {
dish.setName(part[0]);
dish.setUnit_price(Integer.parseInt(part[2]));
Specialties[i] = new T();
Specialties[i].setIs(1);
Specialties[i].setType(part[1]);
dish.setT(Specialties[i]);
}
else {
dish.setName(part[0]);
dish.setUnit_price(Integer.parseInt(part[1]));
Specialties[i] = new T();
Specialties[i].setIs(0);
Specialties[i].setType("无");
dish.setT(Specialties[i]);
}
dishes[i] = new Dish();
dishes[i].setName(dish.getName());
dishes[i].setUnit_price(dish.getUnit_price());
dishes[i].setT(dish.getT());
menu.setDishes(dishes);
i++;
}
}
lableB:
if(part[0].equals("table")) {
if(input.enter_correction(line,1)==false) {
System.out.println("wrong format");
y=1;
x=1;
break lableB;
}
if(judgetime(part[6],judgedate(part[5]))==0) {
System.out.println("table "+part[1]+" out of opening hours");
y=1;
x=1;
break lableB;
}
y=0;
x=0;
orders[n] = new Order();
orders[n].space( orders[n].records);
orders[n].table = new Table();
orders[n].table.setTablenum(Integer.parseInt(part[1]));
orders[n].table.setCustomer(part[3]);
orders[n].table.setPhonenum(part[4]);
orders[n].table.setDate(part[5]);
orders[n].table.setTime(part[6]);
System.out.println("table "+orders[n].table.getTablenum()+": ");
n++;
j=0;
}
else if(part[0].matches("\\d+")&&part[1].matches("[\\u4e00-\\u9fa5]+")){
if(y==1)
break lableB;
if(menu.searthDish(part[1],i)!= null) {
records.setD(menu.searthDish(part[1],i));
a=menu.searthDish(part[1],i).getT().getIs();
}
else {
System.out.println(part[1]+" does not exist");
break lableB;
}
try {
check(Integer.parseInt(part[2]),menu.searthDish(part[1],i).getT().getType());
}
catch(DataException e) {
if(menu.searthDish(part[1],i).getT().getType().equals("川菜"))
System.out.println("spicy num out of range :"+part[2]);
else if(menu.searthDish(part[1],i).getT().getType().equals("晋菜"))
System.out.println("acidity num out of range :"+part[2]);
else if(menu.searthDish(part[1],i).getT().getType().equals("浙菜"))
System.out.println("sweetness num out of range :"+part[2]);
break lableB;
}
records.setOrderNum(Integer.parseInt(part[0]));
if(a==0) {
records.setDegree(null);
records.setPortion(Integer.parseInt(part[2]));
records.setNum(Integer.parseInt(part[3]));
}
else if(a==1) {
records.setDegree(Integer.parseInt(part[2]));
records.setPortion(Integer.parseInt(part[3]));
records.setNum(Integer.parseInt(part[4]));
}
orders[n-1].records[j] = new Record();
orders[n-1].records[j].setOrderNum(records.getOrderNum());
orders[n-1].records[j].setD(records.getD());
orders[n-1].records[j].setDegree(records.getDegree());
orders[n-1].records[j].setPortion(records.getPortion());
orders[n-1].records[j].setNum(records.getNum());
System.out.println(orders[n-1].records[j].getOrderNum()+" "+orders[n-1].records[j].getD().getName()+" "+orders[n-1].records[j].getPrice());
j++;
}
lableA:
if(line.matches("\\d+\\s\\d+\\s[\\u4e00-\\u9fa5]+\\s\\d+\\s\\d+\\s\\d+")) {
if(y==1)
break lableA;
if(menu.searthDish(part[2],i)!= null) {
records.setD(menu.searthDish(part[2],i));
a=menu.searthDish(part[2],i).getT().getIs();
}
else {
System.out.println(part[2]+" does not exist");
break lableA;
}
records.setOrderNum(Integer.parseInt(part[1]));
if(a==0) {
records.setDegree(null);
records.setPortion(Integer.parseInt(part[3]));
records.setNum(Integer.parseInt(part[4]));
}
else if(a==1) {
records.setDegree(Integer.parseInt(part[3]));
records.setPortion(Integer.parseInt(part[4]));
records.setNum(Integer.parseInt(part[5]));
}
orders[n-1].records[j] = new Record();
orders[n-1].records[j].setOrderNum(records.getOrderNum());
orders[n-1].records[j].setD(records.getD());
orders[n-1].records[j].setDegree(-1);
orders[n-1].records[j].setPortion(records.getPortion());
orders[n-1].records[j].setNum(records.getNum());
System.out.println(part[1]+" table "+orders[n-1].table.getTablenum()+" pay for table "+part[0]+" "+orders[n-1].records[j].getPrice());
j++;
c=Integer.parseInt(part[0]);
d= Ts(orders,c).findorderlength();
Ts(orders,c).records[d] = new Record();
Ts(orders,c).records[d].setOrderNum(records.getOrderNum());
Ts(orders,c).records[d].setD(records.getD());
Ts(orders,c).records[d].setDegree(records.getDegree());
Ts(orders,c).records[d].setPortion(0);
Ts(orders,c).records[d].setNum(records.getNum());
}
if(judgeline(line)==1) {
if(x==0)
System.out.println("wrong format");
}
}
for(int t=0;t<n;t++) {
orders[t].getTotalPrice(orders[t].findorderlength(),judgetime(orders[t].table.getTime(),judgedate(orders[t].table.getDate())));
orders[t].computing();
orders[t].show(customer,orders[t].getultiprice(orders[t].findorderlength(),judgetime(orders[t].table.getTime(),judgedate(orders[t].table.getDate()))));
if(t<n-1) {
System.out.print("\n");
}
}
if(y!=1)
System.out.print("\n");
sort(customer);
while(customer[b]!= null){
System.out.print(customer[b].getName()+" "+customer[b].getTelphone()+" "+customer[b].getPrice());
if(customer[b+1]!= null) {
System.out.print("\n");
}
b++;
}
}
public static Order Ts(Order[] order,int n) {
int i=0;
while(order[i]!=null) {
if(order[i].table.getTablenum()==n)
return order[i];
i++;
}
return null;
}
public static void check(int n,String type)throws DataException{
if(!(n>=0&&n<=5)&&(type.equals("川菜")))
throw new DataException();
else if(!(n>=0&&n<=4)&&(type.equals("晋菜")))
throw new DataException();
else if(!(n>=0&&n<=3)&&(type.equals("浙菜")))
throw new DataException();
}
public static Customer[] sort(Customer[] customer) {//根据首字母排序
int t=0;
Customer role = new Customer();
while(customer[t]!=null) {
t++;
}
for(int i=0;i<t;i++) {
for(int j=i+1;j<t;j++) {
if(customer[i].getName().compareToIgnoreCase(customer[j].getName())>0) {
role.setName(customer[i].getName());
role.setTelphone(customer[i].getTelphone());
role.setPrice(customer[i].getPrice());
customer[i].setName(customer[j].getName());
customer[i].setTelphone(customer[j].getTelphone());
customer[i].setPrice(customer[j].getPrice());
customer[j].setName(role.getName());
customer[j].setTelphone(role.getTelphone());
customer[j].setPrice(role.getPrice());
}
}
}
return customer;
}
public static int judgedate(String dateStr) throws ParseException {//判断日期是周几
String inputdate = dateStr;
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
Date inputDate;
inputDate = dateFormat.parse(inputdate);
Calendar calendar = Calendar.getInstance();
calendar.setTime(inputDate);
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK)-1;
if(dayOfWeek==0)
dayOfWeek=7;
return dayOfWeek;
}
public static int judgetime(String timeStr,int dayOfWeek) {//判断时间是上午还是下午还是晚上
String[] time = timeStr.split("/");
int hour = Integer.parseInt(time[0]);
int minutes = Integer.parseInt(time[1]);
if(dayOfWeek>=1&&dayOfWeek<=5) {
if((hour == 17 && minutes >= 0 && minutes <= 59) ||
(hour > 17 && hour < 20) ||
(hour == 20 && minutes >= 0 && minutes <= 30)){
return 1;
}
else if((hour == 10 && minutes >= 30 && minutes <= 59) ||
(hour > 10 && hour < 14) ||
(hour == 14 && minutes >= 0 && minutes <= 30)){
return 2;
}
else
return 0;
}
else {
if((hour == 9 && minutes >= 30 && minutes <= 59) ||
(hour > 9 && hour < 21) ||
(hour == 21 && minutes >= 0 && minutes <= 30)) {
return 3;
}
else
return 0;
}
}
public static int judgeline(String line) {
String[] part = line.split(" ");
try {
if(!part[1].equals("delete")&&!part[0].matches("([\\u4E00-\\u9FA5]+)")
&&!part[0].equals("table")&&!(part[0].matches("\\d+")&&part[1].matches("[\\u4e00-\\u9fa5]+"))
&&!line.matches("\\d+\\s\\d+\\s[\\u4e00-\\u9fa5]+\\s\\d+\\s\\d+\\s\\d+"))
return 1;
else
return 0;}
catch(ArrayIndexOutOfBoundsException e) {
return 1;
}
}
public static boolean isValidDate(String dateStr) {//判断日期是否合法
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
dateFormat.setLenient(false);
try {
dateFormat.parse(dateStr);
return true;
} catch (ParseException e) {
return false;
}
}
}
class Dish{//菜品类:对应菜谱上一道菜的名称
private String name;//菜品名称
private int unit_price;//单价
private T t;//是否是特色菜
public Dish(String name,int unit_price,T t){//构造器
this.name = name;
this.unit_price = unit_price;
this.t = t;
}
public Dish(){
}
public void setName(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setUnit_price(int unit_price){
this.unit_price = unit_price;
}
public int getUnit_price() {
return unit_price;
}
public void setT(T t){
this.t = t;
}
public T getT() {
return t;
}
public int getPrice(int n){//计算菜品价格的方法
double []portion = new double[3];
portion[0] = 1;
portion[1] = 1.5;
portion[2] = 2;
return Math.round((float)(unit_price*portion[n-1]));
}
public int getI(Dish dishes[],String part,int num){//找到菜单中重复菜名的下标
if(num==0)
return -1;
for(int i=0;;i++) {
if(dishes[i].getName().equals(part))
return i;
else if(i==num-1)
return -1;
}
}
}
class Menu {//菜单类：对应菜谱，包含饭店提供的所有菜的信息。
Dish[] dishes;//菜品数组，保存所有菜品信息
public Menu(Dish[] dishes){//构造器
this.dishes = new Dish[20];
}
public Menu(){
}
public void setDishes(Dish[] dishes) {
this.dishes = dishes;
}
public Dish searthDish(String dishName,int i){
int n=0;
while(n<i)
{
if(dishes[n].getName().equals(dishName))
return dishes[n];
n++;
}
return null;
}
public Dish[] addDish(String dishName,int unit_price){//添加一道菜品信息
int i=0;
while(true)
{
if(dishes[i].getName()== null) {
dishes[i].setName(dishName);
dishes[i].setUnit_price(unit_price);
return dishes;}
i++;
}
}
}
class Record {//记录类：保存订单上的一道菜品记录
private Integer orderNum;//序号
private Dish d;//菜品
private Integer degree;//口味度值
private int portion;//份额（1/2/3代表小/中/大份）
private int num;//份数
public Record(){
}
public Record(Integer orderNum,Dish d,Integer degree,int portion,int num) {
this.orderNum = orderNum;
this.d = d;
this.degree = degree;
this.portion = portion;
this.num = num;
}
public Integer getDegree() {
return degree;
}
public void setDegree(Integer degree) {
this.degree = degree;
}
public Integer getOrderNum() {
return orderNum;
}
public void setOrderNum(Integer 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 void setNum(int num) {
this.num = num;
}
public int getPrice(){//计价
if(portion==0) {
return 0;
}
else
return d.getPrice(portion)*num;
}
}
class Order {//订单类：保存用户点的所有菜的信息
Record[] records;//保存订单上每一道的记录
Table table;//桌号
public Order() {
}
public void space(Record[] records) {
this.records = new Record[20];
}
public void setRecords(Record[] records) {
this.records = records;
}
public void getTotalPrice(int n,int discount){//计算订单的总价
int i = 0;
int j = 0;
int init_totalprice = 0;
int ulti_totalprice = 0;
int price=0;
while(i<n) {
init_totalprice = init_totalprice+records[i].getPrice();
i++;
}
while(j<n) {
if(discount==1&&records[j].getD().getT().getIs()==0) {
price=Math.round((float)(records[j].getPrice()*0.8));
}
else if(discount==1&&records[j].getD().getT().getIs()==1) {
price=Math.round((float)(records[j].getPrice()*0.7));
}
else if(discount==2&&records[j].getD().getT().getIs()==0) {
price=Math.round((float)(records[j].getPrice()*0.6));
}
else if(discount==2&&records[j].getD().getT().getIs()==1) {
price=Math.round((float)(records[j].getPrice()*0.7));
}
else if(discount==3) {
price=records[j].getPrice();
}
ulti_totalprice = ulti_totalprice+price;
j++;
}
System.out.print("table "+table.getTablenum()+": "+init_totalprice+" "+ulti_totalprice+" ");
}
public int getultiprice(int n,int discount){//计算订单
int j = 0;
int ulti_totalprice = 0;
int price=0;
while(j<n) {
if(discount==1&&records[j].getD().getT().getIs()==0) {
price=Math.round((float)(records[j].getPrice()*0.8));
}
else if(discount==1&&records[j].getD().getT().getIs()==1) {
price=Math.round((float)(records[j].getPrice()*0.7));
}
else if(discount==2&&records[j].getD().getT().getIs()==0) {
price=Math.round((float)(records[j].getPrice()*0.6));
}
else if(discount==2&&records[j].getD().getT().getIs()==1) {
price=Math.round((float)(records[j].getPrice()*0.7));
}
else if(discount==3) {
price=records[j].getPrice();
}
ulti_totalprice = ulti_totalprice+price;
j++;
}
return ulti_totalprice;
}
public Record[] delARecordByOrderNum(Integer orderNum,int n){//根据序号删除一条记录
if(n==0)
return null;
int t=n;
for(int i=0;i<n;i++)
{
if(records[i].getOrderNum()== orderNum) {
for(int j=i;;j++) {
if(j == t-1) {
records[j] = null;
t--;
i=0;
return records;
}
else {
records[j].setOrderNum(records[j+1].getOrderNum());
records[j].setD(records[j+1].getD());
records[j].setPortion(records[j+1].getPortion());
records[j].setNum(records[j+1].getNum());
}
}
}
if(t==n&&i==n-1)
return null;
}
return records;
}
public Record[] addARecord(Integer orderNum,Dish D,int portion,int num){//添加一条菜品信息到订单中
int t=findorderlength();
records[t] = new Record();
records[t].setOrderNum(orderNum);
records[t].setD(D);
records[t].setPortion(portion);
records[t].setNum(num);
return records;
}
public void findRecordByNum(Integer orderNum){//根据序号查找一条记录
int i =0;
while(records[i].getOrderNum()!= null) {
if(records[i].getOrderNum()== orderNum) {
System.out.println(records[i].getOrderNum()+" "+records[i].getD().getName()+" "+records[i].getPortion()+" "+records[i].getNum());
}
}
}
public int findorderlength() {//查找订单的长度
int i=0;
while(records[i] != null) {
i++;
}
return i;
}
public void computing() {//计算订单的口味度值
int i=0;
int chuan=0;
int jin=0;
int zhe=0;
int a=0;
int b=0;
int c=0;
while(records[i] != null) {
laBleA:
if(records[i].getD().getT().getType().equals("川菜")) {
if(records[i].getDegree()==-1) {
break laBleA;
}
chuan = chuan+records[i].getDegree()*records[i].getNum();
a = a+records[i].getNum();
}
laBleB:
if(records[i].getD().getT().getType().equals("晋菜")) {
if(records[i].getDegree()==-1) {
break laBleB;
}
jin = jin+records[i].getDegree()*records[i].getNum();
b = b+records[i].getNum();
}
laBleC:
if(records[i].getD().getT().getType().equals("浙菜")) {
if(records[i].getDegree()==-1) {
break laBleC;
}
zhe = zhe+records[i].getDegree()*records[i].getNum();
c = c+records[i].getNum();
}
i++;
}
if(a>0) {
if(Math.round((float)((float)chuan/(float)a))==0) {
System.out.print("川菜"+" "+a+" "+"不辣");
}
else if(Math.round((float)((float)chuan/(float)a))==1) {
System.out.print("川菜"+" "+a+" "+"微辣");
}
else if(Math.round((float)((float)chuan/(float)a))==2) {
System.out.print("川菜"+" "+a+" "+"稍辣");
}
else if(Math.round((float)((float)chuan/(float)a))==3) {
System.out.print("川菜"+" "+a+" "+"辣");
}
else if(Math.round((float)((float)chuan/(float)a))==4) {
System.out.print("川菜"+" "+a+" "+"很辣");
}
else if(Math.round((float)((float)chuan/(float)a))==5) {
System.out.print("川菜"+" "+a+" "+"爆辣");
}
}
if(b>0) {
if(a>0) {
System.out.print(" ");
}
if(Math.round((float)((float)jin/(float)b))==0) {
System.out.print("晋菜"+" "+b+" "+"不酸");
}
else if(Math.round((float)((float)jin/(float)b))==1) {
System.out.print("晋菜"+" "+b+" "+"微酸");
}
else if(Math.round((float)((float)jin/(float)b))==2) {
System.out.print("晋菜"+" "+b+" "+"稍酸");
}
else if(Math.round((float)((float)jin/(float)b))==3) {
System.out.print("晋菜"+" "+b+" "+"酸");
}
else if(Math.round((float)((float)jin/(float)b))==4) {
System.out.print("晋菜"+" "+b+" "+"很酸");
}
}
if(c>0) {
if(a>0||b>0) {
System.out.print(" ");
}
if(Math.round((float)((float)zhe/(float)c))==0) {
System.out.print("浙菜"+" "+c+" "+"不甜");
}
else if(Math.round((float)((float)zhe/(float)c))==1) {
System.out.print("浙菜"+" "+c+" "+"微甜");
}
else if(Math.round((float)((float)zhe/(float)c))==2) {
System.out.print("浙菜"+" "+c+" "+"稍甜");
}
else if(Math.round((float)((float)zhe/(float)c))==3) {
System.out.print("浙菜"+" "+c+" "+"甜");
}
}
}
public Customer[] show(Customer[] customer,int price) {
int i=0;
while(i<20) {
if(customer[i] == null){
customer[i] = new Customer();
customer[i].setName(table.getCustomer());
customer[i].setTelphone(table.getPhonenum());
customer[i].setPrice(price);
return customer;
}
else if(table.getCustomer().equals(customer[i].getName())) {
customer[i].setPrice(price+customer[i].getPrice());
return customer;
}
i++;
}
return customer;
}
}
class Table{//桌号类
private int tablenum;//桌号
private String customer;//客户姓名
private String phonenum;//客户电话
private String date;//年月日
private String time;//时分秒
public Table(int tablenum,String customer,String phonenum,String date,String time){//构造器
this.tablenum = tablenum;
this.customer = customer;
this.phonenum = phonenum;
this.date = date;
this.time = time;
}
public String getCustomer() {
return customer;
}
public void setCustomer(String customer) {
this.customer = customer;
}
public String getPhonenum() {
return phonenum;
}
public void setPhonenum(String phonenum) {
this.phonenum = phonenum;
}
public Table(){
}
public int getTablenum() {
return tablenum;
}
public void setTablenum(int 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;
}
}
class Enter_correction{//输入校正类
public Boolean enter_correction(String line,int n) {
if(n==1)
return line.matches("table\\s[1-9]\\d*\\s:\\s\\w{1,10}\\s(180|181|189|133|135|136)\\d{8}\\s\\d{4}/\\d{1,2}/\\d{1,2}\\s\\d{1,2}/\\d{1,2}/\\d{1,2}");
else if(n==2)
return line.matches("[\\u4e00-\\u9fa5]+ [1-9]\\d*");
else if(n==3)
return line.matches("[1-9]\\d*\\s[\\u4e00-\\u9fa5a-zA-Z]++\\s[1-9]\\s[1-9]\\d*");
else if(n==4)
return line.matches("[1-9]\\d*\\s\\d+\\s[\\u4e00-\\u9fa5]+\\s\\d+\\s\\d+");
else if(n==5)
return line.matches("[\\u4e00-\\u9fa5]+ [\\u4e00-\\u9fa5]+ [1-9]\\d* T");
else
return true;
}
}
class T{//特色菜类
private int is;//特色菜状态
private String type;//特色菜类型
public T(int is,String type){//构造器
this.is=is;
this.type=type;
}
public int getIs() {
return is;
}
public void setIs(int is) {
this.is = is;
}
public T(){
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
class Customer{//客户类
private String name;
private String telphone;
private int price;
public Customer(String name,String telphone,int price) {
this.name = name;
this.telphone = telphone;
this.price = price;
}
public Customer() {
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTelphone() {
return telphone;
}
public void setTelphone(String telphone) {
this.telphone = telphone;
}
}
class DataException extends Exception{
}
题目难度大，题量大，其和作业集五一样，属于菜单类型题目的不同迭代，其包括少量部分的异常处理，其更注重如何设计类与类之间的关系，还有如何解决类对象数据的存入调用等
期中考试编程题
7-1 测验1-圆类设计 分数 10 作者 段喜龙 单位 南昌航空大学创建一个圆形类（Circle），私有属性为圆的半径，从控制台输入圆的半径，输出圆的面积
输入格式:
输入圆的半径，取值范围为(0,+∞)，输入数据非法，则程序输出Wrong Format，注意：只考虑从控制台输入数值的情况
输出格式:
输出圆的面积（保留两位小数，可以使用String.format(“%.2f”,输出数值）控制精度）
输入样例:
在这里给出一组输入。例如：
2.35
输出样例:
在这里给出相应的输出。例如：
17.35
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Circle circle = new Circle();
circle.setR(input.nextDouble());
if(circle.getR() <= 0)
System.out.print("Wrong Format");
else
circle.jisuan();
}
}
class Circle{
private double r;
public Circle(double r){//构造器
this.r=r;
}
public Circle(){
}
public double getR() {
return r;
}
public void setR(double r) {
this.r = r;
}
public void jisuan() {
//String.format("%.2f",3.14*r*r);
double area = Math.PI * Math.pow(r, 2);
System.out.print(String.format("%.2f",area));
}
}
题目简单，题量不大，唯一难点在于如何用java语言表达Π值
7-2 测验2-类结构设计 分数 10 作者 段喜龙 单位 南昌航空大学
设计一个矩形类，其属性由矩形左上角坐标点（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 input = new Scanner(System.in);
Point point1 = new Point();
Point point2 = new Point();
point1.setX(input.nextDouble());
point1.setY(input.nextDouble());
point2.setX(input.nextDouble());
point2.setY(input.nextDouble());
Rectangle rectangle = new Rectangle();
rectangle.setPoint1(point1);
rectangle.setPoint2(point2);
rectangle.jisuan();
}
}
class Rectangle{
private Point point1;
private Point point2;
public Rectangle(Point point1,Point point2){//构造器
this.point1=point1;
this.point2=point2;
}
public Rectangle(){
}
public Point getPoint1() {
return point1;
}
public void setPoint1(Point point1) {
this.point1 = point1;
}
public Point getPoint2() {
return point2;
}
public void setPoint2(Point point2) {
this.point2 = point2;
}
public void jisuan() {
double width = Math.abs(point2.getX() - point1.getX());
double height = Math.abs(point2.getY() - point1.getY());
double area = (width*height);
System.out.print(String.format("%.2f",area));
}
}
class Point{
private double x;
private double y;
public Point(double x,double y){//构造器
this.x=x;
this.y=y;
}
public Point(){
}
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;
}
}
题目简单，题量不大，主要考察简单的类设计
7-3 测验3-继承与多态 分数 20 作者 段喜龙 单位 南昌航空大学
将测验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.Scanner;
public class Main {
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);
if(radiums<= 0)
System.out.print("Wrong Format");
else
circle.jisuan2();
//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);
rectangle.jisuan1();
//printArea(rectangle);
break;
}
}
public static void printArea(Shape shape) {
}
}
class Shape{
public void jisuan2() {
// TODO Auto-generated method stub
}
}
class Rectangle extends Shape{
private Point point1;
private Point point2;
public Rectangle(Point point1,Point point2){//构造器
this.point1=point1;
this.point2=point2;
}
public Rectangle(){
}
public Point getPoint1() {
return point1;
}
public void setPoint1(Point point1) {
this.point1 = point1;
}
public Point getPoint2() {
return point2;
}
public void setPoint2(Point point2) {
this.point2 = point2;
}
public void jisuan1() {
double width = Math.abs(point2.getX() - point1.getX());
double height = Math.abs(point2.getY() - point1.getY());
double area = (width*height);
System.out.print(String.format("%.2f",area));
}
}
class Circle extends Shape{
private double r;
public Circle(double r){//构造器
this.r=r;
}
public Circle(){
}
public double getR() {
return r;
}
public void setR(double r) {
this.r = r;
}
public void jisuan2() {
double area = Math.PI * Math.pow(r, 2);
System.out.print(String.format("%.2f",area));
}
}
class Point{
private double x;
private double y;
public Point(double x,double y){//构造器
this.x=x;
this.y=y;
}
public Point(){
}
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;
}
}
题目难度中等，题量一般，主要考察了类的封装，继承和多态
7-4 测验4-抽象类与接口 分数 20 作者 段喜龙 单位 南昌航空大学
在测验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.Comparator;
import java.util.Scanner;
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()) + " ");
}
}
}
interface Shape extends Comparable {
double getArea();
}
class Circle implements Shape {
private double r;
public Circle(double r) {
this.r = r;
}
public double getArea() {
return Math.PI * r * r;
}
public int compareTo(Shape other) {
return Double.compare(this.getArea(), other.getArea());
}
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
return 0;
}
}
class Rectangle implements Shape {
private Point point1;
private Point point2;
public Rectangle(Point point1, Point point2) {
this.point1 = point1;
this.point2 = point2;
}
public double getArea() {
double width = Math.abs(point2.getX() - point1.getX());
double height = Math.abs(point2.getY() - point1.getY());
return width * height;
}
public int compareTo(Shape other) {
return Double.compare(this.getArea(), other.getArea());
}
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
return 0;
}
}
class Point {
private double x;
private double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double getX() {
return x;
}
public double getY() {
return y;
}
}
题目难度大，题量一般，主要考察了接口的定义与使用，还考察了动态数组的自定义排序，我没有拿到全分，主要在没有弄清楚动态数组的自定义排序
以上题目的一些类图：
3.踩坑心得 在这第四次，第五次，第六次的pta作业集中，大多数题目都能够快速解决，只有在菜单的后面两次迭代中花费了大量的时间和精力，也不可避免的踩了许多的坑，首先是正则表达式方面，因为不够深切地理解正则表达式的书写规则，因此在排除异常时常常因此浪费了许多的时间；其次是在关联类问题中，如何给类属性是一个类的对象数组赋值卡了许久，最开始因为一些错误的书写，导致每次给对象数组赋值时一个对象改变会导致整个对象数组的值全发生变化，后面才知道是因为封装的问题，导致每次赋给对象数组的都不是确切的值而是一个对象的地址。最后最难的还是类设计方面，这方面常常因为题目的复杂，而无法设计出简单有效的设计。最后是在期中考试题目中，最后一道题中，因为不能熟练地使用接口的定义和调用等浪费了许多的时间，最后又因为对动态数组的自定义排序理解不够深刻因此未能拿到满分。 4.主要困难以及改进建议 我的主要困难是设计不够简单也不够有效，其次是代码能力不强，常常无法快速地敲出正确的代码实现自己的逻辑，最后就是也不太能降低自己代码的复杂度等等。 改进建议是希望后面的pta作业能够更有针对性，如一个知识点一个题目，比如接口类出一道题目等。 5.总结 经过这几次pta实验的学习，我对Java语言的基本语法和面向对象编程有了更深入的了解和掌握。在这几次pta作业集中，我学习了如何使用Java语言实现基本的数据类型、运算符、流程控制语句、数组、字符串和输入输出等功能。同时，我还学习了Java中面向对象的编程思想，掌握了类、对象、继承、多态等概念和使用方法，能够编写简单的面向对象程序。总之，这几次作业集让我对Java语言有了更深入的了解和掌握，也让我对编程有了更深刻的认识和理解。同时也发现了自己的许多的不足和敲代码的不良习惯，希望在后面的学习能够进一步的提升自我实力和改掉不好的代码习惯。 标签：空格,int,BLOG,records,part,table,public From： https://www.cnblogs.com/jiangxisheng1/p/17842616.html