前言：
本篇blog主要分析PTA4和PTA5的两道菜单计价程序和期中考试题目。
实现菜单计价程序是一个常见的编程练习，可以帮助学习者巩固Java语言的基础知识和面向对象编程的概念。下面将介绍涉及的知识点和难度。
1. 知识点：
- 类和对象：程序需要设计菜单类和菜品类，通过创建对象来表示不同的菜单和菜品。
- 数据类型和变量：需要使用不同的数据类型来存储菜单和菜品的信息，如字符串、整数、浮点数等。
- 方法和函数：需要定义方法来实现计价功能，如计算总价、添加菜品、删除菜品等。
- 控制流程：需要使用条件语句和循环语句来实现菜单的选择和操作。
- 输入输出：需要使用输入输出流来获取用户的选择和显示计算结果。
2. 难度：
- 初级难度：实现一个简单的菜单计价程序并不复杂，只需要掌握基本的语法和面向对象的概念即可。
- 中级难度：如果要实现更复杂的功能，如菜单的分类、菜品的多样性等，需要更深入地理解面向对象的设计原则和数据结构的使用。
- 高级难度：如果要实现菜单的持久化存储、多用户管理等功能，需要了解数据库和网络编程等相关知识。
期中考试题目：
1. 创建一个圆形类（Circle），私有属性为圆的半径，从控制台输入圆的半径，输出圆的面积。
这个题目涉及的知识点包括类的创建、属性的定义、从控制台输入、数值判断、面积计算和输出格式控制。难度较低。
2. 设计一个矩形类，其属性由矩形左上角坐标点（x1，y1）及右下角坐标点（x2，y2）组成，其中，坐标点属性包括该坐标点的X轴及Y轴的坐标值（实型数），求得该矩形的面积。
这个题目涉及的知识点包括类的创建、属性的定义、坐标点的表示、面积计算。难度适中。
3. 抽象出Shape父类（抽象类），Circle及Rectangle作为子类。
这个题目涉及的知识点包括抽象类的创建、子类的继承、多态性。难度适中。
4. 重构类设计，实现列表内图形的排序功能（按照图形的面积进行排序）。
这个题目涉及的知识点包括类的设计、排序算法的实现、接口的使用。难度较高。
总结：这四个题目涵盖了面向对象编程的基本知识点，从简单到复杂逐渐增加难度。通过完成这些题目，可以加深对类的定义、属性的使用、方法的实现、继承和多态性的理解，并且锻炼编程能力和解决问题的能力。
以下是逐题分析：
7-1 菜单计价程序-4 分数 100 作者 蔡轲 单位 南昌航空大学 这道题目的难点主要包括以下几个方面： 1. 输入格式的处理：需要正确解析输入的菜单和订单信息，并按照规定的格式进行处理。需要注意处理桌号标识、点菜记录和删除信息、代点菜信息的格式。 2. 菜品价格的计算：根据不同份额的菜品，需要按照规定的计算方法计算价格。需要注意四舍五入的规则。 3. 删除记录的处理：需要正确处理删除记录的情况，如果序号不正确，需要输出相应的错误信息。 4. 代点菜信息的处理：需要正确处理代点菜的情况，将代点菜的价格计算在当前桌上。 5. 折扣计算：根据不同的营业时间和折扣规则，需要正确计算每桌的总价。需要注意时间格式的合法性和营业时间的判断。 6. 异常情况的处理：需要正确处理各种异常情况，如菜谱信息与订单信息混合、桌号时间格式非法、重复删除、代点菜桌号不存在等情况，并输出相应的错误信息。 7. 记录的合并和排序：需要正确合并相同桌号的点菜记录，并按照序号从小到大的顺序排列。需要注意合并时可能出现的四舍五入误差。 8. 输出格式的处理：需要按照要求输出每桌的总价，并保留整数。需要注意输出格式的正确性。 源码： 1 import java.time.DateTimeException;
2 import java.time.Duration;
3 import java.time.LocalDateTime;
4 import java.util.ArrayList;
5 import java.util.Scanner;
6
7 public class Main {
8 public static void main(String[] args) {
9 Menu menu = new Menu();
10 ArrayList<Table> tables = new ArrayList<Table>();
11 Scanner input = new Scanner(System.in);
12 String str1 = new String();
13 int i = 0;
14 int portion = 0, quota = 0;
15 while (true) {// 输入菜单
16 Dish temp = new Dish();
17 int isRepeat = -1;
18 str1 = input.nextLine();
19 if (str1.matches("[\\S]* [1-9][\\d]*")) {
20 String[] token = str1.split(" ");
21 temp.name = token[0];
22 temp.unit_price = Integer.parseInt(token[1]);
23 if (temp.unit_price > 300) {
24 System.out.println(temp.name + " price out of range " + temp.unit_price);
25 continue;
26 }
27 temp.isT = false;
28 isRepeat = menu.searchDish(temp.name);
29 if (isRepeat != -1) {
30 menu.dishs.remove(isRepeat);
31 }
32 menu.dishs.add(temp);
33 } else if (str1.matches("[\\S]* [\\d]* T")) {
34 String[] token = str1.split(" ");
35 temp.name = token[0];
36 temp.unit_price = Integer.parseInt(token[1]);
37 if (temp.unit_price > 300) {
38 System.out.println(temp.name + " price out of range " + temp.unit_price);
39 continue;
40 }
41 temp.isT = true;
42 isRepeat = menu.searchDish(temp.name);
43 if (isRepeat != -1) {
44 menu.dishs.remove(isRepeat);
45 }
46 menu.dishs.add(temp);
47 } else if (str1.equals("end")) {
48 break;
49 } else if (str1.matches("tab.*")) {
50 break;
51 } else {
52 System.out.println("wrong format");
53 continue;
54 }
55 }
56 while (!str1.equals("end")) {
57 Table temp = new Table();
58 boolean isRepeat = false;
59 int repeatNum = 0;
60 if (str1.matches(".*t.*a.*")) {
61 if (str1.matches(
62 "table [1-9][\\d]* [\\d]*/[\\d][\\d]?/[\\d][\\d]? [\\d][\\d]?/[\\d][\\d]?/[\\d][\\d]?")) {
63 String[] token = str1.split(" ");
64 String[] Date = token[2].split("/");
65 String[] Time = token[3].split("/");
66 int[] intDate = new int[3];
67 int[] intTime = new int[3];
68 for (i = 0; i < 3; i++) {
69 intDate[i] = Integer.parseInt(Date[i]);
70 intTime[i] = Integer.parseInt(Time[i]);
71 }
72 temp.num = Integer.parseInt(token[1]);
73 if (temp.num > 55) {
74 System.out.println(temp.num + " table num out of range");
75 str1 = input.nextLine();
76 continue;
77
78 }
79 try {
80 temp.time = LocalDateTime.of(intDate[0], intDate[1], intDate[2], intTime[0], intTime[1],
81 intTime[2]);
82 temp.getWeekDay();
83 } catch (DateTimeException e) {
84 System.out.println(temp.num + " date error");
85 str1 = input.nextLine();
86 continue;
87 }
88 if (!temp.isOpen()) {
89 System.out.println("table " + temp.num + " out of opening hours");
90 str1 = input.nextLine();
91 continue;
92 }
93 if (!(temp.time.isAfter(LocalDateTime.of(2022, 1, 1, 0, 0, 0))
94 && temp.time.isBefore(LocalDateTime.of(2024, 1, 1, 0, 0, 0)))) {
95 System.out.println("not a valid time period");
96 str1 = input.nextLine();
97 continue;
98 }
99 // 判断桌号是否重复
100 if (temp.isOpen()) {
101 for (i = 0; i < tables.size(); i++) {
102 // 有重复的桌号
103 if (temp.num == tables.get(i).num && tables.get(i).isOpen()) {
104 Duration duration = Duration.between(temp.time, tables.get(i).time);
105 // 同一天
106 if (duration.toDays() == 0) {
107 // 在周一到周五
108 if (temp.weekday > 0 && temp.weekday < 6) {
109 // 在同一时间段
110 if (temp.time.getHour() < 15 && tables.get(i).time.getHour() < 15) {
111 isRepeat = true;
112 repeatNum = i;
113 break;
114 }
115 }
116 // 在周末
117 else {
118 // 时间相差小于一小时
119 if (duration.toHours() < 3600) {
120 repeatNum = i;
121 isRepeat = true;
122 break;
123 }
124 }
125 }
126 }
127 }
128 }
129 System.out.println("table " + temp.num + ": ");
130
131 } else {
132 System.out.println("wrong format");
133 str1 = input.nextLine();
134 continue;
135 }
136 // 本桌开始点菜
137 while (true) {
138 str1 = input.nextLine();
139 if (str1.matches("[1-9][\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
140 String[] token = str1.split(" ");
141 portion = Integer.parseInt(token[2]);
142 quota = Integer.parseInt(token[3]);
143 if (temp.order.records.size() > 0) {
144 if (Integer.parseInt(
145 token[0]) <= temp.order.records.get(temp.order.records.size() - 1).orderNum) {
146 System.out.println("record serial number sequence error");
147 continue;
148 }
149 }
150 if (menu.searchDish(token[1]) == -1) {
151 System.out.println(token[1] + " does not exist");
152 continue;
153 }
154 if (portion > 3 || portion < 1) {
155 System.out.println(Integer.parseInt(token[0]) + " portion out of range " + portion);
156 continue;
157 }
158 if (quota > 15) {
159 System.out.println(Integer.parseInt(token[0]) + " num out of range " + quota);
160 continue;
161 }
162 temp.od(menu, token[0], token[1], portion, quota);
163 }
164 // 判断是否为删除订单
165 else if (str1.matches("[1-9][\\d]* delete")) {
166 String[] token = str1.split(" ");
167 temp.order.delARecordByOrderNum(Integer.parseInt(token[0]));
168 }
169 // 判断是否为夹杂菜单
170 else if (str1.matches("[\\S]* [\\d]*")) {
171 System.out.println("invalid dish");
172 continue;
173 } else if (str1.matches("[\\S]* [\\d]* T")) {
174 System.out.println("invalid dish");
175 continue;
176 }
177 // 判断是否为代点
178 else if (str1.matches("[\\d]* [\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
179 String[] token = str1.split(" ");
180 // 判断代点桌号是否存在
181 boolean exist = false;
182 for (int j = 0; j < tables.size(); j++) {
183 if (tables.get(j).num == Integer.parseInt(token[0])) {
184 exist = true;
185 break;
186 }
187 }
188 if (exist) {
189 System.out.print(Integer.parseInt(token[1]) + " table " + temp.num + " pay for table "
190 + Integer.parseInt(token[0]) + " ");
191 Record treat = new Record();
192 treat.d = menu.dishs.get(menu.searchDish(token[2]));
193 portion = Integer.parseInt(token[3]);
194 quota = Integer.parseInt(token[4]);
195 treat.portion = portion;
196 treat.quota = quota;
197 System.out.print(treat.getPrice() + "\n");
198 temp.order.records.add(treat);
199 }
200 // 若不存在则输出内容
201 else {
202 System.out.println("Table number ：" + Integer.parseInt(token[0]) + " does not exist");
203 }
204
205 } else if (str1.equals("end")) {
206 break;
207 } else if (str1.matches("table.*")) {
208 break;
209 } else {
210 System.out.println("wrong format");
211 continue;
212 }
213 }
214 // 本桌点菜结束，进入下一桌
215 if (isRepeat) {
216 for (i = 0; i < tables.get(repeatNum).order.records.size(); i++) {
217 for (int j = 0; j < temp.order.records.size(); j++) {
218 if (tables.get(repeatNum).order.records.get(i).d.name == temp.order.records.get(j).d.name) {
219 if (tables.get(repeatNum).order.records.get(i).portion == temp.order.records
220 .get(j).portion) {
221 tables.get(repeatNum).order.records.get(i).quota += temp.order.records.get(j).quota;
222 temp.order.records.remove(j);
223 }
224 }
225 }
226
227 }
228 tables.get(repeatNum).order.records.addAll(temp.order.records);
229 continue;
230 }
231 tables.add(temp);
232 } else {
233 str1 = input.nextLine();
234 }
235 }
236
237 // 最终输出桌号订单信息
238 for (i = 0; i < tables.size(); i++) {
239 if (tables.get(i).isOpen()) {
240 tables.get(i).getSum();
241 System.out
242 .println("table " + tables.get(i).num + ": " + tables.get(i).origSum + " " + tables.get(i).sum);
243 }
244
245 }
246 }
247
248 static class Dish {
249 String name;
250 int unit_price;
251 boolean isT = false;
252 }
253
254 static class Record {
255 int orderNum;
256 Dish d;
257 int portion;
258 int quota;
259 boolean isDeleted = false;
260
261 int getPrice() {
262 if (portion == 2)
263 return (int) Math.round(1.5 * d.unit_price) * quota;
264 else if (portion == 3)
265 return 2 * d.unit_price * quota;
266 else
267 return d.unit_price * quota;
268 }
269 }
270
271 static class Menu {
272 ArrayList<Dish> dishs = new ArrayList<Dish>();
273
274 int searchDish(String dishName) {
275 for (int i = 0; i < dishs.size(); i++) {
276 if (dishName.equals(dishs.get(i).name)) {
277 return i;
278 }
279 }
280 return -1;
281 }
282 }
283
284 static class Order {
285 ArrayList<Record> records = new ArrayList<Record>();
286
287 Record addARecord(int orderNum, String dishName, int portion, int quota, Menu menu) {
288 Record newRecord = new Record();
289 newRecord.orderNum = orderNum;
290 newRecord.d = menu.dishs.get(menu.searchDish(dishName));
291 newRecord.portion = portion;
292 newRecord.quota = quota;
293 System.out.println(newRecord.orderNum + " " + newRecord.d.name + " " + newRecord.getPrice());
294 return newRecord;
295 }
296
297 boolean delARecordByOrderNum(int orderNum) {
298 int i = 0, flag = 0;
299 for (i = 0; i < records.size(); i++) {
300 if (records.get(i).orderNum == orderNum) {
301 if (records.get(i).isDeleted == false) {
302 records.get(i).isDeleted = true;
303 } else {
304 System.out.println("deduplication " + orderNum);
305 }
306 flag++;
307 }
308 }
309 if (flag == 0) {
310 System.out.println("delete error;");
311 return false;
312 }
313 return true;
314 }
315 }
316
317 static class Table {
318 Order order = new Order();
319 int num;
320 LocalDateTime time;
321 int weekday;
322 long sum = 0;
323 long origSum = 0;
324
325 void od(Menu menu, String str1, String str2, int portion, int quota) {
326 {
327 order.records.add(order.addARecord(Integer.parseInt(str1), str2, portion, quota, menu));
328
329 }
330 }
331
332 void getWeekDay() {
333 weekday = time.getDayOfWeek().getValue();
334 }
335
336 void getSum() {
337 for (int i = 0; i < order.records.size(); i++) {
338 if (!order.records.get(i).isDeleted) {
339 origSum += order.records.get(i).getPrice();
340 if (order.records.get(i).d.isT) {
341 if (weekday > 0 && weekday < 6) {
342 sum += Math.round(order.records.get(i).getPrice() * 0.7);
343 } else {
344 sum += order.records.get(i).getPrice();
345 }
346 } else {
347 if (weekday > 0 && weekday < 6) {
348 if (time.getHour() >= 17 && time.getHour() < 20)
349 sum += Math.round(order.records.get(i).getPrice() * 0.8);
350 if (time.getHour() == 20) {
351 if (time.getMinute() <= 30)
352 sum += Math.round(order.records.get(i).getPrice() * 0.8);
353 }
354 if (time.getHour() >= 10 && time.getHour() < 14)
355 sum += Math.round(order.records.get(i).getPrice() * 0.6);
356 if (time.getHour() == 14) {
357 if (time.getMinute() <= 30)
358 sum += Math.round(order.records.get(i).getPrice() * 0.6);
359 }
360 } else
361 sum += order.records.get(i).getPrice();
362 }
363 }
364 }
365
366 }
367
368 boolean isOpen() {
369 if (weekday > 0 && weekday < 6) {
370 if (time.getHour() >= 17 && time.getHour() < 20)
371 return true;
372 if (time.getHour() == 20) {
373 if (time.getMinute() <= 30)
374 return true;
375 }
376 if (time.getHour() > 10 && time.getHour() < 14)
377 return true;
378 if (time.getHour() == 10) {
379 if (time.getMinute() >= 30)
380 return true;
381 }
382 if (time.getHour() == 14) {
383 if (time.getMinute() <= 30)
384 return true;
385 }
386 } else {
387 if (time.getHour() > 9 && time.getHour() < 21)
388 return true;
389 if (time.getHour() == 9) {
390 if (time.getMinute() >= 30)
391 return true;
392 }
393 if (time.getHour() == 21) {
394 if (time.getMinute() <= 30)
395 return true;
396 }
397 }
398 return false;
399
400 }
401 }
402 }
类图：
7-1 菜单计价程序-5
分数 100 作者 蔡轲 单位 南昌航空大学 这道题目是一个设计点菜计价程序的问题，主要涉及到输入输出的处理和计算逻辑的实现。下面对题目的难度、重难点和知识点进行分析。 难度： 这道题目的难度适中，需要考虑多种情况的输入和计算逻辑，但是整体上并不复杂。对于有一定编程基础的人来说，应该可以比较容易地完成。 重难点： 1. 输入输出的处理：题目中给出了输入的格式要求，需要按照指定的格式解析输入，并按照要求输出结果。这需要对字符串的处理和格式化输出有一定的了解。 2. 计算逻辑的实现：题目中涉及到了菜品的计价逻辑，包括不同份额菜价的计算、特色菜的口味度计算、折扣的计算等。这需要对条件判断和数值计算有一定的掌握。 知识点： 1. 字符串的处理：题目中需要对输入的字符串进行解析和拼接，涉及到字符串的分割、拼接、格式化输出等操作。 2. 条件判断和循环：题目中需要根据不同的条件进行不同的处理，需要使用条件判断和循环语句来实现。 3. 数值计算：题目中需要进行一些数值的计算，包括菜价的计算、折扣的计算等，需要使用数值计算的相关操作。 源码： 1 import java.time.DateTimeException;
2 import java.time.Duration;
3 import java.time.LocalDateTime;
4 import java.util.ArrayList;
5 import java.util.Comparator;
6 import java.util.Scanner;
7
8 public class Main {
9 public static boolean isNumeric(String string) {
10 int intValue;
11 try {
12 intValue = Integer.parseInt(string);
13 return true;
14 } catch (NumberFormatException e) {
15 return false;
16 }
17 }
18
19 public static void main(String[] args) {
20 Menu menu = new Menu();
21 ArrayList<Table> tables = new ArrayList<Table>();
22 ArrayList<User> users = new ArrayList<User>();
23 Scanner input = new Scanner(System.in);
24 String str1 = new String();
25 int i = 0;
26 int portion = 0, quota = 0;
27 while (true) {// 输入菜单
28 Dish temp = new Dish();
29 int isRepeat = -1;
30 str1 = input.nextLine();
31 if (str1.matches("[\\S]* [1-9][\\d]*")) {
32 String[] token = str1.split(" ");
33 temp.name = token[0];
34 temp.unit_price = Integer.parseInt(token[1]);
35 temp.isT = false;
36 isRepeat = menu.searchDish(temp.name);
37 if (isRepeat != -1) {
38 menu.dishs.remove(isRepeat);
39 }
40 menu.dishs.add(temp);
41 } else if (str1.matches("[\\S]* [\\S]* [\\d]* T")) {
42 String[] token = str1.split(" ");
43 temp.name = token[0];
44 temp.unit_price = Integer.parseInt(token[2]);
45 temp.isT = true;
46 switch (token[1]) {
47 case "川菜":
48 temp.FlavorType = "spicy";
49 temp.MaxFlavor = 5;
50 break;
51 case "晋菜":
52 temp.FlavorType = "acidity";
53 temp.MaxFlavor = 4;
54 break;
55 case "浙菜":
56 temp.FlavorType = "sweetness";
57 temp.MaxFlavor = 3;
58 break;
59 default :str1 = input.nextLine();
60 System.out.println("wrong format");
61 continue;
62
63 }
64 isRepeat = menu.searchDish(temp.name);
65 if (isRepeat != -1) {
66 menu.dishs.remove(isRepeat);
67 }
68 menu.dishs.add(temp);
69 } else if (str1.equals("end")) {
70 break;
71 } else if (str1.matches("tab.*")) {
72 break;
73
74 } else {
75 str1 = input.nextLine();
76 System.out.println("wrong format");
77 continue;
78 }
79 }
80 while (!str1.equals("end")) {
81 Table temp = new Table();
82 boolean isRepeat = false;
83 int repeatNum = 0;
84 if (str1.matches(".*t.*a.*")) {
85 if (str1.matches(
86 "table [1-9][\\d]* : [\\S]* [\\d]* [\\d]*/[\\d][\\d]?/[\\d][\\d]? [\\d][\\d]?/[\\d][\\d]?/[\\d][\\d]?")) {
87 String[] token = str1.split(" ");
88 temp.userName = token[3];
89 if(token[3].length()>10) {
90 str1 = input.nextLine();
91 System.out.println("wrong format");
92 continue;
93 }
94 temp.callNum = token[4];
95 if(token[4].length()!=11) {
96 str1 = input.nextLine();
97 System.out.print("wrong format");
98 continue;
99 }
100 String headNum = token[4].substring(0, 3);
101 if(!headNum.equals("180")&&!headNum.equals("181")&&!headNum.equals("189")&&!headNum.equals("133")&&!headNum.equals("135")&&!headNum.equals("136")) {
102 str1 = input.nextLine();
103 System.out.println("wrong format");
104 continue;
105 }
106 String[] Date = token[5].split("/");
107 String[] Time = token[6].split("/");
108 int[] intDate = new int[5];
109 int[] intTime = new int[6];
110 for (i = 0; i < 3; i++) {
111 intDate[i] = Integer.parseInt(Date[i]);
112 intTime[i] = Integer.parseInt(Time[i]);
113 }
114 temp.num = Integer.parseInt(token[1]);
115 try {
116 temp.time = LocalDateTime.of(intDate[0], intDate[1], intDate[2], intTime[0], intTime[1],
117 intTime[2]);
118 temp.getWeekDay();
119 } catch (DateTimeException e) {
120 System.out.println(temp.num + " date error");
121 str1 = input.nextLine();
122 continue;
123 }
124 if (!temp.isOpen()) {
125 System.out.println("table " + temp.num + " out of opening hours");
126 str1 = input.nextLine();
127 continue;
128 }
129
130 System.out.println("table " + temp.num + ": ");
131
132 } else {
133 System.out.println("wrong format");
134 str1 = input.nextLine();
135 continue;
136 }
137 // 本桌开始点菜
138 while (true) {
139 str1 = input.nextLine();
140 //判断是否为非特色菜
141 if (str1.matches("[1-9][\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
142 String[] token = str1.split(" ");
143 portion = Integer.parseInt(token[2]);
144 quota = Integer.parseInt(token[3]);
145 if (menu.searchDish(token[1]) == -1) {
146 System.out.println(token[1] + " does not exist");
147 continue;
148 }
149 Record tempRecord = new Record();
150 tempRecord.d = menu.dishs.get(menu.searchDish(token[1]));
151 tempRecord.orderNum = Integer.parseInt(token[0]);
152 tempRecord.portion = portion;
153 tempRecord.quota = quota;
154 temp.records.add(tempRecord);
155 System.out.println(tempRecord.orderNum +" "+token[1]+ " " +tempRecord.getPrice());
156 }
157 //判断是否为特色菜
158 else if(str1.matches("[1-9][\\d]* [\\S]* [\\d] [\\d] [1-9][\\d]*")) {
159 String[] token = str1.split(" ");
160 if (menu.searchDish(token[1]) == -1) {
161 System.out.println(token[1] + " does not exist");
162 continue;
163 }
164 int FlavorNum = Integer.parseInt(token[2]);
165 if(FlavorNum<0||FlavorNum>menu.dishs.get(menu.searchDish(token[1])).MaxFlavor) {
166 System.out.println(menu.dishs.get(menu.searchDish(token[1])).FlavorType+" num out of range :"+FlavorNum);
167 continue;
168 }
169 portion = Integer.parseInt(token[3]);
170 quota = Integer.parseInt(token[4]);
171 if (menu.searchDish(token[1]) == -1) {
172 System.out.println(token[1] + " does not exist");
173 continue;
174 }
175 Record tempRecord = new Record();
176 tempRecord.d = menu.dishs.get(menu.searchDish(token[1]));
177 tempRecord.FlavorNum = FlavorNum;
178 tempRecord.orderNum = Integer.parseInt(token[0]);
179 tempRecord.portion = portion;
180 tempRecord.quota = quota;
181 temp.records.add(tempRecord);
182 System.out.println(tempRecord.orderNum +" "+token[1]+" "+ tempRecord.getPrice());
183 }
184 // 判断是否为删除订单
185 else if (str1.matches("[1-9][\\d]* delete")) {
186 String[] token = str1.split(" ");
187 int delNum = Integer.parseInt(token[0]);
188 for(i=0;i<temp.records.size();i++) {
189 if(temp.records.get(i).orderNum==delNum) {
190 if(!temp.records.get(i).isDeleted) {
191 temp.records.get(i).isDeleted = true;
192 }
193 else System.out.println("delete error");
194 break;
195 }
196 if(i==temp.records.size())System.out.println("delete error");
197 }
198
199 }
200 // 判断是否为代点
201 else if (str1.matches("[\\d]* [\\d]* [\\S].*")) {
202 String[] token = str1.split(" ");
203 // 判断代点桌号是否存在
204 boolean exist = false;
205 int j = 0;
206 for (j = 0; j < tables.size(); j++) {
207 if (tables.get(j).num == Integer.parseInt(token[0])) {
208 exist = true;
209 break;
210 }
211 }
212 if (exist) {
213 System.out.print(Integer.parseInt(token[1]) + " table " + temp.num + " pay for table "
214 + Integer.parseInt(token[0]) + " ");
215 Record treat = new Record();
216 treat.d = menu.dishs.get(menu.searchDish(token[2]));
217 if(treat.d.isT) {
218 treat.FlavorNum = Integer.parseInt(token[3]);
219 treat.portion = Integer.parseInt(token[4]);
220 treat.quota = Integer.parseInt(token[5]);
221 if(treat.d.FlavorType.equals("spicy")) {
222 tables.get(j).ChuanNum+=treat.quota;
223 tables.get(j).spicyType +=treat.FlavorNum*treat.quota;
224 }
225 if(treat.d.FlavorType.equals("acidity")) {
226 tables.get(j).JinNum+=treat.quota;
227 tables.get(j).spicyType +=treat.FlavorNum*treat.quota;
228 }
229 if(treat.d.FlavorType.equals("sweetness")) {
230 tables.get(j).ZheNum+=treat.quota;
231 tables.get(j).spicyType +=treat.FlavorNum*treat.quota;
232 }
233 }
234 else {
235 treat.portion = Integer.parseInt(token[3]);
236 treat.quota = Integer.parseInt(token[4]);
237 }
238 System.out.print(treat.getPrice() + "\n");
239 treat.isTreat = true;
240 temp.records.add(treat);
241 }
242 // 若不存在则输出内容
243 else {
244 System.out.println("Table number ：" + Integer.parseInt(token[0]) + " does not exist");
245 }
246
247 } else if (str1.equals("end")) {
248 break;
249 } else if (str1.matches("table.*")) {
250 break;
251 } else {
252 System.out.println("wrong format");
253 continue;
254 }
255 }
256 // 本桌点菜结束，进入下一桌
257 tables.add(temp);
258 } else {
259 str1 = input.nextLine();
260 }
261 }
262
263 // 最终输出桌号订单信息
264 for (i = 0; i < tables.size(); i++) {
265 if (tables.get(i).isOpen()) {
266 tables.get(i).getSum();
267 tables.get(i).getFlavorNum();
268 if(i!=0)System.out.print("\n");
269 tables.get(i).showEnd();
270 boolean isRepeat = false;
271 for(int j=0;j<users.size();j++) {
272 if(tables.get(i).userName.equals(users.get(j).userName)) {
273 users.get(j).paidMoney+=tables.get(i).sum;
274 isRepeat = true;
275 break;
276 }
277 }
278 if(!isRepeat) {
279 User tempUser = new User();
280 tempUser.userName = tables.get(i).userName;
281 tempUser.callNum = tables.get(i).callNum;
282 tempUser.paidMoney = tables.get(i).sum;
283 users.add(tempUser);
284 }
285 }
286
287 }
288 users.sort(new Comparator<User>() {
289 public int compare(User a,User b) {
290 return a.userName.compareTo(b.userName);
291 }
292 });
293 for(i=0;i<users.size();i++) {
294 System.out.print("\n"+users.get(i).userName +" "+ users.get(i).callNum +" "+ users.get(i).paidMoney);
295 }
296 }
297
298 static class Dish {
299 String name;
300 String FlavorType;
301 int MaxFlavor;
302 int unit_price;
303 boolean isT = false;
304 }
305
306 static class Record {
307 int orderNum;
308 Dish d;
309 int FlavorNum;
310 int portion;
311 int quota;
312 boolean isDeleted = false;
313 boolean isTreat = false;
314
315 int getPrice() {
316 if (portion == 2)
317 return (int) Math.round(1.5 * d.unit_price) * quota;
318 else if (portion == 3)
319 return 2 * d.unit_price * quota;
320 else
321 return d.unit_price * quota;
322 }
323 }
324
325 static class Menu {
326 ArrayList<Dish> dishs = new ArrayList<Dish>();
327 int searchDish(String dishName) {
328 for (int i = 0; i < dishs.size(); i++) {
329 if (dishName.equals(dishs.get(i).name)) {
330 return i;
331 }
332 }
333 return -1;
334 }
335 }
336
337 static class User{
338 String userName;
339 String callNum;
340 long paidMoney;
341 }
342 static class Table {
343 ArrayList<Record> records = new ArrayList<Record>();
344 int num;
345 String userName;
346 String callNum;
347 LocalDateTime time;
348 int weekday;
349 int ChuanNum = 0;
350 float spicyType = 0;
351 int JinNum = 0;
352 float acidType = 0;
353 int ZheNum = 0;
354 float sweetType = 0;
355 long sum = 0;
356 long origSum = 0;
357
358 void getWeekDay() {
359 weekday = time.getDayOfWeek().getValue();
360 }
361 void getFlavorNum() {
362 for(int i=0;i<records.size();i++) {
363 if(records.get(i).d.isT&&!records.get(i).isDeleted&&!records.get(i).isTreat) {
364 if(records.get(i).d.FlavorType.equals("spicy")) {
365 ChuanNum+=records.get(i).quota;
366 spicyType +=records.get(i).FlavorNum*records.get(i).quota;
367 }
368 if(records.get(i).d.FlavorType.equals("acidity")) {
369 JinNum+=records.get(i).quota;
370 acidType +=records.get(i).FlavorNum*records.get(i).quota;
371 }
372 if(records.get(i).d.FlavorType.equals("sweetness")) {
373 ZheNum+=records.get(i).quota;
374 sweetType +=records.get(i).FlavorNum*records.get(i).quota;
375 }
376 }
377 }
378 if(ChuanNum!=0)spicyType = Math.round(spicyType/ChuanNum*1.0);
379 if(JinNum!=0)acidType = Math.round(acidType/JinNum*1.0);
380 if(ZheNum!=0)sweetType = Math.round(sweetType/ZheNum*1.0);
381 }
382 void showEnd() {
383 System.out.print("table " + num + ": " + origSum + " " + sum);
384 //输出川菜
385 if(ChuanNum!=0) {
386 System.out.print(" 川菜 "+ChuanNum);
387 switch((int)spicyType) {
388 case 0 :System.out.print(" 不辣");break;
389 case 1 :System.out.print(" 微辣");break;
390 case 2 :System.out.print(" 稍辣");break;
391 case 3 :System.out.print(" 辣");break;
392 case 4 :System.out.print(" 很辣");break;
393 case 5 :System.out.print(" 爆辣");break;
394 }
395 }
396 //输出晋菜
397 if(JinNum!=0) {
398 System.out.print(" 晋菜 "+JinNum);
399 switch((int)acidType) {
400 case 0 :System.out.print(" 不酸");break;
401 case 1 :System.out.print(" 微酸");break;
402 case 2 :System.out.print(" 稍酸");break;
403 case 3 :System.out.print(" 酸");break;
404 case 4 :System.out.print(" 很酸");break;
405 }
406 }
407 //输出浙菜
408 if(ZheNum!=0) {
409 System.out.print(" 浙菜 "+ZheNum);
410 switch((int)sweetType) {
411 case 0 :System.out.print(" 不甜");break;
412 case 1 :System.out.print(" 微甜");break;
413 case 2 :System.out.print(" 稍甜");break;
414 case 3 :System.out.print(" 甜");break;
415 }
416 }
417
418 }
419 void getSum() {
420 for (int i = 0; i < records.size(); i++) {
421 if (!records.get(i).isDeleted) {
422 origSum += records.get(i).getPrice();
423 if (records.get(i).d.isT) {
424 if (weekday > 0 && weekday < 6) {
425 sum += Math.round(records.get(i).getPrice() * 0.7);
426 } else {
427 sum += records.get(i).getPrice();
428 }
429 } else {
430 if (weekday > 0 && weekday < 6) {
431 if (time.getHour() >= 17 && time.getHour() < 20)
432 sum += Math.round(records.get(i).getPrice() * 0.8);
433 if (time.getHour() == 20) {
434 if (time.getMinute() <= 30)
435 sum += Math.round(records.get(i).getPrice() * 0.8);
436 }
437 if (time.getHour() >= 10 && time.getHour() < 14)
438 sum += Math.round(records.get(i).getPrice() * 0.6);
439 if (time.getHour() == 14) {
440 if (time.getMinute() <= 30)
441 sum += Math.round(records.get(i).getPrice() * 0.6);
442 }
443 } else
444 sum += records.get(i).getPrice();
445 }
446 }
447 }
448
449 }
450
451 boolean isOpen() {
452 if (weekday > 0 && weekday < 6) {
453 if (time.getHour() >= 17 && time.getHour() < 20)
454 return true;
455 if (time.getHour() == 20) {
456 if (time.getMinute() <= 30)
457 return true;
458 }
459 if (time.getHour() > 10 && time.getHour() < 14)
460 return true;
461 if (time.getHour() == 10) {
462 if (time.getMinute() >= 30)
463 return true;
464 }
465 if (time.getHour() == 14) {
466 if (time.getMinute() <= 30)
467 return true;
468 }
469 } else {
470 if (time.getHour() > 9 && time.getHour() < 21)
471 return true;
472 if (time.getHour() == 9) {
473 if (time.getMinute() >= 30)
474 return true;
475 }
476 if (time.getHour() == 21) {
477 if (time.getMinute() <= 30)
478 return true;
479 }
480 }
481 return false;
482
483 }
484 }
485 }
类图：
7-1 测验1-圆类设计
分数 12 作者 段喜龙 单位 南昌航空大学创建一个圆形类（Circle），私有属性为圆的半径，从控制台输入圆的半径，输出圆的面积
输入格式:
输入圆的半径，取值范围为(0,+∞)，输入数据非法，则程序输出Wrong Format，注意：只考虑从控制台输入数值的情况
输出格式:
输出圆的面积（保留两位小数，可以使用String.format(“%.2f”,输出数值）控制精度）
这道题目是一个关于圆形类设计的Java题目。题目要求创建一个圆形类，其中私有属性为圆的半径。从控制台输入圆的半径，然后输出圆的面积。 难度分析： 这道题目的难度属于初级水平。它主要考察对类的设计和属性的使用，以及对输入输出的处理。 重难点分析： 1. 类的设计：需要创建一个圆形类，其中包含一个私有属性表示圆的半径。这需要对类的基本结构和属性的定义有一定的了解。 2. 输入处理：需要从控制台输入圆的半径，并进行合法性判断。如果输入数据非法，则需要输出错误提示信息。 3. 输出处理：需要计算圆的面积，并将结果保留两位小数进行输出。这需要对浮点数的格式化输出有一定的了解。 知识点分析： 1. 类的定义和属性的使用：需要了解如何定义一个类，并在类中定义私有属性。还需要了解如何在类中定义方法来实现对属性的操作。 2. 输入输出处理：需要了解如何从控制台输入数据，并进行合法性判断。还需要了解如何对浮点数进行格式化输出。 3. 数学计算：需要了解如何计算圆的面积，即使用数学公式πr^2进行计算。 总结： 这道题目是一个初级水平的Java题目，主要考察对类的设计和属性的使用，以及对输入输出的处理。需要掌握类的定义和属性的使用，输入输出的处理方法，以及数学计算的基本知识。完成这道题目可以帮助学生巩固对类的理解和应用，以及对输入输出的处理方法的掌握。 源码： 1 import java.util.Scanner;
2
3 public class Main {
4 private double radius;
5
6 public Main(double radius) {
7 this.radius = radius;
8 }
9
10 public double getArea() {
11 return Math.PI * radius * radius;
12 }
13
14 public static void main(String[] args) {
15 Scanner scanner = new Scanner(System.in);
16 double radius = scanner.nextDouble();
17 if (radius <= 0) {
18 System.out.println("Wrong Format");
19 } else {
20 Main circle = new Main(radius);
21 double area = circle.getArea();
22 System.out.println(String.format("%.2f", area));
23 }
24 }
25 }
类图：
这段Java代码主要涉及以下知识点：
1. 类和对象：代码中定义了一个名为Main的类，其中包含一个私有属性radius和一些方法。通过创建Main类的对象，可以使用这些方法来计算圆的面积。
2. 构造方法：代码中定义了一个构造方法Main(double radius)，用于初始化radius属性。
3. 方法：代码中定义了一个getArea()方法，用于计算圆的面积。该方法使用了Math类中的PI常量和radius属性。
4. 输入输出：代码中使用Scanner类来获取用户输入的半径值，并通过System.out.println()方法将结果输出到控制台。
需要改进的地方：
1. 输入验证：代码中对输入的半径值进行了简单的验证，如果半径小于等于0，则输出"Wrong Format"。但这种验证方式并不严谨，可以考虑使用异常处理来更好地处理输入错误的情况。
2. 输出格式化：代码中使用了String.format()方法来格式化输出结果，保留两位小数。这种方式可以改进为使用DecimalFormat类来更灵活地控制输出格式。
心得体会：
这段代码实现了一个简单的圆面积计算程序，通过输入半径值，计算并输出圆的面积。代码结构清晰，逻辑简单明了。在实际应用中，可以根据需求进行一些改进，例如添加更多的输入验证和输出格式化选项，以提高代码的健壮性和可扩展性。
7-2 测验2-类结构设计 分数 18 作者 段喜龙 单位 南昌航空大学设计一个矩形类，其属性由矩形左上角坐标点（x1，y1）及右下角坐标点（x2，y2）组成，其中，坐标点属性包括该坐标点的X轴及Y轴的坐标值（实型数），求得该矩形的面积。
这道题目是一个简单的类结构设计题，要求设计一个矩形类，计算矩形的面积。
首先，我们需要定义一个矩形类，该类包含两个属性：左上角坐标点和右下角坐标点。坐标点属性包括X轴和Y轴的坐标值，可以使用实型数来表示。
接下来，我们需要设计一个方法来计算矩形的面积。根据矩形的左上角和右下角坐标点，可以通过计算矩形的宽度和高度来得到面积。矩形的宽度可以通过右下角的X轴坐标减去左上角的X轴坐标得到，矩形的高度可以通过左上角的Y轴坐标减去右下角的Y轴坐标得到。最后，将宽度和高度相乘即可得到矩形的面积。
在输入方面，需要分别输入两个坐标点的坐标值x1，y1，x2，y2。这些输入值可以通过Java的Scanner类来获取。
在输出方面，需要输出矩形的面积值，保留两位小数。可以使用Java的System.out.printf()方法来实现。
这道题目的难度较低，主要考察的是对类的设计和方法的实现。需要注意的是，要正确计算矩形的宽度和高度，并保留两位小数的输出格式。
总结起来，这道题目的重难点在于理解矩形的属性和计算面积的方法，以及正确处理输入和输出的格式。知识点包括类的设计和方法的实现，以及输入输出的处理。
源码：
1 import java.util.Scanner;
2
3 public class Main {
4 private double x1, y1, x2, y2;
5
6 public Main(double x1, double y1, double x2, double y2) {
7 this.x1 = x1;
8 this.y1 = y1;
9 this.x2 = x2;
10 this.y2 = y2;
11 }
12
13 public double getArea() {
14 double width = Math.abs(x2 - x1);
15 double height = Math.abs(y2 - y1);
16 return width * height;
17 }
18
19 public static void main(String[] args) {
20 Scanner scanner = new Scanner(System.in);
21 double x1 = scanner.nextDouble();
22 double y1 = scanner.nextDouble();
23 double x2 = scanner.nextDouble();
24 double y2 = scanner.nextDouble();
25
26 Main rectangle = new Main(x1, y1, x2, y2);
27 double area = rectangle.getArea();
28 System.out.printf("%.2f", area);
29 }
30 }
类图：
这段Java代码主要涉及以下知识点：
1. 类和对象：代码中定义了一个名为Main的类，用于表示一个矩形对象。
2. 构造方法：Main类中定义了一个构造方法，用于初始化矩形的坐标。
3. 成员变量和成员方法：Main类中定义了四个成员变量（x1、y1、x2、y2）和一个计算矩形面积的成员方法（getArea）。
4. Math类的使用：代码中使用了Math类的abs方法来计算矩形的宽度和高度。
5. 输入输出：代码中使用了Scanner类来获取用户输入的矩形坐标，并使用System.out.printf方法输出矩形的面积。
需要改进的地方：
1. 缺乏输入验证：代码中没有对用户输入的坐标进行验证，可能导致输入非法的坐标值。
2. 变量命名不规范：代码中的变量命名不够清晰和具有描述性，可以考虑改进命名风格。
3. 缺乏异常处理：代码中没有对可能出现的异常进行处理，比如用户输入非法字符导致的输入错误。
写出这段代码的心得：
这段代码实现了一个简单的矩形面积计算功能，通过输入矩形的两个顶点坐标，计算出矩形的面积并输出。代码结构清晰，使用了面向对象的思想，将矩形的坐标和计算面积的方法封装在一个类中。通过使用Scanner类获取用户输入，使得代码具有交互性。在实际应用中，可以根据需求对代码进行改进和优化，比如添加输入验证和异常处理等功能。
7-3 测验3-继承与多态
分数 30 作者 段喜龙 单位 南昌航空大学将测验1与测验2的类设计进行合并设计，抽象出Shape父类（抽象类），Circle及Rectangle作为子类
这道题目主要涉及面向对象的基本概念和Java语言的基础知识。题目要求创建一个圆形类和一个矩形类，并设计一个抽象的父类Shape，通过输入参数计算出图形的面积。
首先，我们来分析圆形类（Circle）。根据题目要求，圆形类有一个私有属性半径，需要从控制台输入半径，并输出圆的面积。难度较低，重难点在于计算圆的面积公式的正确使用。知识点包括类的定义、属性的定义和使用、输入输出的处理以及面积计算公式的应用。
接下来，我们分析矩形类（Rectangle）。矩形类的属性由左上角坐标点和右下角坐标点组成，需要根据输入的坐标点计算矩形的面积。难度适中，重难点在于坐标点的输入和处理，以及面积计算公式的正确使用。知识点包括类的定义、属性的定义和使用、输入输出的处理以及面积计算公式的应用。
最后，我们来分析抽象父类Shape。根据题目要求，Shape是一个抽象类，用于统一圆形和矩形的计算面积的方法。难度较低，重难点在于抽象类的定义和使用。知识点包括抽象类的定义和使用、方法的重写和调用。
总体来说，这道题目的难度适中，重难点在于面积计算公式的正确使用和输入输出的处理。知识点涉及类的定义和使用、属性的定义和使用、输入输出的处理、抽象类的定义和使用、方法的重写和调用等。
在解题过程中，需要注意输入的合法性判断，例如输入类型选择的范围、坐标点的合法性等。同时，需要注意保留面积的小数位数，题目要求保留两位小数。
总结起来，这道题目是一个基础的面向对象的题目，通过实现圆形类和矩形类，并设计一个抽象的父类Shape，来计算图形的面积。通过解答这道题目，可以加深对面向对象的理解，并巩固Java语言的基础知识。
源码：
1 import java.util.ArrayList;
2 import java.util.Comparator;
3 import java.util.Scanner;
4
5 abstract class Shape implements Comparable<Shape> {
6 public abstract double getArea();
7
8 @Override
9 public int compareTo(Shape s) {
10 return Double.compare(this.getArea(), s.getArea());
11 }
12 }
13
14 class Circle extends Shape {
15 private double radius;
16
17 public Circle(double radius) {
18 this.radius = radius;
19 }
20
21 @Override
22 public double getArea() {
23 return Math.PI * radius * radius;
24 }
25 }
26
27
28 class Point {
29 private double x;
30 private double y;
31
32 public Point(double x, double y) {
33 this.x = x;
34 this.y = y;
35 }
36
37 public double getX() {
38 return x;
39 }
40
41 public double getY() {
42 return y;
43 }
44 }
45
46 class Rectangle extends Shape{
47 private Point upperLeft;
48 private Point lowerRight;
49
50 public Rectangle(Point upperLeft, Point lowerRight) {
51 this.upperLeft = upperLeft;
52 this.lowerRight = lowerRight;
53 }
54
55
56
57 public Point getUpperLeft() {
58 return upperLeft;
59 }
60
61
62
63 public void setUpperLeft(Point upperLeft) {
64 this.upperLeft = upperLeft;
65 }
66
67
68
69 public Point getLowerRight() {
70 return lowerRight;
71 }
72
73
74
75 public void setLowerRight(Point lowerRight) {
76 this.lowerRight = lowerRight;
77 }
78
79
80 @Override
81 public double getArea() {
82 double width = Math.abs(lowerRight.getX() - upperLeft.getX());
83 double height = Math.abs(lowerRight.getY() - upperLeft.getY());
84 return width * height;
85 }
86 }
87
88
89 public class Main {
90 public static void main(String[] args) {
91 Scanner input = new Scanner(System.in);
92 ArrayList<Shape> list = new ArrayList<>();
93
94 int choice = input.nextInt();
95
96 while(choice != 0) {
97 switch(choice) {
98 case 1://Circle
99 double radius = input.nextDouble();
100 Shape circle = new Circle(radius);
101 list.add(circle);
102 break;
103 case 2://Rectangle
104 double x1 = input.nextDouble();
105 double y1 = input.nextDouble();
106 double x2 = input.nextDouble();
107 double y2 = input.nextDouble();
108 Point leftTopPoint = new Point(x1,y1);
109 Point lowerRightPoint = new Point(x2,y2);
110 Rectangle rectangle = new Rectangle(leftTopPoint,lowerRightPoint);
111 list.add(rectangle);
112 break;
113 }
114 choice = input.nextInt();
115 }
116
117 list.sort(Comparator.naturalOrder());//正向排序
118
119 for(int i = 0; i < list.size(); i++) {
120 System.out.print(String.format("%.2f", list.get(i).getArea()) + " ");
121 }
122 }
123 }
类图：
这段代码涉及到的知识点有：抽象类、继承、多态、接口、比较器、输入输出、集合等。
需要改进的地方：
1. 在Rectangle类中，应该添加合适的构造方法来初始化upperLeft和lowerRight属性，而不是通过set方法来设置。
2. 在Main类中，应该添加输入验证，确保输入的选择是合法的。
写出这段代码的心得：
这段代码展示了面向对象编程的一些基本概念和用法。通过抽象类Shape和具体类Circle、Rectangle的继承关系，实现了多态性。通过实现Comparable接口和重写compareTo方法，实现了Shape对象的比较。通过Scanner类实现了用户输入的读取，通过ArrayList集合来存储Shape对象。这段代码的设计思路清晰，结构合理，可以方便地扩展和修改。
7-4 测验4-抽象类与接口 分数 40 作者 段喜龙 单位 南昌航空大学在测验3的题目基础上，重构类设计，实现列表内图形的排序功能（按照图形的面积进行排序）。
这道题目主要涉及面向对象的设计和实现，以及排序算法的应用。下面对题目进行分析和解答。
首先，题目要求创建一个圆形类和一个矩形类，并实现计算面积的功能。圆形类的私有属性是半径，矩形类的属性是左上角和右下角的坐标点。可以分别创建Circle和Rectangle类，并在类中定义计算面积的方法。
其次，题目要求设计一个抽象类Shape作为父类，Circle和Rectangle作为子类。这是为了实现多态性，方便对不同类型的图形进行统一的操作。在Shape类中，可以定义一个抽象方法getArea()，在Circle和Rectangle类中分别实现该方法。
然后，题目要求重构类设计，实现列表内图形的排序功能，按照图形的面积进行排序。这里可以使用Comparable接口来实现排序功能。在Shape类中实现Comparable接口，并重写compareTo()方法，根据图形的面积进行比较。
最后，根据输入的图形类型和参数，创建相应的图形对象，并将其添加到列表中。然后对列表进行排序，并按照要求输出排序后的图形面积。
总结起来，这道题目的难度主要在于对面向对象的理解和应用，以及对排序算法的掌握。重难点包括设计类的继承关系、实现抽象方法和接口、以及使用排序算法对对象进行排序。知识点涉及面向对象的基本概念、抽象类和接口的使用、以及排序算法的原理和实现。
源码：
1 import java.util.ArrayList;
2 import java.util.Collections;
3 import java.util.List;
4 import java.util.Scanner;
5
6 abstract class Shape implements Comparable<Shape> {
7 abstract double getArea();
8
9 @Override
10 public int compareTo(Shape shape) {
11 return Double.compare(this.getArea(), shape.getArea());
12 }
13 }
14
15 class Circle extends Shape {
16 private double radius;
17
18 public Circle(double radius) {
19 this.radius = radius;
20 }
21
22 @Override
23 double getArea() {
24 return Math.PI * radius * radius;
25 }
26 }
27
28 class Rectangle extends Shape {
29 private double x1, y1, x2, y2;
30
31 public Rectangle(double x1, double y1, double x2, double y2) {
32 this.x1 = x1;
33 this.y1 = y1;
34 this.x2 = x2;
35 this.y2 = y2;
36 }
37
38 @Override
39 double getArea() {
40 return Math.abs(x2 - x1) * Math.abs(y2 - y1);
41 }
42 }
43
44 public class Main {
45 public static void main(String[] args) {
46 Scanner scanner = new Scanner(System.in);
47 List<Shape> shapes = new ArrayList<>();
48
49 while (true) {
50 int type = scanner.nextInt();
51 if (type == 0) {
52 break;
53 }
54
55 if (type == 1) {
56 double radius = scanner.nextDouble();
57 shapes.add(new Circle(radius));
58 } else if (type == 2) {
59 double x1 = scanner.nextDouble();
60 double y1 = scanner.nextDouble();
61 double x2 = scanner.nextDouble();
62 double y2 = scanner.nextDouble();
63 shapes.add(new Rectangle(x1, y1, x2, y2));
64 }
65 }
66
67 Collections.sort(shapes);
68
69 for (Shape shape : shapes) {
70 System.out.printf("%.2f ", shape.getArea());
71 }
72 }
73 }
类图：
这段Java代码涉及到的知识点包括抽象类、继承、多态、接口、集合、输入输出、排序等。
需要改进的地方：
1. 在输入部分，没有对输入进行异常处理，如果用户输入非法数据（如字符），程序会抛出异常。可以使用try-catch语句来捕获异常并进行处理。
2. 在输入部分，没有对输入的类型进行验证，如果用户输入的类型不是预期的类型（如输入了负数），程序会继续执行并计算面积，这可能导致错误的结果。可以在输入之前添加一些验证逻辑，确保输入的数据符合要求。
3. 在输出部分，使用了System.out.printf()方法来格式化输出面积，但没有换行。可以在循环结束后添加一个换行符，使输出结果更清晰。
心得体会：
这段代码展示了面向对象编程的一些基本概念和技巧，通过抽象类和多态的使用，可以方便地对不同类型的形状进行统一的操作。使用集合来存储形状对象，并通过实现Comparable接口来实现排序功能，使得形状按照面积大小进行排序输出。这段代码简洁明了，易于理解和扩展。
题目集方面，我有以下改进建议和意见：
1. 提供更详细的题目说明：有时候题目的表述可能不够清晰，容易引起理解上的困惑。建议在题目中提供更详细的说明和示例，以帮助学生更好地理解题意。
2. 强调编码规范和最佳实践：在题目的要求中可以加入对编码规范和最佳实践的要求，例如命名规范、注释要求、代码风格等。这有助于培养良好的编码习惯和提高代码的可读性和可维护性。
3. 提供范例代码和解析：对于每个题目，可以提供范例代码和解析，以便学生参考和学习。这有助于学生理解问题的解决思路和方法。
综合性总结：
这段时间（6-9周）学习Java，我收获了很多知识和技能。首先，我学会了Java的基本语法和面向对象的编程思想。通过学习Java的数据类型、控制流程、数组、类和对象等基础知识，我能够编写简单的Java程序，并且能够理解和分析他人编写的代码。
其次，我学习了Java的核心类库和常用API。Java的标准类库提供了丰富的功能和工具，如集合框架、IO操作、多线程、网络编程等。通过学习这些类库和API，我能够更高效地开发Java应用程序，并且能够解决一些常见的编程问题。
另外，我也学习了Java的异常处理机制和文件操作。异常处理是Java中重要的编程概念，通过学习异常处理，我能够编写更健壮的程序，并且能够更好地处理程序中可能出现的错误。文件操作是Java中常用的功能之一，通过学习文件操作，我能够读写文件、创建目录、删除文件等，这对于实际开发中的数据存储和读取非常有用。
在学习过程中，我也发现了一些需要进一步学习和研究的地方。首先，我需要深入学习Java的多线程编程。多线程是Java中重要的特性之一，通过使用多线程，可以实现程序的并发执行，提高程序的性能。但是多线程编程也存在一些问题，如线程安全、死锁等，我需要进一步学习和理解这些问题，并且学会如何解决它们。
其次，我还需要学习Java的网络编程和数据库操作。网络编程是现代应用开发中不可或缺的一部分，通过学习网络编程，我能够实现网络通信、数据传输等功能。数据库操作是Java应用开发中常用的功能之一，通过学习数据库操作，我能够实现数据的存储和读取，并且能够使用数据库来支持应用程序的功能。
总的来说，这段时间学习Java让我对这门语言有了更深入的了解，我学会了Java的基本语法和面向对象的编程思想，掌握了Java的核心类库和常用API，也学习了Java的异常处理和文件操作。但是我也意识到还有很多需要进一步学习和研究的地方，如多线程编程、网络编程和数据库操作等。通过不断学习和实践，我相信我能够更好地掌握Java编程技术，并且能够在实际开发中运用自如。
意见与建议：
作为学生，我对Java课程的教师、课程内容、作业、实验以及课上和课下的组织方式有一些改进建议和意见。
首先，关于教师方面，我认为教师应该具备扎实的Java编程知识和丰富的实践经验。他们应该能够清晰地传授Java的基本概念和核心知识，并能够引导学生进行实际的编程练习和项目开发。此外，教师应该积极与学生互动，鼓励学生提问和参与讨论，以激发学生的学习兴趣和思考能力。
其次，关于课程内容方面，我建议在设计课程大纲时，应该充分考虑到学生的实际需求和就业市场的需求。课程内容应该包括Java语言的基础知识、面向对象编程、数据结构与算法、多线程编程、网络编程等方面的内容。同时，可以适当引入一些实际应用案例，让学生能够将所学知识应用到实际项目中。
第三，关于作业和实验方面，我认为应该注重实践能力的培养。作业和实验应该具有一定的难度和挑战性，能够让学生运用所学知识解决实际问题。同时，作业和实验应该有明确的要求和评分标准，以便学生能够清楚地知道自己的学习进展和不足之处。
第四，关于课上和课下的组织方式，我建议采用多种教学方法和手段。除了传统的讲授和演示，可以引入案例分析、小组讨论、编程实践等方式，以提高学生的学习效果和参与度。此外，可以利用在线学习平台和资源，提供课程资料、习题和编程练习等，方便学生在课下进行自主学习和巩固。
总之，我希望Java课程能够更加注重实践能力的培养，教师能够具备扎实的专业知识和教学经验，课程内容能够紧密结合实际应用，作业和实验能够有针对性和挑战性，课上和课下的组织方式能够多样化和灵活性。相信通过这些改进和优化，Java课程将能够更好地满足学生的学习需求，提高学生的编程能力和就业竞争力。