一、前言：
第四次PTA作业：难度较大，只有一道题，需要综合运用Java的各种技巧。
第五次PTA作业：难度较大，只有一道题，需要综合运用Java的各种技巧。
期中考试：除最后一题外，难度适中，有四道题。
二、设计与分析
第四次PTA作业：
1、设计分析：
这是一个关于设计点菜计价程序的问题。根据输入的信息，程序将计算并输出总价格。输入内容包括菜单和订单两部分，最后以"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类对应菜谱上一道菜的信息。 Menu类对应菜谱，包含饭店提供的所有菜的信息。 Record类保存订单上的一道菜品记录。 Order类保存用户点的所有菜的信息。
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 sum = 0; 13 int cntTable = 0;//桌号 14 int count; 15 String[] temp; 16 int a1,a2,a3,a4,a5; 17 18 while (true) { 19 String st = sc.nextLine(); 20 temp = st.split(" "); 21 if(st.equals("end")) 22 break; 23 count = temp.length; 24 if (count == 2) {//一个空格 25 //String[] temp1 = st.split(" "); 26 if (temp[1].equals("delete")) {//第二个为delete 27 a1 = Integer.parseInt(temp[0]); 28 int c = tablemes[cntTable].odt.delARecordByOrderNum(a1); 29 tablemes[cntTable].sum-=c; 30 } else {//菜单添加 31 a2 = Integer.parseInt(temp[1]); 32 mu.dishs[j] = mu.addDish(temp[0], a2); 33 j++; 34 } 35 //continue; 36 } 37 else if (count == 4) {//三个空格 38 //String[] temp2 = st.split(" "); 39 if (temp[0].equals("table")) {//桌号 40 cntTable++;//跳过0; 41 l = 0; 42 tablemes[cntTable] = new Table(); 43 //tablemes[cntTable].tableDtime = st; 44 tablemes[cntTable].AheadProcess(st); 45 46 System.out.println("table " + cntTable + ": "); 47 } else {//增加订单的情况； 48 a3 =Integer.parseInt(temp[0]); 49 a4 = Integer.parseInt(temp[2]); 50 a5=Integer.parseInt(temp[3]); 51 tablemes[cntTable].odt.addARecord(a3, temp[1],a4 , a5); 52 tt = mu.searthDish(temp[1]); 53 if (tt != null) { 54 tablemes[cntTable].odt.records[l].d = tt; 55 int a = tablemes[cntTable].odt.records[l].getPrice(); 56 System.out.println(tablemes[cntTable].odt.records[l].orderNum + " " + tt.name + " " +a ); 57 tablemes[cntTable].sum +=a; 58 } 59 l++; 60 } 61 //continue; 62 } 63 64 else if (count == 5) {//代点菜 65 //String[] temp3 = st.split(" "); 66 a1 = Integer.parseInt(temp[1]); 67 a2 = Integer.parseInt(temp[3]); 68 a3 = Integer.parseInt(temp[4]); 69 tablemes[cntTable].odt.addARecord( a1, temp[2], a2, a3); 70 tt = mu.searthDish(temp[2]); 71 if (tt != null) { 72 tablemes[cntTable].odt.records[l].d.unit_price = tt.unit_price; 73 int b = tablemes[cntTable].odt.records[l].getPrice(); 74 System.out.println(temp[1] + " table " + tablemes[cntTable].tableNum + " pay for table " + temp[0] + " " + b); 75 tablemes[cntTable].sum += b; 76 } 77 l++; 78 } 79 //st = sc.nextLine(); 80 81 } 82 for (int i = 1; i < cntTable + 1; i++) { 83 tablemes[i].Gettottalprice(); 84 } 85 } 86 } 87 class Table { 88 int tableNum; 89 String tableDtime; 90 int year,month,day,week,hh,mm,ss; 91 int sum = 0;//一桌价格 ； 92 // boolean f = true; 93 Order odt = new Order(); 94 //Order odre = new Order(); 95 float discnt = -1; 96 void Gettottalprice(){ 97 if(discnt>0){ 98 sum = Math.round(sum*discnt); 99 System.out.println("table " + tableNum + ": " + sum); 100 }else { 101 System.out.println("table " + tableNum + " out of opening hours"); 102 } 103 } 104 void AheadProcess(String tableDtime){ 105 this.tableDtime = tableDtime; 106 processTime(); 107 discount(); 108 //CheckAtime(); 109 } 110 111 112 void processTime(){//处理时间 113 String[] temp = tableDtime.split(" "); 114 tableNum = Integer.parseInt(temp[1]); 115 String[] temp1 = temp[2].split("/"); 116 String[] temp2 = temp[3].split("/"); 117 118 year = Integer.parseInt(temp1[0]); 119 month = Integer.parseInt(temp1[1]); 120 day = Integer.parseInt(temp1[2]); 121 122 Calendar c = Calendar.getInstance(); 123 c.set(year, (month-1), day); 124 week = c.get(Calendar.DAY_OF_WEEK); 125 if(week==1) 126 week = 7; 127 else 128 week--; 129 hh = Integer.parseInt(temp2[0]); 130 mm = Integer.parseInt(temp2[1]); 131 ss = Integer.parseInt(temp2[2]); 132 133 } 134 //void CheckAtime(){ 135 // f= !(discnt < 0); 136 // } 137 void discount(){ 138 if(week>=1&&week<=5) 139 { 140 if(hh>=17&&hh<20) 141 discnt=0.8F; 142 else if(hh==20&&mm<30) 143 discnt=0.8F; 144 else if(hh==20&&mm==30&&ss==0) 145 discnt=0.8F; 146 else if(hh>=11&&hh<=13||hh==10&&mm>=30) 147 discnt=0.6F; 148 else if(hh==14&&mm<30) 149 discnt=0.6F; 150 else if(hh==14&&mm==30&&ss==0) 151 discnt=0.6F; 152 } 153 else 154 { 155 if(hh>=10&&hh<=20) 156 discnt= 1.0F; 157 else if(hh==9&&mm>=30) 158 discnt= 1.0F; 159 else if(hh==21&&mm<30||hh==21&&mm==30&&ss==0) 160 discnt= 1.0F; 161 } 162 } 163 } 164 class Order { 165 Record[] records = new Record[10];//保存订单上每一道的记录 166 int count = 0;//订单数量 167 //int forcount = 0;//代点菜的数量 168 /*int getTotalPrice(){ 169 int sum=0; 170 for(int i=0;i<count;i++){ 171 if(records[i].exist==0) 172 continue; 173 sum=sum+records[i].getPrice(); 174 } 175 return sum; 176 }//计算订单的总价*/ 177 void addARecord(int orderNum,String dishName,int portion,int num){ 178 records[count] = new Record(); 179 records[count].d.name = dishName; 180 records[count].orderNum = orderNum; 181 records[count].portion = portion; 182 records[count].num = num; 183 count++; 184 }//添加一条菜品信息到订单中。 185 /*Record TakeOdfor(int AnotherNUm,int orderNum,String dishName,int portion,int num){ 186 Record rd2 = new Record(); 187 rd2.d.name = dishName; 188 rd2.orderNum = orderNum; 189 rd2.portion = portion; 190 rd2.d.num = num; 191 rd2.AntherOrderNum = AnotherNUm; 192 //forcount++; 193 return rd2; 194 }*/ 195 int delARecordByOrderNum(int orderNum){ 196 if(orderNum>count||orderNum<=0){ 197 System.out.println("delete error;"); 198 return 0; 199 }else { 200 return records[orderNum - 1].getPrice(); 201 } 202 }//根据序号删除一条记录 203 } 204 class Record { 205 int orderNum;//序号\ 206 //int AntherOrderNum; 207 Dish d = new Dish();//菜品\ 208 int num = 0; 209 int portion;//份额（1/2/3代表小/中/大份）\ 210 //int exist = 1; 211 int getPrice(){ 212 return d.getPrice(portion)*num; 213 }//计价，计算本条记录的价格\ 214 } 215 class Menu { 216 Dish[] dishs = new Dish[10];//菜品数组，保存所有菜品信息 217 int count = 0; 218 Dish searthDish(String dishName){ 219 Dish temd = null; 220 for(int i=count-1;i>=0;i--){ 221 if(dishName.equals(dishs[i].name)){ 222 temd = dishs[i]; 223 break; 224 } 225 } 226 if(temd==null){ 227 System.out.println(dishName+" does not exist"); 228 } 229 return temd; 230 }//根据菜名在菜谱中查找菜品信息，返回Dish对象。 231 Dish addDish(String dishName,int unit_price){ 232 Dish dh = new Dish(); 233 dh.name = dishName; 234 dh.unit_price = unit_price; 235 count++; 236 return dh; 237 }//添加一道菜品信息 238 } 239 class Dish { 240 String name;//菜品名称 241 int unit_price; //单价 242 //int num; 243 244 int getPrice(int portion) { 245 int peic = 0; 246 if (portion == 1) { 247 peic = unit_price ; 248 } else if (portion == 2) { 249 peic = Math.round((float) (unit_price * 1.5)) ; 250 } else if (portion == 3) { 251 peic = (unit_price * 2) ; 252 } 253 return peic;//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） 254 } 255 }
2、源码分析：
这些代码实现了一个点菜计价程序。程序中定义了几个类，包括Main、Table、Order、Record、Menu和Dish。
Main类是程序的入口点，它包含一个名为main的静态方法。在这个方法中，首先创建了一个名为sc的Scanner对象来读取用户输入。然后创建了一个名为mu的Menu对象来存储菜单信息，以及一个名为tablemes的数组来存储桌子信息。
接下来，程序进入一个循环，不断读取用户输入并进行处理。如果输入为"end"，则退出循环。否则，根据输入内容的不同进行不同的处理。
如果输入内容包含两个部分（即包含一个空格），则判断第二部分是否为"delete"。如果是，则根据第一部分指定的序号删除对应的点菜记录。否则，将输入内容作为菜单信息添加到菜单中。
如果输入内容包含四个部分（即包含三个空格），则判断第一部分是否为"table"。如果是，则将输入内容作为桌号标识进行处理。否则，将输入内容作为点菜记录添加到订单中。
如果输入内容包含五个部分（即包含四个空格），则将输入内容作为代点菜信息进行处理。
在循环结束后，程序遍历所有桌子并输出每一桌的总价。
除了主类之外，还有其他几个类用于实现程序的功能。
Table类表示一张桌子。它包含若干个字段用于存储桌子的信息，如桌号、时间、总价等。它还包含若干个方法用于处理桌子相关的操作，如计算总价、处理时间和折扣等。Order类表示一张订单。它包含一个名为records的数组用于存储订单上的所有点菜记录。它还包含若干个方法用于处理订单相关的操作，如添加点菜记录、删除点菜记录等。Record类表示一条点菜记录。它包含若干个字段用于存储点菜记录的信息，如序号、菜品、份额、份数等。它还包含一个名为getPrice的方法用于计算本条记录的价格。Menu类表示菜单。它包含一个名为dishs的数组用于存储所有菜品信息。它还包含若干个方法用于处理菜单相关的操作，如查找菜品信息、添加菜品信息等。-
Dish类表示一道菜品。它包含若干个字段用于存储菜品的信息，如名称、单价等。它还包含一个名为getPrice的方法用于计算菜品的价格。该方法根据点菜的份额（输入数据只能是1/2/3，代表小/中/大份）来计算菜品的价格。这些类通过相互协作来实现点菜计价程序的功能。在程序运行过程中，用户可以输入菜单信息、桌号标识、点菜记录、删除记录和代点菜信息等内容。程序会根据输入内容进行相应的处理，并在最后输出每一桌的总价。
类图;
第五次PTA作业：
1、设计分析：
这是一个关于点菜计价程序的问题。在输入菜单时，可以增加特色菜。特色菜的输入格式为：菜品名+英文空格+口味类型+英文空格+基础价格+“T”。例如：麻婆豆腐 川菜 9 T。
特色菜的口味类型包括川菜、晋菜和浙菜。川菜增加辣度值，辣度0-5级；对应辣度水平为：不辣、微辣、稍辣、辣、很辣、爆辣。晋菜增加酸度值，酸度0-4级；对应酸度水平为：不酸、微酸、稍酸、酸、很酸。浙菜增加甜度值，甜度0-3级；对应酸度水平为：不甜、微甜、稍甜、甜。
输入订单记录时，如果是特色菜，则需要添加口味度（辣/酸/甜度）值。格式为：序号+英文空格+菜名+英文空格+口味度值+英文空格+份额+英文空格+份数。
单条信息在处理时，如果口味度超过正常范围，输出"spicy/acidity/sweetness num out of range : "+口味度值，spicy/acidity/sweetness（辣度/酸度/甜度）根据菜品类型择一输出。
输出一桌的信息时，按辣、酸、甜度的顺序依次输出本桌菜各种口味的口味度水平。如果没有某个类型的菜，则对应的口味（辣/酸/甜）度不输出，只输出已点的菜的口味度。口味度水平由口味度平均值确定，口味度平均值只综合对应口味菜系的菜计算，不做所有菜的平均。
一桌信息的输出格式为：table+英文空格+桌号+“:”+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格+“川菜”+数量+辣度+英文空格+“晋菜”+数量+酸度+英文空格+“浙菜”+数量+甜度。
如果整桌菜没有特色菜，则只输出table的基本信息。
计算口味度时要累计本桌各类菜系所有记录的口味度总和（每条记录的口味度乘以菜的份数），再除以对应菜系菜的总份数，最后四舍五入。
此外，还需要考虑客户订多桌菜的情况。输入时桌号时，需要增加用户的信息。格式为：table+英文空格+桌号+英文空格+": "+英文空格+客户姓名+英文空格+手机号+日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）。
约束条件：客户姓名不超过10个字符，手机号11位，前三位必须是180、181、189、133、135、136其中之一。
输出结果时，先按要求输出每一桌的信息，最后按字母顺序依次输出每位客户需要支付的金额。不考虑各桌时间段的问题，同一个客户的所有table金额都要累加。
输出用户支付金额格式为：用户姓名+英文空格+手机号+英文空格+支付总金额。
这些是点菜计价程序的一些新功能和约束条件。在设计程序时，需要考虑这些内容并进行相应的处理。
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; 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 String[] token = str1.split(" "); 32 if (str1.matches("[\\S]* [1-9][\\d]*")) { 33 temp.name = token[0]; 34 temp.unit_price = Integer.parseInt(token[1]); 35 if (temp.unit_price > 300) { 36 System.out.println(temp.name + " price out of range " + temp.unit_price); 37 continue; 38 } 39 temp.isT = false; 40 isRepeat = menu.searchDish(temp.name); 41 if (isRepeat != -1) { 42 menu.dishs.remove(isRepeat); 43 } 44 menu.dishs.add(temp); 45 } else if (str1.matches("[\\S]* [\\S]* [\\d]* T")) { 46 temp.name = token[0]; 47 temp.unit_price = Integer.parseInt(token[2]); 48 if (temp.unit_price > 300) { 49 System.out.println(temp.name + " price out of range " + temp.unit_price); 50 continue; 51 } 52 temp.isT = true; 53 switch (token[1]) { 54 case "川菜": 55 temp.FlavorType = "spicy"; 56 temp.MaxFlavor = 5; 57 break; 58 case "晋菜": 59 temp.FlavorType = "acidity"; 60 temp.MaxFlavor = 4; 61 break; 62 case "浙菜": 63 temp.FlavorType = "sweetness"; 64 temp.MaxFlavor = 3; 65 break; 66 } 67 isRepeat = menu.searchDish(temp.name); 68 if (isRepeat != -1) { 69 menu.dishs.remove(isRepeat); 70 } 71 menu.dishs.add(temp); 72 } else if (str1.equals("end")) { 73 break; 74 } else if (str1.matches("tab.*")) { 75 break; 76 77 } else { 78 System.out.println("wrong format"); 79 } 80 } 81 while (!str1.equals("end")) { 82 Table temp = new Table(); 83 boolean isRepeat = false; 84 int repeatNum = -1; 85 if (str1.matches(".*t.*a.*")) { 86 if (str1.matches("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.println("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 if (temp.num > 55) { 116 System.out.println(temp.num + " table num out of range"); 117 str1 = input.nextLine(); 118 continue; 119 120 } 121 try { 122 temp.time = LocalDateTime.of(intDate[0], intDate[1], intDate[2], intTime[0], intTime[1], 123 intTime[2]); 124 temp.getWeekDay(); 125 } catch (DateTimeException e) { 126 System.out.println(temp.num + " date error"); 127 str1 = input.nextLine(); 128 continue; 129 } 130 if (!temp.isOpen()) { 131 System.out.println("table " + temp.num + " out of opening hours"); 132 str1 = input.nextLine(); 133 continue; 134 } 135 if (!(temp.time.isAfter(LocalDateTime.of(2022, 1, 1, 0, 0, 0)) 136 && temp.time.isBefore(LocalDateTime.of(2024, 1, 1, 0, 0, 0)))) { 137 System.out.println("not a valid time period"); 138 str1 = input.nextLine(); 139 continue; 140 } 141 for (i = 0; i < tables.size(); i++) { 142 143 if (temp.num == tables.get(i).num && tables.get(i).isOpen()) { 144 Duration duration = Duration.between(temp.time, tables.get(i).time); 145 146 if (duration.toDays() == 0) { 147 148 if (temp.weekday > 0 && temp.weekday < 6) { 149 150 if (temp.time.getHour() < 15 && tables.get(i).time.getHour() < 15) { 151 isRepeat = true; 152 repeatNum = i; 153 break; 154 } 155 } else { 156 157 if (duration.toHours() < 3600) { 158 repeatNum = i; 159 isRepeat = true; 160 break; 161 } 162 } 163 } 164 } 165 } 166 167 System.out.println("table " + temp.num + ": "); 168 } else { 169 System.out.println("wrong format"); 170 str1 = input.nextLine(); 171 continue; 172 } 173 // 本桌开始点菜 174 while (true) { 175 str1 = input.nextLine(); 176 177 if (str1.matches("[1-9][\\d]* [\\S]* [\\d] [1-9][\\d]*")) { 178 String[] token = str1.split(" "); 179 portion = Integer.parseInt(token[2]); 180 quota = Integer.parseInt(token[3]); 181 if (menu.searchDish(token[1]) == -1) { 182 System.out.println(token[1] + " does not exist"); 183 continue; 184 } 185 Record tempRecord = new Record(); 186 tempRecord.d = menu.dishs.get(menu.searchDish(token[1])); 187 tempRecord.orderNum = Integer.parseInt(token[0]); 188 tempRecord.portion = portion; 189 tempRecord.quota = quota; 190 temp.records.add(tempRecord); 191 System.out.println(tempRecord.orderNum + " " + token[1] + " " + tempRecord.getPrice()); 192 } else if (str1.matches("[1-9][\\d]* [\\S]* [\\d] [\\d] [1-9][\\d]*")) { 193 String[] token = str1.split(" "); 194 int FlavorNum = Integer.parseInt(token[2]); 195 if (FlavorNum < 0 || FlavorNum > menu.dishs.get(menu.searchDish(token[1])).MaxFlavor) { 196 System.out.println(menu.dishs.get(menu.searchDish(token[1])).FlavorType + " num out of range :" + FlavorNum); 197 continue; 198 } 199 portion = Integer.parseInt(token[3]); 200 quota = Integer.parseInt(token[4]); 201 if (menu.searchDish(token[1]) == -1) { 202 System.out.println(token[1] + " does not exist"); 203 continue; 204 } 205 Record tempRecord = new Record(); 206 tempRecord.d = menu.dishs.get(menu.searchDish(token[1])); 207 tempRecord.FlavorNum = FlavorNum; 208 tempRecord.orderNum = Integer.parseInt(token[0]); 209 tempRecord.portion = portion; 210 tempRecord.quota = quota; 211 temp.records.add(tempRecord); 212 System.out.println(tempRecord.orderNum + " " + token[1] + " " + tempRecord.getPrice()); 213 } else if (str1.matches("[1-9][\\d]* delete")) { 214 String[] token = str1.split(" "); 215 int delNum = Integer.parseInt(token[0]); 216 217 for (i = 0; i < temp.records.size(); i++) { 218 if (temp.records.get(i).orderNum == delNum) { 219 if (!temp.records.get(delNum).isDeleted) { 220 temp.records.get(delNum).isDeleted = true; 221 } else { 222 System.out.println("deduplication :" + delNum); 223 } 224 break; 225 } 226 if (i == temp.records.size() - 1) { 227 System.out.println("delete error"); 228 } 229 } 230 231 } else if (str1.matches("[\\S]* [\\d]*")) { 232 System.out.println("invalid dish"); 233 continue; 234 } else if (str1.matches("[\\S]* [\\S]* [\\d]* T")) { 235 System.out.println("invalid dish"); 236 continue; 237 } else if (str1.matches("[\\d]* [\\d]* [\\S].*")) {String[] token = str1.split(" "); 238 239 boolean exist = false; 240 int j = 0; 241 for (j = 0; j < tables.size(); j++) { 242 if (tables.get(j).num == Integer.parseInt(token[0])) { 243 exist = true; 244 break; 245 } 246 } 247 if (exist) { 248 System.out.print(Integer.parseInt(token[1]) + " table " + temp.num + " pay for table " 249 + Integer.parseInt(token[0]) + " "); 250 Record treat = new Record(); 251 treat.d = menu.dishs.get(menu.searchDish(token[2])); 252 if (treat.d.isT) { 253 treat.FlavorNum = Integer.parseInt(token[3]); 254 treat.portion = Integer.parseInt(token[4]); 255 treat.quota = Integer.parseInt(token[5]); 256 if (treat.d.FlavorType.equals("spicy")) { 257 tables.get(j).ChuanNum += treat.quota; 258 tables.get(j).spicyType += treat.FlavorNum * treat.quota; 259 } 260 if (treat.d.FlavorType.equals("acidity")) { 261 tables.get(j).JinNum += treat.quota; 262 tables.get(j).spicyType += treat.FlavorNum * treat.quota; 263 } 264 if (treat.d.FlavorType.equals("sweetness")) { 265 tables.get(j).ZheNum += treat.quota; 266 tables.get(j).spicyType += treat.FlavorNum * treat.quota; 267 } 268 } else { 269 treat.portion = Integer.parseInt(token[3]); 270 treat.quota = Integer.parseInt(token[4]); 271 } 272 System.out.print(treat.getPrice() + "\n"); 273 treat.isTreat = true; 274 temp.records.add(treat); 275 } else { 276 System.out.println("Table number ：" + Integer.parseInt(token[0]) + " does not exist"); 277 } 278 279 } else if (str1.equals("end")) { 280 break; 281 } else if (str1.matches("table.*")) { 282 break; 283 } else { 284 System.out.println("wrong format"); 285 continue; 286 } 287 } 288 // 本桌点菜结束，进入下一桌 289 if (isRepeat) { 290 for (i = 0; i < tables.get(repeatNum).records.size(); i++) { 291 for (int j = 0; j < temp.records.size(); j++) { 292 if (tables.get(repeatNum).records.get(i).d.name == temp.records.get(j).d.name) { 293 if (tables.get(repeatNum).records.get(i).portion == temp.records 294 .get(j).portion) { 295 tables.get(repeatNum).records.get(i).quota += temp.records.get(j).quota; 296 temp.records.remove(j); 297 } 298 } 299 300 } 301 302 } 303 tables.get(repeatNum).records.addAll(temp.records); 304 continue; 305 } 306 tables.add(temp); 307 } else { 308 str1 = input.nextLine(); 309 } 310 } 311 312 // 最终输出桌号订单信息 313 for (i = 0; i < tables.size(); i++) { 314 if (tables.get(i).isOpen()) { 315 tables.get(i).getSum(); 316 tables.get(i).getFlavorNum(); 317 if (i != 0) { 318 System.out.print("\n"); 319 } 320 tables.get(i).showEnd(); 321 boolean isRepeat = false; 322 for (int j = 0; j < users.size(); j++) { 323 if (tables.get(i).userName.equals(users.get(j).userName)) { 324 users.get(j).paidMoney += tables.get(i).sum; 325 isRepeat = true; 326 break; 327 } 328 } 329 if (!isRepeat) { 330 User tempUser = new User(); 331 tempUser.userName = tables.get(i).userName; 332 tempUser.callNum = tables.get(i).callNum; 333 tempUser.paidMoney = tables.get(i).sum; 334 users.add(tempUser); 335 } 336 } 337 338 } 339 users.sort(new Comparator<User>() { 340 public int compare(User a, User b) { 341 return a.userName.compareTo(b.userName); 342 } 343 }); 344 for (i = 0; i < users.size(); i++) { 345 System.out.print("\n" + users.get(i).userName + " " + users.get(i).callNum + " " + users.get(i).paidMoney); 346 } 347 } 348 349 static class Dish { 350 String name; 351 String FlavorType; 352 int MaxFlavor; 353 int unit_price; 354 boolean isT = false; 355 } 356 357 static class Record { 358 int orderNum; 359 Dish d; 360 int FlavorNum; 361 int portion; 362 int quota; 363 boolean isDeleted = false; 364 boolean isTreat = false; 365 366 int getPrice() { 367 if (portion == 2) 368 return (int) Math.round(1.5 * d.unit_price) * quota; 369 else if (portion == 3) 370 return 2 * d.unit_price * quota; 371 else 372 return d.unit_price * quota; 373 } 374 } 375 376 static class Menu { 377 ArrayList<Dish> dishs = new ArrayList<Dish>(); 378 379 int searchDish(String dishName) { 380 for (int i = 0; i < dishs.size(); i++) { 381 if (dishName.equals(dishs.get(i).name)) { 382 return i; 383 } 384 } 385 return -1; 386 } 387 388 Dish addDish(String dishName, int unit_price) { 389 Dish newDish = new Dish(); 390 newDish.name = dishName; 391 newDish.unit_price = unit_price; 392 return newDish; 393 } 394 } 395 396 static class User { 397 String userName; 398 String callNum; 399 long paidMoney; 400 } 401 static class Table { 402 ArrayList<Record> records = new ArrayList<Record>(); 403 int num; 404 String userName; 405 String callNum; 406 LocalDateTime time; 407 int weekday; 408 int ChuanNum = 0; 409 float spicyType = 0; 410 int JinNum = 0; 411 float acidType = 0; 412 int ZheNum = 0; 413 float sweetType = 0; 414 long sum = 0; 415 long origSum = 0; 416 417 void getWeekDay() { 418 weekday = time.getDayOfWeek().getValue(); 419 } 420 421 void getFlavorNum() { 422 for (int i = 0; i < records.size(); i++) { 423 if (records.get(i).d.isT && !records.get(i).isDeleted && !records.get(i).isTreat) { 424 if (records.get(i).d.FlavorType.equals("spicy")) { 425 ChuanNum += records.get(i).quota; 426 spicyType += records.get(i).FlavorNum * records.get(i).quota; 427 } 428 if (records.get(i).d.FlavorType.equals("acidity")) { 429 JinNum += records.get(i).quota; 430 acidType += records.get(i).FlavorNum * records.get(i).quota; 431 } 432 if (records.get(i).d.FlavorType.equals("sweetness")) { 433 ZheNum += records.get(i).quota; 434 sweetType += records.get(i).FlavorNum * records.get(i).quota; 435 } 436 } 437 } 438 if (ChuanNum != 0) { 439 spicyType = Math.round(spicyType / ChuanNum * 1.0); 440 } 441 if (JinNum != 0) { 442 acidType = Math.round(acidType / JinNum * 1.0); 443 } 444 if (ZheNum != 0) { 445 sweetType = Math.round(sweetType / ZheNum * 1.0); 446 } 447 } 448 449 void showEnd() { 450 System.out.print("table " + num + ": " + origSum + " " + sum); 451 452 if (ChuanNum != 0) { 453 System.out.print(" 川菜 " + ChuanNum); 454 switch ((int) spicyType) { 455 case 0: 456 System.out.print(" 不辣"); 457 break; 458 case 1: 459 System.out.print(" 微辣"); 460 break; 461 case 2: 462 System.out.print(" 稍辣"); 463 break; 464 case 3: 465 System.out.print(" 辣"); 466 break; 467 case 4: 468 System.out.print(" 很辣"); 469 break; 470 case 5: 471 System.out.print(" 爆辣"); 472 break; 473 } 474 } 475 476 if (JinNum != 0) { 477 System.out.print(" 晋菜 " + JinNum); 478 switch ((int) acidType) { 479 case 0: 480 System.out.print(" 不酸"); 481 break; 482 case 1: 483 System.out.print(" 微酸"); 484 break; 485 case 2: 486 System.out.print(" 稍酸"); 487 break; 488 case 3: 489 System.out.print(" 酸"); 490 break; 491 case 4: 492 System.out.print(" 很酸"); 493 break; 494 } 495 } 496 497 if (ZheNum != 0) { 498 System.out.print(" 浙菜 " + ZheNum); 499 switch ((int) sweetType) { 500 case 0: 501 System.out.print(" 不甜"); 502 break; 503 case 1: System.out.print(" 微甜"); 504 break; 505 case 2: 506 System.out.print(" 稍甜"); 507 break; 508 case 3: 509 System.out.print(" 甜"); 510 break; 511 } 512 } 513 514 } 515 516 void getSum() { 517 for (int i = 0; i < records.size(); i++) { 518 if (!records.get(i).isDeleted) { 519 origSum += records.get(i).getPrice(); 520 if (records.get(i).d.isT) { 521 if (weekday > 0 && weekday < 6) { 522 sum += Math.round(records.get(i).getPrice() * 0.7); 523 } else { 524 sum += records.get(i).getPrice(); 525 } 526 } else { 527 if (weekday > 0 && weekday < 6) { 528 if (time.getHour() >= 17 && time.getHour() < 20) 529 sum += Math.round(records.get(i).getPrice() * 0.8); 530 if (time.getHour() == 20) { 531 if (time.getMinute() <= 30) 532 sum += Math.round(records.get(i).getPrice() * 0.8); 533 } 534 if (time.getHour() >= 10 && time.getHour() < 14) 535 sum += Math.round(records.get(i).getPrice() * 0.6); 536 if (time.getHour() == 14) { 537 if (time.getMinute() <= 30) 538 sum += Math.round(records.get(i).getPrice() * 0.6); 539 } 540 } else 541 sum += records.get(i).getPrice(); 542 } 543 } 544 } 545 546 } 547 548 boolean isOpen() { 549 if (weekday > 0 && weekday < 6) { 550 if (time.getHour() >= 17 && time.getHour() < 20) 551 return true; 552 if (time.getHour() == 20) { 553 if (time.getMinute() <= 30) 554 return true; 555 } 556 if (time.getHour() > 10 && time.getHour() < 14) 557 return true; 558 if (time.getHour() == 10) { 559 if (time.getMinute() >= 30) 560 return true; 561 } 562 if (time.getHour() == 14) { 563 if (time.getMinute() <= 30) 564 return true; 565 } 566 } else { 567 if (time.getHour() > 9 && time.getHour() < 21) 568 return true; 569 if (time.getHour() == 9) { 570 if (time.getMinute() >= 30) 571 return true; 572 } 573 if (time.getHour() == 21) { 574 if (time.getMinute() <= 30) 575 return true; 576 } 577 } 578 return false; 579 580 } 581 } 582 }
2、源码分析：
这段代码定义了一个名为 Main 的公共类，其中包含两个静态方法：isNumeric 和 main。
isNumeric 方法接受一个字符串作为参数，并尝试将其转换为整数。如果转换成功，则返回 true，否则返回 false。
main 方法是程序的入口点。它首先创建了一个名为 menu 的 Menu 对象，两个 ArrayList 对象分别用于存储 Table 和 User 对象，以及一个名为 input 的 Scanner 对象用于读取用户输入。
接下来，该方法定义了一些变量，包括字符串变量 str1，整数变量 i, portion, 和 quota。
然后进入一个无限循环。在循环中，首先创建一个名为 temp 的新的 Dish 对象，并将变量 isRepeat 初始化为 -1。然后读取用户输入并将其存储在变量 str1 中。接着使用空格将输入字符串分割成若干个子字符串，并将结果存储在字符串数组 token 中。
接下来是一系列的条件判断语句。如果输入字符串匹配正则表达式 [\\S]* [1-9][\\d]*"，则执行以下操作：
- 将
temp.name设置为子字符串数组的第一个元素。 - 将
temp.unit_price设置为子字符串数组的第二个元素所表示的整数。 - 如果
temp.unit_price > 300, 则输出错误信息并继续下一次循环。 - 将
temp.isT设置为false. - 调用
menu.searchDish(temp.name)方法并将返回值存储在变量isRepeat中。 - 如果变量
isRepeat != -1, 则从菜单中删除索引为isRepeat的菜品。 - 将新创建的菜品添加到菜单中。
如果输入字符串匹配正则表达式 [\\S]* [\\S]* [\\d]* T"，则执行以下操作：
- 将
temp.name设置为子字符串数组的第一个元素。 - 将
temp.unit_price设置为子字符串数组的第三个元素所表示的整数。 - 如果
temp.unit_price > 300, 则输出错误信息并继续下一次循环。 - 将
temp.isT设置为true. - 根据子字符串数组的第二个元素，设置
temp.FlavorType和temp.MaxFlavor的值。 - 调用
menu.searchDish(temp.name)方法并将返回值存储在变量isRepeat中。 - 如果变量
isRepeat != -1, 则从菜单中删除索引为isRepeat的菜品。 - 将新创建的菜品添加到菜单中。
如果输入字符串等于 "end"，则退出循环。如果输入字符串匹配正则表达式 "tab.*"，则退出循环。否则，输出错误信息。
接下来是另一个循环，直到输入字符串等于 "end" 为止。在循环中，首先创建一个名为 temp 的新的 Table 对象，并将变量 isRepeat 初始化为 false，变量 repeatNum 初始化为 -1。
接下来是一系列的条件判断语句。如果输入字符串匹配正则表达式 ".*t.*a.*" 并且匹配正则表达式 "table [1-9][\\d]* : [\\S]* [\\d]* [\\d]*/[\\d][\\d]?/[\\d][\\d]? [\\d][\\d]?/[\\d][\\d]?/[\\d][\\d]?"，则执行以下操作：
- 使用空格将输入字符串分割成若干个子字符串，并将结果存储在字符串数组
token中。 - 将
temp.userName设置为子字符串数组的第四个元素。 - 如果子字符串数组的第四个元素的长度大于 10，则读取下一行输入并输出错误信息，然后继续下一次循环。
- 将
temp.callNum设置为子字符串数组的第五个元素。 - 如果子字符串数组的第五个元素的长度不等于 11，则读取下一行输入并输出错误信息，然后继续下一次循环。
类图：
期中考试：
7-1 测验1-圆类设计：
1、设计分析：
这道题目要求创建一个名为 Circle 的类，它具有一个私有属性，表示圆的半径。程序需要从控制台读取圆的半径，然后计算并输出圆的面积。
输入格式为一个数值，表示圆的半径，取值范围为 (0, +∞)。如果输入数据非法，则程序应输出 “Wrong Format”。
输出格式为一个数值，表示圆的面积，保留两位小数。可以使用 String.format("%.2f", 输出数值) 来控制精度。
1 import java.util.*; 2 3 public class Main { 4 public static void main(String[] args) { 5 Circle circle = new Circle(); 6 7 } 8 } 9 class Circle{ 10 private double radius; 11 Scanner s = new Scanner(System.in); 12 double r = s.nextDouble(); 13 public Circle() { 14 if(r <= 0 ){ 15 System.out.println("Wrong Format"); 16 }else{ 17 this.radius = r; 18 System.out.println(String.format("%.2f", getRadius())); 19 } 20 } 21 public double getRadius(){ 22 return Math.PI*radius*radius; 23 } 24 25 26 }
2、源码分析：
这段代码定义了一个名为 Circle 的类，它具有一个私有属性 radius，表示圆的半径。在 Circle 类中，还定义了一个 Scanner 对象 s，用于从控制台读取输入。
在 Circle 类的构造函数中，首先使用 s.nextDouble() 方法读取一个双精度浮点数作为圆的半径，并将其赋值给变量 r。然后，判断 r 是否小于等于 0。如果是，则输出 “Wrong Format”。否则，将 r 赋值给私有属性 radius，并调用 getRadius() 方法计算圆的面积，最后使用 String.format("%.2f", getRadius()) 控制精度并输出结果。
在 Circle 类中，还定义了一个名为 getRadius() 的公共方法，它返回圆的面积。计算公式为 Math.PI * radius * radius。
在主类 Main 中的 main 方法中，创建了一个新的 Circle 对象，并调用其构造函数。
这段代码实现了题目要求的功能，但是有一些可以改进的地方。例如，在构造函数中直接读取输入并进行计算可能不是最佳实践。更好的做法是在主方法中读取输入，并将其作为参数传递给构造函数。此外，方法名 getRadius() 可能会让人误解为返回圆的半径，而不是面积。更好的命名方式是使用 getArea()。
类图：
7-2 测验2-类结构设计：
1、设计分析：
这道题目要求使用 Java 设计一个矩形类，其属性由矩形左上角坐标点 (x1, y1) 及右下角坐标点 (x2, y2) 组成。程序需要从控制台读取这两个坐标点的坐标值，然后计算并输出矩形的面积。
输入格式为四个实型数，分别表示两个坐标点的坐标值 x1、y1、x2、y2。
输出格式为一个实型数，表示矩形的面积，保留两位小数。
1 import java.util.Scanner; 2 3 public class Main { 4 public static void main(String[] args) { 5 Scanner scanner = new Scanner(System.in); 6 double x1 = scanner.nextDouble(); 7 double y1 = scanner.nextDouble(); 8 double x2 = scanner.nextDouble(); 9 double y2 = scanner.nextDouble(); 10 Rectangle rectangle = new Rectangle(x1, y1, x2, y2); 11 System.out.println(String.format("%.2f", rectangle.getArea())); 12 } 13 } 14 15 class Rectangle { 16 private double x1; 17 private double y1; 18 private double x2; 19 private double y2; 20 21 public Rectangle(double x1, double y1, double x2, double y2) { 22 this.x1 = x1; 23 this.y1 = y1; 24 this.x2 = x2; 25 this.y2 = y2; 26 } 27 28 public double getArea() { 29 return Math.abs((x2 - x1) * (y2 - y1)); 30 } 31 }
2、源码分析：
这段代码定义了一个名为 Rectangle 的类，它具有四个私有属性 x1、y1、x2 和 y2，分别表示矩形左上角坐标点 (x1, y1) 及右下角坐标点 (x2, y2) 的坐标值。
在 Rectangle 类的构造函数中，接收四个参数，分别表示两个坐标点的坐标值。构造函数将这些参数赋值给对应的私有属性。
在 Rectangle 类中，还定义了一个名为 getArea() 的公共方法，它返回矩形的面积。计算公式为 Math.abs((x2 - x1) * (y2 - y1))。由于矩形的边长可能为负数，所以使用 Math.abs() 方法取绝对值。
在主类 Main 中的 main 方法中，首先创建一个 Scanner 对象用于从控制台读取输入。然后使用 scanner.nextDouble() 方法分别读取四个实型数，表示两个坐标点的坐标值。接着，创建一个新的 Rectangle 对象，并将读取到的坐标值作为参数传递给构造函数。最后，调用 rectangle.getArea() 方法计算矩形的面积，并使用 String.format("%.2f", rectangle.getArea()) 控制精度并输出结果。
类图：
7-3 测验3-继承与多态：
1、设计分析：
这道题目要求将之前的 Circle 类和 Rectangle 类进行合并设计，抽象出一个 Shape 父类（抽象类），Circle 和 Rectangle 作为子类。程序需要从控制台读取输入，根据输入的类型选择创建 Circle 或 Rectangle 对象，并计算并输出图形的面积。
输入格式为一个整数，表示类型选择，1 表示 Circle，2 表示 Rectangle。接下来是对应图形的参数。
输出格式为一个实型数，表示图形的面积，保留两位小数。
1 import java.util.Scanner; 2 3 public class Main { 4 public static void main(String[] args) { 5 Scanner input = new Scanner(System.in); 6 7 int choice = input.nextInt(); 8 9 switch (choice) { 10 case 1://Circle 11 double radius = input.nextDouble(); 12 Shape circle = new Circle(radius); 13 printArea(circle); 14 break; 15 case 2://Rectangle 16 double x1 = input.nextDouble(); 17 double y1 = input.nextDouble(); 18 double x2 = input.nextDouble(); 19 double y2 = input.nextDouble(); 20 21 Point leftTopPoint = new Point(x1, y1); 22 Point lowerRightPoint = new Point(x2, y2); 23 24 Rectangle rectangle = new Rectangle(leftTopPoint, lowerRightPoint); 25 26 printArea(rectangle); 27 break; 28 } 29 } 30 31 public static void printArea(Shape shape) { 32 System.out.println(String.format("%.2f", shape.getArea())); 33 } 34 } 35 36 abstract class Shape { 37 public abstract double getArea(); 38 } 39 40 class Circle extends Shape { 41 private double radius; 42 43 public Circle(double radius) { 44 this.radius = radius; 45 } 46 47 @Override 48 public double getArea() { 49 return Math.PI * radius * radius; 50 } 51 } 52 53 class Rectangle extends Shape { 54 private Point leftTopPoint; 55 private Point lowerRightPoint; 56 57 public Rectangle(Point leftTopPoint, Point lowerRightPoint) { 58 this.leftTopPoint = leftTopPoint; 59 this.lowerRightPoint = lowerRightPoint; 60 } 61 62 @Override 63 public double getArea() { 64 return Math.abs((lowerRightPoint.getX() - leftTopPoint.getX()) * (lowerRightPoint.getY() - leftTopPoint.getY())); 65 } 66 } 67 68 class Point { 69 private double x; 70 private double y; 71 72 public Point(double x, double y) { 73 this.x = x; 74 this.y = y; 75 } 76 77 public double getX() { 78 return x; 79 } 80 81 public double getY() { 82 return y; 83 } 84 }
2、源码分析：
这段代码定义了一个抽象类 Shape，它具有一个抽象方法 getArea()，用于计算图形的面积。
代码中还定义了两个类 Circle 和 Rectangle，它们都继承自 Shape 类。Circle 类具有一个私有属性 radius，表示圆的半径。在构造函数中，接收一个参数表示圆的半径，并将其赋值给私有属性 radius。Circle 类重写了父类的 getArea() 方法，计算公式为 Math.PI * radius * radius。
Rectangle 类具有两个私有属性 leftTopPoint 和 lowerRightPoint，分别表示矩形左上角坐标点和右下角坐标点。在构造函数中，接收两个参数表示两个坐标点，并将其赋值给对应的私有属性。Rectangle 类重写了父类的 getArea() 方法，计算公式为 Math.abs((lowerRightPoint.getX() - leftTopPoint.getX()) * (lowerRightPoint.getY() - leftTopPoint.getY()))。由于矩形的边长可能为负数，所以使用 Math.abs() 方法取绝对值。
代码中还定义了一个类 Point，它具有两个私有属性 x 和 y，分别表示坐标点的横纵坐标。在构造函数中，接收两个参数表示坐标点的横纵坐标，并将其赋值给对应的私有属性。此外，还提供了两个公共方法 getX() 和 getY()，用于获取坐标点的横纵坐标。
在主类 Main 中的 main 方法中，首先创建一个 Scanner 对象用于从控制台读取输入。然后使用 input.nextInt() 方法读取一个整数，表示类型选择。接下来根据类型选择创建 Circle 或 Rectangle 对象，并调用其 getArea() 方法计算图形的面积。最后调用静态方法 printArea(Shape shape) 输出结果。
静态方法 printArea(Shape shape) 接收一个 Shape 类型的参数，并调用其 getArea() 方法获取图形的面积。然后使用 String.format("%.2f", shape.getArea()) 控制精度并输出结果。
这段代码实现了题目要求的功能，并且通过抽象类和多态性使得程序结构更加清晰、易于扩展。
类图：
7-4 测验4-抽象类与接口：
1、设计分析:
这道题目要求在测验 3 的题目基础上，重构类设计，实现列表内图形的排序功能（按照图形的面积进行排序）。提示：题目中 Shape 类要实现 Comparable 接口。
程序需要从控制台读取输入，根据输入的类型选择创建 Circle 或 Rectangle 对象，并将其添加到列表中。当输入为 0 时，结束输入，对列表中的图形按照面积进行升序排序，并输出结果。
输入格式为多行，每行一个整数或实型数。第一行为一个整数，表示类型选择，1 表示 Circle，2 表示 Rectangle，0 表示结束输入。接下来是对应图形的参数。
输出格式为一行实型数，表示列表中各图形的面积（按升序排序），保留两位小数。各图形面积之间用空格分隔。
1 import java.util.ArrayList; 2 import java.util.Comparator; 3 import java.util.Scanner; 4 5 public class Main { 6 public static void main(String[] args) { 7 Scanner input = new Scanner(System.in); 8 ArrayList<Shape> list = new ArrayList<>(); 9 10 int choice = input.nextInt(); 11 12 while (choice != 0) { 13 switch (choice) { 14 case 1://Circle 15 double radius = input.nextDouble(); 16 Shape circle = new Circle(radius); 17 list.add(circle); 18 break; 19 case 2://Rectangle 20 double x1 = input.nextDouble(); 21 double y1 = input.nextDouble(); 22 double x2 = input.nextDouble(); 23 double y2 = input.nextDouble(); 24 25 Point leftTopPoint = new Point(x1, y1); 26 Point lowerRightPoint = new Point(x2, y2); 27 28 Rectangle rectangle = new Rectangle(leftTopPoint, lowerRightPoint); 29 30 list.add(rectangle); 31 break; 32 } 33 choice = input.nextInt(); 34 } 35 36 list.sort(Comparator.naturalOrder());//正向排序 37 38 for (int i = 0; i < list.size(); i++) { 39 System.out.print(String.format("%.2f", list.get(i).getArea()) + " "); 40 } 41 } 42 } 43 44 abstract class Shape implements Comparable<Shape> { 45 public abstract double getArea(); 46 47 @Override 48 public int compareTo(Shape o) { 49 return Double.compare(this.getArea(), o.getArea()); 50 } 51 } 52 53 class Circle extends Shape { 54 private double radius; 55 56 public Circle(double radius) { 57 this.radius = radius; 58 } 59 60 @Override 61 public double getArea() { 62 return Math.PI * radius * radius; 63 } 64 } 65 66 class Rectangle extends Shape { 67 private Point leftTopPoint; 68 private Point lowerRightPoint; 69 70 public Rectangle(Point leftTopPoint, Point lowerRightPoint) { 71 this.leftTopPoint = leftTopPoint; 72 this.lowerRightPoint = lowerRightPoint; 73 } 74 75 @Override 76 public double getArea() { 77 return Math.abs((lowerRightPoint.getX() - leftTopPoint.getX()) * (lowerRightPoint.getY() - leftTopPoint.getY())); 78 } 79 } 80 81 class Point { 82 private double x; 83 private double y; 84 85 public Point(double x, double y) { 86 this.x = x; 87 this.y = y; 88 } 89 90 public double getX() { 91 return x; 92 } 93 94 public double getY() { 95 return y; 96 } 97 }
2、源码分析：
这段代码定义了一个抽象类 Shape，它实现了 Comparable 接口，并重写了 compareTo 方法，用于比较两个图形的面积。Shape 类还具有一个抽象方法 getArea()，用于计算图形的面积。
代码中还定义了两个类 Circle 和 Rectangle，它们都继承自 Shape 类。Circle 类具有一个私有属性 radius，表示圆的半径。在构造函数中，接收一个参数表示圆的半径，并将其赋值给私有属性 radius。Circle 类重写了父类的 getArea() 方法，计算公式为 Math.PI * radius * radius。
Rectangle 类具有两个私有属性 leftTopPoint 和 lowerRightPoint，分别表示矩形左上角坐标点和右下角坐标点。在构造函数中，接收两个参数表示两个坐标点，并将其赋值给对应的私有属性。Rectangle 类重写了父类的 getArea() 方法，计算公式为 Math.abs((lowerRightPoint.getX() - leftTopPoint.getX()) * (lowerRightPoint.getY() - leftTopPoint.getY()))。由于矩形的边长可能为负数，所以使用 Math.abs() 方法取绝对值。
代码中还定义了一个类 Point，它具有两个私有属性 x 和 y，分别表示坐标点的横纵坐标。在构造函数中，接收两个参数表示坐标点的横纵坐标，并将其赋值给对应的私有属性。此外，还提供了两个公共方法 getX() 和 getY()，用于获取坐标点的横纵坐标。
在主类 Main 中的 main 方法中，首先创建一个 Scanner 对象用于从控制台读取输入。然后使用 input.nextInt() 方法读取一个整数，表示类型选择。接下来根据类型选择创建 Circle 或 Rectangle 对象，并将其添加到列表中。当输入为 0 时，结束输入，对列表中的图形按照面积进行升序排序，并输出结果。
类图：
三、踩坑心得：
-
输入数据的格式检查：在
parseInput()方法中，需要检查用户输入的数据格式是否正确。这需要编写一个InputMatching类来实现。在这个类中，需要编写一个matchingInput()方法来判断用户输入的数据格式是否正确。这个方法的实现可能会比较复杂，需要仔细设计和测试。例如，需要考虑各种不同的输入格式，以及如何准确地判断它们是否符合要求。 -
数据的存储和管理：在
ParseInput类中，需要使用多个ArrayList来存储信息。在处理用户输入的数据时，需要对这些列表进行增删改查操作。这些操作需要仔细设计和实现，以避免出现错误。 -
错误处理：在处理用户输入的数据时，可能会出现各种错误情况，例如输入的成绩数量不匹配、权重之和不为1、课程不存在等。需要在代码中对这些错误情况进行检查，并输出相应的错误信息。这部分代码需要仔细设计和测试，以确保能够准确地捕获并处理各种错误情况。
-
代码的可读性和可维护性：上述代码包含了多个类和方法，实现了较为复杂的功能。为了提高代码的可读性和可维护性，需要对代码进行良好的组织和规划，合理地划分模块和功能，并编写清晰易懂的注释。此外，在编写代码时，应该注意遵循一些良好的编程实践，例如使用有意义的变量名、避免过长的方法和过深的嵌套等。
四、改进意见：
-
输入数据的格式检查：为了更好地检查用户输入的数据格式是否正确，可以考虑使用正则表达式来实现。可以用来准确地判断用户输入的数据格式是否符合要求。在
InputMatching类中，可以编写一个matchingInput()方法，使用正则表达式来判断用户输入的数据格式是否正确。 -
数据的存储和管理：为了更好地存储和管理数据，可以考虑使用更加高效的数据结构来替换
ArrayList。 -
错误处理：为了更好地处理错误情况，可以考虑使用异常处理机制来实现。在代码中，可以定义一些自定义异常类，用来表示各种不同的错误情况。然后，在处理用户输入的数据时，如果遇到错误情况，则抛出相应的异常。在
main方法中，可以使用try-catch语句来捕获并处理这些异常。 -
代码的可读性和可维护性：为了提高代码的可读性和可维护性，应该注意遵循一些良好的编程实践。例如，在编写代码时，应该使用有意义的变量名、避免过长的方法和过深的嵌套等。此外，在编写代码时，应该注意模块化设计，将程序划分成若干个独立的模块，每个模块负责实现一个特定的功能。
-
持续重构：在编写代码的过程中，应该不断地重构代码，以提高代码的质量。重构是指在不改变代码外部行为的情况下，改进代码的内部结构。通过重构，可以消除代码中的重复、简化复杂的逻辑、提高代码的可读性和可维护性等。
-
编写测试用例：为了确保代码的正确性，应该编写测试用例来对代码进行测试。测试用例可以帮助我们快速地发现代码中的错误，并及时修复它们。此外，测试用例还可以帮助我们验证重构后的代码是否仍然能够正确地工作。
-
代码审查：可以定期进行代码审查，邀请其他开发人员对代码进行审查。通过代码审查，可以发现代码中的问题，并及时修复它们。此外，代码审查还可以帮助我们学习其他开发人员的经验和技巧，从而提高自己的编程能力。
-
持续学习：作为一名开发人员，应该不断地学习新知识和技能，以便更好地应对各种挑战。可以阅读技术书籍、参加技术培训、参加技术交流会等方式来学习新知识和技能。
五、总结：
通过本阶段（10-16周）的学习，可以学到以下几点：
-
通过本阶段的学习，可以了解Java语言的基本语法和特性，以及如何使用Java语言来实现各种功能。
-
如何组织和管理数据：上述代码中包含了多个类和方法，用来存储和管理学生、课程、班级和选课信息。通过学习这段代码，可以了解如何使用
ArrayList等数据结构来存储和管理数据，以及如何对数据进行增删改查操作。 -
如何处理用户输入：上述代码中包含了一个
parseInput()方法，用来处理用户输入的数据。通过学习这段代码，可以了解如何使用Scanner类来读取用户输入，以及如何对用户输入的数据进行解析和处理。 -
如何进行错误处理：上述代码中包含了多处错误处理的代码，用来检查用户输入的数据是否正确，并输出相应的错误信息。通过学习这段代码，可以了解如何在代码中进行错误检查，并输出相应的错误信息。
对于需要进一步学习和研究的地方，包括：
-
更深入地学习Java语言：上述代码只展示了Java语言的基础知识，要想更好地掌握Java语言，还需要更深入地学习Java语言的高级特性和技巧。
-
学习更多的数据结构和算法：上述代码中只使用了
ArrayList这一种数据结构，要想更好地存储和管理数据，还需要学习更多的数据结构和算法。 -
学习软件工程相关知识：上述代码只是一个简单的程序，要想编写更大型、更复杂的软件系统，还需要学习软件工程相关知识，包括需求分析、设计、编码、测试等方面。
对教师、课程、作业、实验、课上及课下组织方式等方面的改进建议及意见：
1.希望能有更加充裕的时间来完成作业。
2.希望老师能提供更加详细周到的帮助。
3.希望作业的难度能够循序渐进，不要难度跨越过大。
4.希望老师能使用更加有趣的教学方式。