题目集7~11的总结性Blog3

　　本次题目集的主要难点是菜单计价程序-5以及三次课程成绩统计程序，课程成绩统计程序相对于菜单程序来说代码量比较少，而且只要第一次的作业类设计的合理的话，后面的两次的课程统计程序的代码至于要在原来的基础上稍微修改一下就能运行了，后面要做的就是对bug的调试工作了。在本次题目集中，我大量的使用到了容器如Arraylist、HashMap等等代替了以前只使用数组的习惯，毕竟好东西问什么不学着去用呢。总的来说，虽然本次题目集的题量较大，但是难度是不及上一次题目集的难度的(又或者是经过上次的历练我升级变厉害啦？)。

2、设计与分析

菜单计价程序-5

　　书接上回，这次的菜单程序是是菜单计价程序-3的另外的一次迭代，与-4不同，不需要分析那么多的异常情况了，而是增添了口味度以及菜品类型。写这次菜单的作业，因为有了前两次的经验，因而最后的结果比前两次都好。

以下是本题的类图:

从类图中可以看到，图中主要的关系是组合，也就是一个类在另外一个类中做属性，这样可以访问其中的方法。题目中还增加了特色菜的类型，因此相较于上次的程序中，我增加了SpecialDish类，用来记录特色菜的类型。题目还新添加了顾客，因此还增加了一个Customer，专门用来储存顾客的信息比如人名、电话号码以及总的消费。还有一些异常的情况比如说电话号码的匹配，我都是用的正则表达式匹配字符串来判断是否合法，这已经是前面几次题目集说过的方法了。下面是本题的代码，因为有很多gettet和setter方法没有用到，我没没有删除，因此代码长度比较长。

   1 package OrderDish;
   2 
   3 import java.time.LocalDate;
   4 
   5 import java.util.*;
   6 
   7 import static javax.swing.UIManager.get;
   8 
   9 public class Main {
  10     public static void main(String[] args) {
  11         Scanner input = new Scanner(System.in);
  12         Menu menu = new Menu();
  13         Order[] order = new Order[100];
  14         String str = " ";
  15         int tableTimes = 0,wrongMenu = 0,customerNum = 0;//桌数、错误的菜单、顾客数
  16         Customer[] customer = new Customer[100];
  17         String[] splitedStr;
  18         str = input.nextLine();
  19         splitedStr = str.split(" ");
  20         int[] invalidDish = new int[100];//无效的菜单信息
  21         int[][] behalfOrder = new int[100][100];//代点菜记录，第一个为代点菜的桌号
  22         for (; ! str.equals("end");){
  23             for (;splitedStr.length >= 2 && splitedStr.length <= 4;) {
  24                 if (tableTimes == 0) {//如果没有一桌点菜记录，则这是菜单，需要记录
  25                     if (splitedStr.length == 2) {
  26                         if (menu.searchDish(splitedStr[0]) == null) {
  27                             menu.addDish(splitedStr[0], Integer.parseInt(splitedStr[1]));
  28                         }else{
  29                             menu.searchDish(splitedStr[0]).setUnit_price(Integer.parseInt(splitedStr[1]));
  30                         }
  31                     } else if (splitedStr.length == 4 && splitedStr[3].equals("T")) {
  32                         if (menu.searchDish(splitedStr[0]) == null) {
  33                             menu.addSpecialDish(splitedStr[0], Integer.parseInt(splitedStr[2]), splitedStr[3], splitedStr[1]);
  34                         }else{
  35                             menu.searchDish(splitedStr[0]).setUnit_price(Integer.parseInt(splitedStr[2]));
  36                             menu.searchDish(splitedStr[0]).getSpecialDish().whichSpecialDish(splitedStr[1]);
  37                         }
  38                     } else {//输入错误需要记录，后面的记录直接作废
  39                         System.out.println("wrong format");
  40                         wrongMenu = 1;
  41                     }
  42                     str = input.nextLine();
  43                     splitedStr = str.split(" ");
  44                 }else{//如果有了点菜记录，则忽略
  45                     break;
  46                 }
  47             }
  48             if (str.equals("end")){
  49                 break;
  50             }
  51             order[tableTimes] = new Order();
  52             Table table = new Table();
  53             order[tableTimes].setTable(table);
  54             order[tableTimes].getTable().isValidity(str);
  55             if (wrongMenu == 1){
  56                 break;
  57             }else{
  58                 str = input.nextLine();
  59                 splitedStr = str.split(" ");
  60                 if (splitedStr.length >= 2 && splitedStr.length <= 4 && !splitedStr[0].matches("\\d")) {
  61                     invalidDish[tableTimes] = 1;
  62                     str = input.nextLine();
  63                     splitedStr = str.split(" ");
  64                 }
  65                 for (int j = 0; splitedStr.length == 4 || splitedStr.length == 5 || splitedStr.length == 6 && splitedStr[0].matches("\\d+"); j++) {//添加订单
  66                     if (splitedStr[0].matches("\\d+") && splitedStr[1].matches("\\d+")) {
  67                         if (menu.searchDish(splitedStr[2]).getIsSpecial().equals("T")) {
  68                             behalfOrder[tableTimes][j] = Integer.parseInt(splitedStr[0]);//记录桌号
  69                             order[tableTimes].addASpecialRecord(Integer.parseInt(splitedStr[1]), splitedStr[2], splitedStr[3], Integer.parseInt(splitedStr[4]), Integer.parseInt(splitedStr[5]), menu);
  70                             order[tableTimes].getRecordsJ(order[tableTimes].getI() - 1).setBehalfOrder(true);
  71                             order[searchOrderNumByTableNum(order,Integer.parseInt(splitedStr[0]))].addTotalTaste(splitedStr[2], Integer.parseInt(splitedStr[5]), Integer.parseInt(splitedStr[3]));
  72                             order[searchOrderNumByTableNum(order,Integer.parseInt(splitedStr[0]))].addSpecialDishNum(splitedStr[2], Integer.parseInt(splitedStr[5]));
  73                             order[tableTimes].minusTotalTaste(splitedStr[2], Integer.parseInt(splitedStr[5]), Integer.parseInt(splitedStr[3]));
  74                             order[tableTimes].minusSpecialDishNum(splitedStr[2], Integer.parseInt(splitedStr[5]));
  75                         } else if (menu.searchDish(splitedStr[2]) != null) {
  76                             behalfOrder[tableTimes][j] = Integer.parseInt(splitedStr[0]);
  77                             order[tableTimes].addARecord(Integer.parseInt(splitedStr[1]), splitedStr[2], Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4]), menu);
  78                             order[tableTimes].getRecordsJ(order[tableTimes].getI() - 1).setBehalfOrder(true);
  79                         }
  80                     } else if (menu.searchDish(splitedStr[1]).getIsSpecial().equals("T")) {
  81                         order[tableTimes].addASpecialRecord(Integer.parseInt(splitedStr[0]), splitedStr[1], splitedStr[2], Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4]), menu);
  82                     } else if (menu.searchDish(splitedStr[1]) != null) {
  83                         order[tableTimes].addARecord(Integer.parseInt(splitedStr[0]), splitedStr[1], Integer.parseInt(splitedStr[2]), Integer.parseInt(splitedStr[3]), menu);
  84                     }
  85                     str = input.nextLine();
  86                     splitedStr = str.split(" ");
  87                 }
  88                 for (;splitedStr.length == 2;){
  89                     order[tableTimes].setDeplication(Integer.parseInt(splitedStr[0]));
  90                     str = input.nextLine();
  91                     splitedStr = str.split(" ");
  92                 }
  93                 tableTimes++;
  94             }
  95         }
  96         for (int i = 0;i <= tableTimes - 1;i ++){//输出桌每盘菜的费用
  97             WhichDay whichDay = new WhichDay(order[i]);
  98             whichDay.setCompareTime();
  99             whichDay.isValidDate();
 100             order[i].setMenu(menu);
 101             if (order[i].getTable().isValidTable()){
 102                 if (order[i].getTable().isValidNumFormat()) {
 103                     if (order[i].getTable().isValidName()) {
 104                         if (order[i].getTable().isValidTelephone()) {
 105                             if (whichDay.getValidDate()) {
 106                                 System.out.println("table " + order[i].getTable().getTableNum() + ": ");
 107                                 for (int k = 0; order[i].getDeplicationI(k) != 0; k++) {
 108                                     if (order[i].findRecordByNum(order[i].getDeplicationI(k))) {
 109                                         order[i].delARecordByOrderNum(order[i].getDeplicationI(k));
 110                                         order[i].setDeplicationI(k);
 111                                     }
 112                                 }
 113                                 int o = 0;//用于记录代点菜的参数
 114                                 for (int j = 0; order[i].getRecordsJ(j) != null; j++) {
 115                                     order[i].getRecordsJ(j).setD(menu.searchDish(order[i].getRecordsJ(j).getD().getName()));
 116                                     if (menu.searchDish(order[i].getRecordsJ(j).getD().getName()) != null) {
 117                                         if (order[i].getRecordsJ(j).printOutTasteRate() == 0) {
 118                                             if (!order[i].getRecordsJ(j).isBehalfOrder()) {
 119                                                 System.out.println(order[i].getRecordsJ(j).getOrderNum() + " " + order[i].getRecordsJ(j).getD().getName() + " " + order[i].getRecordsJ(j).getPrice());//普通点菜
 120                                             } else {
 121                                                 System.out.println(order[i].getRecordsJ(j).getOrderNum() + " table " + order[i].getTable().getTableNum() + " pay for table " + behalfOrder[i][o] + " " + order[i].getRecordsJ(j).getPrice());//代点菜
 122                                                 o ++;
 123                                             }
 124                                         } else {
 125                                             order[i].delARecordByOrderNum(order[i].getRecordsJ(j).getOrderNum());
 126                                             j--;
 127                                         }
 128                                     } else {
 129                                         System.out.println(order[i].getRecordsJ(j).getD().getName() + " does not exist");
 130                                     }
 131                                 }
 132                                 for (int k = 0; order[i].getDeplicationI(k) != 0; k++) {
 133                                     if (order[i].getDeplicationI(k) != -1) {
 134                                         if (order[i].getRecordsJ(order[i].getDeplicationI(k)) == null) {
 135                                             System.out.println("delete error;");
 136                                         }
 137                                     }
 138                                 }
 139                                 order[i].setTotalTaste();
 140                                 order[i].setSpecialDishNum();
 141                                 order[i].setAverageTaste();
 142                                 if (customerNum == 0) {//当为第一个人时，开辟新空间
 143                                     customer[customerNum] = new Customer(order[i].getTable().getName(), order[i].getTable().getTelephone());
 144                                     customer[customerNum].addCost((int) (getDiscountedPrice(whichDay, menu) + 0.5));
 145                                     customerNum++;
 146                                 } else {//否则
 147                                     int flag = 0;//记录是否有相同的人名
 148                                     for (int k = 0; k < customerNum; k++) {//是同一个人的话直接加钱
 149                                         if (customer[k].getCustomer().equals(order[i].getTable().getName())) {
 150                                             customer[customerNum - 1].addCost((int) (getDiscountedPrice(whichDay, menu) + 0.5));
 151                                             flag = 1;
 152                                         }
 153                                     }
 154                                     if (flag == 0) {
 155                                         customer[customerNum] = new Customer(order[i].getTable().getName(), order[i].getTable().getTelephone());
 156                                         customer[customerNum].addCost((int) (getDiscountedPrice(whichDay, menu) + 0.5));
 157                                         customerNum++;
 158                                     }
 159                                 }
 160                             } else {
 161                                 System.out.println("table " + order[i].getTable().getTableNum() + " out of opening hours");
 162                             }
 163                         } else {
 164                             System.out.println("wrong format");
 165                         }
 166                     } else {
 167                         System.out.println("wrong format");
 168                     }
 169                 }else{
 170                     System.out.println("wrong format");
 171                 }
 172             }else{
 173                 System.out.println("wrong format");
 174             }
 175         }
 176         for (int i = 0;i <= tableTimes - 1;i ++) {//输出每桌的费用
 177             WhichDay whichDay = new WhichDay(order[i]);
 178             whichDay.setCompareTime();
 179             whichDay.isValidDate();
 180             order[i].setMenu(menu);
 181             if (order[i].getTable().isValidTable()) {
 182                 if (order[i].getTable().isValidTable()) {
 183                     if (order[i].getTable().isValidNumFormat()) {
 184                         if (order[i].getTable().isValidName()) {
 185                             if (order[i].getTable().isValidTelephone()) {
 186                                 if (whichDay.getValidDate()) {
 187                                     if (order[tableTimes - 1].getChuanNum() + order[tableTimes - 1].getJinNum() + order[tableTimes - 1].getZheNum() > 0) {
 188                                         if (order[i].getTotalPrice() == 0) {
 189                                             System.out.println(("table " + order[i].getTable().getTableNum() + ": " + order[i].getTotalPrice() + " " + (int) (getDiscountedPrice(whichDay, menu) + 0.5)));
 190                                             order[i].printOrder();
 191                                         } else {
 192                                             System.out.print(("table " + order[i].getTable().getTableNum() + ": " + order[i].getTotalPrice() + " " + (int) (getDiscountedPrice(whichDay, menu) + 0.5)));
 193                                             order[i].printOrder();
 194                                         }
 195                                     } else {
 196                                         System.out.print(("table " + order[i].getTable().getTableNum() + ": " + order[i].getTotalPrice() + " " + (int) (getDiscountedPrice(whichDay, menu) + 0.5)) + " ");
 197                                         order[i].printOrder();
 198                                     }
 199                                 }
 200                             }
 201                         }
 202                     }
 203                 }
 204             }
 205         }
 206         sortCustomer(customer,customerNum);
 207         for (int i = 0;i <= customerNum - 1;i ++){//输出用户
 208             if (order[tableTimes - 1].getChuanNum() + order[tableTimes - 1].getJinNum() + order[tableTimes - 1].getZheNum() > 0) {
 209                 System.out.println(customer[i].getCustomer() + " " + customer[i].getTelephone() + " " + customer[i].getCost());
 210             } else {
 211                 System.out.println("\n" + customer[i].getCustomer() + " " + customer[i].getTelephone() + " " + customer[i].getCost());
 212             }
 213         }
 214         if (tableTimes == 0){
 215             if (!order[0].getTable().isValidTable() || !order[0].getTable().isValidName() || !order[0].getTable().isValidTelephone()){
 216                 System.out.println("wrong format");
 217             }
 218         }
 219     }
 220     public static double getDiscountedPrice(WhichDay whichDay, Menu menu){//获得折扣后的总价
 221         int getDiscountedPrice = 0,totalSpecial = 0;
 222         double discount = 1,total = 0;
 223         if (whichDay.getWeek() == 6 || whichDay.getWeek() == 7){
 224             getDiscountedPrice = whichDay.getOrder().getTotalPrice();
 225             return getDiscountedPrice;
 226         }else{
 227             discount = whichDay.setDiscount();
 228             for (int i = 0;whichDay.getOrder().getRecordsJ(i) != null;i ++){
 229                 if (menu.searchDish(whichDay.getOrder().getRecordsJ(i).getD().getName()) != null) {
 230                     if (menu.searchDish(whichDay.getOrder().getRecordsJ(i).getD().getName()).getIsSpecial().equals("F")) {
 231                         getDiscountedPrice += (int)(whichDay.getOrder().getRecordsJ(i).getPrice() * discount + 0.5);
 232                     } else {
 233                         totalSpecial += (int)(whichDay.getOrder().getRecordsJ(i).getPrice() * 0.7 + 0.5);
 234                     }
 235                 }
 236             }
 237             total = (int)(getDiscountedPrice  + totalSpecial + 0.5);
 238             return total;
 239         }
 240     }
 241 
 242     public static Customer[] sortCustomer(Customer[] customer,int customerNum){//给数组排序
 243         String str;
 244         Customer customerT;
 245         for (int i = 0;i < customerNum - 1;i ++){
 246             int flag = 0;
 247             for (int j = i + 1;j < customerNum;j ++){
 248                 str = customer[i].getCustomer();
 249                 if (str.compareTo(customer[j].getCustomer()) > 0){
 250                     customerT = customer[i];
 251                     customer[i] = customer[j];
 252                     customer[j] = customerT;
 253                 }
 254             }
 255         }
 256         return customer;
 257     }
 258 
 259     public static int searchOrderNumByTableNum(Order[] order,int x){
 260         for (int i = 0;order[i] != null;i ++){
 261             if (order[i].getTable().getTableNum() == x){
 262                 return i;
 263             }
 264         }
 265         return 0;
 266     }
 267 }
 268 
 269 class Dish{//菜品类
 270     private String name;//菜品名称
 271     private int unit_price;//单价
 272     private String isSpecial = "F";
 273     private SpecialDish specialDish = new SpecialDish();//特殊菜的类型
 274     public Dish(){//无参数的构造方法
 275 
 276     }
 277     public Dish(String name,int unit_price,String isSpecial) {
 278         this.name = name;
 279         this.unit_price = unit_price;
 280         this.isSpecial = isSpecial;
 281     }
 282 
 283     public Dish(String name,int unit_price) {
 284         this.name = name;
 285         this.unit_price = unit_price;
 286     }
 287 
 288     public int getUnit_price() {
 289         return unit_price;
 290     }
 291 
 292     public String getIsSpecial() {
 293         return isSpecial;
 294     }
 295 
 296     public void setIsSpecial(String isSpecial) {
 297         this.isSpecial = isSpecial;
 298     }
 299 
 300     public int getPrice(int portion){////计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
 301         return (int)(unit_price * (1 + (float)(portion - 1) / 2) + 0.5);
 302     }
 303     public void setName(String name){
 304         this.name = name;
 305     }
 306     public String getName(){
 307         return this.name;
 308     }
 309     public int setUnit_price(int unit_price){
 310         return this.unit_price = unit_price;
 311     }
 312 
 313     public SpecialDish getSpecialDish() {
 314         return specialDish;
 315     }
 316 
 317     public void setSpecialDish(SpecialDish specialDish) {
 318         this.specialDish = specialDish;
 319     }
 320 }
 321 
 322 class Menu{//菜单类
 323     private Dish[] dishes = new Dish[100];//菜品数组，保存菜品信息
 324     private boolean isValidPrice = true;
 325     int i;
 326 
 327     public boolean isValidPrice() {
 328         return isValidPrice;
 329     }
 330 
 331     public void setValidPrice(boolean validPrice) {
 332         isValidPrice = validPrice;
 333     }
 334 
 335     public Dish searchDish(String dishName){//根据菜名在菜谱中查找菜品信息，返回Dish对象
 336         int len = 0;
 337         for (int j = 0;dishes[j] != null;j ++){
 338             len ++;
 339         }
 340         for (int j = 0;j < len;j++){
 341             if (dishes[j].getName().equals(dishName)){
 342                 return dishes[j];
 343             }
 344         }
 345         return null;
 346     }
 347 
 348     public Dish[] getDishes() {
 349         return dishes;
 350     }
 351 
 352     public void setDishes(Dish[] dishes) {
 353         this.dishes = dishes;
 354     }
 355 
 356     public Dish addDish(String dishName, int unit_price){//添加一道菜品信息
 357         if (unit_price > 0 && unit_price < 300) {
 358             if (i == 0) {//当为第一个菜品时
 359                 dishes[0] = new Dish(dishName, unit_price);
 360                 i++;
 361                 return dishes[0];
 362             } else {//当有了i样菜时，为第i+1个数组开辟新空间
 363                 dishes[i] = new Dish(dishName, unit_price);
 364                 i++;
 365                 return dishes[i];
 366             }
 367         }
 368         return null;
 369     }
 370 
 371     public Dish addSpecialDish(String dishName, int unit_price,String isSpecial,String whichSpecial){//添加一道菜品信息
 372         if (unit_price > 0 && unit_price < 300) {
 373             if (i == 0) {//当为第一个菜品时
 374                 dishes[0] = new Dish(dishName, unit_price, isSpecial);
 375                 dishes[0].getSpecialDish().whichSpecialDish(whichSpecial);
 376                 i++;
 377                 return dishes[0];
 378             } else {//当有了i样菜时，为第i+1个数组开辟新空间
 379                 dishes[i] = new Dish(dishName, unit_price, isSpecial);
 380                 dishes[i].getSpecialDish().whichSpecialDish(whichSpecial);
 381                 i++;
 382                 return dishes[i];
 383             }
 384         }
 385         return null;
 386     }
 387 
 388     public Menu(){//无参数的构造方法
 389 
 390     }
 391     public Menu(Dish[] dishes){
 392         this.dishes = dishes;
 393     }
 394 }
 395 
 396 class Record{//点菜记录类
 397     private int orderNum;//序号
 398     private Menu menu;
 399     private Dish d = new Dish();//菜品
 400     private int portion;//份额
 401     private int num;//份数
 402     private int price;
 403     private int tasteRate;//点的菜的口味度
 404     private boolean isBehalfOrder = false;
 405     public Record(){//无参数的构造方法
 406 
 407     }
 408 
 409     public Menu getMenu() {
 410         return menu;
 411     }
 412 
 413     public Record(int orderNum, Dish d, int portion, int num){
 414         this.orderNum = orderNum;
 415         this.d = d;
 416         this.portion = portion;
 417         this.num = num;
 418     }
 419 
 420     public boolean isBehalfOrder() {
 421         return isBehalfOrder;
 422     }
 423 
 424     public void setBehalfOrder(boolean behalfOrder) {
 425         isBehalfOrder = behalfOrder;
 426     }
 427 
 428     public void setMenu(Menu menu) {
 429         this.menu = menu;
 430     }
 431 
 432     public void setD(Dish d){
 433         this.d = d;
 434     }
 435     public int getPrice(){//计价
 436         return d.getPrice(portion)*num;
 437     }
 438 
 439     public Dish getD(){
 440 
 441         return this.d;
 442     }
 443     public int getOrderNum(){
 444         return this.orderNum;
 445     }
 446 
 447     public void setOrderNum(int orderNum) {
 448         this.orderNum = orderNum;
 449     }
 450 
 451     public int getPortion() {
 452         return portion;
 453     }
 454 
 455     public void setPortion(int portion) {
 456         this.portion = portion;
 457     }
 458 
 459     public int getNum() {
 460         return num;
 461     }
 462 
 463     public void setNum(int num) {
 464         this.num = num;
 465     }
 466 
 467     public void setPrice(int price) {
 468         this.price = price;
 469     }
 470 
 471     public void setTasteRate(String dishName, String str){
 472         setD(menu.searchDish(dishName));
 473         if (d.getSpecialDish().isChuanDish()){
 474             tasteRate = Integer.parseInt(str);
 475         }
 476         if (d.getSpecialDish().isJinDish()){
 477             tasteRate = Integer.parseInt(str);
 478         }
 479         if (d.getSpecialDish().isZheDish()){
 480             tasteRate = Integer.parseInt(str);
 481         }
 482     }
 483 
 484     public int getTasteRate() {
 485         return tasteRate;
 486     }
 487 
 488     public int printOutTasteRate(){
 489         int a = 0;//a用于记录是否超出口味度
 490         if (d.getSpecialDish().isChuanDish()){
 491             if (tasteRate > 5 || tasteRate < 0){
 492                 System.out.println("spicy num out of range :" + tasteRate);
 493                 a = 1;
 494             }
 495         }
 496         if (d.getSpecialDish().isJinDish()){
 497             if (tasteRate > 4 || tasteRate < 0){
 498                 System.out.println("acidity num out of range :" + tasteRate);
 499                 a = 1;
 500             }
 501         }
 502         if (d.getSpecialDish().isZheDish()){
 503             if (tasteRate > 3 || tasteRate < 0){
 504                 System.out.println("sweetness num out of range :" + tasteRate);
 505                 a = 1;
 506             }
 507         }
 508         return a;
 509     }
 510 }
 511 
 512 class Order {//订单类
 513     private Menu menu;
 514     private Record[] records = new Record[100];//点菜记录类数组
 515     private Table table = new Table();
 516     private float zheNum = 0;//浙菜的份数
 517     private float chuanNum = 0;//川菜的份数
 518     private float jinNum = 0;//晋菜的份数
 519     private float totalZhe = 0;//浙菜的总口味度
 520     private float totalChuan = 0;//川菜的总口味度
 521     private float totalJin = 0;//晋菜的总口味度
 522     private int averageZhe = 0;//浙菜的平均口味度
 523     private int averageChuan = 0;//川菜的平均口味度
 524     private int averageJin = 0;//晋菜的平均口味度
 525     private int[] deplication = new int[100];//删除记录
 526     int i = 0;
 527 
 528     public int getI() {
 529         return i;
 530     }
 531 
 532     public void setI(int i) {
 533         this.i = i;
 534     }
 535 
 536     public void setMenu(Menu menu) {
 537         this.menu = menu;
 538     }
 539 
 540     public Table getTable() {
 541         return table;
 542     }
 543 
 544     public void setTable(Table table) {
 545         this.table = table;
 546     }
 547 
 548     public int getTotalPrice(int dishesNum) {//获取本条记录的价格
 549         int totalPrice = 0;
 550         for (int j = 0; j < dishesNum; j++) {
 551             totalPrice += records[j].getPrice();
 552         }
 553         return totalPrice;
 554     }
 555 
 556     public Record addARecord(int orderNum, String dishName, int portion,int num,Menu menu) {//添加菜品信息
 557         if (i == 0) {//当为第一条订单时
 558             records[0] = new Record();
 559             records[0] = new Record(orderNum, records[0].getD(), portion,num);
 560             records[0].setMenu(menu);
 561             records[0].getD().setName(dishName);
 562             i++;
 563             return records[0];
 564         } else {//超过一条，在第i+1个数组开辟新空间
 565             records[i] = new Record();
 566             records[i] = new Record(orderNum, records[i].getD(), portion,num);
 567             records[i].setMenu(menu);
 568             records[i].getD().setName(dishName);
 569             i++;
 570             return records[i];
 571         }
 572     }
 573 
 574     public void addASpecialRecord(int orderNum, String dishName,String tasteRate, int portion,int num,Menu menu){
 575         if (i == 0) {//当为第一条订单时
 576             records[0] = new Record();
 577             records[0] = new Record(orderNum, records[0].getD(), portion,num);
 578             records[0].setMenu(menu);
 579             records[0].getD().setName(dishName);
 580             records[0].setTasteRate(dishName,tasteRate);
 581             i++;
 582         } else {//超过一条，在第i+1个数组开辟新空间
 583             records[i] = new Record();
 584             records[i] = new Record(orderNum, records[i].getD(), portion,num);
 585             records[i].setMenu(menu);
 586             records[i].getD().setName(dishName);
 587             records[i].setTasteRate(dishName,tasteRate);
 588             i++;
 589         }
 590     }
 591 
 592     public int delARecordByOrderNum(int orderNum) {//根据序号删除订单
 593         int len = 0;
 594         for (int i = 0;records[i] != null;i ++){
 595             len ++;
 596         }
 597         for (int i = 0; i < records.length; i++) {
 598             if (records[i].getOrderNum() == orderNum) {
 599                 if (i < len - 1) {//如果删除的不是最后一个菜品
 600                     records[i] = null;//删除第i项订单
 601                     for (int j = i; j < records.length - 1; j++) {//将i后方的订单往前移一位
 602                         records[j] = records[j + 1];
 603                     }
 604                 }else{
 605                     records[i] = null;//删除第i项订单
 606                 }
 607                 return 1;
 608             }
 609         }
 610         return -1;
 611     }
 612 
 613     public boolean findRecordByNum(int orderNum) {//查找是否有某序号
 614         for (int j = 0; j < records.length; j++) {
 615             if (records[j].getOrderNum() == orderNum) {
 616                 return true;
 617             }
 618         }
 619         return false;
 620     }
 621 
 622     public Record getRecordsJ(int j) {//获取第j+1道菜品订单的信息
 623         return records[j];
 624     }
 625 
 626     public void setRecords(Record[] records) {//获取本条记录的总价
 627         this.records = records;
 628     }
 629 
 630     public int getTotalPrice(){
 631         int totalPrice = 0;
 632         for (int j = 0;records[j] != null;j ++){
 633             totalPrice += records[j].getPrice();
 634         }
 635         return totalPrice;
 636     }
 637 
 638     public void setSpecialDishNum(){//获得特殊菜的总份数
 639         for (int j = 0;records[j] != null;j ++){
 640             if (records[j].getD().getIsSpecial().equals("F")){
 641                 continue;
 642             }else{
 643                 if (records[j].getD().getSpecialDish().isChuanDish()){
 644                     chuanNum += records[j].getNum();
 645                 }else if (records[j].getD().getSpecialDish().isZheDish()){
 646                     zheNum += records[j].getNum();
 647                 }else if (records[j].getD().getSpecialDish().isJinDish()){
 648                     jinNum += records[j].getNum();
 649                 }
 650             }
 651         }
 652     }
 653 
 654     public void addSpecialDishNum(String dishName,int num){
 655         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isChuanDish()){
 656             chuanNum += num;
 657         }
 658         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isJinDish()){
 659             jinNum += num;
 660         }
 661         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isZheDish()){
 662             zheNum += num;
 663         }
 664     }
 665 
 666     public void addTotalTaste(String dishName,int num,int taste){
 667         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isChuanDish()){
 668             totalChuan += num * taste;
 669         }
 670         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isJinDish()){
 671             totalJin += num * taste;
 672         }
 673         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isZheDish()){
 674             totalZhe += num * taste;
 675         }
 676     }
 677 
 678     public void minusSpecialDishNum(String dishName,int num){
 679         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isChuanDish()){
 680             chuanNum -= num;
 681         }
 682         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isJinDish()){
 683             jinNum -= num;
 684         }
 685         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isZheDish()){
 686             zheNum -= num;
 687         }
 688     }
 689 
 690     public void minusTotalTaste(String dishName,int num,int taste){
 691         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isChuanDish()){
 692             totalChuan -= num * taste;
 693         }
 694         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isJinDish()){
 695             totalJin -= num * taste;
 696         }
 697         if (records[i - 1].getMenu().searchDish(dishName).getSpecialDish().isZheDish()){
 698             totalZhe -= num * taste;
 699         }
 700     }
 701 
 702     public void setTotalTaste(){//获得总口味度
 703         for (int i = 0;records[i] != null;i ++){
 704             records[i].setD(menu.searchDish(getRecordsJ(i).getD().getName()));
 705             if (records[i].getD().getIsSpecial().equals("T")){
 706                 if (records[i].getD().getSpecialDish().isChuanDish()){
 707                     totalChuan += records[i].getTasteRate() * records[i].getNum();
 708                 }
 709                 if (records[i].getD().getSpecialDish().isZheDish()){
 710                     totalZhe += records[i].getTasteRate() * records[i].getNum();
 711                 }
 712                 if (records[i].getD().getSpecialDish().isJinDish()){
 713                     totalJin += records[i].getTasteRate() * records[i].getNum();
 714                 }
 715             }
 716         }
 717     }
 718 
 719     public void setAverageTaste(){//平均口味度
 720         if (totalZhe != 0) {
 721             averageZhe = (int) ((float)(totalZhe / zheNum) + 0.5);
 722         }
 723         if (totalChuan != 0) {
 724             averageChuan = (int) ((float)(totalChuan / chuanNum) + 0.5);
 725         }
 726         if (totalJin != 0) {
 727             averageJin = (int) ((float)(totalJin / jinNum) + 0.5);
 728         }
 729     }
 730 
 731     public void printOrder(){
 732         int flag = 0;//记录有没有特色菜输出，如果有，则flag赋值为1，输出空行
 733         if (chuanNum > 0){
 734             System.out.print(" 川菜 " + (int)(chuanNum));
 735             if  (averageChuan == 0){
 736                 System.out.print(" 不辣");
 737             }
 738             if (averageChuan == 1){
 739                 System.out.print(" 微辣");
 740             }
 741             if (averageChuan == 2){
 742                 System.out.print(" 稍辣");
 743             }
 744             if (averageChuan == 3){
 745                 System.out.print(" 辣");
 746             }
 747             if (averageChuan == 4){
 748                 System.out.print(" 很辣");
 749             }
 750             if (averageChuan == 5){
 751                 System.out.print(" 爆辣");
 752             }
 753             flag = 1;
 754         }
 755         if (jinNum > 0){
 756             System.out.print(" 晋菜 " + (int)(jinNum));
 757             if (averageJin == 0){
 758                 System.out.print(" 不酸");
 759             }
 760             if (averageJin == 1){
 761                 System.out.print(" 微酸");
 762             }
 763             if (averageJin == 2){
 764                 System.out.print(" 稍酸");
 765             }
 766             if (averageJin == 3){
 767                 System.out.print(" 酸");
 768             }
 769             if (averageJin == 4){
 770                 System.out.print(" 很酸");
 771             }
 772             flag = 1;
 773         }
 774         if (zheNum > 0){
 775             System.out.print(" 浙菜 " + (int)(zheNum));
 776             if (averageZhe == 0){
 777                 System.out.print(" 不甜");
 778             }
 779             if (averageZhe == 1){
 780                 System.out.print(" 微甜");
 781             }
 782             if (averageZhe == 2){
 783                 System.out.print(" 稍甜");
 784             }
 785             if (averageZhe == 3){
 786                 System.out.print(" 甜");
 787             }
 788             flag = 1;
 789         }
 790         if (flag == 1){
 791             System.out.println();
 792         }
 793     }
 794 
 795     public void setDeplication(int delete){//将删除菜品的序号储存下来
 796         int k = 0;
 797         for (int j = 0;deplication[j] != 0;j ++){
 798             k = j + 1;
 799         }
 800         deplication[k] = delete;
 801     }
 802 
 803     public void setDeplicationI(int i){//将第i+1个元素设为-1
 804         deplication[i] = -1;
 805     }
 806 
 807     public int getDeplicationI(int i){//获得第i个删除记录
 808         return deplication[i];
 809     }
 810 
 811     public float getZheNum() {
 812         return zheNum;
 813     }
 814 
 815     public float getChuanNum() {
 816         return chuanNum;
 817     }
 818 
 819     public float getJinNum() {
 820         return jinNum;
 821     }
 822 }
 823 
 824 class OrderTime{//点菜时间类
 825     private Calendar orderTime = Calendar.getInstance();//点菜时间
 826 
 827     private LocalDate orderTimeDate;
 828 
 829 
 830     public Calendar getOrderTime() {
 831         return orderTime;
 832     }
 833 
 834     public void setOrderTime(int year,int month,int day,int hour,int minutes,int seconds) {//初始化点菜时间
 835         this.orderTime.set(year,month,day,hour,minutes,seconds);
 836     }
 837 
 838     public void setOrderTimeDate(int year,int month,int day) {//初始化点菜时间
 839         this.orderTimeDate = LocalDate.of(year,month,day);
 840     }
 841 
 842     public void setOrderTime(Calendar orderTime) {
 843         this.orderTime = orderTime;
 844     }
 845 
 846     public LocalDate getOrderTimeDate() {
 847         return orderTimeDate;
 848     }
 849 }
 850 
 851 class Table{
 852     private OrderTime orderTime = new OrderTime();//点菜时间
 853     private int tableNum;
 854     private String name;//点菜人名
 855     private String telephone;//点菜人电话
 856     private boolean isValidName = true;//人名是否有效(合法)
 857     private boolean isValidTelephone = true;//电话是否有效(合法)
 858     private boolean isValidTable = true;//是否为table
 859     private boolean isValidNum = true;//桌号是否在1-55
 860     private boolean isValidNumFormat = true;//桌号是否为数字
 861     private boolean dateData = true;//日期的数据是否合法
 862     private boolean isValidDateData = true;//日期是否在范围内
 863     private boolean isValidDateFormat = true;//日期格式是否合法
 864 
 865     public boolean isValidNumFormat() {
 866         return isValidNumFormat;
 867     }
 868 
 869     public String getName() {
 870         return name;
 871     }
 872 
 873     public String getTelephone() {
 874         return telephone;
 875     }
 876 
 877     public boolean isValidName() {
 878         return isValidName;
 879     }
 880 
 881     public boolean isValidTelephone() {
 882         return isValidTelephone;
 883     }
 884 
 885     public boolean isValidDateData() {
 886         return isValidDateData;
 887     }
 888 
 889     public boolean isValidDateFormat() {
 890         return isValidDateFormat;
 891     }
 892 
 893     public boolean isDateData() {
 894         return dateData;
 895     }
 896 
 897     public OrderTime getOrderTime() {
 898         return orderTime;
 899     }
 900 
 901     public void setOrderTime(OrderTime orderTime) {
 902         this.orderTime = orderTime;
 903     }
 904 
 905     public Table(OrderTime orderTime) {
 906         this.orderTime = orderTime;
 907     }
 908 
 909     public Table() {
 910     }
 911 
 912     public boolean isValidTable() {
 913         return isValidTable;
 914     }
 915 
 916     public boolean isValidNum() {
 917         return isValidNum;
 918     }
 919 
 920     public void isValidity(String str){//判断输入的订单桌号信息是否有效，有效则将桌号记录下来，无效则纪录无效
 921         String[] splitedStr = str.split(" ");
 922         String[] splitedDate = splitedStr[splitedStr.length - 2].split("/");
 923         String[] splitedDay = splitedStr[splitedStr.length - 1].split("/");
 924         if (Integer.parseInt(splitedDate[0]) >= 2022 && Integer.parseInt(splitedDate[0]) <= 2023){
 925             isValidDateData = true;
 926         }else{
 927             isValidDateData = false;
 928         }
 929         if (splitedStr[0].equals("table")){//第一个是否为table开头
 930             isValidTable = true;
 931         }else{
 932             isValidTable = false;
 933         }
 934         if (splitedDate[0].matches("\\d{4}") && splitedDate[1].matches("\\d{1,2}") && splitedDate[2].matches("\\d{1,2}") &&
 935                 splitedDay[0].matches("\\d{1,2}") && splitedDay[1].matches("\\d{1,2}") && splitedDay[2].matches("\\d{1,2}")){//记录日期是否合法
 936             isValidDateFormat = true;
 937         }else{
 938             isValidDateFormat = false;
 939         }
 940         setIsValidName(splitedStr[splitedStr.length - 4]);
 941         setIsValidTelephone(splitedStr[splitedStr.length - 3]);
 942         if (splitedStr[splitedStr.length - 6].matches("[1-9]|[1-9]\\d+")){//记录桌号
 943             isValidNumFormat = true;
 944             tableNum = Integer.parseInt(splitedStr[splitedStr.length-6]);
 945             if (splitedStr[splitedStr.length - 6].matches("[1-9]|[1-4]\\d|5[0-5]")){
 946                 isValidNum = true;
 947             }else{
 948                 isValidNum = false;
 949             }//移出去了
 950         }else{
 951             isValidNumFormat = false;
 952         }
 953         if (Integer.parseInt(splitedDate[1]) > 0 && Integer.parseInt(splitedDate[1]) <= 12) {//判断输入的年月是否合法
 954             Calendar calendar = Calendar.getInstance();
 955             calendar.set(Integer.parseInt(splitedDate[0]), Integer.parseInt(splitedDate[1]), Integer.parseInt(splitedDate[2]));
 956             if (Integer.parseInt(splitedDate[2]) > 0 && Integer.parseInt(splitedDate[2]) <= calendar.getActualMaximum(Calendar.DAY_OF_MONTH)) {//判断输入的日是否合法
 957                 if (Integer.parseInt(splitedDay[0]) >= 0 && Integer.parseInt(splitedDay[0]) <= 23 && Integer.parseInt(splitedDay[1]) >= 0 &&
 958                         Integer.parseInt(splitedDay[1]) <= 59 &&Integer.parseInt(splitedDay[2]) >= 0 && Integer.parseInt(splitedDay[2]) <= 59) {//判断输入的当天的时间是否合法
 959                     orderTime.setOrderTime(Integer.parseInt(splitedDate[0]), Integer.parseInt(splitedDate[1]) - 1, Integer.parseInt(splitedDate[2])//若合法，则记录该时间
 960                             , Integer.parseInt(splitedDay[0]), Integer.parseInt(splitedDay[1]), Integer.parseInt(splitedDay[2]));
 961                     orderTime.setOrderTimeDate(Integer.parseInt(splitedDate[0]), Integer.parseInt(splitedDate[1]), Integer.parseInt(splitedDate[2]));
 962                 }
 963             }else{
 964                 dateData = false;
 965             }
 966         }else{
 967             dateData = false;
 968         }
 969     }
 970 
 971     public int getTableNum() {
 972         return tableNum;
 973     }
 974 
 975     public void setTableNum(int tableNum) {
 976         this.tableNum = tableNum;
 977     }
 978 
 979     public void setIsValidName(String str){//判断点菜人名是否有效(合法)
 980         if (str.length() <= 10){
 981             isValidName = true;
 982             this.name = str;
 983         }else{
 984             isValidName = false;
 985         }
 986     }
 987 
 988     public void setIsValidTelephone(String str){//判断电话号码是否有效(合法)
 989         if (str.matches("1(80|81|89|33|35|36)\\d{8}")){
 990             isValidTelephone = true;
 991             this.telephone = str;
 992         }else{
 993             isValidTelephone = false;
 994         }
 995     }
 996 }
 997 
 998 class WhichDay{
 999     private Order order;
1000     private boolean isValidDate = true;
1001     private int week;
1002     Calendar[] compareTime = new Calendar[6];
1003 
1004     String[][] strArray = {{"MONDAY", "1"}, {"TUESDAY", "2"}, {"WEDNESDAY", "3"}, {"THURSDAY", "4"}, {"FRIDAY", "5"}, {"SATURDAY", "6"}, {"SUNDAY", "7"}};
1005     public WhichDay() {
1006     }
1007 
1008     public Order getOrder() {
1009         return order;
1010     }
1011 
1012     public void setOrder(Order order) {
1013         this.order = order;
1014     }
1015 
1016     public void setCompareTime() {//将营业时间的节点记录下来
1017         for (int i = 0;i < 6;i++){
1018             compareTime[i] = Calendar.getInstance();
1019         }
1020         compareTime[0].set(order.getTable().getOrderTime().getOrderTime().get(Calendar.YEAR),order.getTable().getOrderTime().getOrderTime().get(Calendar.MONTH)
1021                 ,order.getTable().getOrderTime().getOrderTime().get(Calendar.DATE),10,30,0);
1022         compareTime[1].set(order.getTable().getOrderTime().getOrderTime().get(Calendar.YEAR),order.getTable().getOrderTime().getOrderTime().get(Calendar.MONTH)
1023                 ,order.getTable().getOrderTime().getOrderTime().get(Calendar.DATE),14,30,0);
1024         compareTime[2].set(order.getTable().getOrderTime().getOrderTime().get(Calendar.YEAR),order.getTable().getOrderTime().getOrderTime().get(Calendar.MONTH)
1025                 ,order.getTable().getOrderTime().getOrderTime().get(Calendar.DATE),17,30,0);
1026         compareTime[3].set(order.getTable().getOrderTime().getOrderTime().get(Calendar.YEAR),order.getTable().getOrderTime().getOrderTime().get(Calendar.MONTH)
1027                 ,order.getTable().getOrderTime().getOrderTime().get(Calendar.DATE),20,30,0);
1028         compareTime[4].set(order.getTable().getOrderTime().getOrderTime().get(Calendar.YEAR),order.getTable().getOrderTime().getOrderTime().get(Calendar.MONTH)
1029                 ,order.getTable().getOrderTime().getOrderTime().get(Calendar.DATE),9,30,0);
1030         compareTime[5].set(order.getTable().getOrderTime().getOrderTime().get(Calendar.YEAR),order.getTable().getOrderTime().getOrderTime().get(Calendar.MONTH)
1031                 ,order.getTable().getOrderTime().getOrderTime().get(Calendar.DATE),21,30,0);
1032     }
1033 
1034     public WhichDay(Order order) {
1035         setOrder(order);
1036         String k = String.valueOf(this.order.getTable().getOrderTime().getOrderTimeDate().getDayOfWeek());
1037         for (int i = 0; i < strArray.length; i++) {
1038             if (k.equals(strArray[i][0])) {
1039                 k = strArray[i][1];
1040                 break;
1041             }
1042         }
1043         this.week = Integer.parseInt(k);
1044     }
1045 
1046     public int getWeek() {
1047         return week;
1048     }
1049 
1050     public void isValidDate(){//还有输入格式错误的问题没有解决
1051         if (week >= 1 && week <= 5){
1052             if (((((order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() >= compareTime[0].getTimeInMillis())) &&
1053                     (order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() <= (compareTime[1].getTimeInMillis())) ||
1054                     (((order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() >= (compareTime[2]).getTimeInMillis()) &&
1055                             ((order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() <= (compareTime[3]).getTimeInMillis()))){
1056                 isValidDate = true;
1057             }else if((((order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() >= (compareTime[0].getTimeInMillis())) &&
1058                     (order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() <= (compareTime[1].getTimeInMillis())) ||
1059                     (((order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() >= (compareTime[2].getTimeInMillis())) &&
1060                             ((order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() <= (compareTime[3].getTimeInMillis())))){
1061                 isValidDate = true;
1062             }else{
1063                 isValidDate = false;
1064             }
1065         }else{
1066             if ((((order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() >= (compareTime[4].getTimeInMillis())) &&
1067                     ((order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() <= (compareTime[5].getTimeInMillis())))){
1068                 isValidDate = true;
1069             }else if ((((order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() >= (compareTime[4].getTimeInMillis())) &&
1070                     ((order.getTable().getOrderTime().getOrderTime()).getTimeInMillis() <= (compareTime[5].getTimeInMillis())))){
1071                 isValidDate = true;
1072             }else{
1073                 isValidDate = false;
1074             }
1075         }
1076     }
1077 
1078     public double setDiscount(){
1079         double discount;
1080         if (((order.getTable().getOrderTime().getOrderTime()).compareTo(compareTime[0]) == 1) &&
1081                 (order.getTable().getOrderTime().getOrderTime()).compareTo(compareTime[1]) == -1){
1082             discount = 0.6;
1083         }else{
1084             discount = 0.8;
1085         }
1086         return discount;
1087     }
1088 
1089     public void setValidDate(boolean validDate) {
1090         isValidDate = validDate;
1091     }
1092 
1093     public boolean getValidDate(){
1094         return isValidDate;
1095     }
1096 
1097 }
1098 class SpecialDish{//特殊菜类型类
1099     private boolean isZheDish = false;
1100     private boolean isChuanDish = false;
1101     private boolean isJinDish = false;
1102 
1103     public SpecialDish() {
1104     }
1105 
1106     public void whichSpecialDish(String str){//判断是那种特殊菜
1107         if (str.equals("川菜")){
1108             this.isChuanDish = true;
1109         }else if (str.equals("浙菜")){
1110             this.isZheDish = true;
1111         }else if (str.equals("晋菜")){
1112             this.isJinDish = true;
1113         }
1114     }
1115 
1116     public boolean isZheDish() {
1117         return isZheDish;
1118     }
1119 
1120     public void setZheDish(boolean zheDish) {
1121         isZheDish = zheDish;
1122     }
1123 
1124     public boolean isChuanDish() {
1125         return isChuanDish;
1126     }
1127 
1128     public void setChuanDish(boolean chuanDish) {
1129         isChuanDish = chuanDish;
1130     }
1131 
1132     public boolean isJinDish() {
1133         return isJinDish;
1134     }
1135 
1136     public void setJinDish(boolean jinDish) {
1137         isJinDish = jinDish;
1138     }
1139 }
1140 
1141 class Customer{
1142     private String customer;
1143     private String telephone;
1144     private int cost = 0;
1145 
1146     public void addCost(int price){
1147         cost += price;
1148     }
1149 
1150     public Customer() {
1151     }
1152 
1153     public Customer(String customer,String telephone) {
1154         this.customer = customer;
1155         this.telephone = telephone;
1156     }
1157 
1158     public String getCustomer() {
1159         return customer;
1160     }
1161 
1162     public void setCustomer(String customer) {
1163         this.customer = customer;
1164     }
1165 
1166     public int getCost() {
1167         return cost;
1168     }
1169 
1170     public void setCost(int cost) {
1171         this.cost = cost;
1172     }
1173 
1174     public String getTelephone() {
1175         return telephone;
1176     }
1177 }

点击查看代码

成绩课程统计程序-1

　　这个题目最难的就是第一次写，因为第一次写需要做类的需求分析，以及要理解题目的意思，在后面的迭代的题目都是按照这次题目的代码的基础上进行修改的，因此，想要后面的作业更加轻松，这次作业类的设计必须要合理。

以下是本题的类图:

可以看到类与类之间大关系还是比较简单明了的，大部分都是组合的关系，与以前的菜单不同，这里我把储存数据用的容器都改成了Arraylist，Arraylist的一个优点是，这是一个动态数组，会根据数据的多少进行自动的扩容，所以在存放数据是就不用担心数组没有初始化以及空数组的问题了。

　　在这次作业中我设计了course课程类，student学生类以及class班级类这三个主要类。classes类以及courses类是用于存放多个对应的class和course的信息并且求出对应的数据的类，例如班级和课程都需要排序并且求出对应的平均分，这个工作就由这几个类来完成。还有一个studentdata学生数据类，就是用于存储学生单名课程的课程信息，这个类将会作为属性以Arraylist的形式存在于学生类当中，用于存放学生每门课程的成绩。

　　这当中还有一个比较有意思的点就是课程的排序，因为课程名称有可能是中文的，也有可能是英文的，所以需要使用中文的排序方法来进行排序，因此需要新定义一个Collator，并且以新定义的那个Collator进行比较返回值。

　　最后主类的设计我感觉我第一次设计的十分不合理，逻辑非常混乱，因此在后面的两次迭代的作业中我都做出了相应的优化，使逻辑更加的清晰，代码的可复用性更强。

以下是本题的代码(由于本题的代码行数有限制，我提交的代码并不是这一份代码):

  1 package Grade;
  2 
  3 import java.text.Collator;
  4 import java.util.*;
  5 
  6 public class Main {
  7     public static void main(String[] args){
  8         Scanner input = new Scanner(System.in);
  9         String str = input.nextLine();
 10         String[] splitedStr;
 11         Classes classes = new Classes();
 12         Courses courses = new Courses();
 13         while (!str.equals("end")){
 14             splitedStr = str.split(" ");
 15             while (splitedStr.length == 3){
 16                 Course course = new Course(splitedStr[0],splitedStr[1],splitedStr[2]);
 17                 courses.addACourse(course);
 18                 str = input.nextLine();
 19                 splitedStr = str.split(" ");
 20             }
 21             courses.inspectIsRightExaming();
 22             while (splitedStr.length == 4 || splitedStr.length == 5){
 23                 String classNum = splitedStr[0].substring(0,6);//获得该学生学号的前六位，也就是班级号
 24                 if (splitedStr.length == 4){//此门课程为选修课
 25                     if (splitedStr[3].matches("0|[1-9]|[1-9]\\d|100")) {
 26                         if (courses.courseExistance(splitedStr[2])) {//先查找此门课程是否存在在courses中
 27                             if (classes.ifAClassExist(classNum)) {//查找此学号前六位对应的班级号存在不存在
 28                                 if (classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {//查找该学号的学生是否存在
 29                                     Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
 30                                     classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).addData(course, splitedStr[3]);//先查找班级，再查找该学号的学生，最后将该门课程的考试信息录入
 31                                     course.addAInspectGrade(new InspectGrade(Integer.parseInt(splitedStr[3])));//将此学生的该门课程成绩录入
 32                                 } else {//不存在则建立一个新的学生对象存入该班号的学生ArrayList中
 33                                     Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 34                                     Course course = courses.findAClassByName(splitedStr[2]);//通过课程名称查找该课程
 35                                     student.addData(course, splitedStr[3]);//将课程以及课程成绩录入该学生的信息中
 36                                     classes.findAClassByNum(classNum).addAStudent(student);//将该学生录入这个班级当中
 37                                     course.addAInspectGrade(new InspectGrade(Integer.parseInt(splitedStr[3])));//将此学生的该门课程成绩录入
 38                                 }
 39                             } else {//否则就新建立一个班级的信息，并且存到classes中
 40                                 Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 41                                 Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
 42                                 student.addData(course, splitedStr[3]);//将课程信息和课程成绩录入该学生的信息中
 43                                 Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
 44                                 classes.addAClass(newClass);//将这个新的班级加入classes
 45                                 course.addAInspectGrade(new InspectGrade(Integer.parseInt(splitedStr[3])));//将此学生的该门课程成绩录入
 46                             }
 47                         } else {
 48                             System.out.println(splitedStr[2] + " does not exist");
 49                             Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 50                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
 51                             classes.addAClass(newClass);//将这个新的班级加入classes
 52                         }
 53                     }else{
 54                         System.out.println("wrong format");
 55                     }
 56                 }
 57                 if (splitedStr.length == 5){//此门课程为必修课
 58                     if (splitedStr[3].matches("0|[1-9]|[1-9]\\d|100") && splitedStr[4].matches("0|[1-9]|[1-9]\\d|100")) {
 59                         if (courses.courseExistance(splitedStr[2])) {//先查找此门课程是否存在在courses中
 60                             if (classes.ifAClassExist(classNum)) {//查找此学号前六位对应的班级号存在不存在
 61                                 if (classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {//查找该学号的学生是否存在
 62                                     Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
 63                                     classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).addData(course, splitedStr[3], splitedStr[4]);//先查找班级，再查找该学号的学生，最后将该门课程的考试信息录入
 64                                     course.addAExamGrade(new ExamGrade(Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4])));//将此学生的该门课程成绩录入
 65                                 } else {//不存在则建立一个新的学生对象存入该班号的学生ArrayList中
 66                                     Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 67                                     Course course = courses.findAClassByName(splitedStr[2]);//通过课程名称查找该课程
 68                                     student.addData(course, splitedStr[3], splitedStr[4]);//将课程以及课程成绩录入该学生的信息中
 69                                     classes.findAClassByNum(classNum).addAStudent(student);//将该学生录入这个班级当中
 70                                     course.addAExamGrade(new ExamGrade(Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4])));//将此学生的该门课程成绩录入
 71                                 }
 72                             } else {//否则就新建立一个班级的信息，并且存到classes中
 73                                 Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 74                                 Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
 75                                 student.addData(course, splitedStr[3], splitedStr[4]);//将课程信息和课程成绩录入该学生的信息中
 76                                 Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
 77                                 classes.addAClass(newClass);//将这个新的班级加入classes
 78                                 course.addAExamGrade(new ExamGrade(Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4])));//将此学生的该门课程成绩录入
 79                             }
 80                         } else {
 81                             System.out.println(splitedStr[2] + " does not exist");
 82                             Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 83                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
 84                             classes.addAClass(newClass);//将这个新的班级加入classes
 85                         }
 86                     }else{
 87                         System.out.println("wrong format");
 88                     }
 89                 }
 90                 str = input.nextLine();
 91                 splitedStr = str.split(" ");
 92             }
 93         }
 94         classes.setStudentsAve();
 95         classes.setClassesAve();
 96         courses.setCoursesAve();
 97         classes.sort();
 98         courses.sort();
 99         classes.showStudents();
100         courses.showCourses();
101         classes.showClasses();
102     }
103 }
104 
105 class ExamGrade{
106     private int usualScore;//平时成绩
107     private int examScore;//考试成绩
108     private int totalScore;
109     public int getUsualScore() {
110         return usualScore;
111     }
112 
113     public int getExamScore() {
114         return examScore;
115     }
116 
117     public Boolean isValidScore(String score){
118         if (!score.matches("0|[1-9]|[1-9]\\d|100")){
119             System.out.println("wrong format");
120             return false;
121         }
122         return true;
123     }
124 
125     public void setUsualScore(int usualScore) {
126         this.usualScore = usualScore;
127     }
128 
129     public void setExamScore(int examScore) {
130         this.examScore = examScore;
131     }
132 
133     public ExamGrade() {
134     }
135 
136     public ExamGrade(int usualScore, int examScore) {
137         this.usualScore = usualScore;
138         this.examScore = examScore;
139     }
140 
141     public void setTotalScore(){
142         totalScore = (int)(usualScore * 0.3 + examScore * 0.7);
143     }
144 
145     public int getTotalScore() {
146         return totalScore;
147     }
148 }
149 
150 class InspectGrade{
151     private int grade;//考察成绩
152 
153     public InspectGrade() {
154     }
155 
156     public InspectGrade(int grade) {
157         this.grade = grade;
158     }
159 
160     public void setGrade(int grade) {
161         this.grade = grade;
162     }
163 
164     public int getGrade() {
165         return grade;
166     }
167 }
168 
169 class Student implements Comparable<Student>{
170     private ArrayList<StudentData> data = new ArrayList<>();
171     private String num;
172     private String name;
173     private int averageGrade = -1;
174 
175     public Student(String num, String name) {
176         if (name.length() < 10){
177             this.name = name;
178         }else{
179             System.out.println("wrong format");
180         }
181         if (num.length() == 8){
182             this.num = num;
183         }else{
184             System.out.println("wrong format");
185         }
186     }
187 
188     public void setAverageGrade(){
189         int sum = 0;//sum计算该学生成绩的综合
190         if (data.size() != 0) {
191             for (StudentData s : data) {
192                 sum += s.getGrade();
193             }
194             averageGrade = sum / data.size();
195         }
196     }
197 
198     public String getName() {
199         return name;
200     }
201 
202     public String getNum() {
203         return num;
204     }
205 
206     public void addData(Course course,String score1/*平时成绩*/,String score2/*考试成绩*/){//addData方法有两个重载，一个是有平时成绩和考试成绩的方法，另外一个是只有考察成绩的方法
207         ExamGrade examGrade = new ExamGrade();
208         examGrade.setUsualScore(Integer.parseInt(score1));
209         examGrade.setExamScore(Integer.parseInt(score2));
210         data.add(new StudentData(course,examGrade));
211     }
212 
213     public void addData(Course course,String score){
214         InspectGrade inspectGrade = new InspectGrade();
215         inspectGrade.setGrade(Integer.parseInt(score));
216         data.add(new StudentData(course,inspectGrade));
217     }
218 
219     public int getAverageGrade() {
220         return averageGrade;
221     }
222 
223     public void setGrades(){
224         for (StudentData d : data){
225             d.setGrade();
226         }
227     }
228 
229     @Override
230     public int compareTo(Student o) {
231         return num.compareTo(o.getNum());
232     }
233 }
234 
235 class Course implements Comparable<Course>{
236     private String name;
237     private String type;
238     private String examing;
239     private ArrayList<ExamGrade> examGrades = new ArrayList<>();//两个ArrayList根据考核方式只会用到一个
240     private ArrayList<InspectGrade> inspectGrades = new ArrayList<>();//两个ArrayList根据考核方式只会用到一个
241     private int averageUsualGrade = -1;
242     private int averageExamGrade = -1;
243     private int averageGrade = -1;
244     private int averageScore = -1;
245 
246     public Course(String name, String type, String examing) {
247         this.name = name;
248         this.type = type;
249         this.examing = examing;
250     }
251 
252     public String getName() {
253         return name;
254     }
255 
256     public String getType() {
257         return type;
258     }
259 
260     public String getExaming() {
261         return examing;
262     }
263 
264     public void addAExamGrade(ExamGrade examGrade){
265         examGrades.add(examGrade);
266     }
267 
268     public void addAInspectGrade(InspectGrade inspectGrade){
269         inspectGrades.add(inspectGrade);
270     }
271 
272     public void setAverageScore(){
273         int examSum = 0,usualSum = 0,sum = 0;
274         if (examing.equals("考试") && examGrades.size() != 0){
275             for (ExamGrade e : examGrades){
276                 e.setTotalScore();
277                 examSum += e.getExamScore();
278                 usualSum += e.getUsualScore();
279                 sum += e.getTotalScore();
280             }
281             averageExamGrade = examSum / examGrades.size();
282             averageUsualGrade = usualSum / examGrades.size();
283             averageScore = sum / examGrades.size();
284         }
285         if (examing.equals("考察") && inspectGrades.size() != 0){
286             for (InspectGrade i : inspectGrades){
287                 sum += i.getGrade();
288             }
289             averageGrade = sum / inspectGrades.size();
290             averageScore = averageGrade;
291         }
292     }
293 
294     @Override
295     public int compareTo(Course o) {
296         Collator collator = Collator.getInstance(Locale.CHINA);
297         return collator.compare(this.name,o.getName());
298     }
299 
300     public int getAverageUsualGrade() {
301         return averageUsualGrade;
302     }
303 
304     public int getAverageExamGrade() {
305         return averageExamGrade;
306     }
307 
308     public int getAverageScore() {
309         return averageScore;
310     }
311 }
312 
313 class Courses{
314     ArrayList<Course> courses = new ArrayList<>();
315 
316     public void addACourse(Course course){
317         courses.add(course);
318     }
319 
320     public Boolean courseExistance(String str){//查找课程是否存在
321         for (Course c : courses){
322             if (c.getName().equals(str)){
323                 return true;
324             }
325         }
326         return false;
327     }
328 
329     public void inspectIsRightExaming(){//检验必修类的课程的考察方式是否为考试
330         ArrayList<Course> C = new ArrayList<>();
331         for (Course c : courses){
332             if (c.getType().equals("必修")){
333                 if (c.getExaming().equals("考察")){
334                     System.out.println( c.getName() + " : course type & access mode mismatch");
335                     C.add(c);
336                 }
337             }
338         }
339         for (Course c : C){
340             courses.remove(c);
341         }
342     }
343 
344     public Course findAClassByName(String name){//通过名字查找课程，并且返回这个课程的信息
345         for (Course c : courses){
346             if (name.equals(c.getName())){
347                 return c;
348             }
349         }
350         return null;//永远不会走到这一步,因为使用这个方法的前提是先查找这门课程是否存在,所以放心
351     }
352 
353     public void setCoursesAve(){
354         for (Course c : courses){
355             c.setAverageScore();
356         }
357     }
358 
359     public void sort(){
360         Collections.sort(courses);
361     }
362 
363     public void showCourses(){
364         for (Course c : courses){
365             if (c.getAverageScore() != -1) {
366                 if (c.getExaming().equals("考试")) {
367                     System.out.println(c.getName() + " " + c.getAverageUsualGrade() + " " + c.getAverageExamGrade() + " " + c.getAverageScore());
368                 } else {
369                     System.out.println(c.getName() + " " + c.getAverageScore() + " " + c.getAverageScore());
370                 }
371             }else{
372                 System.out.println(c.getName() + " has no grades yet");
373             }
374         }
375     }
376 }
377 
378 class Class implements Comparable<Class>{
379     private ArrayList<Student> students = new ArrayList<>();
380     private int averageScore;
381     private String num;
382 
383     public String getNum() {
384         return num;
385     }
386 
387     public Class(String num,Student student) {
388         students.add(student);
389         this.num = num;
390     }
391 
392     public Boolean isStudentExist(String str){//对应学号的学生是否存在
393         for (Student s : students){
394             if (s.getNum().equals(str)){
395                 return true;
396             }
397         }
398         return false;
399     }
400 
401     public void addAStudent(Student student){
402         students.add(student);
403     }
404 
405     public Student findAStudentByNum(String str){
406         for (Student s : students){
407             if (s.getNum().equals(str)){
408                 return s;
409             }
410         }
411         return null;//同样，因为先判断该学号的学生是否存在所以不用担心会返回null
412     }
413 
414     public void setAverageScore(){
415         int sum = 0;
416         if (students.size() != 0) {
417             for (Student s : students) {
418 
419                 sum += s.getAverageGrade();
420             }
421             this.averageScore = sum / students.size();
422         }
423     }
424 
425     @Override
426     public int compareTo(Class o) {
427         return num.compareTo(o.getNum());
428     }
429 
430     public ArrayList<Student> getStudents() {
431         return students;
432     }
433 
434     public int getAverageScore() {
435         return averageScore;
436     }
437 }
438 
439 class StudentData{//学生单门课程的的信息
440     private Course course;
441     private ExamGrade totalGrade;//考试成绩
442     private InspectGrade grade;//考查成绩
443     private int Grade;
444 
445     public void setGrade(){
446         if (course.getExaming().equals("考试")){
447             Grade = (int) (totalGrade.getUsualScore() * 0.3 + totalGrade.getExamScore() * 0.7);
448         }else{
449             Grade = grade.getGrade();
450         }
451     }
452 
453     public int getGrade() {
454         return Grade;
455     }
456 
457     public StudentData(Course course,ExamGrade examGrade){
458         this.course = course;
459         totalGrade = examGrade;
460     }
461 
462     public StudentData(Course course, InspectGrade inspectGrade){
463         this.course = course;
464         this.grade = inspectGrade;
465     }
466 }
467 
468 class Classes{
469     private ArrayList<Class> classes = new ArrayList<>();
470 
471     public void addAClass(Class newClass){//在调用这个方法之前，会先调用班级是否存在方法
472         classes.add(newClass);
473     }
474 
475     public Boolean ifAClassExist(String Num){//判断该班号的班级是否在存在
476         for (Class c : classes){
477             if (c.getNum().equals(Num)){
478                 return true;
479             }
480         }
481         return false;
482     }
483 
484     public Class findAClassByNum(String str){//通过班号查找一个班级
485         for (Class c : classes){
486             if (c.getNum().equals(str)){
487                 return c;
488             }
489         }
490         return null;//不会走到这一步，因为在调用这个方法之前首先会判断这个班号对应的班级是否存在
491     }
492 
493     public void setClassesAve(){
494         for (Class c : classes){
495             c.setAverageScore();
496         }
497     }
498 
499     public void setStudentsAve(){
500         for (Class c : classes){
501             for (Student s : c.getStudents()){
502                 s.setGrades();
503                 s.setAverageGrade();
504             }
505         }
506     }
507 
508     public void sort(){
509         for (Class c : classes){
510             Collections.sort(c.getStudents());
511         }
512         Collections.sort(classes);
513     }
514 
515     public void showStudents(){
516         for (Class c : classes){
517             for (Student s : c.getStudents()){
518                 if (s.getAverageGrade() != -1) {
519                     System.out.println(s.getNum() + " " + s.getName() + " " + s.getAverageGrade());
520                 }else{
521                     System.out.println(s.getNum() + " " + s.getName() + " did not take any exams");
522                 }
523             }
524         }
525     }
526 
527     public void showClasses(){
528         for (Class c : classes){
529             if (c.getAverageScore() != -1) {
530                 System.out.println(c.getNum() + " " + c.getAverageScore());
531             }else{
532                 System.out.println(c.getNum() + " has no grades yet");
533             }
534         }
535     }
536 }

点击查看代码

统计java程序中关键词出现的次数

　　这道题就是正则表达式的一道训练题，就是从一段java程序中统计关键词出现的次数。这道题主要有两种方法，一种是用replace方法去改变文本，最后统计出现的关键词。还有一种就是用split分割字符串，然后一个一个字符串去匹配是否是关键词。这里我使用的是第二种方法，但是我感觉第二种方法要比第一种方法复杂许多，因为注释和引号里面出现的关键词是不统计的，因此需要再碰到多行注释以及双引号之间做标记，使得逻辑性非常强，因此我大量的使用了if语句将各种情况分割开来。

以下是本题的代码:

 1 import java.util.*;
 2 public class Main {
 3     public static void main(String[] args) {
 4         String[] keyWordsArr = {"abstract","assert","boolean","break","byte","case","catch","char","class","const","continue","default",
 5                 "do","double","else","enum","extends","false","final","finally","float","for","goto","if","implements",
 6                 "import","instanceof","int","interface","long","native","new","null","package",
 7                 "private","protected","public","return","short","static","strictfp","super","switch",
 8                 "synchronized","this","throw","throws","transient","true","try","void","volatile","while"};
 9         Scanner input = new Scanner(System.in);
10         String str = input.nextLine();
11         HashMap<String,Integer> keyWordsMap = setKeyWordsMap(keyWordsArr);
12         TreeSet<String> strSet = new TreeSet<>();
13         int note1 = 1,flag = 0;
14         while (!str.equals("exit")){
15             flag = 1;
16             int note2 = 1;
17             String[] splitedStr = str.split("[\\s+;.()}{\\[\\]:,<>]");
18             for (String s : splitedStr){
19                 if (s.matches("/\\*.*") && note2 != 0){
20                     note1 = 0;
21                 }
22                 else if (s.matches("//.*") || (s.matches("\".*") && note2 != 0 && !s.matches("\"\""))){
23                     note2 = 0;
24                 }
25                 else if (s.matches(".*\\*/") && note2 != 0){
26                     note1 = 1;
27                 }
28                 else if ((s.matches(".*//") && note2 == 0 && note1 != 0) || (s.matches(".*\"") && !s.matches(".*\\\\\".*"))){
29                     note2 = 1;
30                 }
31                 if ((keyWordsMap.containsKey(s) && note1 != 0 && note2 != 0)){
32                     keyWordsMap.put(s,keyWordsMap.get(s) + 1);
33                 }
34             }
35             str = input.nextLine();
36         }
37         for (String s : keyWordsMap.keySet()){
38             if (keyWordsMap.get(s) > 0) {
39                 strSet.add(s);
40             }
41         }
42         for (String s : strSet){
43             System.out.println(keyWordsMap.get(s) + "\t" + s);
44         }
45         if (flag == 0){
46             System.out.println("Wrong Format");
47         }
48     }
49     public static HashMap<String,Integer> setKeyWordsMap(String[] arr){/*this*/
50         HashMap<String,Integer> hashMap = new HashMap<>();
51         for (String s : arr){
52             hashMap.put(s,0);
53         }
54         return hashMap;
55     }
56 
57 }

课程成绩统计程序-2 && 3

　　这两次作业非常相似，2是在1的基础上增加了实验课，并且有实验次数的限制，而3实在2的基础上改变了课程的总分方式，增加了权重这一概念，但是总体的思路还是查不了多少的，所以这两题的设计与分析放在了一起。

　　因为这两次的作业的类分析没有什么太大的变化，只是新加了一个实验类的课程，因此这里就不放出类图了。

　　首先，作业2实在原来的基础上增加了实验课，因此需要增加一个实验课的类，然后存于studentdata之中，并且需要记录实验课的实验次数。因为多了实验课，所以主函数对输入的课程的信息也需要做出相应的修改，因为我第一次作业写的主函数实在是混乱不堪，所以我在作业2中重新写了一次我的主函数，主要就是用if语句以及正则表达式来匹配输入的信息，如果都没有匹配到，那么输入的信息就会被视为非法输入输出wrong format。主函数匹配的方式是这样的：

与第一次作业作对比，逻辑就清晰了许多。

　　第三次作业是在第二次作业的基础上更改了计分的方式，增加了权重，但是类的设计的方法是没有改变的，主要的还是在主函数上修改了匹配输入的信息的正则表达式，与第二次作业相差不大。

  1 package Grade;
  2 
  3 import java.text.Collator;
  4 import java.util.*;
  5 
  6 public class Main {
  7     public static void main(String[] args){
  8         Classes classes = new Classes();
  9         Courses courses = new Courses();
 10         Scanner input = new Scanner(System.in);
 11         while (true){
 12             String str = input.nextLine();
 13             String[] splitedStr = str.split(" ");
 14             if (str.equals("end")){
 15                 break;
 16             }
 17             if (str.matches(".{1,10} 必修 实验") || str.matches(".{1,10} 必修 考察") ||
 18                     str.matches(".{1,10} 选修 实验") || str.matches(".{1,10} 实验 考察") ||
 19                     str.matches(".{1,10} 实验 考试")){
 20                 System.out.println(splitedStr[0] + " : course type & access mode mismatch");
 21             } else if (str.matches(".{1,10} 必修 考试")){
 22                 if (courses.findAClassByName(splitedStr[0]) == null) {
 23                     Course course = new Course(splitedStr[0], splitedStr[1], splitedStr[2]);
 24                     courses.addACourse(course);
 25                 }
 26             } else if (str.matches(".{1,10} 选修 考察")){
 27                 if (courses.findAClassByName(splitedStr[0]) == null) {
 28                     Course course = new Course(splitedStr[0], splitedStr[1], splitedStr[2]);
 29                     courses.addACourse(course);
 30                 }
 31             } else if (str.matches(".{1,10} 选修 考试")){
 32                 if (courses.findAClassByName(splitedStr[0]) == null) {
 33                     Course course = new Course(splitedStr[0], splitedStr[1], splitedStr[2]);
 34                     courses.addACourse(course);
 35                 }
 36             } else if (str.matches(".{1,10} 实验 实验")){
 37                 if (courses.findAClassByName(splitedStr[0]) == null) {
 38                     Course course = new Course(splitedStr[0], splitedStr[1], splitedStr[2]);
 39                     courses.addACourse(course);
 40                 }
 41             }else if (str.matches("\\d{8} [\\u4E00-\\u9FA5A-Za-z]{1,10} [\\u4E00-\\u9FA5A-Za-z]{1,10} (100|0|[1-9]\\d?) (100|0|[1-9]\\d?)")){//考试,录入学生信息
 42                 String classNum = splitedStr[0].substring(0,6);//获得该学生学号的前六位，也就是班级号
 43                 if (courses.courseExistence(splitedStr[2])) {//先查找此门课程是否存在在courses中
 44                     if (courses.findAClassByName(splitedStr[2]).getExaming().equals("考试")) {
 45                         if (classes.ifAClassExist(classNum)) {//查找此学号前六位对应的班级号存在不存在
 46                             if (classes.findAClassByNum(classNum).isStudentExist(splitedStr[0]) && classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).getName().equals(splitedStr[1])) {//查找该学号的学生是否存在
 47                                 if (!classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).finACourseExist(splitedStr[2])) {
 48                                     Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
 49                                     classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).addData(course, splitedStr[3], splitedStr[4]);//先查找班级，再查找该学号的学生，最后将该门课程的考试信息录入
 50                                     course.addAExamGrade(new ExamGrade(Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4])));//将此学生的该门课程成绩录入
 51                                 }
 52                             } else if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {//不存在则建立一个新的学生对象存入该班号的学生ArrayList中
 53                                 Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 54                                 Course course = courses.findAClassByName(splitedStr[2]);//通过课程名称查找该课程
 55                                 student.addData(course, splitedStr[3], splitedStr[4]);//将课程以及课程成绩录入该学生的信息中
 56                                 classes.findAClassByNum(classNum).addAStudent(student);//将该学生录入这个班级当中
 57                                 course.addAExamGrade(new ExamGrade(Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4])));//将此学生的该门课程成绩录入
 58                             }
 59                         } else {//否则就新建立一个班级的信息，并且存到classes中
 60                             Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 61                             Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
 62                             student.addData(course, splitedStr[3], splitedStr[4]);//将课程信息和课程成绩录入该学生的信息中
 63                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
 64                             classes.addAClass(newClass);//将这个新的班级加入classes
 65                             course.addAExamGrade(new ExamGrade(Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4])));//将此学生的该门课程成绩录入
 66                         }
 67                     }else{
 68                         Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 69                         if (classes.ifAClassExist(classNum)) {
 70                             if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
 71                                 classes.findAClassByNum(classNum).addAStudent(student);
 72                             }
 73                         }else {
 74                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
 75                             classes.addAClass(newClass);//将这个新的班级加入classes
 76                         }
 77                         System.out.println(splitedStr[0] + " " + splitedStr[1] + " : access mode mismatch");
 78                     }
 79                 }else {
 80                     System.out.println(splitedStr[2] + " does not exist");
 81                     Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 82                     if (classes.ifAClassExist(classNum)) {
 83                         if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
 84                             classes.findAClassByNum(classNum).addAStudent(student);
 85                         }
 86                     }else {
 87                         Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
 88                         classes.addAClass(newClass);//将这个新的班级加入classes
 89                     }
 90                 }
 91             } else if (str.matches("\\d{8} [\\u4E00-\\u9FA5A-Za-z]{1,10} [\\u4E00-\\u9FA5A-Za-z]{1,10} (100|0|[1-9]\\d?)")){//考察，录入学生信息
 92                 String classNum = splitedStr[0].substring(0,6);//获得该学生学号的前六位，也就是班级号
 93                 if (courses.courseExistence(splitedStr[2])) {//先查找此门课程是否存在在courses中
 94                     if (courses.findAClassByName(splitedStr[2]).getExaming().equals("考察")) {
 95                         if (classes.ifAClassExist(classNum)) {//查找此学号前六位对应的班级号存在不存在
 96                             if (classes.findAClassByNum(classNum).isStudentExist(splitedStr[0]) && classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).getName().equals(splitedStr[1])) {//查找该学号的学生是否存在
 97                                 if (!classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).finACourseExist(splitedStr[2])) {
 98                                     Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
 99                                     classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).addData(course, splitedStr[3]);//先查找班级，再查找该学号的学生，最后将该门课程的考试信息录入
100                                     course.addAInspectGrade(new InspectGrade(Integer.parseInt(splitedStr[3])));//将此学生的该门课程成绩录入
101                                 }
102                             } else if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {//不存在则建立一个新的学生对象存入该班号的学生ArrayList中
103                                 Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
104                                 Course course = courses.findAClassByName(splitedStr[2]);//通过课程名称查找该课程
105                                 student.addData(course, splitedStr[3]);//将课程以及课程成绩录入该学生的信息中
106                                 classes.findAClassByNum(classNum).addAStudent(student);//将该学生录入这个班级当中
107                                 course.addAInspectGrade(new InspectGrade(Integer.parseInt(splitedStr[3])));//将此学生的该门课程成绩录入
108                             }
109                         } else {//否则就新建立一个班级的信息，并且存到classes中
110                             Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
111                             Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
112                             student.addData(course, splitedStr[3]);//将课程信息和课程成绩录入该学生的信息中
113                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
114                             classes.addAClass(newClass);//将这个新的班级加入classes
115                             course.addAInspectGrade(new InspectGrade(Integer.parseInt(splitedStr[3])));//将此学生的该门课程成绩录入
116                         }
117                     }else{
118                         Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
119                         if (classes.ifAClassExist(classNum)) {
120                             if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
121                                 classes.findAClassByNum(classNum).addAStudent(student);
122                             }
123                         }else {
124                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
125                             classes.addAClass(newClass);//将这个新的班级加入classes
126                         }
127                         System.out.println(splitedStr[0] + " " + splitedStr[1] + " : access mode mismatch");
128                     }
129                 }else {
130                     System.out.println(splitedStr[2] + " does not exist");
131                     Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
132                     if (classes.ifAClassExist(classNum)) {
133                         if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
134                             classes.findAClassByNum(classNum).addAStudent(student);
135                         }
136                     }else {
137                         Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
138                         classes.addAClass(newClass);//将这个新的班级加入classes
139                     }
140                 }
141             } else if (str.matches("\\d{8} [\\u4E00-\\u9FA5A-Za-z]{1,10} [\\u4E00-\\u9FA5A-Za-z]{1,10} [4-9]( (100|0|[1-9]\\d?))*")){
142                 String classNum = splitedStr[0].substring(0,6);//获得该学生学号的前六位，也就是班级号
143                 if ((splitedStr.length - 4) == Integer.parseInt(splitedStr[3])){
144                     if (courses.courseExistence(splitedStr[2])) {//先查找此门课程是否存在在courses中
145                         if (courses.findAClassByName(splitedStr[2]).getExaming().equals("实验")) {
146                             ArrayList<Integer> experiments = new ArrayList<>();
147                             for (int i = 4;i < splitedStr.length;i ++){
148                                 experiments.add(Integer.parseInt(splitedStr[i]));
149                             }
150                             if (classes.ifAClassExist(classNum)){//班级是否存在
151                                 if (classes.findAClassByNum(classNum).isStudentExist(splitedStr[0]) && classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).getName().equals(splitedStr[1])){//班级存在的话学生是否存在
152                                     if (!classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).finACourseExist(splitedStr[2])) {
153                                         Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
154                                         classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).addData(course, experiments);
155                                         course.addAExperimentGrade(new ExperimentGrade(experiments));
156                                     }
157                                 } else if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])){//学生不存在
158                                     Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
159                                     Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
160                                     student.addData(course,experiments);//录入学生信息
161                                     classes.findAClassByNum(classNum).addAStudent(student);
162                                     course.addAExperimentGrade(new ExperimentGrade(experiments));//录入课程成绩
163                                 }
164                             }else{//班级不存在
165                                 Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
166                                 Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
167                                 student.addData(course,experiments);//录入学生信息
168                                 Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
169                                 classes.addAClass(newClass);//将这个新的班级加入classes
170                                 course.addAExperimentGrade(new ExperimentGrade(experiments));//录入课程成绩
171                             }
172                         }else{
173                             Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
174                             if (classes.ifAClassExist(classNum)) {
175                                 if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
176                                     classes.findAClassByNum(classNum).addAStudent(student);
177                                 }
178                             }else {
179                                 Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
180                                 classes.addAClass(newClass);//将这个新的班级加入classes
181                             }
182                             System.out.println(splitedStr[0] + " " + splitedStr[1] + " : access mode mismatch");
183                         }
184                     }else{
185                         System.out.println(splitedStr[2] + " does not exist");
186                         Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
187                         if (classes.ifAClassExist(classNum)) {
188                             if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
189                                 classes.findAClassByNum(classNum).addAStudent(student);
190                             }
191                         }else {
192                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
193                             classes.addAClass(newClass);//将这个新的班级加入classes
194                         }
195                     }
196                 } else{//不匹配也要录入学生的信息
197                     Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
198                     if (classes.ifAClassExist(classNum)) {
199                         if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
200                             classes.findAClassByNum(classNum).addAStudent(student);
201                         }
202                     }else {
203                         Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
204                         classes.addAClass(newClass);//将这个新的班级加入classes
205                     }
206                     System.out.println(splitedStr[0] + " " + splitedStr[1] + " : access mode mismatch");
207                 }
208             } else{
209                 if (!str.matches("end")) {
210                     System.out.println("wrong format");
211                 }
212             }
213         }
214         classes.setStudentsAve();
215         classes.setClassesAve();
216         courses.setCoursesAve();
217         classes.sort();
218         courses.sort();
219         classes.showStudents();
220         courses.showCourses();
221         classes.showClasses();
222     }
223 }
224 
225 class ExamGrade{
226     private int usualScore;//平时成绩
227     private int examScore;//考试成绩
228     private int totalScore;
229     public int getUsualScore() {
230         return usualScore;
231     }
232 
233     public int getExamScore() {
234         return examScore;
235     }
236 
237     public Boolean isValidScore(String score){
238         if (!score.matches("0|[1-9]|[1-9]\\d|100")){
239             System.out.println("wrong format");
240             return false;
241         }
242         return true;
243     }
244 
245     public void setUsualScore(int usualScore) {
246         this.usualScore = usualScore;
247     }
248 
249     public void setExamScore(int examScore) {
250         this.examScore = examScore;
251     }
252 
253     public ExamGrade() {
254     }
255 
256     public ExamGrade(int usualScore, int examScore) {
257         this.usualScore = usualScore;
258         this.examScore = examScore;
259     }
260 
261     public void setTotalScore(){
262         totalScore = (int)(usualScore * 0.3 + examScore * 0.7);
263     }
264 
265     public int getTotalScore() {
266         return totalScore;
267     }
268 }
269 
270 class InspectGrade{
271     private int grade;//考察成绩
272 
273     public InspectGrade() {
274     }
275 
276     public InspectGrade(int grade) {
277         this.grade = grade;
278     }
279 
280     public void setGrade(int grade) {
281         this.grade = grade;
282     }
283 
284     public int getGrade() {
285         return grade;
286     }
287 }
288 
289 class ExperimentGrade{
290     private ArrayList<Integer> grades = new ArrayList<>();//每次实验成绩
291     private int totalScore;
292 
293     public void addAGrade(int grade){
294         grades.add(grade);
295     }
296 
297     public void calculateTotalScore(){
298         int sum = 0;
299         for (int g : grades){
300             sum += g;
301         }
302         totalScore = sum / grades.size();
303     }
304 
305     public int getTotalScore() {
306         return totalScore;
307     }
308 
309     public ExperimentGrade() {
310     }
311 
312     public ExperimentGrade(ArrayList<Integer> grades) {
313         this.grades = grades;
314     }
315 }
316 
317 class Student implements Comparable<Student>{
318     private ArrayList<StudentData> data = new ArrayList<>();
319     private String num;
320     private String name;
321     private int averageGrade = -1;
322 
323     public Student(String num, String name) {
324         if (name.length() < 10){
325             this.name = name;
326         }else{
327             System.out.println("wrong format");
328         }
329         if (num.length() == 8){
330             this.num = num;
331         }else{
332             System.out.println("wrong format");
333         }
334     }
335 
336     public void setAverageGrade(){
337         int sum = 0;//sum计算该学生成绩的综合
338         if (data.size() != 0) {
339             for (StudentData s : data) {
340                 sum += s.getGrade();
341             }
342             averageGrade = sum / data.size();
343         }
344     }
345 
346     public String getName() {
347         return name;
348     }
349 
350     public String getNum() {
351         return num;
352     }
353 
354     public void addData(Course course,String score1/*平时成绩*/,String score2/*考试成绩*/){//addData方法有两个重载，一个是有平时成绩和考试成绩的方法，另外一个是只有考察成绩的方法
355         ExamGrade examGrade = new ExamGrade();
356         examGrade.setUsualScore(Integer.parseInt(score1));
357         examGrade.setExamScore(Integer.parseInt(score2));
358         data.add(new StudentData(course,examGrade));
359     }
360 
361     public void addData(Course course,String score){
362         InspectGrade inspectGrade = new InspectGrade();
363         inspectGrade.setGrade(Integer.parseInt(score));
364         data.add(new StudentData(course,inspectGrade));
365     }
366 
367     public void addData(Course course,ArrayList<Integer> grades){
368         ExperimentGrade experimentGrade = new ExperimentGrade(grades);
369         data.add(new StudentData(course,experimentGrade));
370     }
371 
372     public int getAverageGrade() {
373         return averageGrade;
374     }
375 
376     public void setGrades(){
377         for (StudentData d : data){
378             d.setGrade();
379         }
380     }
381 
382     @Override
383     public int compareTo(Student o) {
384         return num.compareTo(o.getNum());
385     }
386 
387     public boolean finACourseExist(String str){
388         for (StudentData s : data){
389             if (s.getCourse().getName().equals(str)){
390                 return true;
391             }
392         }
393         return false;
394     }
395 }
396 
397 class Course implements Comparable<Course>{
398     private String name;//课程名称
399     private String type;//课程类型
400     private String examing;//考试类型
401     private ArrayList<ExamGrade> examGrades = new ArrayList<>();//三个ArrayList根据考核方式只会用到一个
402     private ArrayList<InspectGrade> inspectGrades = new ArrayList<>();//三个ArrayList根据考核方式只会用到一个
403     private ArrayList<ExperimentGrade> experimentGrades = new ArrayList<>();//三个ArrayList根据考核方式只会用到一个
404     private int averageUsualGrade = -1;//平时
405     private int averageExamGrade = -1;//考试
406     private int averageExperiment = -1;//实验
407     private int averageGrade = -1;//考察
408     private int averageScore = -1;//总的平均
409 
410     public Course(String name, String type, String examing) {
411         this.name = name;
412         this.type = type;
413         this.examing = examing;
414     }
415 
416     public String getName() {
417         return name;
418     }
419 
420     public String getType() {
421         return type;
422     }
423 
424     public String getExaming() {
425         return examing;
426     }
427 
428     public void addAExamGrade(ExamGrade examGrade){
429         examGrades.add(examGrade);
430     }
431 
432     public void addAInspectGrade(InspectGrade inspectGrade){
433         inspectGrades.add(inspectGrade);
434     }
435 
436     public void addAExperimentGrade(ExperimentGrade experimentGrade){
437         experimentGrades.add(experimentGrade);
438     }
439 
440     public void setAverageScore(){
441         int examSum = 0,usualSum = 0,sum = 0;
442         if (examing.equals("考试") && examGrades.size() != 0){
443             for (ExamGrade e : examGrades){
444                 e.setTotalScore();
445                 examSum += e.getExamScore();
446                 usualSum += e.getUsualScore();
447                 sum += e.getTotalScore();
448             }
449             averageExamGrade = examSum / examGrades.size();
450             averageUsualGrade = usualSum / examGrades.size();
451             averageScore = sum / examGrades.size();
452         }
453         if (examing.equals("考察") && inspectGrades.size() != 0){
454             for (InspectGrade i : inspectGrades){
455                 sum += i.getGrade();
456             }
457             averageGrade = sum / inspectGrades.size();
458             averageScore = averageGrade;
459         }
460         if (examing.equals("实验") && experimentGrades.size() != 0){
461             for (ExperimentGrade e : experimentGrades){
462                 e.calculateTotalScore();
463                 sum += e.getTotalScore();
464             }
465             averageScore = sum / experimentGrades.size();
466         }
467     }
468 
469     @Override
470     public int compareTo(Course o) {
471         Collator collator = Collator.getInstance(Locale.CHINA);
472         return collator.compare(this.name,o.getName());
473     }
474 
475     public int getAverageUsualGrade() {
476         return averageUsualGrade;
477     }
478 
479     public int getAverageExamGrade() {
480         return averageExamGrade;
481     }
482 
483     public int getAverageScore() {
484         return averageScore;
485     }
486 }
487 
488 class Courses{
489     ArrayList<Course> courses = new ArrayList<>();
490 
491     public void addACourse(Course course){
492         courses.add(course);
493     }
494 
495     public Boolean courseExistence(String str){//查找课程是否存在
496         for (Course c : courses){
497             if (c.getName().equals(str)){
498                 return true;
499             }
500         }
501         return false;
502     }
503 
504     public void inspectIsRightExaming(){//检验必修类的课程的考察方式是否为考试
505         ArrayList<Course> C = new ArrayList<>();
506         for (Course c : courses){
507             if (c.getType().equals("必修")){
508                 if (c.getExaming().equals("考察")){
509                     System.out.println( c.getName() + " : course type & access mode mismatch");
510                     C.add(c);
511                 }
512             }
513         }
514         for (Course c : C){
515             courses.remove(c);
516         }
517     }
518 
519     public Course findAClassByName(String name){//通过名字查找课程，并且返回这个课程的信息
520         for (Course c : courses){
521             if (name.equals(c.getName())){
522                 return c;
523             }
524         }
525         return null;//永远不会走到这一步,因为使用这个方法的前提是先查找这门课程是否存在,所以放心
526     }
527 
528     public void setCoursesAve(){
529         for (Course c : courses){
530             c.setAverageScore();
531         }
532     }
533 
534     public void sort(){
535         Collections.sort(courses);
536     }
537 
538     public void showCourses(){
539         for (Course c : courses){
540             if (c.getAverageScore() != -1) {
541                 if (c.getExaming().equals("考试")) {
542                     System.out.println(c.getName() + " " + c.getAverageUsualGrade() + " " + c.getAverageExamGrade() + " " + c.getAverageScore());
543                 } else if (c.getExaming().equals("考察")){
544                     System.out.println(c.getName() + " " + c.getAverageScore() + " " + c.getAverageScore());
545                 }else{
546                     System.out.println(c.getName() + " " + c.getAverageScore());
547                 }
548             }else{
549                 System.out.println(c.getName() + " has no grades yet");
550             }
551         }
552     }
553 }
554 
555 class Class implements Comparable<Class>{
556     private ArrayList<Student> students = new ArrayList<>();
557     private int averageScore = -1;
558     private String num;
559 
560     public String getNum() {
561         return num;
562     }
563 
564     public Class(String num,Student student) {
565         students.add(student);
566         this.num = num;
567     }
568 
569     public Boolean isStudentExist(String str){//对应学号的学生是否存在
570         for (Student s : students){
571             if (s.getNum().equals(str)){
572                 return true;
573             }
574         }
575         return false;
576     }
577 
578     public void addAStudent(Student student){
579         students.add(student);
580     }
581 
582     public Student findAStudentByNum(String str){
583         for (Student s : students){
584             if (s.getNum().equals(str)){
585                 return s;
586             }
587         }
588         return null;//同样，因为先判断该学号的学生是否存在所以不用担心会返回null
589     }
590 
591     public void setAverageScore(){
592         int sum = 0,i = 0;
593         if (students.size() != 0) {
594             for (Student s : students) {
595                 if (s.getAverageGrade() != -1) {
596                     sum += s.getAverageGrade();
597                     i ++;
598                 }
599             }
600             if (i != 0){
601                 this.averageScore = sum / i;
602             }
603         }
604     }
605 
606     @Override
607     public int compareTo(Class o) {
608         return num.compareTo(o.getNum());
609     }
610 
611     public ArrayList<Student> getStudents() {
612         return students;
613     }
614 
615     public int getAverageScore() {
616         return averageScore;
617     }
618 }
619 
620 class StudentData{//学生单门课程的的信息
621     private Course course;
622     private ExamGrade totalGrade;//考试成绩
623     private InspectGrade grade;//考查成绩
624     private ExperimentGrade experimentGrade;
625     private int Grade;
626 
627     public void setGrade(){
628         if (course.getExaming().equals("考试")){
629             Grade = (int) (totalGrade.getUsualScore() * 0.3 + totalGrade.getExamScore() * 0.7);
630         }else if (course.getExaming().equals("考察")){
631             Grade = grade.getGrade();
632         }else{
633             experimentGrade.calculateTotalScore();
634             Grade = experimentGrade.getTotalScore();
635         }
636     }
637 
638     public int getGrade() {
639         return Grade;
640     }
641 
642     public StudentData(Course course,ExamGrade examGrade){
643         this.course = course;
644         totalGrade = examGrade;
645     }
646 
647     public StudentData(Course course, InspectGrade inspectGrade){
648         this.course = course;
649         this.grade = inspectGrade;
650     }
651 
652     public StudentData(Course course,ExperimentGrade experimentGrade){
653         this.course = course;
654         this.experimentGrade = experimentGrade;
655     }
656 
657     public Course getCourse() {
658         return course;
659     }
660 }
661 
662 class Classes{
663     private ArrayList<Class> classes = new ArrayList<>();
664 
665     public void addAClass(Class newClass){//在调用这个方法之前，会先调用班级是否存在方法
666         classes.add(newClass);
667     }
668 
669     public Boolean ifAClassExist(String Num){//判断该班号的班级是否在存在
670         for (Class c : classes){
671             if (c.getNum().equals(Num)){
672                 return true;
673             }
674         }
675         return false;
676     }
677 
678     public Class findAClassByNum(String str){//通过班号查找一个班级
679         for (Class c : classes){
680             if (c.getNum().equals(str)){
681                 return c;
682             }
683         }
684         return null;//不会走到这一步，因为在调用这个方法之前首先会判断这个班号对应的班级是否存在
685     }
686 
687     public void setClassesAve(){
688         for (Class c : classes){
689             c.setAverageScore();
690         }
691     }
692 
693     public void setStudentsAve(){
694         for (Class c : classes){
695             for (Student s : c.getStudents()){
696                 s.setGrades();
697                 s.setAverageGrade();
698             }
699         }
700     }
701 
702     public void sort(){
703         for (Class c : classes){
704             Collections.sort(c.getStudents());
705         }
706         Collections.sort(classes);
707     }
708 
709     public void showStudents(){
710         for (Class c : classes){
711             for (Student s : c.getStudents()){
712                 if (s.getAverageGrade() != -1) {
713                     System.out.println(s.getNum() + " " + s.getName() + " " + s.getAverageGrade());
714                 }else{
715                     System.out.println(s.getNum() + " " + s.getName() + " did not take any exams");
716                 }
717             }
718         }
719     }
720 
721     public void showClasses(){
722         for (Class c : classes){
723             if (c.getAverageScore() != -1) {
724                 System.out.println(c.getNum() + " " + c.getAverageScore());
725             }else{
726                 System.out.println(c.getNum() + " has no grades yet");
727             }
728         }
729     }
730 }

成绩-2点击查看代码

  1 package 备份;
  2 
  3 import java.text.Collator;
  4 import java.util.*;
  5 
  6 public class Main {
  7     public static void main(String[] args){
  8         Classes classes = new Classes();
  9         Courses courses = new Courses();
 10         Scanner input = new Scanner(System.in);
 11         while (true){
 12             String str = input.nextLine();
 13             String[] splitedStr = str.split(" ");
 14             if (str.equals("end")){
 15                 break;
 16             }
 17             if (str.matches(".{1,10} 必修 实验") || str.matches(".{1,10} 必修 考察") ||
 18                     str.matches(".{1,10} 选修 实验") || str.matches(".{1,10} 实验 考察") ||
 19                     str.matches(".{1,10} 实验 考试")){
 20                 System.out.println(splitedStr[0] + " : course type & access mode mismatch");
 21             } else if (str.matches(".{1,10} 必修 考试( ([0-9]{1,}[.][0-9]*))+")){
 22                 if (courses.findAClassByName(splitedStr[0]) == null) {
 23                     if (splitedStr.length == 5) {
 24                         double weight = 0;
 25                         weight = Double.parseDouble(splitedStr[3]) + Double.parseDouble(splitedStr[3]);
 26                         if (weight == 1) {
 27                             Course course = new Course(splitedStr[0], splitedStr[1], splitedStr[2],2, new ArrayList<>(Arrays.asList(Double.parseDouble(splitedStr[3]), Double.parseDouble(splitedStr[3]))));
 28                             courses.addACourse(course);
 29                         }else{
 30                             System.out.println(splitedStr[0] + " : weight value error");
 31                         }
 32                     }else{
 33                         System.out.println(splitedStr[0] + " : number of scores does not match");
 34                     }
 35                 }
 36             } else if (str.matches(".{1,10} 选修 考察")){
 37                 if (courses.findAClassByName(splitedStr[0]) == null) {
 38                     Course course = new Course(splitedStr[0], splitedStr[1], splitedStr[2]);
 39                     courses.addACourse(course);
 40                 }
 41             } else if (str.matches(".{1,10} 选修 考试( ([0-9]{1,}[.][0-9]*))+")){
 42                 if (courses.findAClassByName(splitedStr[0]) == null) {
 43                     if (splitedStr.length == 5) {
 44                         double weight = 0;
 45                         weight = Double.parseDouble(splitedStr[3]) + Double.parseDouble(splitedStr[3]);
 46                         if (weight == 1) {
 47                             Course course = new Course(splitedStr[0], splitedStr[1], splitedStr[2],2, new ArrayList<>(Arrays.asList(Double.parseDouble(splitedStr[3]), Double.parseDouble(splitedStr[3]))));
 48                             courses.addACourse(course);
 49                         }else{
 50                             System.out.println(splitedStr[0] + " : weight value error");
 51                         }
 52                     }else{
 53                         System.out.println(splitedStr[0] + " : number of scores does not match");
 54                     }
 55                 }
 56             } else if (str.matches(".{1,10} 实验 实验 [4-9]( ([0-9]{1,}[.][0-9]*))+")){
 57                 if (courses.findAClassByName(splitedStr[0]) == null) {
 58                     if (Integer.parseInt(splitedStr[3]) == splitedStr.length - 4) {
 59                         double weight = 0;
 60                         ArrayList<Double> weights = new ArrayList<>();
 61                         for (int i = 1;i <= Integer.parseInt(splitedStr[3]);i ++){
 62                             weight += Double.parseDouble(splitedStr[3 + i]);
 63                             weights.add(Double.parseDouble(splitedStr[3 + i]));
 64                         }
 65                         if (weight == 1) {
 66                             Course course = new Course(splitedStr[0], splitedStr[1], splitedStr[2], Integer.parseInt(splitedStr[3]), weights);
 67                             courses.addACourse(course);
 68                         }else{
 69                             System.out.println(splitedStr[0] + " : weight value error");
 70                         }
 71                     }else{
 72                         System.out.println(splitedStr[0] + " : number of scores does not match");
 73                     }
 74                 }
 75             }else if (str.matches("\\d{8} [\\u4E00-\\u9FA5A-Za-z]{1,10} [\\u4E00-\\u9FA5A-Za-z]{1,10} (100|0|[1-9]\\d?) (100|0|[1-9]\\d?)")){//考试,录入学生信息
 76                 String classNum = splitedStr[0].substring(0,6);//获得该学生学号的前六位，也就是班级号
 77                 if (courses.courseExistence(splitedStr[2])) {//先查找此门课程是否存在在courses中
 78                     if (courses.findAClassByName(splitedStr[2]).getExaming().equals("考试")) {
 79                         if (classes.ifAClassExist(classNum)) {//查找此学号前六位对应的班级号存在不存在
 80                             if (classes.findAClassByNum(classNum).isStudentExist(splitedStr[0]) && classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).getName().equals(splitedStr[1])) {//查找该学号的学生是否存在
 81                                 if (!classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).finACourseExist(splitedStr[2])) {
 82                                     Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
 83                                     classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).addData(course, splitedStr[3], splitedStr[4],course.getWeights());//先查找班级，再查找该学号的学生，最后将该门课程的考试信息录入
 84                                     course.addAExamGrade(new ExamGrade(Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4]),course.getWeights()));//将此学生的该门课程成绩录入
 85                                 }
 86                             } else if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {//不存在则建立一个新的学生对象存入该班号的学生ArrayList中
 87                                 Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 88                                 Course course = courses.findAClassByName(splitedStr[2]);//通过课程名称查找该课程
 89                                 student.addData(course, splitedStr[3], splitedStr[4],course.getWeights());//将课程以及课程成绩录入该学生的信息中
 90                                 classes.findAClassByNum(classNum).addAStudent(student);//将该学生录入这个班级当中
 91                                 course.addAExamGrade(new ExamGrade(Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4]),course.getWeights()));//将此学生的该门课程成绩录入
 92                             }
 93                         } else {//否则就新建立一个班级的信息，并且存到classes中
 94                             Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
 95                             Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
 96                             student.addData(course, splitedStr[3], splitedStr[4],course.getWeights());//将课程信息和课程成绩录入该学生的信息中
 97                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
 98                             classes.addAClass(newClass);//将这个新的班级加入classes
 99                             course.addAExamGrade(new ExamGrade(Integer.parseInt(splitedStr[3]), Integer.parseInt(splitedStr[4]),course.getWeights()));//将此学生的该门课程成绩录入
100                         }
101                     }else{
102                         Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
103                         if (classes.ifAClassExist(classNum)) {
104                             if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
105                                 classes.findAClassByNum(classNum).addAStudent(student);
106                             }
107                         }else {
108                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
109                             classes.addAClass(newClass);//将这个新的班级加入classes
110                         }
111                         System.out.println(splitedStr[0] + " " + splitedStr[1] + " : access mode mismatch");
112                     }
113                 }else {
114                     System.out.println(splitedStr[2] + " does not exist");
115                     Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
116                     if (classes.ifAClassExist(classNum)) {
117                         if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
118                             classes.findAClassByNum(classNum).addAStudent(student);
119                         }
120                     }else {
121                         Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
122                         classes.addAClass(newClass);//将这个新的班级加入classes
123                     }
124                 }
125             } else if (str.matches("\\d{8} [\\u4E00-\\u9FA5A-Za-z]{1,10} [\\u4E00-\\u9FA5A-Za-z]{1,10} (100|0|[1-9]\\d?)")){//考察，录入学生信息
126                 String classNum = splitedStr[0].substring(0,6);//获得该学生学号的前六位，也就是班级号
127                 if (courses.courseExistence(splitedStr[2])) {//先查找此门课程是否存在在courses中
128                     if (courses.findAClassByName(splitedStr[2]).getExaming().equals("考察")) {
129                         if (classes.ifAClassExist(classNum)) {//查找此学号前六位对应的班级号存在不存在
130                             if (classes.findAClassByNum(classNum).isStudentExist(splitedStr[0]) && classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).getName().equals(splitedStr[1])) {//查找该学号的学生是否存在
131                                 if (!classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).finACourseExist(splitedStr[2])) {
132                                     Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
133                                     classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).addData(course, splitedStr[3]);//先查找班级，再查找该学号的学生，最后将该门课程的考试信息录入
134                                     course.addAInspectGrade(new InspectGrade(Integer.parseInt(splitedStr[3])));//将此学生的该门课程成绩录入
135                                 }
136                             } else if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {//不存在则建立一个新的学生对象存入该班号的学生ArrayList中
137                                 Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
138                                 Course course = courses.findAClassByName(splitedStr[2]);//通过课程名称查找该课程
139                                 student.addData(course, splitedStr[3]);//将课程以及课程成绩录入该学生的信息中
140                                 classes.findAClassByNum(classNum).addAStudent(student);//将该学生录入这个班级当中
141                                 course.addAInspectGrade(new InspectGrade(Integer.parseInt(splitedStr[3])));//将此学生的该门课程成绩录入
142                             }
143                         } else {//否则就新建立一个班级的信息，并且存到classes中
144                             Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
145                             Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
146                             student.addData(course, splitedStr[3]);//将课程信息和课程成绩录入该学生的信息中
147                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
148                             classes.addAClass(newClass);//将这个新的班级加入classes
149                             course.addAInspectGrade(new InspectGrade(Integer.parseInt(splitedStr[3])));//将此学生的该门课程成绩录入
150                         }
151                     }else{
152                         Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
153                         if (classes.ifAClassExist(classNum)) {
154                             if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
155                                 classes.findAClassByNum(classNum).addAStudent(student);
156                             }
157                         }else {
158                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
159                             classes.addAClass(newClass);//将这个新的班级加入classes
160                         }
161                         System.out.println(splitedStr[0] + " " + splitedStr[1] + " : access mode mismatch");
162                     }
163                 }else {
164                     System.out.println(splitedStr[2] + " does not exist");
165                     Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
166                     if (classes.ifAClassExist(classNum)) {
167                         if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
168                             classes.findAClassByNum(classNum).addAStudent(student);
169                         }
170                     }else {
171                         Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
172                         classes.addAClass(newClass);//将这个新的班级加入classes
173                     }
174                 }
175             } else if (str.matches("\\d{8} [\\u4E00-\\u9FA5A-Za-z]{1,10} [\\u4E00-\\u9FA5A-Za-z]{1,10}( (100|0|[1-9]\\d?))*")){
176                 String classNum = splitedStr[0].substring(0,6);//获得该学生学号的前六位，也就是班级号
177                 if ((splitedStr.length - 3) == courses.findAClassByName(splitedStr[2]).getTimes() || courses.findAClassByName(splitedStr[2]) == null){
178                     if (courses.courseExistence(splitedStr[2])) {//先查找此门课程是否存在在courses中
179                         if (courses.findAClassByName(splitedStr[2]).getExaming().equals("实验")) {
180                             ArrayList<Integer> experiments = new ArrayList<>();
181                             for (int i = 3;i < splitedStr.length;i ++){
182                                 experiments.add(Integer.parseInt(splitedStr[i]));
183                             }
184                             if (classes.ifAClassExist(classNum)){//班级是否存在
185                                 if (classes.findAClassByNum(classNum).isStudentExist(splitedStr[0]) && classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).getName().equals(splitedStr[1])){//班级存在的话学生是否存在
186                                     if (!classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).finACourseExist(splitedStr[2])) {
187                                         Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
188                                         classes.findAClassByNum(classNum).findAStudentByNum(splitedStr[0]).addData(course, experiments,course.getWeights());
189                                         course.addAExperimentGrade(new ExperimentGrade(experiments,course.getWeights()));
190                                     }
191                                 } else if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])){//学生不存在
192                                     Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
193                                     Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
194                                     student.addData(course,experiments,course.getWeights());//录入学生信息
195                                     classes.findAClassByNum(classNum).addAStudent(student);
196                                     course.addAExperimentGrade(new ExperimentGrade(experiments,course.getWeights()));//录入课程成绩
197                                 }
198                             }else{//班级不存在
199                                 Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
200                                 Course course = courses.findAClassByName(splitedStr[2]);//通过课程名字查找该课程
201                                 student.addData(course,experiments,course.getWeights());//录入学生信息
202                                 Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
203                                 classes.addAClass(newClass);//将这个新的班级加入classes
204                                 course.addAExperimentGrade(new ExperimentGrade(experiments,course.getWeights()));//录入课程成绩
205                             }
206                         }else{
207                             Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
208                             if (classes.ifAClassExist(classNum)) {
209                                 if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
210                                     classes.findAClassByNum(classNum).addAStudent(student);
211                                 }
212                             }else {
213                                 Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
214                                 classes.addAClass(newClass);//将这个新的班级加入classes
215                             }
216                             System.out.println(splitedStr[0] + " " + splitedStr[1] + " : access mode mismatch");
217                         }
218                     }else{
219                         System.out.println(splitedStr[2] + " does not exist");
220                         Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
221                         if (classes.ifAClassExist(classNum)) {
222                             if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
223                                 classes.findAClassByNum(classNum).addAStudent(student);
224                             }
225                         }else {
226                             Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
227                             classes.addAClass(newClass);//将这个新的班级加入classes
228                         }
229                     }
230                 } else{//不匹配也要录入学生的信息
231                     Student student = new Student(splitedStr[0], splitedStr[1]);//学生的名字和学号
232                     if (classes.ifAClassExist(classNum)) {
233                         if (!classes.findAClassByNum(classNum).isStudentExist(splitedStr[0])) {
234                             classes.findAClassByNum(classNum).addAStudent(student);
235                         }
236                     }else {
237                         Class newClass = new Class(classNum, student);//将班号和该名学生录入这个新的班级中
238                         classes.addAClass(newClass);//将这个新的班级加入classes
239                     }
240                     System.out.println(splitedStr[0] + " " + splitedStr[1] + " : access mode mismatch");
241                 }
242             } else{
243                 if (!str.matches("end")) {
244                     System.out.println("wrong format");
245                 }
246             }
247         }
248         classes.setStudentsAve();
249         classes.setClassesAve();
250         courses.setCoursesAve();
251         classes.sort();
252         courses.sort();
253         classes.showStudents();
254         courses.showCourses();
255         classes.showClasses();
256     }
257 }
258 
259 class ExamGrade{
260     private ArrayList<Double> weights = new ArrayList<>();
261     private int usualScore;//平时成绩
262     private int examScore;//考试成绩
263     private int totalScore;
264     public int getUsualScore() {
265         return usualScore;
266     }
267 
268     public int getExamScore() {
269         return examScore;
270     }
271 
272     public ExamGrade() {
273     }
274 
275     public ExamGrade(int usualScore, int examScore, ArrayList<Double> weights) {
276         this.usualScore = usualScore;
277         this.examScore = examScore;
278         this.weights = weights;
279     }
280 
281     public void setTotalScore(){
282         totalScore = (int)(usualScore * weights.get(0) + examScore * weights.get(1));
283     }
284 
285     public int getTotalScore() {
286         return totalScore;
287     }
288 }
289 
290 class InspectGrade{
291     private int grade;//考察成绩
292 
293     public InspectGrade() {
294     }
295 
296     public InspectGrade(int grade) {
297         this.grade = grade;
298     }
299 
300     public void setGrade(int grade) {
301         this.grade = grade;
302     }
303 
304     public int getGrade() {
305         return grade;
306     }
307 }
308 
309 class ExperimentGrade{
310     private ArrayList<Double> weights = new ArrayList<>();
311     private ArrayList<Integer> grades = new ArrayList<>();//每次实验成绩
312     private int totalScore;
313 
314     public void calculateTotalScore(){
315         double sum = 0;
316         int i = 0;
317         for (int g : grades){
318             sum += g * weights.get(i);
319             i ++;
320         }
321         totalScore = (int)sum;
322     }
323 
324     public int getTotalScore() {
325         return totalScore;
326     }
327 
328     public ExperimentGrade(ArrayList<Integer> grades,ArrayList<Double> weights) {
329         this.grades = grades;
330         this.weights = weights;
331     }
332 }
333 
334 class Student implements Comparable<Student>{
335     private ArrayList<StudentData> data = new ArrayList<>();
336     private String num;
337     private String name;
338     private int averageGrade = -1;
339 
340     public Student(String num, String name) {
341         if (name.length() < 10){
342             this.name = name;
343         }else{
344             System.out.println("wrong format");
345         }
346         if (num.length() == 8){
347             this.num = num;
348         }else{
349             System.out.println("wrong format");
350         }
351     }
352 
353     public void setAverageGrade(){
354         int sum = 0;//sum计算该学生成绩的综合
355         if (data.size() != 0) {
356             for (StudentData s : data) {
357                 sum += s.getGrade();
358             }
359             averageGrade = sum / data.size();
360         }
361     }
362 
363     public String getName() {
364         return name;
365     }
366 
367     public String getNum() {
368         return num;
369     }
370 
371     public void addData(Course course,String score1/*平时成绩*/,String score2/*考试成绩*/,ArrayList<Double> weights){//addData方法有两个重载，一个是有平时成绩和考试成绩的方法，另外一个是只有考察成绩的方法
372         ExamGrade examGrade = new ExamGrade(Integer.parseInt(score1),Integer.parseInt(score2),weights);
373         data.add(new StudentData(course,examGrade));
374     }
375 
376     public void addData(Course course,String score){
377         InspectGrade inspectGrade = new InspectGrade();
378         inspectGrade.setGrade(Integer.parseInt(score));
379         data.add(new StudentData(course,inspectGrade));
380     }
381 
382     public void addData(Course course,ArrayList<Integer> grades,ArrayList<Double> weights){
383         ExperimentGrade experimentGrade = new ExperimentGrade(grades,weights);
384         data.add(new StudentData(course,experimentGrade));
385     }
386 
387     public int getAverageGrade() {
388         return averageGrade;
389     }
390 
391     public void setGrades(){
392         for (StudentData d : data){
393             d.setGrade();
394         }
395     }
396 
397     @Override
398     public int compareTo(Student o) {
399         return num.compareTo(o.getNum());
400     }
401 
402     public boolean finACourseExist(String str){
403         for (StudentData s : data){
404             if (s.getCourse().getName().equals(str)){
405                 return true;
406             }
407         }
408         return false;
409     }
410 }
411 
412 class Course implements Comparable<Course>{
413     private String name;//课程名称
414     private String type;//课程类型
415     private String examing;//考试类型
416     private ArrayList<ExamGrade> examGrades = new ArrayList<>();//三个ArrayList根据考核方式只会用到一个
417     private ArrayList<InspectGrade> inspectGrades = new ArrayList<>();//三个ArrayList根据考核方式只会用到一个
418     private ArrayList<ExperimentGrade> experimentGrades = new ArrayList<>();//三个ArrayList根据考核方式只会用到一个
419     private int averageUsualGrade = -1;//平时
420     private int averageExamGrade = -1;//考试
421     private int averageExperiment = -1;//实验
422     private int averageGrade = -1;//考察
423     private int averageScore = -1;//总的平均
424     private int times;//成绩次数
425     private ArrayList<Double> weights;
426 
427     public Course(String name, String type, String examing) {
428         this.name = name;
429         this.type = type;
430         this.examing = examing;
431     }
432 
433     public Course(String name, String type, String examing,int times,ArrayList<Double> weights) {
434         this.name = name;
435         this.type = type;
436         this.examing = examing;
437         this.times = times;
438         this.weights = weights;
439     }
440 
441     public String getName() {
442         return name;
443     }
444 
445     public String getExaming() {
446         return examing;
447     }
448 
449     public void addAExamGrade(ExamGrade examGrade){
450         examGrades.add(examGrade);
451     }
452 
453     public void addAInspectGrade(InspectGrade inspectGrade){
454         inspectGrades.add(inspectGrade);
455     }
456 
457     public void addAExperimentGrade(ExperimentGrade experimentGrade){
458         experimentGrades.add(experimentGrade);
459     }
460 
461     public int getTimes() {
462         return times;
463     }
464 
465     public void setAverageScore(){
466         int examSum = 0,usualSum = 0,sum = 0;
467         if (examing.equals("考试") && examGrades.size() != 0){
468             for (ExamGrade e : examGrades){
469                 e.setTotalScore();
470                 examSum += e.getExamScore();
471                 usualSum += e.getUsualScore();
472                 sum += e.getTotalScore();
473             }
474             averageExamGrade = examSum / examGrades.size();
475             averageUsualGrade = usualSum / examGrades.size();
476             averageScore = sum / examGrades.size();
477         }
478         if (examing.equals("考察") && inspectGrades.size() != 0){
479             for (InspectGrade i : inspectGrades){
480                 sum += i.getGrade();
481             }
482             averageGrade = sum / inspectGrades.size();
483             averageScore = averageGrade;
484         }
485         if (examing.equals("实验") && experimentGrades.size() != 0){
486             for (ExperimentGrade e : experimentGrades){
487                 e.calculateTotalScore();
488                 sum += e.getTotalScore();
489             }
490             averageScore = sum / experimentGrades.size();
491         }
492     }
493 
494     public ArrayList<Double> getWeights() {
495         return weights;
496     }
497 
498     @Override
499     public int compareTo(Course o) {
500         Collator collator = Collator.getInstance(Locale.CHINA);
501         return collator.compare(this.name,o.getName());
502     }
503 
504     public int getAverageUsualGrade() {
505         return averageUsualGrade;
506     }
507 
508     public int getAverageExamGrade() {
509         return averageExamGrade;
510     }
511 
512     public int getAverageScore() {
513         return averageScore;
514     }
515 }
516 
517 class Courses{
518     ArrayList<Course> courses = new ArrayList<>();
519 
520     public void addACourse(Course course){
521         courses.add(course);
522     }
523 
524     public Boolean courseExistence(String str){//查找课程是否存在
525         for (Course c : courses){
526             if (c.getName().equals(str)){
527                 return true;
528             }
529         }
530         return false;
531     }
532 
533     public Course findAClassByName(String name){//通过名字查找课程，并且返回这个课程的信息
534         for (Course c : courses){
535             if (name.equals(c.getName())){
536                 return c;
537             }
538         }
539         return null;//永远不会走到这一步,因为使用这个方法的前提是先查找这门课程是否存在,所以放心
540     }
541 
542     public void setCoursesAve(){
543         for (Course c : courses){
544             c.setAverageScore();
545         }
546     }
547 
548     public void sort(){
549         Collections.sort(courses);
550     }
551 
552     public void showCourses(){
553         for (Course c : courses){
554             if (c.getAverageScore() != -1) {
555                 if (c.getExaming().equals("考试")) {
556                     System.out.println(c.getName() + " " + c.getAverageUsualGrade() + " " + c.getAverageExamGrade() + " " + c.getAverageScore());
557                 } else if (c.getExaming().equals("考察")){
558                     System.out.println(c.getName() + " " + c.getAverageScore() + " " + c.getAverageScore());
559                 }else{
560                     System.out.println(c.getName() + " " + c.getAverageScore());
561                 }
562             }else{
563                 System.out.println(c.getName() + " has no grades yet");
564             }
565         }
566     }
567 }
568 
569 class Class implements Comparable<Class>{
570     private ArrayList<Student> students = new ArrayList<>();
571     private int averageScore = -1;
572     private String num;
573 
574     public String getNum() {
575         return num;
576     }
577 
578     public Class(String num,Student student) {
579         students.add(student);
580         this.num = num;
581     }
582 
583     public Boolean isStudentExist(String str){//对应学号的学生是否存在
584         for (Student s : students){
585             if (s.getNum().equals(str)){
586                 return true;
587             }
588         }
589         return false;
590     }
591 
592     public void addAStudent(Student student){
593         students.add(student);
594     }
595 
596     public Student findAStudentByNum(String str){
597         for (Student s : students){
598             if (s.getNum().equals(str)){
599                 return s;
600             }
601         }
602         return null;//同样，因为先判断该学号的学生是否存在所以不用担心会返回null
603     }
604 
605     public void setAverageScore(){
606         int sum = 0,i = 0;
607         if (students.size() != 0) {
608             for (Student s : students) {
609                 if (s.getAverageGrade() != -1) {
610                     sum += s.getAverageGrade();
611                     i ++;
612                 }
613             }
614             if (i != 0){
615                 this.averageScore = sum / i;
616             }
617         }
618     }
619 
620     @Override
621     public int compareTo(Class o) {
622         return num.compareTo(o.getNum());
623     }
624 
625     public ArrayList<Student> getStudents() {
626         return students;
627     }
628 
629     public int getAverageScore() {
630         return averageScore;
631     }
632 }
633 
634 class StudentData{//学生单门课程的的信息
635     private Course course;
636     private ExamGrade totalGrade;//考试成绩
637     private InspectGrade grade;//考查成绩
638     private ExperimentGrade experimentGrade;
639     private int Grade;
640 
641     public void setGrade(){
642         if (course.getExaming().equals("考试")){
643             Grade = (int) (totalGrade.getUsualScore() * 0.3 + totalGrade.getExamScore() * 0.7);
644         }else if (course.getExaming().equals("考察")){
645             Grade = grade.getGrade();
646         }else{
647             experimentGrade.calculateTotalScore();
648             Grade = experimentGrade.getTotalScore();
649         }
650     }
651 
652     public int getGrade() {
653         return Grade;
654     }
655 
656     public StudentData(Course course,ExamGrade examGrade){
657         this.course = course;
658         totalGrade = examGrade;
659     }
660 
661     public StudentData(Course course, InspectGrade inspectGrade){
662         this.course = course;
663         this.grade = inspectGrade;
664     }
665 
666     public StudentData(Course course,ExperimentGrade experimentGrade){
667         this.course = course;
668         this.experimentGrade = experimentGrade;
669     }
670 
671     public Course getCourse() {
672         return course;
673     }
674 }
675 
676 class Classes{
677     private ArrayList<Class> classes = new ArrayList<>();
678 
679     public void addAClass(Class newClass){//在调用这个方法之前，会先调用班级是否存在方法
680         classes.add(newClass);
681     }
682 
683     public Boolean ifAClassExist(String Num){//判断该班号的班级是否在存在
684         for (Class c : classes){
685             if (c.getNum().equals(Num)){
686                 return true;
687             }
688         }
689         return false;
690     }
691 
692     public Class findAClassByNum(String str){//通过班号查找一个班级
693         for (Class c : classes){
694             if (c.getNum().equals(str)){
695                 return c;
696             }
697         }
698         return null;//不会走到这一步，因为在调用这个方法之前首先会判断这个班号对应的班级是否存在
699     }
700 
701     public void setClassesAve(){
702         for (Class c : classes){
703             c.setAverageScore();
704         }
705     }
706 
707     public void setStudentsAve(){
708         for (Class c : classes){
709             for (Student s : c.getStudents()){
710                 s.setGrades();
711                 s.setAverageGrade();
712             }
713         }
714     }
715 
716     public void sort(){
717         for (Class c : classes){
718             Collections.sort(c.getStudents());
719         }
720         Collections.sort(classes);
721     }
722 
723     public void showStudents(){
724         for (Class c : classes){
725             for (Student s : c.getStudents()){
726                 if (s.getAverageGrade() != -1) {
727                     System.out.println(s.getNum() + " " + s.getName() + " " + s.getAverageGrade());
728                 }else{
729                     System.out.println(s.getNum() + " " + s.getName() + " did not take any exams");
730                 }
731             }
732         }
733     }
734 
735     public void showClasses(){
736         for (Class c : classes){
737             if (c.getAverageScore() != -1) {
738                 System.out.println(c.getNum() + " " + c.getAverageScore());
739             }else{
740                 System.out.println(c.getNum() + " has no grades yet");
741             }
742         }
743     }
744 }

成绩-3点击查看代码

3、踩坑心得

　　这次题目集踩坑的地方主要有两个地方，第一个是java程序匹配关键词的那一次作业，在写到最后面时，我总是有两个测试点过不了，改掉了很多的bug都没有过新的测试点。后面发现是正则表达式出了问题，这是我提交的作业的截图

后面被告知问题出在空格上面，听到其他的同学说只要把空格改成\\s+就对了，我就抱着试试的态度改了一下我的代码，最后还真的全对了。

我也上网查了一下\\s+是匹配空白字符，我也不知道为什么使用空格会出问题，虽然说\\s+的涵盖范围更广，可是在这道题当中，除了空格是空白字符还有什么是空白字符需要分割的呢？？？

　　还有一个踩的坑是课程成绩统计程序-3，这道题做到后面我有很多个测试点都过不去，但是我怎么设计测试样例都是对的，这就让我很头疼，到后面我就发现我设计的一个测试样例出现了问题，后面经过调试发现问题出现在这里

我设置的这个测试样例的java课程权重加起来是1，可是经过调试发现居然有浮点误差，所以最后输出的会是权重错误的异常，因此需要用结果去减去1的绝对值和0.000001去比较才能避免出现浮点误差，虽然第一次写blog的时候也碰到过类似的问题，可是当时写这个的时候真的没想这么多啊XD，以后真的要多注意这个问题了。

4、改进建议

　　大部分的建议在前面两次的blog中已经提的差不多了，不过还是有一个我想再提一下，pta作业的测试样例啊！！！要是可以多给几个就好叻，我好多次提交答案前和测试样例都是一样的，我还以为我可以一发直接ac...谁知到十几几十个测试点里面我只对了测试样例里面的数据。

5、总结

　　这个阶段做题目的感觉比上个阶段要好多了，类与类之间的关系也能搞得很明白，相较于之前也可以比较合理的做出题目的需求分析，而且也能够比较熟练地使用java里面的容器了。对于课程老师，前面几次也评价过了，说一下我对pta作业的想法，虽然pta的作业有时候很难，甚至会让人破防，但是至少在有pta作业的时候对学习的积极性还是很强得，没事的时候干嘛？写pta啊，看着上百号人的排名，提交代码，过测试点然后排名上升，感觉就和竞速一样，因为排名还带着学号，所以有一种实名开卷（第三声）的感觉，真的非常的刺激。

6、面向对象课程评价

　　我认为，课堂上边讲边练的课时次数可以相应的增加一点，因为面向对象课上我认为大部分东西都是比较抽象难懂的，光是老师在上面讲，说实话我是有一点晕乎乎的，甚至有点想要开小差的感觉。但是又有很矛盾的一点就是，我觉得上课讲一点概念，然后就开始让我们码代码，如果就这样上课的话，我又会感觉有点水（在这个课的后半段感觉尤为明显），所以我也不知道是什么问题。关于pta上面已经说了，实名开卷的那种竞速的感觉确实很刺激！！！

没用的废话

　　想不到啊，考完试了，java还来一次blog作业，真的是走了还给我来一拳，触发亡语了属于是。但是不管它，现在已经写完了，哈哈，终于可以干自己的事情了，用我最喜欢的一张表情包来描述我现在的心情belike: