BLOG-1
一、前言
通过前三次题目集，不难看出这是为了让我们逐渐理解和熟悉Java语言的风格而精心设计的题目集。第一次题目集题量较大，但难度并不高，考察的知识点也不多，稍微花些时间便可以拿满分，用心完成可以快速熟悉Java语言的风格；第二次题目集题量不多，但是难度开始上升，这是我们第一次开始接触类，考察我们对类和方法的设计与使用，需要费些功夫方能拿到高分；第三次题目集题量适中，难度有高有低，更像是第一次题目集和第二次题目集的混合升级版，也考察了新的知识点，让我们对面向对象编程的封装性有了更深的理解，还需要我们通过查询Java API文档，了解Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法，了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则，了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法，突出自主学习能力。
二、设计与分析
（1）第一次题目集：
本次题目集难度并不高，本次题目集主要巩固对Java语言基础知识的掌握程度，只列举比较有代表性的一题。
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。
输出格式:
（1）如果输入数据非法，则输出“Wrong Format”；
（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；
（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；
（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；
（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；
（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；
（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。
输入样例1:
在这里给出一组输入。例如：
50 50 50.0
输出样例1:
在这里给出相应的输出。例如：
Equilateral triangle
输入样例2:
在这里给出一组输入。例如：
60.2 60.2 80.56
输出样例2:
在这里给出相应的输出。例如：
Isosceles triangle
输入样例3:
在这里给出一组输入。例如：
0.5 20.5 80
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
1 import java.util.Scanner;
2 public class Main {
3 public static void main(String[] args) {
4 Scanner in = new Scanner(System.in);
5 double a=in.nextDouble();
6 double b=in.nextDouble();
7 double c=in.nextDouble();
8 if(a>=1&&a<=200&&b>=1&&b<=200&&c>=1&&c<=200) {
9 if(a+b>c&&a+c>b&&b+c>a) {
10 if(a==b&&b==c) {
11 System.out.println("Equilateral triangle");
12 } else {
13 if((a==b)||(b==c)|(a==c)) {
14 if((a*a+b*b-c*c<0.1)||(a*a+c*c-b*b<0.1)||(b*b+c*c-a*a<0.1)) {
15 System.out.println("Isosceles right-angled triangle");
16 } else {
17 System.out.println("Isosceles triangle");
18 }
19 } else {
20 if((a*a+b*b-c*c<0.1)||(a*a+c*c-b*b<0.1)||(b*b+c*c-a*a<0.1)) {
21 System.out.println("Right-angled triangle");
22 } else {
23 System.out.println("General triangle");
24 }
25 }
26 }
27 } else {
28 System.out.println("Not a triangle");
29 }
30 } else {
31 System.out.println("Wrong Format");
32 }
33 }
34 }
分析：本题看似较为复杂，但只需要缕清思路、逻辑严谨，不难发现本题并不难。
（2）第二次题目集：
本次题目集相比上次难度上升了许多，尤其是引入了类的概念，类是Java的一大特色，需要着重掌握，菜单计价程序便是本次题目集中的重点。
某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9
设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}
点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}
输入格式:
每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。
输出格式:
订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 2
西红柿炒蛋 3
end
输出样例:
在这里给出相应的输出。例如：
48
输入样例1:
订单中包含不存在的菜品记录。例如：
麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end
输出样例1:
在这里给出相应的输出。例如：
炒脆肚 does not exist
48
代码展示
1 import java.util.*;
2 public class Main{
3 public static void main(String[] args) {
4 Scanner sc = new Scanner(System.in);
5 String dish;
6 String dish1="西红柿炒蛋";
7 String dish2="清炒土豆丝";
8 String dish3="麻婆豆腐";
9 String dish4="油淋生菜";
10 int portion;
11 double p=0,price=0;
12 for (;;) {
13 dish = sc.next();
14 if(!dish.equals("end")){
15 portion = sc.nextInt();
16 if(portion == 1) p =1;
17 if(portion == 2) p =1.5;
18 if(portion == 3) p =2;
19 if (dish.equals(dish1)) price = price + 15 * p;
20 else if (dish.equals(dish2)) price = price + 12 * p;
21 else if (dish.equals(dish3)) price = price + 12 * p;
22 else if (dish.equals(dish4)) price = price + 9 * p;
23 else {
24 System.out.println(dish + " does not exist");
25 }
26 }
27 else
28 break;
29 }
30 double x=price%1;
31 if(x>=0.5) {
32 System.out.println((int)price+1);
33 } else {
34 System.out.println((int)price);
35 }
36 }
37 }
分析：由于当时对类的概念不够了解，使用了较多C语言的编程思路来完成本题，题目本身比较简单，通过Scanner来接收字符串，再用equals方法来对接收的字符串进行比较，通过一些逻辑判断就可以完成本题，虽然同样完成了本题，但有些投机取巧的成分在里面。
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"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
1 import java.util.Scanner;
2 public class Main
3 {
4 public static void main(String[] args)
5 {
6 Scanner input=new Scanner(System.in);
7 String []menu =new String[500];
8 int []price=new int[500];
9 String menuName;
10 int inputPrice;
11 int i=0;
12 String wholeJudge;
13 while(true) {
14 int reption=1;
15 menuName=input.next();
16 if(menuName.equals("1")) {
17 wholeJudge="1";
18 break;
19 }
20 if(menuName.equals("end")) {
21 wholeJudge="0";
22 break;
23 }
24 inputPrice=input.nextInt();
25 for(int k=0;k<i;k++)
26 if(menuName.equals(menu[k])) {
27 price[k]=inputPrice;reption=0;
28 break;
29 }
30 if(reption==1) {
31 menu[i]=menuName;
32 price[i]=inputPrice;
33 i++;
34 }
35 }
36 int everyPrice=0;
37 int totalPrice = 0;
38 int count=0;
39 int []recording=new int[100];
40 int re=0;
41 int judge3=1,judge2=0;
42 String endJudge="";
43 if(wholeJudge.equals("1"))
44 while(!wholeJudge.equals("end")) {
45 everyPrice=0;
46 int flag=0;
47 String order=input.next();
48 if(order.equals("delete")) {
49 if(judge2==1&&judge3==0)
50 wholeJudge = endJudge;
51 int p=Integer.parseInt(wholeJudge);
52
53 if(p<1||p>count||recording[p-1]==0)
54 System.out.println("delete error;");
55 if(p>=1&&p<=count&&recording[p-1]!=0) {
56 totalPrice -= recording[p-1];
57 recording[p-1]=0;
58 }
59 endJudge = input.next();
60 judge3 = 0;
61 if(endJudge.equals("end")) {
62 break;
63 } else {
64 judge2=1;
65 wholeJudge=endJudge;
66 continue;
67 }
68 }
69 else judge3=1;
70 int size1=input.nextInt();
71 int b=input.nextInt();
72 for(int j=0;j<i;j++) {
73 if(order.equals(menu[j])) {
74 flag=1;
75 if(size1==1)everyPrice+=price[j];
76 if(size1==2) {
77 if(price[j]%2==1)
78 everyPrice+=price[j]*1.5+1;
79 else
80 everyPrice+=price[j]*1.5;
81 }
82 if(size1==3)
83 everyPrice+=2*price[j];
84 }
85 }
86
87 if(flag==0) {
88 recording[re++]=0;
89 System.out.println(order+" does not exist");
90 count++;
91 }
92
93 if(flag==1) {
94 everyPrice*=b;
95 totalPrice+=everyPrice;
96 recording[re++]=everyPrice;
97 System.out.println(wholeJudge+" "+order+" "+everyPrice);
98 count++;
99 }
100 wholeJudge=input.next();
101 }
102
103 if(!wholeJudge.equals("0")) {
104 System.out.println(totalPrice);
105 } else {
106 System.out.println("0");
107 }
108 }
109 }
分析：本题仍是基于菜单计价程序-1的原理进行修改，由于没有对类进行设计，所以也使得代码量急剧增大，代码也难以维护，这种方法会使接下来的菜单计价程序-3的难度大大提升，本题更好的解法，还是应该按照题目提示，设计Dish，Menu，Record，Order等类，并设计相对应的方法来判断接收的内容，减少代码的冗余，提高代码复用性。
（3）第三次题目集：
本次题目集的重点与难点还是在于菜单计价程序-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+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
输入格式:
桌号标识格式：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
1 import java.util.Calendar;
2 import java.util.Scanner;
3 public class Main {
4 public static void main(String[] args) {
5 Scanner sc = new Scanner(System.in);
6 Menu mu = new Menu();
7 Table[] tablemes = new Table[10];
8 int j = 0;//菜单数
9 int l = 0;//订单数
10 int k = 0;//代点菜数
11 Dish tt;
12 int cntTable = 0;//桌号
13 int count;
14 String[] temp;
15 int a1,a2,a3,a4,a5;
16 while (true) {
17 String st = sc.nextLine();
18 temp = st.split(" ");
19 if(st.equals("end"))
20 break;
21 count = temp.length;
22 if (count == 2) {//一个空格
23 if (temp[1].equals("delete")) {//第二个为delete
24 a1 = Integer.parseInt(temp[0]);
25 int c = tablemes[cntTable].odt.delARecordByOrderNum(a1);
26 tablemes[cntTable].sum-=c;
27 } else {//菜单添加
28 a2 = Integer.parseInt(temp[1]);
29 mu.dishs[j] = mu.addDish(temp[0], a2);
30 j++;
31 }
32 }
33 else if (count == 4) {//三个空格
34 if (temp[0].equals("table")) {//桌号
35 cntTable++;//跳过0;
36 l = 0;
37 tablemes[cntTable] = new Table();
38 tablemes[cntTable].AheadProcess(st);
39 System.out.println("table " + cntTable + ": ");
40 } else {//增加订单的情况；
41 a3 =Integer.parseInt(temp[0]);
42 a4 = Integer.parseInt(temp[2]);
43 a5=Integer.parseInt(temp[3]);
44 tablemes[cntTable].odt.addARecord(a3, temp[1],a4 , a5);
45 tt = mu.searthDish(temp[1]);
46 if (tt != null) {
47 tablemes[cntTable].odt.records[l].d = tt;
48 int a = tablemes[cntTable].odt.records[l].getPrice();
49 System.out.println(tablemes[cntTable].odt.records[l].orderNum + " " + tt.name + " " +a );
50 tablemes[cntTable].sum +=a;
51 }
52 l++;
53 }
54 } else if (count == 5) {//代点菜
55 a1 = Integer.parseInt(temp[1]);
56 a2 = Integer.parseInt(temp[3]);
57 a3 = Integer.parseInt(temp[4]);
58 tablemes[cntTable].odt.addARecord( a1, temp[2], a2, a3);
59 tt = mu.searthDish(temp[2]);
60 if (tt != null) {
61 tablemes[cntTable].odt.records[l].d.unit_price = tt.unit_price;
62 int b = tablemes[cntTable].odt.records[l].getPrice();
63 System.out.println(temp[1] + " table " + tablemes[cntTable].tableNum + " pay for table " + temp[0] + " " + b);
64 tablemes[cntTable].sum += b;
65 }
66 l++;
67 }
68 }
69 for (int i = 1; i < cntTable + 1; i++) {
70 tablemes[i].Gettottalprice();
71 }
72 }
73 }
74 class Menu {
75 Dish[] dishs = new Dish[10];//菜品数组，保存所有菜品信息
76 int count = 0;
77 Dish searthDish(String dishName){
78 Dish temd = null;
79 for(int i=count-1;i>=0;i--){
80 if(dishName.equals(dishs[i].name)){
81 temd = dishs[i];
82 break;
83 }
84 }
85 if(temd==null){
86 System.out.println(dishName+" does not exist");
87 }
88 return temd;
89 }//根据菜名在菜谱中查找菜品信息，返回Dish对象。
90 Dish addDish(String dishName,int unit_price){
91 Dish dh = new Dish();
92 dh.name = dishName;
93 dh.unit_price = unit_price;
94 count++;
95 return dh;
96 }//添加一道菜品信息
97 }
98 class Dish {
99 String name;//菜品名称
100 int unit_price;//单价
101 int getPrice(int portion) {
102 int peic = 0;
103 if (portion == 1) {
104 peic = unit_price ;
105 } else if (portion == 2) {
106 peic = Math.round((float) (unit_price * 1.5)) ;
107 } else if (portion == 3) {
108 peic = (unit_price * 2) ;
109 }
110 return peic;//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
111 }
112 }
113 class Record {
114 int orderNum;//序号\
115 Dish d = new Dish();//菜品\
116 int num = 0;
117 int portion;//份额（1/2/3代表小/中/大份）\
118 int getPrice(){
119 return d.getPrice(portion)*num;
120 }//计价，计算本条记录的价格\
121 }
122 class Order {
123 Record[] records = new Record[10];//保存订单上每一道的记录
124 int count = 0;//订单数量
125 void addARecord(int orderNum,String dishName,int portion,int num){
126 records[count] = new Record();
127 records[count].d.name = dishName;
128 records[count].orderNum = orderNum;
129 records[count].portion = portion;
130 records[count].num = num;
131 count++;
132 }//添加一条菜品信息到订单中。
133 int delARecordByOrderNum(int orderNum){
134 if(orderNum>count||orderNum<=0){
135 System.out.println("delete error;");
136 return 0;
137 }else {
138 return records[orderNum - 1].getPrice();
139 }
140 }//根据序号删除一条记录
141 }
142 class Table {
143 int tableNum;
144 String tableDtime;
145 int year,month,day,week,hh,mm,ss;
146 int sum = 0;//一桌价格 ；
147 Order odt = new Order();
148 float discnt = -1;
149 void Gettottalprice(){
150 if(discnt>0){
151 sum = Math.round(sum*discnt);
152 System.out.println("table " + tableNum + ": " + sum);
153 }else {
154 System.out.println("table " + tableNum + " out of opening hours");
155 }
156 }
157 void AheadProcess(String tableDtime){
158 this.tableDtime = tableDtime;
159 processTime();
160 discount();
161 }
162 void processTime(){//处理时间
163 String[] temp = tableDtime.split(" ");
164 tableNum = Integer.parseInt(temp[1]);
165 String[] temp1 = temp[2].split("/");
166 String[] temp2 = temp[3].split("/");
167 year = Integer.parseInt(temp1[0]);
168 month = Integer.parseInt(temp1[1]);
169 day = Integer.parseInt(temp1[2]);
170 Calendar c = Calendar.getInstance();
171 c.set(year, (month-1), day);
172 week = c.get(Calendar.DAY_OF_WEEK);
173 if(week==1) {
174 week = 7;
175 } else {
176 week--;
177 }
178 hh = Integer.parseInt(temp2[0]);
179 mm = Integer.parseInt(temp2[1]);
180 ss = Integer.parseInt(temp2[2]);
181 }
182 void discount() {
183 if(week>=1&&week<=5) {
184 if(hh>=17&&hh<20)
185 discnt=0.8F;
186 else if(hh==20&&mm<30)
187 discnt=0.8F;
188 else if(hh==20&&mm==30&&ss==0)
189 discnt=0.8F;
190 else if(hh>=11&&hh<=13||hh==10&&mm>=30)
191 discnt=0.6F;
192 else if(hh==14&&mm<30)
193 discnt=0.6F;
194 else if(hh==14&&mm==30&&ss==0)
195 discnt=0.6F;
196 } else {
197 if(hh>=10&&hh<=20)
198 discnt= 1.0F;
199 else if(hh==9&&mm>=30)
200 discnt= 1.0F;
201 else if(hh==21&&mm<30||hh==21&&mm==30&&ss==0)
202 discnt= 1.0F;
203 }
204 }
205 }
分析：这次题目提交的时候由于前两次没有写类，所以这段代码是后来写的，可惜石粒有限，这题并没有全部没写对，本题需要设计相对应的类与方法，主要逻辑还是需要通过equals()等方法和Scanner获取的字符串比较并将其打包成方法进行引用，通过循环来反复调用，并使用恰当的判断来跳出循环。
三、踩坑心得
1.比较字符串应该使用equals()方法进行比较，如果使用 == 比较的话，比较的其实是这两个字符串的地址值，而不是内容，这是初学者很容易犯的错误，需要注意！
2.运行超时，相信大家在写这题的时候也经常出现这个问题吧，最近在csdn和b站上逛的时候偶然学会了arrayList集合，如果使用arrayList去接收对象数组的话，应该就可以解决这个问题了。
3.数组越界，大家使用for循环时建议使用快捷键来生成，比如想遍历dish数组可以写dish.fori再按tab键可以自动生成一个dish数组长度的for循环，十分便捷，也可以避免输入的值超过数组大小，从而发生数组越界的问题。
四、主要困难以及改进建议
主要困难：
像菜单计价程序这种逐渐升级的问题，每次做完后没有答案可以进行参考，题目过去后便过去了，然而下一次的缺需要依赖上一次的作业，大大加大了完成作业的难度。
改进建议：
建议教师在这种类型的作业结束后能够即使给出答案以供参考，或者在上课时进行讲解，以解答学生的困惑。
五、总结
总的来说，这三次题目集的题目出的相当的不错，有简单的也有有难度的，十分具有引导性和挑战性，通过这几次作业，学会了数组和String的很多方法，例如split,charat,length,equls等，也学会了了解认识了Calendar类和Date类，尤其是通过Java API来查询一些Java自带的方法。关于类的理解还不够透彻，类之间的耦合性比较高。希望教师能对PTA的有难度的练习题可以在课堂上进行讲解。
浙公网安备 33010602011771号