7、8、9、10、11次java作业总结

1.第一部分

（1）前言

这五次次作业的整体难度较上次而言有所降低，题目集1有一道题目，这题和第六次题目集菜单计价程序-4同属第四次作业菜单计价程序-3的两个不同迭代分支，有了前几次作业的经验，这次作业不再毫无头绪，难度也稍微降低。题目集2同样只有一道题目，这道题的整体难度并不高，和前几次的菜单计价程序题有许多相似之处，但对细节的要求十分严格，不能只盯着测试点看，需要不断试错，找出程序的漏洞。题目集3只有一道题目，这题主要考察了Map和String的使用，难度不算太大，对细节的要求比较高。题目集4共有四道题目，第一第二题考察了HashMap的检索和排序，难度不高，但需要对HaspMap的用法有一定的了解。第三题是题目集2的的一次迭代，主要添加了一些细节。难度不算太大，但要得到满分有些困难。第四题主要考察对多态的理解和运用，难度不高。题目集5共有5道题目，第一题考察ArrayList，第三四五题考察JAVA的基本语法，第二题是题目集4中第三题的迭代，在上次的基础上改变了类与类之间的关系，整体难度不大。

 

（2）设计与分析

第一次作业

7-1 菜单计价程序-5

题目

本题在菜单计价程序-3的基础上增加了部分内容，增加的内容用加粗字体标识。

注意不是菜单计价程序-4，本题和菜单计价程序-4同属菜单计价程序-3的两个不同迭代分支。

设计点菜计价程序，根据输入的信息，计算并输出总价格。

 

输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。

 

菜单由一条或多条菜品记录组成，每条记录一行

 

每条菜品记录包含：菜名、基础价格  三个信息。

 

订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。

 

桌号标识独占一行，包含两个信息：桌号、时间。

 

桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。

 

点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。

 

不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。

 

删除记录格式：序号  delete

 

标识删除对应序号的那条点菜记录。

 

如果序号不对，输出"delete error"

 

代点菜信息包含：桌号 序号 菜品名称 口味度 份额 份数

 

代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。

 

程序最后按输入的先后顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。

 

每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。

 

折扣的计算方法（注：以下时间段均按闭区间计算）：

 

周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。

 

周末全价，营业时间：9:30-21:30

 

如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"

 

参考以下类的模板进行设计：菜品类：对应菜谱上一道菜的信息。

 

Dish {    

 

   String name;//菜品名称    

 

   int unit_price;    //单价    

 

   int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）    }

 

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。

 

Menu {

 

   Dish[] dishs ;//菜品数组，保存所有菜品信息

 

   Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。

 

   Dish addDish(String dishName,int unit_price)//添加一道菜品信息

 

}

 

点菜记录类：保存订单上的一道菜品记录

 

Record {

 

   int orderNum;//序号\\

 

   Dish d;//菜品\\

 

   int portion;//份额（1/2/3代表小/中/大份）\\

 

   int getPrice()//计价，计算本条记录的价格\\

 

}

 

订单类：保存用户点的所有菜的信息。

 

Order {

 

   Record[] records；//保存订单上每一道的记录

 

   int getTotalPrice()//计算订单的总价

 

   Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。

 

   delARecordByOrderNum(int orderNum)//根据序号删除一条记录

 

   findRecordByNum(int orderNum)//根据序号查找一条记录

 

}

 

### 输入格式:

 

桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

 

菜品记录格式：

 

菜名+英文空格+基础价格

 

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

 

点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。

 

删除记录格式：序号 +英文空格+delete

 

代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数

 

最后一条记录以“end”结束。

 

### 输出格式:

 

按输入顺序输出每一桌的订单记录处理信息，包括：

 

1、桌号，格式：table+英文空格+桌号+”:”

 

2、按顺序输出当前这一桌每条订单记录的处理信息，

 

每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名

 

如果删除记录的序号不存在，则输出“delete error”

 

最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价

 

以上为菜单计价系列-3的题目要求，加粗的部分是有调整的内容。本次课题相比菜单计价系列-3新增要求如下：

 

1、菜单输入时增加特色菜，特色菜的输入格式：菜品名+英文空格+口味类型+英文空格+基础价格+"T"

例如：麻婆豆腐 川菜 9 T

菜价的计算方法：

周一至周五 7折， 周末全价。

特色菜的口味类型：川菜、晋菜、浙菜

川菜增加辣度值：辣度0-5级；对应辣度水平为：不辣、微辣、稍辣、辣、很辣、爆辣；

晋菜增加酸度值，酸度0-4级；对应酸度水平为：不酸、微酸、稍酸、酸、很酸；

浙菜增加甜度值，甜度0-3级；对应酸度水平为：不甜、微甜、稍甜、甜；    

例如：麻婆豆腐 川菜 9 T

输入订单记录时如果是特色菜，添加口味度（辣/酸/甜度）值，格式为：序号+英文空格+菜名+英文空格+口味度值+英文空格+份额+英文空格+份数

例如：1 麻婆豆腐 4 1 9

单条信息在处理时，如果口味度超过正常范围，输出"spicy/acidity/sweetness num out of range : "+口味度值，spicy/acidity/sweetness（辣度/酸度/甜度）根据菜品类型择一输出，例如：

acidity num out of range : 5

输出一桌的信息时，按辣、酸、甜度的顺序依次输出本桌菜各种口味的口味度水平，如果没有某个类型的菜，对应的口味（辣/酸/甜）度不输出，只输出已点的菜的口味度。口味度水平由口味度平均值确定，口味度平均值只综合对应口味菜系的菜计算，不做所有菜的平均。比如，某桌菜点了3份川菜，辣度分别是1、3、5；还有4份晋菜，酸度分别是，1、1、2、2，辣度平均值为3、酸度平均值四舍五入为2，甜度没有，不输出。

一桌信息的输出格式：table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格+"川菜"+数量+辣度+英文空格+"晋菜"+数量+酸度+英文空格+"浙菜"+数量+甜度。

如果整桌菜没有特色菜，则只输出table的基本信息，格式如下：

table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格

例如：table 1: 60 36 川菜 2 爆辣 浙菜 1 微甜

计算口味度时要累计本桌各类菜系所有记录的口味度总和（每条记录的口味度乘以菜的份数），再除以对应菜系菜的总份数，最后四舍五入。

注：本题要考虑代点菜的情况，当前桌点的菜要加上被其他桌代点的菜综合计算口味度平均值。

 

 

2、考虑客户订多桌菜的情况，输入时桌号时，增加用户的信息：

格式：table+英文空格+桌号+英文空格+":"+英文空格+客户姓名+英文空格+手机号+日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

例如：table 1 : tom 13670008181 2023/5/1 21/30/00

约束条件：客户姓名不超过10个字符，手机号11位，前三位必须是180、181、189、133、135、136其中之一。

输出结果时，先按要求输出每一桌的信息，最后按字母顺序依次输出每位客户需要支付的金额。不考虑各桌时间段的问题，同一个客户的所有table金额都要累加。

输出用户支付金额格式：

用户姓名+英文空格+手机号+英文空格+支付金额

 

 

注意：不同的四舍五入顺序可能会造成误差，请按以下步骤累计一桌菜的菜价：

 

计算每条记录的菜价：将每份菜的单价按份额进行四舍五入运算后，乘以份数计算多份的价格，然后乘以折扣，再进行四舍五入，得到本条记录的最终支付价格。

将所有记录的菜价累加得到整桌菜的价格。

输入格式:

桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

 

菜品记录格式：

 

菜名+口味类型+英文空格+基础价格

 

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

 

点菜记录格式：序号+英文空格+菜名+英文空格+辣/酸/甜度值+英文空格+份额+英文空格+份数 注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。辣/酸/甜度取值范围见题目中说明。

 

删除记录格式：序号 +英文空格+delete

 

代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称**+英文空格+辣/酸/甜度值+**英文空格+份额+英文空格+分数

 

最后一条记录以“end”结束。

输出格式:

按输入顺序输出每一桌的订单记录处理信息，包括：

 

1、桌号，格式：table+英文空格+桌号+“:”+英文空格

 

2、按顺序输出当前这一桌每条订单记录的处理信息，

 

每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名

 

如果删除记录的序号不存在，则输出“delete error”

 

之后按输入顺序一次输出每一桌所有菜品的价格（整数数值），

格式：table+英文空格+桌号+“:”+英文空格+当前桌的计算折扣后总价+英文空格+辣度平均值+英文空格+酸度平均值+英文空格+甜度平均值+英文空格

 

最后按拼音顺序输出每位客户(不考虑客户同名或拼音相同的情况)的支付金额，格式： 用户姓名+英文空格+手机号+英文空格+支付总金额，按输入顺序排列。

输入样例1:

桌号时间超出营业范围。例如：

麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 21/30/00
1 麻婆豆腐 3 1 2
2 油淋生菜 2 1
3 麻婆豆腐 2 3 2
end

 

输出样例1:

在这里给出相应的输出。例如：

table 1 out of opening hours

 

输入样例2:

一种口味的菜品。例如：

麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 20/30/00
1 麻婆豆腐 2 1 2
2 油淋生菜 2 1
3 麻婆豆腐 2 3 2
end

 

输出样例2:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 24
2 油淋生菜 14
3 麻婆豆腐 48
table 1: 86 62 川菜 4 稍辣
tom 13605054400 62

 

 

输入样例3:

辣度值超出范围。例如：

麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 18/30/00
1 麻婆豆腐 6 1 2
2 油淋生菜 1 1
3 麻婆豆腐 5 3 2
end

 

输出样例3:

在这里给出相应的输出。例如：

table 1: 
spicy num out of range :6
2 油淋生菜 9
3 麻婆豆腐 48
table 1: 57 41 川菜 2 爆辣
tom 13605054400 41

 

输入样例4:

同一用户对应多桌菜。例如：

麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 18/30/00
1 麻婆豆腐 1 1 2
2 油淋生菜 1 1
3 麻婆豆腐 2 2 2
table 2 : tom 13605054400 2023/5/6 18/30/00
1 麻婆豆腐 2 1 2
2 麻辣鸡丝 2 2
3 麻婆豆腐 2 1 1
end

 

输出样例4:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 24
2 油淋生菜 9
3 麻婆豆腐 36
table 2: 
1 麻婆豆腐 24
2 麻辣鸡丝 30
3 麻婆豆腐 12
table 1: 69 49 川菜 4 稍辣
table 2: 66 66 川菜 3 稍辣
tom 13605054400 115

 

输入样例5:

多用户多桌菜。例如：

东坡肉 浙菜 25 T
油淋生菜 9
蜜汁灌藕 浙菜 10 T
刀削面 晋菜 10 T
醋浇羊肉 晋菜 30 T
麻婆豆腐 川菜 12 T
麻辣鸡丝 川菜 15 T
table 1 : tom 13605054400 2023/5/6 12/30/00
1 醋浇羊肉 4 1 1
3 刀削面 1 1 3
2 东坡肉 3 2 1
4 麻辣鸡丝 2 1 1
table 2 : jerry 18100334566 2023/5/1 12/30/00
1 醋浇羊肉 1 1 2
3 麻婆豆腐 2 2 1
4 麻辣鸡丝 2 3 3
table 3 : jerry 18100334566 2023/5/1 12/30/00
1 醋浇羊肉 2 1 1
3 蜜汁灌藕 1 1 2
2 东坡肉 2 2 1
4 麻辣鸡丝 5 1 1
end

 

输出样例5:

在这里给出相应的输出。例如：

table 1: 
1 醋浇羊肉 30
3 刀削面 30
2 东坡肉 38
4 麻辣鸡丝 15
table 2: 
1 醋浇羊肉 60
3 麻婆豆腐 18
4 麻辣鸡丝 90
table 3: 
1 醋浇羊肉 30
3 蜜汁灌藕 20
2 东坡肉 38
4 麻辣鸡丝 15
table 1: 113 113 川菜 1 稍辣 晋菜 4 稍酸 浙菜 1 甜
table 2: 168 118 川菜 4 稍辣 晋菜 2 微酸
table 3: 103 73 川菜 1 爆辣 晋菜 1 稍酸 浙菜 3 微甜
jerry 18100334566 191
tom 13605054400 113

 

输入样例6:

多用户多桌菜含代点菜。例如：

东坡肉 浙菜 25 T
油淋生菜 9
蜜汁灌藕 浙菜 10 T
刀削面 晋菜 10 T
醋浇羊肉 晋菜 30 T
麻婆豆腐 川菜 12 T
麻辣鸡丝 川菜 15 T
table 1 : tom 13605054400 2023/5/6 12/30/00
1 醋浇羊肉 4 1 1
3 刀削面 1 1 3
2 东坡肉 3 2 1
4 麻辣鸡丝 2 1 1
table 2 : jerry 18100334566 2023/5/1 12/30/00
1 1 醋浇羊肉 0 1 2
3 麻婆豆腐 2 2 1
4 麻辣鸡丝 2 3 3
table 3 : lucy 18957348763 2023/5/1 12/30/00
1 醋浇羊肉 2 1 1
3 蜜汁灌藕 1 1 2
2 东坡肉 2 2 1
4 麻辣鸡丝 5 1 1
end

 

输出样例6:

在这里给出相应的输出。例如：

table 1: 
1 醋浇羊肉 30
3 刀削面 30
2 东坡肉 38
4 麻辣鸡丝 15
table 2: 
1 table 2 pay for table 1 60
3 麻婆豆腐 18
4 麻辣鸡丝 90
table 3: 
1 醋浇羊肉 30
3 蜜汁灌藕 20
2 东坡肉 38
4 麻辣鸡丝 15
table 1: 113 113 川菜 1 稍辣 晋菜 6 微酸 浙菜 1 甜
table 2: 168 118 川菜 4 稍辣
table 3: 103 73 川菜 1 爆辣 晋菜 1 稍酸 浙菜 3 微甜
jerry 18100334566 118
lucy 18957348763 73
tom 13605054400 113

 

输入样例7:

错误的菜品记录和桌号记录，用户丢弃。例如：

东坡肉 25 T
油淋生菜 9
table 1 : tom 136050540 2023/5/1 12/30/00
2 东坡肉 3 2 1
end

 

输出样例7:

在这里给出相应的输出。例如：

wrong format
wrong format

代码展示：

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Calendar;
public class Main{
    public static void main(String args[]) {
        int i = 0,j = 0,k = 0,f = 0,g =0,s,a = 0,b = 0,c = 0,flag = 0,flag1 = 0,flag2 = 0,flag3 = 0,flag4 = 0;
        int dishNum = 0,discountPrice = 0;
        int average =0;
        Scanner input = new Scanner(System.in);
        ArrayList<String> inputs = new ArrayList<>();
        ArrayList<Customer> customers = new ArrayList<>();
        int[] flags = new int[100];
        double[] discount = new double[100];
        double[] Specialdiscount = new double[100];
        for(i = 0;i<100;i++) {
            flags[i] = 0;
        }
        i = 0;
        String in = input.nextLine();
        while(!in.equals("end")) {
            inputs.add(in);
            in = input.nextLine();
        }
        inputs.add(in);//输入信息
        Menu menu = new Menu();
        ArrayList<Table> tables = new ArrayList<>();
        while(!inputs.get(i).contains("table")) {
            String[] dish = inputs.get(i).split(" ");//创建菜单
            if(inputs.get(i).matches(".+\\s[\\d]+")) {
            int price = Integer.parseInt(dish[1]);
            menu.addDish(dish[0],price);//菜名和单价,往菜单里加一道菜         
            }
            else if(inputs.get(i).matches(".+\\s.{2}\\s[\\d]+\\sT")){             
            int price = Integer.parseInt(dish[2]);
            menu.addSpecialDish(dish[0],dish[1],price);
            }
            else System.out.println("wrong format");
            i++;
        }
        int d = menu.dishs.size();
        
        for(b = d - 1;b > 0;b--) {
            for(c = b-1;c >= 0;c--) {
                if(menu.dishs.get(b).name.equals(menu.dishs.get(c).name)) {
                    menu.dishs.remove(c);
                }
            }
        }
          while(!inputs.get(i).contains("end")) {
            if(inputs.get(i).contains("table")) {
                if(inputs.get(i).matches("table\\s.+\\s\\:\\s[\\w]{1,10}"
                        + "\\s(180|181|189|133|135|136)[\\d]{8}"
                        + "\\s[1-9][\\d]{3}/[\\d]{1,2}/[\\d]{1,2}\\s"
                        + "[\\d]{1,2}/[\\d]{1,2}/[\\d]{1,2}"))
                        {
                String[] tableInfo =inputs.get(i).split(" ");//创建桌子
                int num = Integer.parseInt(tableInfo[1]);
                String[] date = tableInfo[5].split("/");//时间
                String[] time = tableInfo[6].split("/");//时间
                int[] Date = new int[date.length];
                int[] Time = new int[time.length];
                for(k = 0;k < date.length;k++)
                    Date[k] = Integer.parseInt(date[k]);
                for(k = 0;k < time.length;k++)
                    Time[k] = Integer.parseInt(time[k]);
                Table table = new Table(tableInfo[1],tableInfo[3],tableInfo[4],tableInfo[5],tableInfo[6]);
                tables.add(table); 
                j++;//桌子数增加
                flag = 1;
                a = 0;
                if(Table.weekday(Date[0],Date[1],Date[2]) >= 1&&
                        Table.weekday(Date[0],Date[1],Date[2]) <= 5) {
                    Specialdiscount[j-1] = 0.7;
                    if((Time[0] >= 17&&Time[0]<=19)||(Time[0] == 20&&Time[1] <= 29)||
                            (Time[0] == 20&&Time[1] == 30&&Time[2] == 0)) {
                        discount[j-1] = 0.8;
                        System.out.println("table "+num+": ");
                    }
                    else if((Time[0] >= 11&&Time[0] <= 13)||
                            ((Time[0] == 10||Time[0] == 14)&&Time[1] <= 29)||
                            ((Time[0] == 10||Time[0] == 14)&&Time[1] == 30&&Time[2] == 0)) {
                        discount[j-1] = 0.6;
                        System.out.println("table "+num+": ");
                    }
                    else {
                        System.out.println("table " + num + " out of opening hours");
                        flags[f] = 1;
                    }
                    
                    }
                else if(Table.weekday(Date[0],Date[1],Date[2]) == 6||
                        Table.weekday(Date[0],Date[1],Date[2]) == 7) {
                    Specialdiscount[j-1] = 1;
                    if((Time[0] >= 10&&Time[0] <= 20)) {
                        discount[j-1] = 1;
                        System.out.println("table "+num+": ");
                    }
                    else if(((Time[0] == 10||Time[0] == 21)&&Time[1] <= 29)||
                            ((Time[0] == 10||Time[0] == 21)&&Time[1] == 30&&Time[2]==0)){
                        discount[j-1] = 1;
                        System.out.println("table "+num+": ");
                            }
                    else  { 
                    System.out.println("table " + num + " out of opening hours");
                    flags[f] = 1;
                    }
                    }
                f++;
            }
                else {System.out.println("wrong format");
                flag = 0;
                }
                
            }
            else if(flag == 1&&flags[f-1]==0){
                  if(inputs.get(i).contains("delete")) {
                    String[] deletes = inputs.get(i).split(" ");
                    int num = Integer.parseInt(deletes[0]);
                    if(tables.get(j-1).getOrder().findRecordByNum(num)){//找到该记录
                        tables.get(j-1).getOrder().delARecordByOrderNum(num);    
                    }
                    else {     
                        System.out.println("delete error");
                    }
                    }        
                else {
                    String[] dishInfo =inputs.get(i).split(" ");//存入一条点菜记录 
                    if(dishInfo.length == 4) {
                    int Num = Integer.parseInt(dishInfo[0]);//点菜序号
                    int portion = Integer.parseInt(dishInfo[2]);//份量
                    int number = Integer.parseInt(dishInfo[3]);//份数
                    
                    if(menu.searthDish(dishInfo[1]) != -1) {//该菜品存在
                        tables.get(j-1).getOrder().addARecord(Num,
                                menu.dishs.get(menu.searthDish(dishInfo[1])),portion,number,discount[j-1]);//添加一条菜品信息

                        System.out.println(tables.get(j-1).getOrder().records.get(a).orderNum//输出订单信息
                                +" "+tables.get(j-1).getOrder().records.get(a).d.name+" "+
                                tables.get(j-1).getOrder().records.get(a).getPrice());
                        a++;
                        }
                        else System.out.println(dishInfo[1]+" does not exist");
                    }
                    else if(dishInfo.length == 5) {
                        int Num = Integer.parseInt(dishInfo[0]);//点菜序号
                        int lever = Integer.parseInt(dishInfo[2]);//口味度
                        int portion = Integer.parseInt(dishInfo[3]);//份量
                        int number = Integer.parseInt(dishInfo[4]);//份数
                        if(menu.searthDish(dishInfo[1]) != -1) {//该菜品存在
                            if((menu.checkType(dishInfo[1]).equals("川菜")
                                    &&(lever<=5&&lever>=0))||
                                    (menu.checkType(dishInfo[1]).equals("晋菜")
                                            &&(lever<=4&&lever>=0))||
                                    (menu.checkType(dishInfo[1]).equals("浙菜")
                                            &&(lever<=3&&lever>=0))) {
                            tables.get(j-1).getOrder().addARecord(Num,
                                    menu.dishs.get(menu.searthDish(dishInfo[1])),lever,portion,number,Specialdiscount[j-1]);//添加一条菜品信息
                            System.out.println(tables.get(j-1).getOrder().records.get(a).orderNum//输出订单信息
                                    +" "+tables.get(j-1).getOrder().records.get(a).d.name+" "+
                                    tables.get(j-1).getOrder().records.get(a).getPrice());
                            a++;
                            }
                            else {
                                if(menu.checkType(dishInfo[1]).equals("川菜")
                                    &&!(lever<=5&&lever>=0)){
                                        System.out.println("spicy num out of range :"+lever);
                                }
                                else if(menu.checkType(dishInfo[1]).equals("晋菜")
                                            &&!(lever<=4&&lever>=0)) {
                                    System.out.println("acidity num out of range :"+lever);
                                }
                                else if(menu.checkType(dishInfo[1]).equals("浙菜")
                                        &&!(lever<=3&&lever>=0)) {
                                    System.out.println("sweetness num out of range :"+lever);
                                }
                            }
                        }
                            else System.out.println(dishInfo[1]+" does not exist");
                    
            }
                    else {//代点菜
                            int subTableNum = Integer.parseInt(dishInfo[0]);
                            int Num = Integer.parseInt(dishInfo[1]);//点菜序号
                            int lever = Integer.parseInt(dishInfo[3]);//口味度
                            int portion = Integer.parseInt(dishInfo[4]);//份量
                            int number = Integer.parseInt(dishInfo[5]);//份数
                            int subOrder = 0;
                            for(s = 0;s < tables.size();s++) {
                                if(tables.get(s).tableNum.equals(dishInfo[0])) {
                                    subOrder = s;
                                }
                            }
                            if(menu.searthDish(dishInfo[2]) != -1) {//该菜品存在
                                if((menu.checkType(dishInfo[2]).equals("川菜")
                                        &&(lever<=5&&lever>=0))||
                                        (menu.checkType(dishInfo[2]).equals("晋菜")
                                                &&(lever<=4&&lever>=0))||
                                        (menu.checkType(dishInfo[2]).equals("浙菜")
                                                &&(lever<=3&&lever>=0))) {
                                    tables.get(subOrder).getOrder().addARecord(Num,
                                            menu.dishs.get(menu.searthDish(dishInfo[2])),lever,portion,number,Specialdiscount[j-1],1);//添加一条菜品信息
                                    tables.get(j-1).getOrder().addARecord(1,Num,
                                menu.dishs.get(menu.searthDish(dishInfo[2])),lever,portion,number,Specialdiscount[j-1]);//添加一条菜品信息
                                    
                                    System.out.println(Num+" table "+tables.get(j-1).tableNum+" pay for table "+subTableNum+" "+
                                            tables.get(j-1).getOrder().records.get(a).getPrice());
                                        a++;
                                }
                                else {
                                    if(menu.checkType(dishInfo[1]).equals("川菜")
                                        &&!(lever<=5&&lever>=0)){
                                            System.out.println("spicy num out of range :"+lever);
                                    }
                                    else if(menu.checkType(dishInfo[1]).equals("晋菜")
                                                &&!(lever<=4&&lever>=0)) {
                                        System.out.println("acidity num out of range :"+lever);
                                    }
                                    else if(menu.checkType(dishInfo[1]).equals("浙菜")
                                            &&!(lever<=3&&lever>=0)) {
                                        System.out.println("sweetness num out of range :"+lever);
                                    }
                                }
                            }
                                else System.out.println(dishInfo[2]+" does not exist");
//                        }
                    }
            }
            }
            i++;
            }
          
          for(i = 0;i < tables.size();i++) {     
              if(flags[i] == 0) {
                  
                  System.out.print("table "+tables.get(i).tableNum+": "+
                  tables.get(i).getOrder().getTotalPrice()+" "+
                          tables.get(i).getOrder().getDiscountTotalPrice()); 
                  if(tables.get(i).getOrder().getDishNum("川菜") != 0) {
                      average = (int)(tables.get(i).getOrder().getAverageLever("川菜")/
                              tables.get(i).getOrder().getDishNum("川菜") +0.5);
                      System.out.print(" 川菜 "+(int)tables.get(i).getOrder().getDishNum("川菜"));         
                      if(average == 0)
                          System.out.print(" 不辣");
                      else if(average == 1)
                          System.out.print(" 微辣");
                      else if(average == 2)
                          System.out.print(" 稍辣");
                      else if(average == 3)
                          System.out.print(" 辣");
                      else if(average == 4)
                          System.out.print(" 很辣");
                      else if(average == 5)
                          System.out.print(" 爆辣");
                  }
                  if(tables.get(i).getOrder().getDishNum("晋菜") != 0) {
                      average = (int)(tables.get(i).getOrder().getAverageLever("晋菜")/
                              tables.get(i).getOrder().getDishNum("晋菜") +0.5);
                      System.out.print(" 晋菜 "+(int)tables.get(i).getOrder().getDishNum("晋菜"));
                      
                      if(average == 0)
                          System.out.print(" 不酸");
                      else if(average == 1)
                          System.out.print(" 微酸");
                      else if(average == 2)
                          System.out.print(" 稍酸");
                      else if(average == 3)
                          System.out.print(" 酸");
                      else if(average == 4)
                          System.out.print(" 很酸");      
                  }
                  if(tables.get(i).getOrder().getDishNum("浙菜") != 0) {
                      average = (int)(tables.get(i).getOrder().getAverageLever("浙菜")/
                              tables.get(i).getOrder().getDishNum("浙菜") +0.5);
                      System.out.print(" 浙菜 "+(int)tables.get(i).getOrder().getDishNum("浙菜"));
                     
                      if(average == 0)
                          System.out.print(" 不甜");
                      else if(average == 1)
                          System.out.print(" 微甜");
                      else if(average == 2)
                          System.out.print(" 稍甜");
                      else if(average == 3)
                          System.out.print(" 甜");   
                  }
                  System.out.print("\n");
              }
            
    }          
          for(i = 0;i < tables.size();i++){
              for(j = 0;j < i;j++){
           if(tables.get(i).customerName.equals(tables.get(j).customerName)) break;}
           if(i==j) {
                 Customer customer = new Customer(tables.get(i).customerName,tables.get(i).number);
                 customers.add(customer);
          }
           }
          for(i = 0;i < customers.size();i++) {
              for(j = 0;j < tables.size();j++) {
                  if(customers.get(i).name.equals(tables.get(j).customerName)) {
                      customers.get(i).TotalPrice = customers.get(i).TotalPrice + 
                              tables.get(j).getOrder().getDiscountTotalPrice();
                  }
              }
          }
          String Cname = " ";
          String Cnumber = " ";
          int Tprice = 0;
          for(i = 0;i < customers.size()-1;i++) {
              for(j = 0;j < customers.size() - i - 1;j++) {
                  if(customers.get(j).name.compareToIgnoreCase(customers.get(j+1).name) > 0) {
                      Cname = customers.get(j).name;
                      customers.get(j).name = customers.get(j+1).name;
                      customers.get(j+1).name = Cname;
                      Cnumber = customers.get(j).number;
                      customers.get(j).number = customers.get(j+1).number;
                      customers.get(j+1).number = Cnumber;
                      Tprice = customers.get(j).TotalPrice;
                      customers.get(j).TotalPrice = customers.get(j+1).TotalPrice;
                      customers.get(j+1).TotalPrice = Tprice;
                  }
                  
              }      
          }
          for(i = 0;i < customers.size();i++) {
              if(flags[i] == 0) {
                  System.out.println(customers.get(i).name+" "+
                          customers.get(i).number+" "+customers.get(i).TotalPrice);
              }
          }

}
    
}
class Customer{
    String name;
    String number;
//    Table[] table = new Table[100];
    int TotalPrice = 0;
    public Customer() {
        
    }
    public Customer(String name,String number) {
        this.name = name;
        this.number = number;
        
}
}
class Table{
    String tableNum;//桌子序号
    String customerName;
    String number;
    String date;
    String time;
    Order order = new Order();
    
    public Table(){
        
    }
    public Table(String tableNum,String customerName,String number,String date,String time){
        this.tableNum = tableNum;
        this.customerName = customerName;
        this.number = number;
        this.date = date;
        this.time = time;
    }
    Order getOrder() {
//        order = new Order();
        return this.order;
    }
    public static int weekday(int year, int month, int day){
        Calendar cal = Calendar.getInstance();
        //月份要减一，在西方周日是一周的第1天（日期也需要减一）
        cal.set(year,month-1,day-1);
        return  cal.get(Calendar.DAY_OF_WEEK);
    }
}
class Dish{
    String name;//菜名
    String type = " ";//菜系
    int unit_price = 0;//菜品单价
    public Dish(){
        
    }
    public Dish(String name,int unit_price){
        this.name = name;
        this.unit_price = unit_price;
    }
    public Dish(String name,String type,int unit_price) {
        this.name = name;
        this.type = type;
        this.unit_price = unit_price;
    }        
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getType(){
        return type;
    }
    public int getPrice(int portion){
        int price = 0;
        if(portion == 1){
             price = (int)unit_price;
        }
        else if(portion == 2){
             price = (int)(1.5*unit_price+0.5);
        }
        else if(portion == 3){
             price = (int)(2*unit_price);
        }
        return price;
    }
    
}
class Menu{
    ArrayList<Dish> dishs = new ArrayList<>();
    public Menu(){
        
    }
    int i = 0;
    int searthDish(String dishName){
        for(i = 0;i < dishs.size();i++)
        if((dishs.get(i).name).equals(dishName)){
            break;
        }
        if(i < dishs.size())
        return i;
        else return -1;
           }
    String checkType(String dishName) {
         for(i = 0;i < dishs.size();i++)
                if((dishs.get(i).name).equals(dishName)){
                    break;
                }
         return dishs.get(i).type;           
    }
    void addDish(String dishName,int unit_price){
        Dish dish = new Dish(dishName,unit_price);
        dishs.add(dish);
    }
    void addSpecialDish(String dishName,String type,int unit_price) {
        Dish dish = new Dish(dishName,type,unit_price);
        dishs.add(dish);
    }
}
class Record{
    int orderNum;//序号
    Dish d;//菜品
    int lever = 0;//口味度
    int portion;//份额
    int num;//份数
    double discount;
    int flag = 0;
    int sign = 0;
    int sign2 = 0;
    public Record(){
        
    }
    public Record(int orderNum,Dish d,int portion,int num,double discount){
        this.orderNum = orderNum;
        this.d = d;
        this.portion = portion;
        this.num = num;
        this.discount = discount;
    }
    public Record(int orderNum,Dish d,int lever,int portion,int num,double discount){
        this.orderNum = orderNum;
        this.d = d;
        this.lever = lever;
        this.portion = portion;
        this.num = num;
        this.discount = discount;
    }
    public Record(int orderNum,Dish d,int lever,int portion,int num,double discount,int sign){
        this.orderNum = orderNum;
        this.d = d;
        this.lever = lever;
        this.portion = portion;
        this.num = num;
        this.discount = discount;
        this.sign = sign;
    }
    public Record(int sign2,int orderNum,Dish d,int lever,int portion,int num,double discount){
        this.sign2 = sign2;
        this.orderNum = orderNum;
        this.d = d;
        this.lever = lever;
        this.portion = portion;
        this.num = num;
        this.discount = discount;
    }
    
    int getPrice(){//计价，计算本条记录的价格     
    return d.getPrice(portion)*num;
    }
    int getDiscountPrice() {
        return (int)(d.getPrice(portion)*num*discount+0.5);
    }
    public void showRecord() {
        
        System.out.println(orderNum+" "+d.name+" "+getPrice());    
        }
    int getLever() {
        return num * lever;
    }
}

class Order {
     int totalprice = 0;
     int total;
     int Lever = 0;
     double dishNum = 0;
     int i = 0,k = 0,a= 0,b = 0;
    ArrayList<Record> records = new ArrayList<>();
     int getTotalPrice(){//计算订单的总价
         totalprice = 0;
     for(i = 0;i < records.size();i++) {
         if(records.get(i).sign == 0) {
         a = records.get(i).getPrice();
        totalprice += a;
         }
     }
        return totalprice;   
}
     int getDiscountTotalPrice() {
         totalprice = 0;
         for(i = 0;i < records.size();i++) {
             if(records.get(i).sign == 0) {
             a = records.get(i).getDiscountPrice();
            totalprice += a;
             }
         }
            return totalprice;  
     }
     int getAverageLever(String type) {//输出指定菜系的口味值
         Lever = 0;
         if(type.equals("川菜"))
         for(i = 0;i < records.size();i++) {
             if(records.get(i).sign2 == 0) {
             if(records.get(i).d.type.equals(type))
             Lever = Lever + records.get(i).getLever();
             }
         }
         else if(type.equals("晋菜")) {
             for(i = 0;i < records.size();i++) {
                 if(records.get(i).sign2 == 0) {
                 if(records.get(i).d.type.equals(type))
                 Lever = Lever + records.get(i).getLever();
                 }
             }
         }
         else if(type.equals("浙菜")) {
             for(i = 0;i < records.size();i++) {
                 if(records.get(i).sign2 == 0) {
                 if(records.get(i).d.type.equals(type))
                 Lever = Lever + records.get(i).getLever();
                 }
             }
         }
         return Lever;      
     }
     double getDishNum(String type) {//输出指定菜系的总份数
         dishNum = 0;
         if(type.equals("川菜")) {
             for(i = 0;i < records.size();i++) {
                 if(records.get(i).sign2 == 0) {
                 if(records.get(i).d.type.equals(type))
                 dishNum = dishNum + records.get(i).num;
                 }
             }
         }
         if(type.equals("晋菜")) {
             for(i = 0;i < records.size();i++) {
                 if(records.get(i).sign2 == 0) {
                 if(records.get(i).d.type.equals(type))
                 dishNum = dishNum + records.get(i).num;
                 }
             }
         }
         if(type.equals("浙菜")) {
             for(i = 0;i < records.size();i++) {
                 if(records.get(i).sign2 == 0) {
                 if(records.get(i).d.type.equals(type))
                 dishNum = dishNum + records.get(i).num;
                 }
             }
         }
         return dishNum;
         
     }
     
void addARecord(int orderNum,Dish d,int portion,int num,double discount){

    Record record = new Record(orderNum,d,portion,num,discount);
    records.add(record);
}//添加一条菜品信息到订单中。
void addARecord(int orderNum,Dish d,int lever,int portion,int num,double discount){

    Record record = new Record(orderNum,d,lever,portion,num,discount);
    records.add(record);
}//添加一条菜品信息到订单中。
void addARecord(int orderNum,Dish d,int lever,int portion,int num,double discount,int sign){

    Record record = new Record(orderNum,d,lever,portion,num,discount,sign);
    records.add(record);
}//添加一条菜品信息到订单中。
void addARecord(int sign2,int orderNum,Dish d,int lever,int portion,int num,double discount){

    Record record = new Record(sign2,orderNum,d,lever,portion,num,discount);
    records.add(record);
}//添加一条菜品信息到订单中。

 void delARecordByOrderNum(int orderNum){
    records.remove(orderNum-1);   
 }//根据序号删除一条记录

boolean findRecordByNum(int orderNum){//根据序号查找一条记录
     for(i = 0;i < records.size();i++)
     if(records.get(i).orderNum == orderNum){
         break;
     }
     if(i == records.size()) {
         return false;
     }
     else return true;
 }
}

 

 

 

 分析如下：

1.本题和第六次题目集菜单计价程序-4同属第四次作业菜单计价程序-3的两个不同迭代分支，他在菜单计价程序-3的基础上新增了许多内容。

2.这道题的难度依旧很高，但总体上来说有了上次题目集中菜单计价程序-4的经验，我认为难度有所下降。

3.由于题目中可能出现的情况有很多种，所以使用了大量的if-else语句，使得程序结构变得十分冗长复杂。

4.从UML图中可以看出各类之间存在大量的依赖关系，有很强的耦合性。

 

 第二次作业

7-1 课程成绩统计程序-1

题目：

某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。

考察的总成绩直接等于期末成绩

必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。

1、输入：

包括课程、课程成绩两类信息。

课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。

课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

课程性质输入项：必修、选修

考核方式输入选项：考试、考察

课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

以上信息的相关约束：

1）平时成绩和期末成绩的权重默认为0.3、0.7

2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】

3）学号由8位数字组成

4）姓名不超过10个字符

5）课程名称不超过10个字符

6）不特别输入班级信息，班级号是学号的前6位。

2、输出：

输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。

为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。

1）学生课程总成绩平均分按学号由低到高排序输出

格式：学号+英文空格+姓名+英文空格+总成绩平均分

如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"

2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出

格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分

如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"

3）班级所有课程总成绩平均分按班级由低到高排序输出

格式：班级号+英文空格+总成绩平均分

如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"

异常情况：

1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"

2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"

以上两种情况如果同时出现，按第一种情况输出结果。

3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"

4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"

5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

信息约束：

1）成绩平均分只取整数部分，小数部分丢弃

参考类图：

输入样例1:

仅有课程。例如：

java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end

 

输出样例1:

在这里给出相应的输出。例如：

java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet

 

输入样例2:

单门考试课程 单个学生。例如：

java 必修 考试
20201103 张三 java 20 40
end

 

输出样例2:

在这里给出相应的输出。例如：

20201103 张三 34
java 20 40 34
202011 34

 

输入样例3:

单门考察课程 单个学生。例如：

java 选修 考察
20201103 张三 java 40
end

 

输出样例3:

在这里给出相应的输出。例如：

20201103 张三 40
java 40 40
202011 40

 

输入样例4:

考试课程 单个学生 不匹配的考核方式。例如：

java 必修 考试
20201103 张三 java 20
end

 

输出样例4:

在这里给出相应的输出。例如：

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet

 

输入样例5:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

java 必修 考察
20201103 张三 java 40
end

 

输出样例5:

在这里给出相应的输出。例如：

java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet

 

输入样例6:

单门课程，多个学生。例如：

java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end

 

输出样例6:

在这里给出相应的输出。例如：

20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53

 

输入样例7:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end

 

输出样例7:

在这里给出相应的输出。例如：

20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73

 

输入样例8:

单门课程，单个学生，成绩越界。例如：

数据结构 选修 考察
20201103 李四 数据结构 101
end

 

输出样例8:

在这里给出相应的输出。例如：

wrong format
数据结构 has no grades yet

 

输入样例9:

多门课程，多个学生，多个成绩。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end

 

输出样例9:

在这里给出相应的输出。例如：

20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72

代码展示：

import java.util.ArrayList;
import java.util.Scanner;
import java.util.Collections;
import java.text.Collator;
import java.util.Comparator;
import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        ArrayList<String> inputs = new ArrayList<>();

        String info = input.nextLine();
        while(!info.equals("end")){
            inputs.add(info);
            info = input.nextLine();
        }
        inputs.add(info);
        ArrayList<Course> courses = new ArrayList<>();
        ArrayList<Class1> classes = new ArrayList<>();
        ArrayList<Student> stu = new ArrayList<>();
        ArrayList<Selection> selections = new ArrayList<>();

       int i,j,k,n,m;
        for(i = 0;!inputs.get(i).equals("end");i++) {
            String[] Info = inputs.get(i).split(" ");
            if (inputs.get(i).matches(".{1,10}\\s(((必修|选修)\\s(考试|考察))|(必修))")) {
                if (inputs.get(i).contains("必修")) {

                    if (inputs.get(i).contains("考察")) {
                        System.out.println(Info[0] + " : course type & access mode mismatch");
                    } else {
                        if (courses.size() == 0) {
                            Course course = new Course(Info[0], Info[1], "考试");
                            courses.add(course);
                        } else {
                            for (j = 0; j < courses.size(); j++) {
                                if (courses.get(j).getLessonName().equals(Info[0])) {
                                    break;
                                }
                            }
                            if (j == courses.size()) {
                                Course course = new Course(Info[0], Info[1], "考试");
                                courses.add(course);
                            }
                        }
                    }

                } else if (inputs.get(i).contains("选修")) {

                    if (courses.size() == 0) {
                        Course course = new Course(Info[0], Info[1], Info[2]);
                        courses.add(course);
                    } else {
                        for (j = 0; j < courses.size(); j++) {
                            if (courses.get(j).getLessonName().equals(Info[0])) {
                                break;
                            }
                        }
                        if (j == courses.size()) {
                            Course course = new Course(Info[0], Info[1],Info[2]);
                            courses.add(course);
                        }
                    }

                }
            }
                else if(inputs.get(i).matches("[\\d]{8}(\\s([\\u4e00-\\u9fa5]|[\\w]){1,10}){2}(\\s([\\d]{1,2}|100)){1,2}")) {

                for (j = 0; j < classes.size(); j++) {
                    if (classes.get(j).getNum().equals(Info[0].substring(0, 6))) {
                        break;//找到了
                    }
                }
                if (j == classes.size()) {//班级不存在
                    Class1 class1 = new Class1(Info[0].substring(0, 6));
                    classes.add(class1);
                }
                for (k = 0; k < classes.get(j).students.size(); k++) {
                    if (classes.get(j).students.get(k).getId().equals(Info[0])) {
                        break;//学生存在
                    }
                }
                if (k == classes.get(j).students.size()) {//学生不存在
                    Student student = new Student(Info[0], Info[1]);
                    classes.get(j).students.add(student);
                    stu.add(student);
                }
                    if (Info.length == 4) {//选修考察

                        int flag = 0;
                        for (n = 0; n < courses.size(); n++) {
                            if (courses.get(n).getLessonName().equals(Info[2])) {
                                break;
                            }
                        }
                        if (n == courses.size()) {
                            System.out.println(Info[2] + " does not exist");
                            flag = 1;
                        }
                        if (courses.size() > 0) {
                            if (flag == 0) {
                                if (courses.get(n).getTestWay().equals("考察")) {
                                    for (m = 0; m < selections.size(); m++) {
                                        if (selections.get(m).getStudent().getId().equals(classes.get(j).students.get(k).getId())
                                                && selections.get(m).getCourse().getLessonName().equals(courses.get(n).getLessonName())) {
                                            break;
                                        }
                                    }
                                    if (m == selections.size()) {
                                        int fGrade = Integer.parseInt(Info[3]);
                                        Score examine = new Examine(fGrade);
                                        Selection selection = new Selection(courses.get(n), classes.get(j).students.get(k), examine);
                                        selections.add(selection);
                                    }
                                } else {
                                    System.out.println(classes.get(j).students.get(k).getId() + " " +
                                            classes.get(j).students.get(k).getName() + " : " + "access mode mismatch");
                                }
                            }
                        }
                    } else if (Info.length == 5) {//考试

                        int flag = 0;
                        for (n = 0; n < courses.size(); n++) {
                            if (courses.get(n).getLessonName().equals(Info[2])) {
                                break;
                            }
                        }
                        if (n == courses.size()) {
                            System.out.println(Info[2] + " does not exist");
                            flag = 1;
                        }
                        if (courses.size() > 0) {
                            if(flag == 0) {
                                if (!courses.get(n).getTestWay().equals("考察")) {
                                    for (m = 0; m < selections.size(); m++) {
                                        if (selections.get(m).getStudent().getId().equals(classes.get(j).students.get(k).getId())
                                                && selections.get(m).getCourse().getLessonName().equals(courses.get(n).getLessonName())) {
                                            break;
                                        }
                                    }
                                    if (m == selections.size()) {
                                        int uGrade = Integer.parseInt(Info[3]);
                                        int fGrade = Integer.parseInt(Info[4]);
                                        Score examScore = new ExamScore(uGrade, fGrade);
                                        Selection selection = new Selection(courses.get(n), classes.get(j).students.get(k), examScore);
                                        selections.add(selection);
                                    }
                                } else  {
                                    System.out.println(classes.get(j).students.get(k).getId() + " " +
                                            classes.get(j).students.get(k).getName() + " : " + "access mode mismatch");
                                }
                            }
                        }
                    }
                }
               else System.out.println("wrong format");
        }
//排序
        ArrayList<Integer> averScore = new ArrayList<>();
        ArrayList<Integer> gradeSize = new ArrayList<>();
        for(i = 0;i < stu.size();i++){
            averScore.add(stu.get(i).getAverageScore());

            gradeSize.add(stu.get(i).grades.size());
        }
        for(i = 0;i < stu.size()-1;i++){
            String t;
            int t1;
            for(j = 0;j < stu.size()-1-i;j++) {
                if(stu.get(j + 1).getIntId() < stu.get(j).getIntId()){
                    t = stu.get(j+1).getId();
                   stu.get(j+1).setId(stu.get(j).getId());
                    stu.get(j).setId(t);
                    t = stu.get(j+1).getName();
                    stu.get(j+1).setName(stu.get(j).getName());
                       stu.get(j).setName(t);
                       t1 = averScore.get(j+1);
                       averScore.set(j+1,averScore.get(j));
                       averScore.set(j,t1);
                       t1 = gradeSize.get(j+1);
                       gradeSize.set(j+1,gradeSize.get(j));
                       gradeSize.set(j,t1);
                }
            }
        }
        ArrayList<Integer> averUgrade = new ArrayList<>();
        ArrayList<Integer> averFgrade = new ArrayList<>();
        ArrayList<Integer> averGrade = new ArrayList<>();
        Collections.sort(courses);
        for(i = 0;i < courses.size();i++){
            averUgrade.add(courses.get(i).getAverageUrades());
            averFgrade.add(courses.get(i).getAverageFrades());
            averGrade.add(courses.get(i).getAverageScore());
        }
        for(i = 0;i < stu.size();i++){
            System.out.print(stu.get(i).getId()+" "+stu.get(i).getName()+" ");
            if(gradeSize.get(i)!= 0) {
                System.out.println(averScore.get(i));
            }
            else System.out.println("did not take any exams");
        }
        for(i = 0;i < courses.size();i++) {
            System.out.print(courses.get(i).getLessonName() + " ");
            if (courses.get(i).grades.size() != 0) {
                if (!courses.get(i).getTestWay().equals("考察")) {
                    System.out.print(averUgrade.get(i) + " ");

                    System.out.print(averFgrade.get(i) + " ");
                } else
                    System.out.print(averFgrade.get(i) + " ");

                System.out.println(averGrade.get(i));
            }
            else System.out.println("has no grades yet");
        }
        ArrayList<Integer> classScore = new ArrayList<>();
        for(i = 0;i < classes.size();i++){
            classScore.add(classes.get(i).getClassScore());
        }
        for(i = 0;i < classes.size()-1;i++){
            String t;
            int t1;
            for(j = 0;j < classes.size()-1-i;j++){
                if(classes.get(j+1).getIntNum() < classes.get(j).getIntNum()){
                    t = classes.get(j+1).getNum();
                    classes.get(j+1).setNum( classes.get(j).getNum());
                    classes.get(j).setNum(t);
                    t1 = classScore.get(j+1);
                    classScore.set(j+1,classScore.get(j));
                    classScore.set(j,t1);
                }
            }
        }
        for(i = 0;i < classes.size();i++){
            System.out.print(classes.get(i).getNum()+" ");
            if(classScore.get(i) != 0)
            System.out.println(classScore.get(i));
            else System.out.println("has no grades yet");
        }
    }
}
 abstract class Score {
    private int Fgrade;
    private int Ugrade;
    public Score(int fgrade) {
        Fgrade = fgrade;
    }
    public Score(int ugrade, int fgrade) {
        super();
        Ugrade = ugrade;
        Fgrade = fgrade;
    }
    public abstract int getScore();
    public int getUgrade() {
        return Ugrade;
    }
    public int getFgrade() {
        return Fgrade;
    }
}
class Examine extends Score{
    public Examine(int fgrade){
        super(fgrade);
    }
    @Override
    public int getScore(){
        return (int)( this.getFgrade());
    }
}
class ExamScore extends Score{
    public ExamScore(int ugrade, int fgrade) {
        super(ugrade, fgrade);
    }
    @Override
    public int getScore(){
        return (int)(this.getUgrade()*0.3 + this.getFgrade()*0.7);
    }
}
class Course implements Comparable<Course> {
    private String lessonName;
    private String lessonAttribute;
    private String testWay;

    ArrayList<Integer> grades = new ArrayList<>();
    ArrayList<Integer> Ugrades = new ArrayList<>();
    ArrayList<Integer> Fgrades = new ArrayList<>();
    public Course(String lessonName) {
        super();
        this.lessonName = lessonName;
    }
    public Course(String lessonName, String lessonAttribute, String testWay) {
        super();
        this.lessonName = lessonName;
        this.lessonAttribute = lessonAttribute;
        this.testWay = testWay;
    }
    public String getLessonName() {return lessonName;}
    public String getLessonAttribute() {
        return lessonAttribute;
    }
    public String getTestWay() {
        return testWay;
    }
    public int getAverageScore() {
        int total = 0;
        for(int i = 0;i < grades.size();i++){
            total = total + grades.get(i);
        }
        if(grades.size() != 0)
        return total/grades.size();
        else return 0;
    }
    public int getAverageUrades() {
        int total = 0;
        for(int i = 0;i < Ugrades.size();i++){
            total = total + Ugrades.get(i);
        }
        if(Ugrades.size() != 0)
        return total/Ugrades.size();
        else return 0;
    }
    public int getAverageFrades() {
        int total = 0;
        for(int i = 0;i < Fgrades.size();i++){
            total = total + Fgrades.get(i);
        }
        if(Fgrades.size() != 0)
        return total/Fgrades.size();
        else return 0;
    }
    @Override
    public int compareTo(Course cou) {
        Comparator<Object> com = Collator.getInstance(Locale.CHINA);
        return ((Collator) com).compare(this.lessonName,cou.getLessonName());
    }
}
class Class1 {
    private String num;
    ArrayList<Student> students = new ArrayList<>();
    public Class1(String num) {
        this.num = num;
    }
    public String getNum() {
        return num;
    }
    public void setNum(String num){
        this.num = num;
    }
    public int getIntNum(){
        return Integer.parseInt(num);
    }
    public int getClassScore(){
        int total = 0;
        for(int i = 0;i < this.students.size();i++){
            total = total +this.students.get(i).getAverageScore();
        }
        if(this.students.size() == 0){
            return 0;
      }
        else return total/this.students.size();
    }
}
 class Selection {
    private Course course;
    private Student student;
    private Score score;
    public Selection(Course course, Student student, Score score) {
        this.course = course;
        this.student = student;
        this.score = score;
 this.student.grades.add(score.getScore());
        this.course.grades.add(score.getScore());
        if(!course.getTestWay().equals("考察")){
            this.course.Ugrades.add(score.getUgrade());
            this.course.Fgrades.add(score.getFgrade());
        }
        else {
            this.course.Fgrades.add(score.getFgrade());
        }
    }
    public Course getCourse() {
        return course;
    }
    public Student getStudent() {
        return student;
    }
    public Score getScore() {
        return score;
    }
}
class Student {
    private String id;
    private String name;
    ArrayList<Integer> grades = new ArrayList<>();
    private int averScore;
    public Student(String id,String name) {
        this.id = id;
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public int getIntId(){
        return Integer.parseInt(id);
    }
    public void setId(String id) {
        this.id = id;
    }
    public int getAverageScore() {
        int total = 0;
       for(int i = 0;i < grades.size();i++){
           total = total + grades.get(i);
       }
       if(grades.size() != 0) {
           this.averScore = total / grades.size();
           return averScore;
       }
       else return 0;
    }
}

类图如下：

 

 

分析如下：

1.该题上前几次的菜单计价程序题有许多相似之处，我用了同样的处理信息的方式来处理这道题，从图中可以看出

这段代码的耦合性很强，原因是我使用了大量的if-else语句，这也是我需要改进的地方。

2.有了前几次的教训和经验，我不再轻视题目，我首先寻找这次题目和上次题目的共同点，这样让我有了更加清晰的

思路。

3.本题同样设计了许多的类，题目还提供了参考类图，我先是大致理解各个类的作用，编写他们的属性和方法，再着重

分析各类之间的关系。

4.此外，这道题代码长度限制很严格，只有16kb，所以在做题的过程中需要十分注重对内存大小的管理和分配。

 

 第三次作业

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

题目如下：

编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：

• Java中共有53个关键字（自行百度）
• 从键盘输入一段源码，统计这段源码中出现的关键字的数量
• 注释中出现的关键字不用统计
• 字符串中出现的关键字不用统计
• 统计出的关键字及数量按照关键字升序进行排序输出
• 未输入源码则认为输入非法

输入格式:

输入Java源码字符串，可以一行或多行，以exit行作为结束标志

输出格式:

• 当未输入源码时，程序输出Wrong Format
• 当没有统计数据时，输出为空
• 当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为数量\t关键字

输入样例:

在这里给出一组输入。例如：

//Test public method
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
exit

 

输出样例:

在这里给出相应的输出。例如：

 

1	float
3	if
2	int
2	new
2	public
3	this
2	throw

代码展示：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Map;
public class Main {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        String[] key = {"abstract","assert","boolean","break","byte","case","catch","char","class","const","continue","default","do","double","else","enum","extends","false","final","finally","float","for","goto","if","implements","import","instanceof","int","interface","long","native","new","null","package","private","protected","public","return","short","static","strictfp","super","switch","synchronized","this","throw","throws","transient","true","try","void","volatile","while"
        };
        Scanner in = new Scanner(System.in);
        ArrayList<String> inputs = new ArrayList<>();
        String str = in.nextLine();
        int i,j,k,n;
           while(!str.equals("exit")) {
            inputs.add(str);
            str = in.nextLine();
        }
        for (i = 0; i < inputs.size(); i++) {
            inputs.set(i, inputs.get(i).replaceAll("\".*\"", " "));
            inputs.set(i, inputs.get(i).replaceAll("//.*", " "));
        }
        ArrayList<Integer> sta = new ArrayList<>();
        ArrayList<Integer> end = new ArrayList<>();
        for(i = 0;i < inputs.size();i++){
            if(inputs.get(i).contains("/*"))
                sta.add(i);
            if(inputs.get(i).contains("*/"))
                end.add(i);
        }
     for(i = 0;i < sta.size();i++){
         for(j = sta.get(i);j <= end.get(i);j++)
             inputs.set(j," ");
     }
        if(inputs.size() > 0 ) {
            for (i = 0; i < inputs.size(); i++){
                inputs.set(i, inputs.get(i).replace("=", "1"));
                inputs.set(i, inputs.get(i).replaceAll("\\W", " "));
            }
            ArrayList<String> afsp = new ArrayList<>();
            for(i = 0;i < inputs.size();i++){
                String[] a = inputs.get(i).split(" +");
                for(String s : a)
                    afsp.add(s);
            }
            for(j = 0; j< key.length;j++) {
                n = 0;
                for (i = 0; i < afsp.size(); i++) {
                    if(key[j].equals(afsp.get(i)))
                    n++;
                }
                map.put(key[j],n);
            }
            for(j = 0;j < key.length;j++){
                if(map.get(key[j]) != 0)
                    System.out.println(map.get(key[j])+"\t"+key[j]);
            }
        } else System.out.println("Wrong Format");
    }
}

 

 

 分析如下：

1.由于要求使用Map并且规定了代码行数，而我对Map的使用还不够熟练，所以这题对我来说有点难度。

2.根据老师在课堂上提供的思路，用replace和repalceAll这两个方法将没用的字符转换为空格字符，然后使用split这个方法将字符串

根据空格分割，存入字符串数组中。

3.将关键字存入到Map中当作key,关键词出现的次数当作value，最后使用Map的方法输出。

 

第四次作业

 第一题

7-1 容器-HashMap-检索

题目如下：

输入多个学生的成绩信息，包括：学号、姓名、成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

使用HashMap存储学生信息，并实现根据学号的检索功能

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

以“end”为输入结束标志

end之后输入某个学号，执行程序输出该生的详细信息

输出格式:

输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩

如果没有查询到，则输出："The student "+查询的学号+" does not exist"

输入样例1:

在这里给出一组输入。例如：

20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20201116

 

输出样例1:

在这里给出相应的输出。例如：

20201116 李四 78

 

输入样例2:

在这里给出一组输入。例如：

20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20202316

 

输出样例2:

在这里给出相应的输出。例如：

The student 20202316 does not exist

 

代码展示：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Student,String> map = new HashMap<>();
        Scanner input = new Scanner(System.in);
        String in = input.nextLine();
        while(!in.equals("end")){
            String[] Info = in.split(" ");
            Student stu = new Student(Info[0],Info[1]);
            map.put(stu,Info[2]);
            in = input.nextLine();
        }
        String id = input.nextLine();
        Set<Student> set = map.keySet();
        int flag = 0;
        for(Student stus : set){
            if(stus.getId().equals(id)){
                flag = 1;
                System.out.println(stus.getId()+" "+stus.getName()+" "+map.get(stus));
                break;
            }
        }
        if(flag == 0){
            System.out.println("The student "+id+" does not exist");
        }

    }
}
class Student {
    String id;
    String name;
    public Student(){

    }
    public Student(String id, String name) {
        this.id = id;
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public void setId(String id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
}

类图如下：

 

 

 

 分析如下：

1、这次题目要求使用HashMap来存储学生信息，于是我创建一个学生类，在主类中创建一个以学生类为key，int类为

value的HashMap，再利用set遍历map。

 

第二题

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

课程成绩统计程序-2在第一次的基础上增加了实验课，以下加粗字体显示为本次新增的内容。

某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。

考察的总成绩直接等于期末成绩

实验的总成绩等于课程每次实验成绩的平均分

必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。

1、输入：

包括课程、课程成绩两类信息。

课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。

课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

课程性质输入项：必修、选修、实验

考核方式输入选项：考试、考察、实验

考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

考试/考查课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩

实验次数至少4次，不超过9次

实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩

以上信息的相关约束：

1）平时成绩和期末成绩的权重默认为0.3、0.7

2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】

3）学号由8位数字组成

4）姓名不超过10个字符

5）课程名称不超过10个字符

6）不特别输入班级信息，班级号是学号的前6位。

2、输出：

输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。

为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。

1）学生课程总成绩平均分按学号由低到高排序输出

格式：学号+英文空格+姓名+英文空格+总成绩平均分

如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"

2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出

考试/考察课程成绩格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分

实验课成绩格式：课程名称+英文空格+总成绩平均分

如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"

3）班级所有课程总成绩平均分按班级由低到高排序输出

格式：班级号+英文空格+总成绩平均分

如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"

异常情况：

1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"

2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"

以上两种情况如果同时出现，按第一种情况输出结果。

3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"

4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"

5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

信息约束：

1）成绩平均分只取整数部分，小数部分丢弃

参考类图（与第一次相同，其余内容自行补充）：

 

输入样例1:

在这里给出一组输入。例如：

java 实验 实验
20201103 张三 java 4 70 80 90
end

 

输出样例1:

在这里给出相应的输出。例如：

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet

 

输入样例2:

在这里给出一组输入。例如：

java 实验 实验
20201103 张三 java 3 70 80 90
end

 

输出样例2:

在这里给出相应的输出。例如：

wrong format
java has no grades yet

 

输入样例3:

在这里给出一组输入。例如：

java 必修 实验
20201103 张三 java 3 70 80 90 100
end

 

输出样例3:

在这里给出相应的输出。例如：

java : course type & access mode mismatch
wrong format

 

输入样例4:

在这里给出一组输入。例如：

java 必修 实验
20201103 张三 java 4 70 80 90 105
end

 

输出样例4:

在这里给出相应的输出。例如：

java : course type & access mode mismatch
wrong format

 

 

输入样例5:

在这里给出一组输入。例如：

java 选修 考察
C语言 选修 考察
java实验 实验 实验
编译原理 必修 考试
20201101 王五 C语言 76
20201216 李四 C语言 78
20201307 张少军 编译原理 82 84
20201103 张三 java实验 4 70 80 90 100
20201118 郑觉先 java 80
20201328 刘和宇 java 77
20201220 朱重九 java实验 4 60 60 80 80
20201132 王萍 C语言 40
20201302 李梦涵 C语言 68
20201325 崔瑾 编译原理 80 84
20201213 黄红 java 82
20201209 赵仙芝 java 76
end

 

输出样例5:

在这里给出相应的输出。例如：

20201101 王五 76
20201103 张三 85
20201118 郑觉先 80
20201132 王萍 40
20201209 赵仙芝 76
20201213 黄红 82
20201216 李四 78
20201220 朱重九 70
20201302 李梦涵 68
20201307 张少军 83
20201325 崔瑾 82
20201328 刘和宇 77
C语言 65 65
java 78 78
java实验 77
编译原理 81 84 82
202011 70
202012 76
202013 77

 

代码展示：

import java.util.ArrayList;
import java.util.Scanner;
import java.util.Collections;
import java.text.Collator;
import java.util.Comparator;
import java.util.Locale;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        ArrayList<String> inputs = new ArrayList<>();

        String info = input.nextLine();
        while(!info.equals("end")){
            inputs.add(info);
            info = input.nextLine();
        }
        inputs.add(info);
        ArrayList<Course> courses = new ArrayList<>();
        ArrayList<Class1> classes = new ArrayList<>();
        ArrayList<Student> stu = new ArrayList<>();
        ArrayList<Selection> selections = new ArrayList<>();

        int i,j,k,n,m,q;
        for(i = 0;!inputs.get(i).equals("end");i++) {
            String[] Info = inputs.get(i).split(" ");
            if (inputs.get(i).matches(".{1,10}\\s(((必修|选修|实验)\\s(考试|考察|实验))|(必修))")) {
                if (inputs.get(i).contains("必修")) {

                    if (inputs.get(i).contains("考察")||inputs.get(i).contains("实验")) {
                        System.out.println(Info[0] + " : course type & access mode mismatch");
                    } else {
                        if (courses.size() == 0) {
                            Course course = new Course(Info[0], Info[1], "考试");
                            courses.add(course);
                        } else {
                            for (j = 0; j < courses.size(); j++) {
                                if (courses.get(j).getLessonName().equals(Info[0])) {
                                    break;
                                }
                            }
                            if (j == courses.size()) {
                                Course course = new Course(Info[0], Info[1], "考试");
                                courses.add(course);
                            }
                        }
                    }
                } else if (inputs.get(i).contains("选修")) {
                    if (inputs.get(i).contains("实验")) {
                        System.out.println(Info[0] + " : course type & access mode mismatch");
                    }else{
                        if (courses.size() == 0) {
                            Course course = new Course(Info[0], Info[1], Info[2]);
                            courses.add(course);
                        } else {
                            for (j = 0; j < courses.size(); j++) {
                                if (courses.get(j).getLessonName().equals(Info[0])) {
                                    break;
                                }
                            }
                            if (j == courses.size()) {
                                Course course = new Course(Info[0], Info[1], Info[2]);
                                courses.add(course);
                            }
                        }
                    }
                }
                else if(inputs.get(i).contains("实验")){
                    if(inputs.get(i).contains("考试")||inputs.get(i).contains("考察")){
                        System.out.println(Info[0] + " : course type & access mode mismatch");
                    }
                    else {
                        if (courses.size() == 0) {
                            Course course = new Course(Info[0], Info[1], Info[2]);
                            courses.add(course);
                        } else {
                            for (j = 0; j < courses.size(); j++) {
                                if (courses.get(j).getLessonName().equals(Info[0])) {
                                    break;
                                }
                            }
                            if (j == courses.size()) {
                                Course course = new Course(Info[0], Info[1], Info[2]);
                                courses.add(course);
                            }
                        }
                    }
                }
            }
            else if(inputs.get(i).matches("[\\d]{8}(\\s([\\u4e00-\\u9fa5]|[\\w]){1,10}){2}(\\s([\\d]{1,2}|100)){1,2}")) {
                for (j = 0; j < classes.size(); j++) {
                    if (classes.get(j).getNum().equals(Info[0].substring(0, 6))) {
                        break;//找到了
                    }
                }
                if (j == classes.size()) {//班级不存在
                    Class1 class1 = new Class1(Info[0].substring(0, 6));
                    classes.add(class1);
                }
                for (k = 0; k < classes.get(j).students.size(); k++) {
                    if (classes.get(j).students.get(k).getId().equals(Info[0])) {
                        break;//学生存在
                    }
                }
                if (k == classes.get(j).students.size()) {//学生不存在
                    Student student = new Student(Info[0], Info[1]);
                    classes.get(j).students.add(student);
                    stu.add(student);
                }
                if (Info.length == 4) {//选修考察

                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {
                        if (courses.get(n).getLessonName().equals(Info[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {
                        System.out.println(Info[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        if (flag == 0) {
                            if (courses.get(n).getTestWay().equals("考察")) {
                                for (m = 0; m < selections.size(); m++) {
                                    if (selections.get(m).getStudent().getId().equals(classes.get(j).students.get(k).getId())
                                            && selections.get(m).getCourse().getLessonName().equals(courses.get(n).getLessonName())) {
                                        break;
                                    }
                                }
                                if (m == selections.size()) {
                                    int fGrade = Integer.parseInt(Info[3]);
                                    Score examine = new Examine(fGrade);
                                    Selection selection = new Selection(courses.get(n), classes.get(j).students.get(k), examine);
                                    selections.add(selection);
                                }
                            }
                            else if(courses.get(n).getTestWay().equals("实验")&&(Integer.parseInt(Info[3])<4||Integer.parseInt(Info[3])>9)){
                                classes.remove(classes.size()-1);
                                stu.remove(stu.size()-1);
                                System.out.println("wrong format");
                            }
                            else{
                                System.out.println(classes.get(j).students.get(k).getId() + " " +
                                        classes.get(j).students.get(k).getName() + " : " + "access mode mismatch");
                            }
                        }
                    }
                } else if (Info.length == 5) {//考试

                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {
                        if (courses.get(n).getLessonName().equals(Info[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {
                        System.out.println(Info[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        if(flag == 0) {
                            if (courses.get(n).getTestWay().equals("考试")) {
                                for (m = 0; m < selections.size(); m++) {
                                    if (selections.get(m).getStudent().getId().equals(classes.get(j).students.get(k).getId())
                                            && selections.get(m).getCourse().getLessonName().equals(courses.get(n).getLessonName())) {
                                        break;
                                    }
                                }
                                if (m == selections.size()) {
                                    int uGrade = Integer.parseInt(Info[3]);
                                    int fGrade = Integer.parseInt(Info[4]);
                                    Score examScore = new ExamScore(uGrade, fGrade);
                                    Selection selection = new Selection(courses.get(n), classes.get(j).students.get(k), examScore);
                                    selections.add(selection);
                                }
                            } else if(courses.get(n).getTestWay().equals("实验")&&(Integer.parseInt(Info[3])<4||Integer.parseInt(Info[3])>9)){
                                classes.remove(classes.size()-1);
                                stu.remove(stu.size()-1);
                                System.out.println("wrong format");
                            }
                            else  {
                                System.out.println(classes.get(j).students.get(k).getId() + " " +
                                        classes.get(j).students.get(k).getName() + " : " + "access mode mismatch");
                            }
                        }
                    }
                }
            }
            else if (inputs.get(i).matches
                    ("[\\d]{8}(\\s([\\u4e00-\\u9fa5]|[\\w]){1,10}){2}\\s[4-9](\\s([\\d]{1,2}|100))+")){
                for (j = 0; j < classes.size(); j++) {
                    if (classes.get(j).getNum().equals(Info[0].substring(0, 6))) {
                        break;//找到了
                    }
                }
                if (j == classes.size()) {//班级不存在
                    Class1 class1 = new Class1(Info[0].substring(0, 6));
                    classes.add(class1);
                }
                for (k = 0; k < classes.get(j).students.size(); k++) {
                    if (classes.get(j).students.get(k).getId().equals(Info[0])) {
                        break;//学生存在
                    }
                }
                if (k == classes.get(j).students.size()) {//学生不存在
                    Student student = new Student(Info[0], Info[1]);
                    classes.get(j).students.add(student);
                    stu.add(student);
                }
                    int flag = 0;
                    int testScores = 0;
                    for (n = 0; n < courses.size(); n++) {
                        if (courses.get(n).getLessonName().equals(Info[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {
                        System.out.println(Info[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        if(flag == 0) {
                            if(!courses.get(n).getTestWay().equals("实验")){
                                classes.remove(classes.size()-1);
                                stu.remove(stu.size()-1);
                                System.out.println("wrong format");
                            }
                            else{
                                if (courses.get(n).getTestWay().equals("实验")&&Info.length - 4== Integer.parseInt(Info[3])) {
                                    for (m = 0; m < selections.size(); m++) {
                                        if (selections.get(m).getStudent().getId().equals(classes.get(j).students.get(k).getId())
                                                && selections.get(m).getCourse().getLessonName().equals(courses.get(n).getLessonName())) {
                                            break;
                                        }
                                    }
                                    if (m == selections.size()) {
                                        for(q = 4;q < Info.length;q++)
                                            testScores = testScores + Integer.parseInt(Info[q]);
                                        Score testScore = new TestScore(testScores,Integer.parseInt(Info[3]));
                                        Selection selection = new Selection(courses.get(n), classes.get(j).students.get(k), testScore);
                                        selections.add(selection);
                                    }
                                } else  {
                                    System.out.println(classes.get(j).students.get(k).getId() + " " +
                                            classes.get(j).students.get(k).getName() + " : " + "access mode mismatch");
                                }
                            }
                        }
                    }
            }
            else System.out.println("wrong format");
        }
//排序
        ArrayList<Integer> averScore = new ArrayList<>();
        ArrayList<Integer> gradeSize = new ArrayList<>();
        for(i = 0;i < stu.size();i++){
            averScore.add(stu.get(i).getAverageScore());

            gradeSize.add(stu.get(i).grades.size());
        }

        for(i = 0;i < stu.size()-1;i++){
            String temp;
            int tp;
            for(j = 0;j < stu.size()-1-i;j++) {
                if(stu.get(j + 1).getIntId() < stu.get(j).getIntId()){
                    temp = stu.get(j+1).getId();
                    stu.get(j+1).setId(stu.get(j).getId());
                    stu.get(j).setId(temp);
                    temp = stu.get(j+1).getName();
                    stu.get(j+1).setName(stu.get(j).getName());
                    stu.get(j).setName(temp);
                    tp = averScore.get(j+1);
                    averScore.set(j+1,averScore.get(j));
                    averScore.set(j,tp);
                    tp = gradeSize.get(j+1);
                    gradeSize.set(j+1,gradeSize.get(j));
                    gradeSize.set(j,tp);
                }
            }
        }
        ArrayList<Integer> averUgrade = new ArrayList<>();
        ArrayList<Integer> averFgrade = new ArrayList<>();
        ArrayList<Integer> averGrade = new ArrayList<>();
        Collections.sort(courses);
        for(i = 0;i < courses.size();i++){
            averUgrade.add(courses.get(i).getAverageUrades());
            averFgrade.add(courses.get(i).getAverageFrades());
            averGrade.add(courses.get(i).getAverageScore());
        }
        for(i = 0;i < stu.size();i++){
            System.out.print(stu.get(i).getId()+" "+stu.get(i).getName()+" ");
            if(gradeSize.get(i)!= 0) {
                System.out.println(averScore.get(i));
            }
            else System.out.println("did not take any exams");
        }
        for(i = 0;i < courses.size();i++) {
            System.out.print(courses.get(i).getLessonName() + " ");
            if (courses.get(i).grades.size() != 0) {
                if (courses.get(i).getTestWay().equals("考试")) {
                    System.out.print(averUgrade.get(i) + " ");

                    System.out.print(averFgrade.get(i) + " ");
                } else if(courses.get(i).getTestWay().equals("考察"))
                    System.out.print(averFgrade.get(i) + " ");

                System.out.println(averGrade.get(i));
            }
            else System.out.println("has no grades yet");
        }
        ArrayList<Integer> classScore = new ArrayList<>();
        for(i = 0;i < classes.size();i++){
            classScore.add(classes.get(i).getClassScore());
        }
        for(i = 0;i < classes.size()-1;i++){
            String temp;
            int tp;
            for(j = 0;j < classes.size()-1-i;j++){
                if(classes.get(j+1).getIntNum() < classes.get(j).getIntNum()){
                    temp = classes.get(j+1).getNum();
                    classes.get(j+1).setNum( classes.get(j).getNum());
                    classes.get(j).setNum(temp);
                    tp = classScore.get(j+1);
                    classScore.set(j+1,classScore.get(j));
                    classScore.set(j,tp);
                }
            }
        }
        for(i = 0;i < classes.size();i++){
            System.out.print(classes.get(i).getNum()+" ");
            if(classScore.get(i) != 0)
                System.out.println(classScore.get(i));
            else System.out.println("has no grades yet");
        }
    }
}
 abstract class Score {
    private int Fgrade;
    private int Ugrade;
    public Score(int fgrade) {
        Fgrade = fgrade;
    }
    public Score(int ugrade, int fgrade) {
        super();
        Ugrade = ugrade;
        Fgrade = fgrade;
    }
    public abstract int getScore();
    public int getUgrade() {
        return Ugrade;
    }
    public int getFgrade() {
        return Fgrade;
    }
}
class Examine extends Score{
    public Examine(int fgrade){
        super(fgrade);
    }
    @Override
    public int getScore(){
        return (int)( this.getFgrade());
    }
}
class ExamScore extends Score{
    public ExamScore(int ugrade, int fgrade) {
        super(ugrade, fgrade);
    }
    @Override
    public int getScore(){
        return (int)(this.getUgrade()*0.3 + this.getFgrade()*0.7);
    }
}
class TestScore extends Score{

    public TestScore(int testScores,int num){
        super(testScores,num);
    }
    @Override
    public int getScore(){
        if(this.getFgrade() != 0)
        return this.getUgrade()/this.getFgrade();
        else return 0;
    }
}
class Course implements Comparable<Course> {
    private String lessonName;
    private String lessonAttribute;
    private String testWay;

    ArrayList<Integer> grades = new ArrayList<>();
    ArrayList<Integer> Ugrades = new ArrayList<>();
    ArrayList<Integer> Fgrades = new ArrayList<>();
    public Course(String lessonName) {
        super();
        this.lessonName = lessonName;
    }
    public Course(String lessonName, String lessonAttribute, String testWay) {
        super();
        this.lessonName = lessonName;
        this.lessonAttribute = lessonAttribute;
        this.testWay = testWay;
    }
    public String getLessonName() {return lessonName;}
    public String getLessonAttribute() {
        return lessonAttribute;
    }
    public String getTestWay() {
        return testWay;
    }
    public int getAverageScore() {
        int total = 0;
        for(int i = 0;i < grades.size();i++){
            total = total + grades.get(i);
        }
        if(grades.size() != 0)
        return total/grades.size();
        else return 0;
    }
    public int getAverageUrades() {
        int total = 0;
        for(int i = 0;i < Ugrades.size();i++){
            total = total + Ugrades.get(i);
        }
        if(Ugrades.size() != 0)
        return total/Ugrades.size();
        else return 0;
    }
    public int getAverageFrades() {
        int total = 0;
        for(int i = 0;i < Fgrades.size();i++){
            total = total + Fgrades.get(i);
        }
        if(Fgrades.size() != 0)
        return total/Fgrades.size();
        else return 0;
    }
    @Override
    public int compareTo(Course cou) {
        Comparator<Object> com = Collator.getInstance(Locale.CHINA);
        return ((Collator) com).compare(this.lessonName,cou.getLessonName());
    }
}
class Class1 {
    private String num;
    ArrayList<Student> students = new ArrayList<>();
    public Class1(String num) {
        this.num = num;
    }
    public String getNum() {
        return num;
    }
    public void setNum(String num){
        this.num = num;
    }
    public int getIntNum(){
        return Integer.parseInt(num);
    }
    public int getClassScore(){
        int total = 0;
        for(int i = 0;i < this.students.size();i++){
            total = total +this.students.get(i).getAverageScore();
        }
        if(this.students.size() == 0){
            return 0;
      }
        else return total/this.students.size();
    }
}
 class Selection {
    private Course course;
    private Student student;
    private Score score;
    public Selection(Course course, Student student, Score score) {
        this.course = course;
        this.student = student;
        this.score = score;
        this.student.grades.add(score.getScore());
        this.course.grades.add(score.getScore());
        if(course.getTestWay().equals("考试")){
            this.course.Ugrades.add(score.getUgrade());
            this.course.Fgrades.add(score.getFgrade());
        }
        else if(course.getTestWay().equals("考察")){
            this.course.Fgrades.add(score.getFgrade());
        }
    }
    public Course getCourse() {
        return course;
    }
    public Student getStudent() {
        return student;
    }
    public Score getScore() {
        return score;
    }
}
class Student {
    private String id;
    private String name;
    ArrayList<Integer> grades = new ArrayList<>();
    private int averScore;
    public Student(String id,String name) {
        this.id = id;
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public int getIntId(){
        return Integer.parseInt(id);
    }
    public void setId(String id) {
        this.id = id;
    }
    public int getAverageScore() {
        int total = 0;
       for(int i = 0;i < grades.size();i++){
           total = total + grades.get(i);
       }
       if(grades.size() != 0) {
           this.averScore = total / grades.size();
           return averScore;
       }
       else return 0;
    }
}

类图如下：

 

 

 分析如下：
1.该题是上次作业的课程成绩统计程序题的迭代，所以根据上次做的题目来解决这题就十分轻松。

2.在上次题目的基础上添加一个实验类课程即可，整体难度不大，但容易忽略一些细节，导致无法得到满分。

 

第五次作业

第一题

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

题目如下：

课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，

要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。

完成课程成绩统计程序-2、3两次程序后，比较继承和组合关系的区别。思考一下哪一种关系运用上更灵活，更能够适应变更。

题目最后的参考类图未做修改，大家根据要求自行调整，以下内容加粗字体显示的内容为本次新增的内容。

某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。

考察的总成绩直接等于期末成绩

实验的总成绩等于课程每次实验成绩乘以权重后累加而得。

课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）

必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。

1、输入：

包括课程、课程成绩两类信息。

课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。

考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重

考察课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重

实验次数至少4次，不超过9次

课程性质输入项：必修、选修、实验

考核方式输入选项：考试、考察、实验

考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

考试/考查课程成绩信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝

实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩

以上信息的相关约束：

1）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】

2）学号由8位数字组成

3）姓名不超过10个字符

4）课程名称不超过10个字符

5）不特别输入班级信息，班级号是学号的前6位。

2、输出：

输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。

为避免四舍五入误差，

计算单个成绩时，分项成绩乘以权重后要保留小数位，计算总成绩时，累加所有分项成绩的权重分以后，再去掉小数位。

学生总成绩/整个班/课程平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。

1）学生课程总成绩平均分按学号由低到高排序输出

格式：学号+英文空格+姓名+英文空格+总成绩平均分

如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"

2）单门课程成绩按课程名称的字符顺序输出

课程成绩输出格式：课程名称+英文空格+总成绩平均分

如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"

3）班级所有课程总成绩平均分按班级由低到高排序输出

格式：班级号+英文空格+总成绩平均分

如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"

异常情况：

1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"

2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"

以上两种情况如果同时出现，按第一种情况输出结果。

3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"

4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"

5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

6）如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"

7）如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"

信息约束：

1）成绩平均分只取整数部分，小数部分丢弃

参考类图（与第一次相同，其余内容自行补充）：

输入样例1:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
end

 

输出样例1:

在这里给出相应的输出。例如：

java has no grades yet

 

输入样例2:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2
end

 

输出样例2:

在这里给出相应的输出。例如：

java : number of scores does not match

 

输入样例3:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.1
end

 

输出样例3:

在这里给出相应的输出。例如：

java : weight value error

 

输入样例4:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100
end

 

输出样例4:

在这里给出相应的输出。例如：

20201116 张三 86
java 86
202011 86

 

输入样例5:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100 80
end

 

输出样例5:

在这里给出相应的输出。例如：

20201116 张三 : access mode mismatch
20201116 张三 did not take any exams
java has no grades yet
202011 has no grades yet

 

代码展示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.text.Collator;
import java.util.Comparator;
import java.util.Locale;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        ArrayList<String> inputs = new ArrayList<>();

        String info = input.nextLine();
        while(!info.equals("end")){
            inputs.add(info);
            info = input.nextLine();
        }
        inputs.add(info);
        ArrayList<Course> courses = new ArrayList<>();
        ArrayList<Class1> classes = new ArrayList<>();
        ArrayList<Student> stu = new ArrayList<>();
        ArrayList<Selection> selections = new ArrayList<>();
        ArrayList<WeightScore> weightScores = new ArrayList<>();
        int i,j,k,n,m,q;
        double sum = 0;
        int flag1 = 0;
        for(i = 0;!inputs.get(i).equals("end");i++) {
            ArrayList<Double> weights = new ArrayList<>();
            ArrayList<Integer> grades = new ArrayList<>();
            String[] Info = inputs.get(i).split(" ");
            if (inputs.get(i).matches("([\\u4e00-\\u9fa5]|[\\w]){1,10}\\s(必修|选修|实验)" +
                    "\\s((考试(\\s0\\.[\\d]*[1-9]){2})|(考察)|(实验\\s[4-9](\\s0\\.[\\d]*[1-9])*))")) {
                if (Info[1].equals("必修")) {
                    flag1 = 0;
                    sum = 0;
                    if (Info[2].equals("考察")||Info[2].equals("实验")) {
                        System.out.println(Info[0] + " : course type & access mode mismatch");
                        flag1 = 1;
                    }
                    if(flag1 == 0){
                    for(j = 3;j < Info.length;j++){
                        sum += Double.parseDouble(Info[j]);
                    }
                    if(Math.abs(sum - 1) > 0.0000001 ){
                        System.out.println(Info[0]+" : weight value error");
                        flag1 = 1;
                    }
                    }
                    if (flag1 == 0){
                        if (courses.size() == 0) {
                            Course course = new Course(Info[0], Info[1], "考试");
                            course.weight.add(Double.parseDouble(Info[3]));
                            course.weight.add(Double.parseDouble(Info[4]));
                            courses.add(course);
                        } else {
                            for (j = 0; j < courses.size(); j++) {
                                if (courses.get(j).getLessonName().equals(Info[0])) {
                                    break;
                                }
                            }
                            if (j == courses.size()) {
                                Course course = new Course(Info[0], Info[1], "考试");
                                course.weight.add(Double.parseDouble(Info[3]));
                                course.weight.add(Double.parseDouble(Info[4]));
                                courses.add(course);
                            }
                        }
                    }
                } else if (Info[1].equals("选修")) {
                    if (Info[2].equals("实验")) {
                        System.out.println(Info[0] + " : course type & access mode mismatch");
                    }else{
                        if (courses.size() == 0) {
                            Course course = new Course(Info[0], Info[1], Info[2]);
                            course.weight.add(1.0);
                            courses.add(course);
                        } else {
                            for (j = 0; j < courses.size(); j++) {
                                if (courses.get(j).getLessonName().equals(Info[0])) {
                                    break;
                                }
                            }
                            if (j == courses.size()) {
                                Course course = new Course(Info[0], Info[1], Info[2]);
                                course.weight.add(1.0);
                                courses.add(course);
                            }
                        }
                    }
                }
                else if(Info[1].equals("实验")){
                    flag1 = 0;
                    sum = 0;
                    if(Info[2].equals("考试")||Info[2].equals("考察")){
                        System.out.println(Info[0] + " : course type & access mode mismatch");
                        flag1 = 1;
                    }
                    if(flag1 == 0) {
                        if (Info.length - 4 != Integer.parseInt(Info[3])) {
                            System.out.println(Info[0] + " : number of scores does not match");
                            flag1 = 1;
                        }
                    }
                    if(flag1 == 0) {
                        for (j = 4; j < Info.length; j++) {
                            sum += Double.parseDouble(Info[j]);
                        }
                        if (Math.abs(sum - 1) > 0.0000001 ) {
                            System.out.println(Info[0] + " : weight value error");
                            flag1 = 1;
                        }
                    }
                    if(flag1 == 0){
                        if (courses.size() == 0) {
                            Course course = new Course(Info[0], Info[1], Info[2]);
                            for(j = 4;j < Info.length;j++){
                                course.weight.add(Double.parseDouble(Info[j]));//把权重当作课程的属性
                            }
                            courses.add(course);
                        } else {
                            for (j = 0; j < courses.size(); j++) {
                                if (courses.get(j).getLessonName().equals(Info[0])) {
                                    break;
                                }
                            }
                            if (j == courses.size()) {
                                Course course = new Course(Info[0], Info[1], Info[2]);
                                for(j = 4;j < Info.length;j++){
                                    course.weight.add(Double.parseDouble(Info[j]));
                                }
                                courses.add(course);
                            }
                        }
                    }
                }
            }
            else if(inputs.get(i).matches("[\\d]{8}(\\s([\\u4e00-\\u9fa5]|[\\w]){1,10}){2}(\\s([\\d]{1,2}|100)){1,2}")) {
                for (j = 0; j < classes.size(); j++) {
                    if (classes.get(j).getNum().equals(Info[0].substring(0, 6))) {
                        break;//找到了
                    }
                }
                if (j == classes.size()) {//班级不存在
                    Class1 class1 = new Class1(Info[0].substring(0, 6));
                    classes.add(class1);
                }
                for (k = 0; k < classes.get(j).students.size(); k++) {
                    if (classes.get(j).students.get(k).getId().equals(Info[0])) {
                        break;//学生存在
                    }
                }
                if (k == classes.get(j).students.size()) {//学生不存在
                    Student student = new Student(Info[0], Info[1]);
                    classes.get(j).students.add(student);
                    stu.add(student);
                }
                if (Info.length == 4) {//选修考察

                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {
                        if (courses.get(n).getLessonName().equals(Info[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {
                        System.out.println(Info[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        if (flag == 0) {
                            if (courses.get(n).getTestWay().equals("考察")) {
                                for (m = 0; m < selections.size(); m++) {
                                    if (selections.get(m).getStudent().getId().equals(classes.get(j).students.get(k).getId())
                                            && selections.get(m).getCourse().getLessonName().equals(courses.get(n).getLessonName())) {
                                        break;
                                    }
                                }
                                if (m == selections.size()) {
                                    WeightScore Wscore = new WeightScore(courses.get(n).weight);
                                    Wscore.Cscores.add(Integer.parseInt(Info[3]));
                                    Score examine = new Score(Wscore);
                                    Selection selection = new Selection(courses.get(n), classes.get(j).students.get(k),examine);
                                    selections.add(selection);
                                }
                            }
                            else{
                                System.out.println(classes.get(j).students.get(k).getId() + " " +
                                        classes.get(j).students.get(k).getName() + " : " + "access mode mismatch");
                            }
                        }
                    }
                } else if (Info.length == 5) {//考试
                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {
                        if (courses.get(n).getLessonName().equals(Info[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {
                        System.out.println(Info[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        if(flag == 0) {
                            if (courses.get(n).getTestWay().equals("考试")) {
                                for (m = 0; m < selections.size(); m++) {
                                    if (selections.get(m).getStudent().getId().equals(classes.get(j).students.get(k).getId())
                                            && selections.get(m).getCourse().getLessonName().equals(courses.get(n).getLessonName())) {
                                        break;
                                    }
                                }
                                if (m == selections.size()) {
                                    WeightScore Wscore = new WeightScore(courses.get(n).weight);
                                    Wscore.Cscores.add(Integer.parseInt(Info[3]));
                                    Wscore.Cscores.add(Integer.parseInt(Info[4]));
                                    Score examScore = new Score(Wscore);
                                    Selection selection = new Selection(courses.get(n), classes.get(j).students.get(k), examScore);
                                    selections.add(selection);
                                }
                            }
                            else  {
                                System.out.println(classes.get(j).students.get(k).getId() + " " +
                                        classes.get(j).students.get(k).getName() + " : " + "access mode mismatch");
                            }
                        }
                    }
                }
            }
            else if (inputs.get(i).matches
                    ("[\\d]{8}(\\s([\\u4e00-\\u9fa5]|[\\w]){1,10}){2}(\\s([\\d]{1,2}|100))*")){
                for (j = 0; j < classes.size(); j++) {
                    if (classes.get(j).getNum().equals(Info[0].substring(0, 6))) {
                        break;//找到了
                    }
                }
                if (j == classes.size()) {//班级不存在
                    Class1 class1 = new Class1(Info[0].substring(0, 6));
                    classes.add(class1);
                }
                for (k = 0; k < classes.get(j).students.size(); k++) {
                    if (classes.get(j).students.get(k).getId().equals(Info[0])) {
                        break;//学生存在
                    }
                }
                if (k == classes.get(j).students.size()) {//学生不存在
                    Student student = new Student(Info[0], Info[1]);
                    classes.get(j).students.add(student);
                    stu.add(student);
                }
                    int flag = 0;
                    int testScores = 0;
                    for (n = 0; n < courses.size(); n++) {
                        if (courses.get(n).getLessonName().equals(Info[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {
                        System.out.println(Info[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        if(flag == 0) {
                                if (courses.get(n).getTestWay().equals("实验")&&Info.length - 3 == courses.get(n).weight.size()) {
                                    for (m = 0; m < selections.size(); m++) {
                                        if (selections.get(m).getStudent().getId().equals(classes.get(j).students.get(k).getId())
                                                && selections.get(m).getCourse().getLessonName().equals(courses.get(n).getLessonName())) {
                                            break;
                                        }
                                    }
                                    if (m == selections.size()) {
                                        WeightScore Wscore = new WeightScore(courses.get(n).weight);
                                        for(q = 3;q < Info.length;q++)
                                        Wscore.Cscores.add(Integer.parseInt(Info[q]));
                                        Score testScore = new Score(Wscore);
                                        Selection selection = new Selection(courses.get(n), classes.get(j).students.get(k), testScore);
                                        selections.add(selection);
                                    }
                                } else  {
                                    System.out.println(classes.get(j).students.get(k).getId() + " " +
                                            classes.get(j).students.get(k).getName() + " : " + "access mode mismatch");
                                }
                            }
                    }
            }
            else System.out.println("wrong format");
        }

//排序
        ArrayList<Integer> averScore = new ArrayList<>();
        ArrayList<Integer> gradeSize = new ArrayList<>();
        for(i = 0;i < stu.size();i++){
            averScore.add(stu.get(i).getAverageScore());
            gradeSize.add(stu.get(i).grades.size());
        }

        for(i = 0;i < stu.size()-1;i++){
            String temp;
            int tp;
            for(j = 0;j < stu.size()-1-i;j++) {
                if(stu.get(j + 1).getIntId() < stu.get(j).getIntId()){
                    temp = stu.get(j+1).getId();
                    stu.get(j+1).setId(stu.get(j).getId());
                    stu.get(j).setId(temp);
                    temp = stu.get(j+1).getName();
                    stu.get(j+1).setName(stu.get(j).getName());
                    stu.get(j).setName(temp);
                    tp = averScore.get(j+1);
                    averScore.set(j+1,averScore.get(j));
                    averScore.set(j,tp);
                    tp = gradeSize.get(j+1);
                    gradeSize.set(j+1,gradeSize.get(j));
                    gradeSize.set(j,tp);
                }
            }
        }
        ArrayList<Integer> averGrade = new ArrayList<>();
        Collections.sort(courses);
        for(i = 0;i < courses.size();i++){
            averGrade.add(courses.get(i).getAverageScore());
        }
        for(i = 0;i < stu.size();i++){
            System.out.print(stu.get(i).getId()+" "+stu.get(i).getName()+" ");
            if(gradeSize.get(i)!= 0) {
                System.out.println(averScore.get(i));
            }
            else System.out.println("did not take any exams");
        }
        for(i = 0;i < courses.size();i++) {
            System.out.print(courses.get(i).getLessonName() + " ");
            if (courses.get(i).grades.size() != 0) {
                System.out.println(averGrade.get(i));
            }
            else System.out.println("has no grades yet");
        }
        ArrayList<Integer> classScore = new ArrayList<>();
        for(i = 0;i < classes.size();i++){
            classScore.add(classes.get(i).getClassScore());
        }
        for(i = 0;i < classes.size()-1;i++){
            String temp;
            int tp;
            for(j = 0;j < classes.size()-1-i;j++){
                if(classes.get(j+1).getIntNum() < classes.get(j).getIntNum()){
                    temp = classes.get(j+1).getNum();
                    classes.get(j+1).setNum( classes.get(j).getNum());
                    classes.get(j).setNum(temp);
                    tp = classScore.get(j+1);
                    classScore.set(j+1,classScore.get(j));
                    classScore.set(j,tp);
                }
            }
        }
        for(i = 0;i < classes.size();i++){
            System.out.print(classes.get(i).getNum()+" ");
            if(classScore.get(i) != 0)
                System.out.println(classScore.get(i));
            else System.out.println("has no grades yet");
        }
//        for(i = 0;i < courses.size();i++) {
//            System.out.println(courses.get(i).getLessonName());
//            System.out.println(courses.get(i).getLessonAttribute());
//        }
    }
}
class WeightScore {
    ArrayList<Integer> Cscores = new ArrayList<>();
    ArrayList<Double> weights = new ArrayList<>();
    public WeightScore() {
    }
    public WeightScore(ArrayList<Double> weights) {
        this.weights = weights;
    }
    public WeightScore(ArrayList<Integer> cscores, ArrayList<Double> weights) {
        Cscores = cscores;
        this.weights = weights;
    }
}
class Score {
    private WeightScore weightScore;
    public Score(WeightScore weightScore){
        this.weightScore = weightScore;
    }
    public int getScore(){
        double totalScore = 0;
        for(int i = 0;i < weightScore.weights.size();i++){
            totalScore += weightScore.weights.get(i) * weightScore.Cscores.get(i);
        }
        return (int)totalScore;
    }
}
class Selection {
    private Course course;
    private Student student;
    private Score score;
    public Selection(Course course, Student student, Score score) {
        this.course = course;
        this.student = student;
        this.score = score;
        this.student.grades.add(score.getScore());
        this.course.grades.add(score.getScore());
    }
    public Course getCourse() {
        return course;
    }
    public Student getStudent() {
        return student;
    }
    public Score getScore() {
        return score;
    }
}
class Student {
    private String id;
    private String name;
    ArrayList<Integer> grades = new ArrayList<>();

    private int averScore;
    public Student(String id,String name) {
        this.id = id;
        this.name = name;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public int getIntId(){
        return Integer.parseInt(id);
    }
    public void setId(String id) {
        this.id = id;
    }
    public int getAverageScore() {
        int total = 0;
       for(int i = 0;i < grades.size();i++){
           total = total + grades.get(i);
       }
       if(grades.size() != 0) {
           this.averScore = total / grades.size();
           return averScore;
       }
       else return 0;
    }
}
class Course implements Comparable<Course> {
    private String lessonName;
    private String lessonAttribute;//课程属性
    private String testWay;//必修课可以没有

    ArrayList<Integer> grades = new ArrayList<>();
    ArrayList<Double> weight = new ArrayList<>();
    public Course(String lessonName) {
        super();
        this.lessonName = lessonName;
    }
    public Course(String lessonName, String lessonAttribute, String testWay) {
        super();
        this.lessonName = lessonName;
        this.lessonAttribute = lessonAttribute;
        this.testWay = testWay;
    }

    public String getLessonName() {return lessonName;}
    public String getLessonAttribute() {
        return lessonAttribute;
    }
    public String getTestWay() {
        return testWay;
    }
    public int getAverageScore() {
        int total = 0;
        for(int i = 0;i < grades.size();i++){
            total = total + grades.get(i);
        }
        if(grades.size() != 0)
        return total/grades.size();
        else return 0;
    }
    @Override
    public int compareTo(Course cou) {
        Comparator<Object> com = Collator.getInstance(Locale.CHINA);
        return ((Collator) com).compare(this.lessonName,cou.getLessonName());  //升序
    }
}
class Class1 {
    private String num;//班号
    ArrayList<Student> students = new ArrayList<>();
    public Class1(String num) {
        this.num = num;
    }
    public String getNum() {
        return num;
    }
    public void setNum(String num){
        this.num = num;
    }

    public int getIntNum(){
        return Integer.parseInt(num);
    }
    public int getClassScore(){
        int total = 0;
        for(int i = 0;i < this.students.size();i++){
            total = total +this.students.get(i).getAverageScore();
        }
        return total/this.students.size();
    }
}

 

 

 

分析如下：

1.该题为课程成绩统计程序-2的迭代，该题在上次题目的基础上改变了类间的关联关系，将继承关系改为了组合关系。

2.从类图和分析图可以看出来，这次题目的复杂度其实不高，有了上次题目的基础，这题就不算难题了。

3.这题比较注重细节，想要拿到满分十分困难，对学生找错误的能力有很高的要求。

 

（3）踩坑心得

第七次作业

7-1 菜单计价程序-5

分析如下：
由于在这题出现之前，我已经做过了菜单计价程序-3和菜单计价程序-4，所以即使看到这么长的题目也觉得没什么。

而且有了前两次的教训，我打起了十二分精神来应对这题。由于这题是菜单计价程序-3的迭代，所以我打算先根据菜单

计价程序-3编写，然后再根据菜单计价程序-5添加额外的东西。有了前两次的踩坑经验，这次题目终于有了头绪，最后

得到了83分

 第八次作业

7-1 课程成绩统计程序-1

分析如下：

这次作业在逻辑上和上次题目有许多相似之处，但仍然有许多坑

这次的坑主要是正则表达式

修改前：

 

 起初我以为在正则表的式中"."可以代表汉字，后来才明白"."可以代表任意字符，所以他无法代表汉字，后来才意识到这一点，

于是我上网搜索，这才得知汉字有特有的表达方式。

修改后：

 起初没有注意到这道题的代码长度限制，于是在命名方面十分随意，导致代码的长度超出限制

 后来为了减少代码长度，不得已删除了许多注释，缩减了许多名字的长度。

例如：

修改前：

 修改后：

缩短了这个数组的名字长度

 

 第九次作业

7-1 统计Java程序中关键词的出现次数

分析如下：

改进前：

起初我想要将一些没用的数学符号转化成空格，于是我采取了最笨的方法，一个一个换，但成绩不理想

 

 改进后

 

 直接使用正则表达式中的\\W代表所有的除了字母和数字外的字符。

第十次作业

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

分析如下：
这题是上次作业的迭代，只需要添加一些简单的东西即可。

但我认为这次题目的测试点过少，导致许多人虽然没有注意到一些错误的点仍然能够得到满分。

例如：

当输入

 会输出

然而按照题目要求，java课是实验，而实验课的实验次数只能是4~9否则一律输出wrong format。

正确输出

 

第十一次作业

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

改进前：

 

改进之前我没有意识到double型的计算并不精准，不能直接用等号判断是否等于1，在一次测试中我让程序输出每次的sum值，

当我输入0.2，0.3，0.3，0.2时他们的和sum输出1.00000002，这才意识到这里有问题。

改进后：

 

 在意识到这点错误后，我进行了修改将 sum != 1改成了 Math.abs(sum - 1) > 0.0000001。

 （4）改进建议：

7-3 课程成绩统计程序-3 

还是要多注重语法细节，很多时候总是会忘记一些十分重要的语法细节，比如忘记double型的数字计算不精确，

还有就是对一些常用类型的方法运用不够熟练。

 

 7-1 统计Java程序中关键词的出现次数

需要加强对常用类型的认识和理解，对ArrayList和String运用不够熟练，不如不了解ArrayList型如何用set方法修改内容，不知道如何使用String类型的replace和

repalceAll方法替换字符串的特定字符。

 

7-1 菜单计价程序-5

应该注重对正则表式的运用和掌握，在这几次作业中能明显感受到正则表的式的作用十分强大，相信在之后的学习中，

正则表达式的使用将越来越频繁，但在这几次作业中我也认识到自己对正则表达使得掌握和理解还不够，特别是在匹配

长语句的时候。

 

7-1课程成绩统计程序-1

需要加深对类间关系的理解和认识，这次题目提供了类图给我们参考，要求我们根据类图编写程序，但看到题目给的类图后，

我发现我更加没有头绪了，我对题目给出的描述的理解和对类图的理解无法一一对应，但在我的认真思索下，我最终看懂了

这个类图的真正含义，捋清楚了各个类间的关系。

 

（5）总结

经过这几周的学习，我对面向对象编程有了更加深入的了解和认识，这几周不光学习了书本上的内容比如javaFx，还学习了许多课本外的

东西比如Stack，Queue和Map。除此之外，还进行了翻转课堂互动。在这几周的学习中，我学习了许多东西。（1）我学会了如何使用接口，

在课堂上，老师让我们写过一些和接口有关的题目，在这几次作业中，也出现了很多接口，我也通过作业的练习掌握了这一重要内容，其中

Comparable接口尤为重要，在几次练习过后，我也掌握了。（2）我学会了如何和使用javaFX，首先需要让自己的IDE能够运行javaFX的代码，

起初我使用的是Eclipse，但要让这个IDE能够运行javaFX的代码十分困难，所以我转向了idea这款软件，无需安装其他东西，就能运行javaFx的

代码。经过了实验和翻转课堂，我也基本掌握了javaFX的使用。（3）Stack,Queue,Map，在后几周的学习中，我们主要学习这一部分书本上没有

的内容，所以我学习这部分内容的主要途径是老师讲解和网络资源，老师并不要求我们掌握这部分的内部原理，只需要我们能够基本掌握如何使用

就行，完成了老师布置的课堂作业和PTA上的编程题后，我也逐步掌握了这部分内容。

 

2.第二部分

我认为这门课程的教学模式和教学理念等大体上来说都是不错的，但仍然存在许多不足。在教学过程中，主要是用PTA作业进行练习，驱动学生去提高

自己的代码能力，在我看来这是不错的一种方式，但问题是学生的确能够认识到自己存在问题，但无法解决自己的问题，甚至不知道问题出在哪里。在一次

作业以后，学生会慢慢忘记上次题目中出现过问题，这个问题始终无法解决。就比如在后几次作业中总会出现几个测试点无法通过，下次作业碰到这个测试点

仍然无法通过，所以我还是希望老师在题目集关闭后能够在课堂上讲解一下题目集中大家错误比较多的题目，以便学生更正自己的错误。对于教学方法，我认为

在课堂上边讲边练是一种十分高效的学习方法，看着书本上的代码，远没有自己敲代码记忆深刻，在敲代码的过程中能认识到自己许多错误。就比如雨刷这个例子，

我在课堂上跟着老师敲了一遍，记忆十分深刻，后续老师布置的题目，也迎刃而解。