面向对象程序设计第三次bolg

前言

本次博客针对面向对象程序设计的课程所发的PTA作业7，8以及期末考试中的面向对象编程题的分析和总结，重点介绍课程成绩统计程序系列题目以及期末考试的编程题。

PTA第七次作业

在这次作业中7-1、7-2内容和考点相同，在此我分析一下7-2Hashmap的排序这个问题。

7-2 容器-HashMap-排序

分数 10

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

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

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

姓名可能会存在重复。

要求：使用HashMap存储学生信息。

输入格式:

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

以“end”为输入结束标志

输出格式:

按学号从大到小的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+成绩

输入样例:

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

20201124 张少军 83
20201136 李四 78
20201118 郑觉先 80
end

输出样例:

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

20201136 李四 78
20201124 张少军 83
20201118 郑觉先 80
这道题目的考点在于Hashmap容器的使用以及排序函数的使用，我的源代码如下：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        HashMap<String,String> hashMap = new HashMap<String,String>();
        while(true)
        {
            String str  =  input.nextLine();
            if(str.equals("end"))
            {
                break;
            }
            String str1[] = str.split(" ");
            String no = str1[0];
            String name = str1[1];
            String grade = str1[2];
            hashMap.put(no,name+" "+grade);
        }
        List<String> studentIds = new ArrayList<>(hashMap.keySet());

        // 按学号从大到小排序
        Collections.sort(studentIds, (s1, s2) -> Integer.parseInt(s2) - Integer.parseInt(s1));

        // 输出学生信息
        for (String studentId : studentIds) {
            String studentInfo = hashMap.get(studentId);
            System.out.println(studentId + " " + studentInfo);
        }
    }
}

　　本次的代码较短且复杂度很低，在此不赘述其类图以及圈复杂度分析。

这次作业中难度较大的是课程成绩统计程序-2，下面是这道题目的介绍和分析。

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

分数 60

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

课程成绩统计程序-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

这个题目是课程成绩统计程序-1的升级，添加了实验课的部分，修改了一部分输入输出以及错误的输出，总体来说相比较第一次改动不大，以下是我的代码：

import java.util.*;
import java.text.Collator;
class Crouse{
    String name;
    String nature;
    String fangshi;
    ArrayList<Integer> pgrade = new ArrayList<>();
    ArrayList<Integer> qgrade = new ArrayList<>();
  ArrayList<Integer> grade = new ArrayList<>();
    public Crouse(String name, String nature, String fangshi) {
        this.name = name; // 将参数赋值给成员变量
        this.nature = nature; // 将参数赋值给成员变量
        this.fangshi = fangshi; // 将参数赋值给成员变量
    }
    public int average()
    {
        int total=0;
        for (int i:grade)
        {
            total+=i;
        }
        return total/grade.size();
    }
    public int average1()
    {
        int total=0;
        for (int i:pgrade)
        {
            total+=i;
        }
        return total/pgrade.size();
    }
    public int average2()
    {
        int total=0;
        for (int i:qgrade)
        {
            total+=i;
        }
        return total/qgrade.size();
    }

}
class Student {
    String id;
    String name;
    HashMap<String,Integer> crouse;
    public Student(String id, String name) {
        this.id = id; // 将参数赋值给成员变量
        this.name = name; // 将参数赋值给成员变量
        this.crouse = new HashMap<>();
    }
    public int averagegrade()
    {
        int total=0;
        for (Integer grade:crouse.values()) {
            total += grade;
        }
        return total/ crouse.size();
    }
}
class Class{
    String cid;
    ArrayList<Student> students = new ArrayList<>();
    public Class(String cid)
    {
        this.cid=cid;
    }
    public int average()
    {
        int total=0;
        for (Student s:students)
        {
            total+=s.averagegrade();
        }
        return total/students.size();
    }
}
class Holder{
    ArrayList<Crouse> clist = new ArrayList<>();
    ArrayList<Student> slist = new ArrayList<>();
    ArrayList<Class> Clist = new ArrayList<>();

    public Crouse searth(String name)
    {
        int falg =0;
        int i;
        for ( i = 0; i < clist.size(); i++) {
            if(clist.get(i).name.equals(name))
            {
                falg++;
                break;
            }
        }
        if(falg!=0)
        {
            return clist.get(i);
        }
        else return null;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Holder holder = new Holder();
        while (true) {
            try {
                String str = input.nextLine();
                if (str.equals("end")) {
                    break;
                }
                String[] str1 = str.split(" ");
                if (str1.length == 3) {
                    if (str1[1].equals("必修")) {
                        if (str1[2].equals("考试")) {
                            String name = str1[0];
                            String nature = str1[1];
                            String fangshi = str1[2];
                            Crouse crouse = null;
                            for (Crouse c:holder.clist)
                            {
                                if(c.name.equals(name)) {
                                    crouse = c;
                                    break;
                                }
                            }
                            if(crouse==null) {
                                crouse = new Crouse(name, nature, fangshi);
                                holder.clist.add(crouse);
                            }
                        } else {
                            System.out.println(str1[0] + " : course type & access mode mismatch");
                        }
                    } else if (str1[1].equals("选修")) {
                        if (str1[2].equals("考试")) {
                            String name = str1[0];
                            String nature = str1[1];
                            String fangshi = str1[2];
                            Crouse crouse = null;
                            for (Crouse c:holder.clist)
                            {
                                if(c.name.equals(name)) {
                                    crouse = c;
                                    break;
                                }
                            }
                            if(crouse==null) {
                                crouse = new Crouse(name, nature, fangshi);
                                holder.clist.add(crouse);
                            }
                        } else if (str1[2].equals("考察")) {
                            String name = str1[0];
                            String nature = str1[1];
                            String fangshi = str1[2];
                            Crouse crouse = null;
                            for (Crouse c:holder.clist)
                            {
                                if(c.name.equals(name)) {
                                    crouse = c;
                                    break;
                                }
                            }
                            if(crouse==null) {
                                crouse = new Crouse(name, nature, fangshi);
                                holder.clist.add(crouse);
                            }
                        } else {
                            System.out.println(str1[0] + " : course type & access mode mismatch");
                        }
                    } else if (str1[1].equals("实验")) {
                        if (str1[2].equals("实验")) {
                            String name = str1[0];
                            String nature = str1[1];
                            String fangshi = str1[2];
                            Crouse crouse = null;
                            for (Crouse c:holder.clist)
                            {
                                if(c.name.equals(name)) {
                                    crouse = c;
                                    break;
                                }
                            }
                            if(crouse==null) {
                                crouse = new Crouse(name, nature, fangshi);
                                holder.clist.add(crouse);
                            }
                        } else {
                            System.out.println(str1[0] + " : course type & access mode mismatch");
                        }
                    }
                } else if (str1.length == 4)//选修，考察
                {
                    if (Integer.parseInt(str1[3]) > 0 && Integer.parseInt(str1[3]) < 100) {
                        if (holder.searth(str1[2]) != null) {
                            String stuid = str1[0];
                            String sname = str1[1];
                            if (holder.searth(str1[2]).nature.equals("选修")) {
                                Student student = null;
                                for (Student s:holder.slist)
                                {
                                    if(s.name.equals(sname))
                                    {
                                        student = s;
                                        break;
                                    }
                                }
                                String cid = stuid.substring(0, 6);
                                Class cla = null;
                                for (Class c : holder.Clist) {
                                    if (c.cid.equals(cid)) {
                                        cla = c;
                                        break;
                                    }
                                }
                                if (cla == null) {
                                    cla = new Class(cid);
                                    holder.Clist.add(cla);
                                }
                                if(student==null) {
                                    student = new Student(stuid,sname);
                                    student.crouse.put(str1[2], Integer.parseInt(str1[3]));
                                    cla.students.add(student);
                                    holder.slist.add(student);
                                    holder.searth(str1[2]).grade.add(Integer.parseInt(str1[3]));
                                }
                                else {
                                    student.crouse.put(str1[2], Integer.parseInt(str1[3]));
                                    holder.searth(str1[2]).grade.add(Integer.parseInt(str1[3]));
                                }
                            } else
                                System.out.println(stuid + " " + sname + " " + ": access mode mismatch");
                        } else
                            System.out.println(str1[0] + " " + str1[1] + " " + ":" + str1[2] + " " + "does not exist");
                    } else System.out.println("wrong format");
                } else if (str1.length == 5)//必修或选修考试
                {
                    if (holder.searth(str1[2]) != null) {
                        String stuid = str1[0];
                        String sname = str1[1];
                        int grade = (int) (Integer.parseInt(str1[3]) * 0.3 + Integer.parseInt(str1[4]) * 0.7);
                        Student student = null;
                        for (Student s:holder.slist)
                        {
                            if(s.name.equals(sname))
                            {
                                student = s;
                                break;
                            }
                        }

                        String cid = stuid.substring(0, 6);
                        Class cla = null;
                        for (Class c : holder.Clist) {
                            if (c.cid.equals(cid)) {
                                cla = c;
                                break;
                            }
                        }
                        if (cla == null) {
                            cla = new Class(cid);
                            holder.Clist.add(cla);
                        }
                        if(student==null) {
                            student = new Student(stuid,sname);
                            student.crouse.put(str1[2], grade);
                            cla.students.add(student);
                            holder.slist.add(student);
                            holder.searth(str1[2]).grade.add(grade);
                            holder.searth(str1[2]).pgrade.add(Integer.parseInt(str1[3]));
                            holder.searth(str1[2]).qgrade.add(Integer.parseInt(str1[4]));
                        }
                        else {
                            student.crouse.put(str1[2], grade);
                            holder.searth(str1[2]).grade.add(grade);
                            holder.searth(str1[2]).pgrade.add(Integer.parseInt(str1[3]));
                            holder.searth(str1[2]).qgrade.add(Integer.parseInt(str1[4]));
                        }
                    } else
                        System.out.println(str1[0] + " " + str1[1] + " " + ":" + str1[2] + " " + "does not exist");
                } else if (Integer.parseInt(str1[3]) > 3 && Integer.parseInt(str1[3]) < 10)//实验
                {
                    int num = Integer.parseInt(str1[3]);
                    int falg = 0;
                    for (int i = 4; i < str1.length; i++) {
                        if (Integer.parseInt(str1[i]) < 0 || Integer.parseInt(str1[i]) > 100)
                            falg++;
                    }
                    if (falg == 0) {
                        if (holder.searth(str1[2]) != null) {
                            String stuid = str1[0];
                            String sname = str1[1];
                            int grade = 0;
                            if (str1.length == 4 + num) {
                                for (int i = 4; i < 4 + num; i++) {
                                    grade += Integer.parseInt(str1[i]);
                                }
                                grade = grade / 4;
                                Student student = null;
                                for (Student s:holder.slist)
                                {
                                    if(s.name.equals(sname))
                                    {
                                        student = s;
                                        break;
                                    }
                                }
                                String cid = stuid.substring(0, 6);
                                Class cla = null;
                                for (Class c : holder.Clist) {
                                    if (c.cid.equals(cid)) {
                                        cla = c;
                                        break;
                                    }
                                }
                                if (cla == null) {
                                    cla = new Class(cid);
                                    holder.Clist.add(cla);
                                }
                                if(student==null) {
                                    student = new Student(stuid,sname);
                                    student.crouse.put(str1[2], grade);
                                    cla.students.add(student);
                                    holder.slist.add(student);
                                    holder.searth(str1[2]).grade.add(grade);
                                }
                                else {
                                    student.crouse.put(str1[2], grade);
                                    holder.searth(str1[2]).grade.add(grade);
                                }
                            } else {
                                Student student = new Student(stuid, sname);
                                String cid = stuid.substring(0, 6);
                                Class cla = null;
                                for (Class c : holder.Clist) {
                                    if (c.cid.equals(cid)) {
                                        cla = c;
                                        break;
                                    }
                                }
                                if (cla == null) {
                                    cla = new Class(cid);
                                    holder.Clist.add(cla);
                                }
                                holder.slist.add(student);
                                System.out.println(stuid + " " + sname + " " + ": access mode mismatch");
                            }
                        } else
                            System.out.println(str1[0] + " " + str1[1] + " " + ":" + str1[2] + " " + "does not exist");
                    } else System.out.println("wrong format");
                } else
                    System.out.println("wrong format");
            }
            catch (NumberFormatException e)
            {
                System.out.println("wrong format");
            }
        }

        holder.slist.sort(Comparator.comparing(s -> s.id));
        for(Student student:holder.slist)
        {
            if(student.crouse.isEmpty())
            {
                System.out.println(student.id+" "+student.name+" "+"did not take any exams");
            }
            else  System.out.println(student.id+" "+student.name+" "+student.averagegrade());
        }

        Collator collator = Collator.getInstance();
        holder.clist.sort(Comparator.comparing(c -> c.name, collator));
        for(Crouse crouse:holder.clist)
        {
            if(crouse.grade.isEmpty())
            {
                System.out.println(crouse.name+" "+"has no grades yet");
            }
            else if(crouse.nature.equals("选修")&&crouse.fangshi.equals("考察"))
                System.out.println(crouse.name+" "+crouse.average()+" "+crouse.average());
            else if(crouse.nature.equals("选修")&&crouse.fangshi.equals("考试"))
                System.out.println(crouse.name+" "+crouse.average1()+" "+crouse.average2()+" "+crouse.average());
            else if(crouse.nature.equals("必修"))
                System.out.println(crouse.name+" "+crouse.average1()+" "+crouse.average2()+" "+crouse.average());
            else if(crouse.nature.equals("实验"))
                System.out.println(crouse.name+" "+crouse.average());
        }
        holder.Clist.sort(Comparator.comparing(c -> c.cid));
        for(Class c:holder.Clist)
        {
            int falg=0;
            for (Student s: c.students)
            {
                if(s.averagegrade()==0)
                {
                    falg++;
                }
            }
            if(falg==c.students.size())
            {
                System.out.println(c.cid+" "+ "has no grades yet");
            }
            else
                System.out.println(c.cid+" "+c.average());
        }
    }
}

　　Crouse类表示课程，包含课程名称、课程性质、考核方式以及成绩列表。Student类表示学生，包含学号、姓名和课程成绩的映射关系。Class类表示班级，包含班级号和学生列表。我用了一个holder类储存课程链表、成绩链表、以及班级链表，进而在Main类中通过循环输出课程的平均成绩、学生的平均成绩、班级的平均成绩以及对无成绩的情况输出。

该代码的类图如下：

 

用source moniter分析圈复杂度情况如下：

从圈复杂度以及代码深度分析图可以看出，我的代码最大复杂性为91，平均复杂度为10.90，根据基维亚特图可以看出我的代码复杂度较高，平均运行时间长。

 

PTA第八次作业

 

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

分数 64

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

课程成绩统计程序-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

这道题目是对课程成绩统计程序-2的升级，主要添加了实验课的成绩权重部分，将原来的平均模式改为了加权平均算法，并且改成了在课程信息中输入实验次数及权重，修改
了一部分输入输出以及错误的输出。
我的代码如下：

import java.util.*;
import java.text.*;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Input_Format inputFormat = new Input_Format();//输入
        Output_Format outputFormat = new Output_Format();//输出
        Data_storage data_storage = new Data_storage();
        while (inputFormat.isEnd){
            String inputLine = scanner.nextLine();
            if(inputLine.equals("end")){
                inputFormat.isEnd = false;
                break;
            }
            inputFormat.inputProcessing(inputLine,data_storage);
        }
        PersonOverride student1 = new PersonOverride();
        outputFormat.outputProcessing(data_storage);
        outputFormat.output_all(data_storage);
    }
}
class Calculate_grades {
    int stu_all_grades(Data_storage data_storage,String num){//单个学生总课程平均分计算  返回一个分数 1)
        int count =0;//这个学生有几门课
        int sum = 0;
        for (Map.Entry<String, Score> entry : data_storage.stu__st_cour.get(num).gradeMap.entrySet()) {
            Score value = entry.getValue();
            if(Integer.parseInt(value.total_scores)>=0) {
                count++;
                sum += Integer.parseInt(value.total_scores);
            }
        }
        if(count!=0)
            return sum/count;
        else
            return -100;//没有参加任何考试
    }
    int[] single_course_grades(Data_storage data_storage,String name){ //2) 课程名
        int count = 0;
        int[] aver_grade = new int[3];//0：平时成绩 1：期末考试 2：总分平均
        for (Map.Entry<String, StudentsAll_mes> e : data_storage.stu__st_cour.entrySet()) {//遍历选课类:num-选课类
            StudentsAll_mes value = e.getValue();
            for (Map.Entry<String, Score> entry : value.gradeMap.entrySet()) {//遍历选课类:course.name-Score
                String key1 = entry.getKey();
                Score value1 = entry.getValue();
                if (key1.equals(name)) {
                    if(Integer.parseInt(value1.total_scores)>=0) {//总分为- 说明算成绩无效
                        count++;
                        aver_grade[2] += Integer.parseInt(value1.total_scores);
                        if (value1 instanceof Test_Score) {
                            if (Integer.parseInt(value1.total_scores) >= 0) {
                                aver_grade[0] += Integer.parseInt(((Test_Score) value1).normal_score);
                                aver_grade[1] += Integer.parseInt(((Test_Score) value1).end_score);
                            }
                        } else if (value1 instanceof Inspect_Score){
                            if (Integer.parseInt(value1.total_scores) >= 0) {
                                aver_grade[0] = -100;//不需要平时成绩
                                aver_grade[1] += Integer.parseInt(((Inspect_Score) value1).end_score);
                            }
                        }else if(value1 instanceof Lab_Score){
                            if(Integer.parseInt(value1.total_scores)>=0){
                                aver_grade[0] = -100;
                                aver_grade[1] += aver_grade[1] += Integer.parseInt(value1.total_scores);
                            }
                        }
                    }
                }
            }
        }
        if(count!=0) {
            for (int i = 0; i < 3; i++) {
                aver_grade[i] = aver_grade[i] / count;
            }
        }else {
            for (int i = 0; i < 3; i++) {
                aver_grade[i] = -100;
            }
        }
        return aver_grade;
    }
    int Class_grades(Data_storage data_storage,String num){//3)
        int sum = 0;
        int count = 0;
        for (Map.Entry<String, Student> mapEntry : data_storage.classes.get(num).students.entrySet()) {//班级号-Student类
            Student value = mapEntry.getValue();//遍历这个班级的所有学生
            for (Map.Entry<String, StudentsAll_mes> e : data_storage.stu__st_cour.entrySet()) {//stu_num-选课类
                String key1 = e.getKey();//遍历学生的选课类 学号
                StudentsAll_mes value1 = e.getValue();
                if (key1.equals(value.num)) {//选课类中 跟输入的学号一样
                    for (Map.Entry<String, Score> entry : value1.gradeMap.entrySet()) {//该num所有成绩遍历
                        Score gra = entry.getValue();
                        if(Integer.parseInt(gra.total_scores)>=0) {//有效才算
                            sum += Integer.parseInt(gra.total_scores);
                            count++;
                        }
                    }
                }
            }
        }
        if(count!=0)
            return sum/count;
        else
            return -100;
    }
    void final_score(Data_storage data_storage,String num){//计算没门课的成绩 学号
        data_storage.stu__st_cour.get(num).gradeMap.forEach((key,value)->{//学号  成绩
            if(value instanceof Test_Score&&((Test_Score) value).normal_score.matches("\\d+")&&((Test_Score) value).end_score.matches("\\d+")) {
                double tem = ((Test_Course) data_storage.courses.get(key)).normal_weight*Integer.parseInt(((Test_Score) value).normal_score);
                double tem1 = ((Test_Course) data_storage.courses.get(key)).end_weight*Integer.parseInt(((Test_Score) value).end_score);
                value.total_scores = String.valueOf((int)(tem+tem1));
            }else if(value instanceof Inspect_Score&&((Inspect_Score) value).end_score.matches("\\d+")){
                value.total_scores = ((Inspect_Score) value).end_score;
            }else if(value instanceof Lab_Score&&((Lab_Score) value).lab_num.matches("\\d+")){
                float sum = 0;
                int i=0;
                for (Integer score : ((Lab_Score) value).scores) {
                    sum+= score* ((Lab_Course) data_storage.courses.get(key)).weights.get(i);
                    i++;
                }
                value.total_scores = String.valueOf((int)sum);
            }
        });
    }
}
class PersonOverride {
    private String name;
    private int age;
    private boolean gender;

    public PersonOverride() {
        this("default", 1, true);
    }

    public PersonOverride(String name, int age, boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    @Override
    public String toString() {
        return name + "-" + age + "-" + gender;
    }
}
class Class {
    String num;
    TreeMap<String, Student> students = new TreeMap<>(); //班级里的学生 学号 学生
    Class(String num){
        this.num = num;
    }
}
class Course {
    String type;
    String test_way;
    String name;
    Course(String name,String type, String test_way){
        this.type = type;
        this.name = name;
        this.test_way = test_way;
    }
}
class Inspect_Course extends Course{
    Inspect_Course(String name, String type, String test_way) {
        super(name, type, test_way);
    }
}

class Test_Course extends Course{
    double normal_weight;
    double end_weight;

    Test_Course(String name, String type, String test_way,String normal_weight,String end_weight) {
        super(name, type, test_way);
        this.normal_weight = Float.parseFloat(normal_weight);
        this.end_weight = Float.parseFloat(end_weight);
    }
}
class Lab_Course extends Course{
    int sub_scores_num;
    ArrayList<Float> weights = new ArrayList<>();
    Lab_Course(String name, String type, String test_way,String line) {
        super(name, type, test_way);
        String[] lines = line.split(" ");
        sub_scores_num = Integer.parseInt(lines[3]);
        for(int i=4;i<lines.length; i++){
            weights.add(Float.parseFloat(lines[i]));
        }
    }
}
class Data_storage {
    TreeMap<String , Course> courses;//课程  k：课程名 v:课程
    TreeMap<String, Class> classes = new TreeMap<>();//班级 k:班级号V:班级
    TreeMap<String, StudentsAll_mes> stu__st_cour;//选课类学生类结合 k:学号 v:选课类
    InAndOut_put output = new InAndOut_put();
    Data_storage(){
        //学生和选课类结合
        stu__st_cour = new TreeMap<>(Data_storage::compare);//重写排序
        courses = new TreeMap<>(Data_storage::compare);
    }

    private static int compare(String o1, String o2) {

        try {
            Comparator<Object> comparator = Collator.getInstance(Locale.CHINA);
            if (comparator.compare(o1, o2) < 0) {
                return -1;
            } else if (comparator.compare(o1, o2) > 0) {
                return 1;
            }
        } catch (Exception ignored) {
        }
        return 0;
    }

    void setInspectCourses(String name, String type, String test_way){
        if(!courses.containsKey(name)) {
            courses.put(name, new Inspect_Course(name, type, test_way));
        }
    }
    void setTestCourses(String name, String type, String test_way,String normal_weight, String end_weight){
        if(!courses.containsKey(name)) {
            courses.put(name, new Test_Course(name, type, test_way,normal_weight, end_weight));
        }
    }
    void setLabCourses(String name, String type, String test_way,String line){
        if(!courses.containsKey(name)) {
            courses.put(name, new Lab_Course(name, type, test_way,line));
        }
    }
    void setClasses(String num){
        if(!classes.containsKey(num)) {
            classes.put(num, new Class(num));
        }
    }
    void setStudents(String clas_num, String name, String num){//班级号 姓名 学号
        if(classes.containsKey(clas_num)){
            if(!classes.get(clas_num).students.containsKey(num))
                classes.get(clas_num).students.put(num,new Student(name,num));
        }
    }
    void setStu__st_courAndMap(String num,String course,String normal_score,String end_score){//添加选课类  学生姓名 课程名称 分数
        if(!stu__st_cour.containsKey(num)){
            stu__st_cour.put(num,new StudentsAll_mes(num,course,normal_score,end_score));
        }
        else{
            stu__st_cour.get(num).setGradeMap(course,normal_score,end_score);
        }
    }
    void setStu__st_courAndMap(String num,String course,String end_score){
        if(!stu__st_cour.containsKey(num)){
            stu__st_cour.put(num,new StudentsAll_mes(num,course,end_score));
        }
        else{
            stu__st_cour.get(num).setGradeMap(course,end_score);
        }
    }
    void set_lab_grades(String stu_num,String course,String lab_num,String grades){
        ArrayList<Integer> scores = new ArrayList<>();
        String[] tem = grades.split(" ");
        for(int i=3;i<tem.length;i++){
            if(tem[i].matches("\\d+"))
                scores.add(Integer.parseInt(tem[i]));
        }
        if(!stu__st_cour.containsKey(stu_num)){
            StudentsAll_mes tem_stu_mes = new StudentsAll_mes();
            tem_stu_mes.set_lab_stu_mes(stu_num,course,lab_num,scores);
            stu__st_cour.put(stu_num,tem_stu_mes);
        }else{
            stu__st_cour.get(stu_num).set_lab_gradeMap(course,lab_num,scores);
        }
    }
}
class Input_Format {
    String regex_c_test = "^[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s(必修|选修)\\s考试\\s((0.\\d{1,2})|(1-9?))\\s((0.\\d{1,2})|(1-9?))$";
    String regex_c_inspect = "[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s选修\\s考察$";
    String regex_c_lab = "^[\\u4e00-\\u9fa5a-zA-Z0-9 ]{1,10}\\s实验\\s实验\\s[4-9]\\s((0.\\d{1,2})|(1-9?))(\\s((0.\\d{1,2})|(1-9?))){3,9}$";
    String regex_CS = "^\\d{8}\\s+[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s+[\\u4E00-\\u9FA5A-Za-z0-9]{1,10}\\s*((100)|(\\d{1,2})|(0))?\\s+((100)|(\\d{1,2})|(0))$";
    String regex_lab = "^\\d{8}\\s[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s[\\u4e00-\\u9fa5a-zA-Z0-9 ]{1,10}\\s((100)|([1-9]\\d)|\\d)(\\s((100)|([1-9]\\d)|\\d)){2,9}$";
    boolean isEnd = true;//结束标志
    String[] strings;
    void inputProcessing(String line,Data_storage data_storage) {
        lineProcessing(line);//分割
        data_storage.output.add_input(line);//存储
        if(line.matches(regex_c_inspect)){
            data_storage.setInspectCourses(strings[0],strings[1],strings[2]);
        }else if(line.matches(regex_c_lab)){
            data_storage.setLabCourses(strings[0],strings[1],strings[2],line);
        }else if(line.matches(regex_c_test)){
            data_storage.setTestCourses(strings[0],strings[1],strings[2],strings[3],strings[4]);//成绩信息
        } else if(line.matches(regex_CS)||line.matches(regex_lab)){
            data_storage.setClasses(strings[0].substring(0,6));
            data_storage.setStudents(strings[0].substring(0, 6), strings[1], strings[0]);//学生的添加
            if (data_storage.courses.containsKey(strings[2])) {//课程里有这个课
                if (data_storage.courses.get(strings[2]).type.equals("选修")) {//
                    if (data_storage.courses.get(strings[2]).test_way.equals("考试")&&strings.length == 5) {
                        data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3], strings[4]);
                    }else if(data_storage.courses.get(strings[2]).test_way.equals("考察")&&strings.length==4){
                        data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3]);
                    } else {
                        data_storage.setStu__st_courAndMap(strings[0], strings[2], "no access", "no access");
                    }
                } else if (data_storage.courses.get(strings[2]).type.equals("必修")) {//
                    if (strings.length == 5) {
                        data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3],strings[4]);
                    } else {//无效
                        data_storage.setStu__st_courAndMap(strings[0], strings[2], "no access", "no access");
                    }
                } else if(data_storage.courses.get(strings[2]).type.equals("实验")){
                    if(strings.length == 3+((Lab_Course) data_storage.courses.get(strings[2])).sub_scores_num){
                        data_storage.set_lab_grades(strings[0],strings[2], String.valueOf(((Lab_Course) data_storage.courses.get(strings[2])).sub_scores_num),line);
                    }else{
                        data_storage.set_lab_grades(strings[0],strings[2],"num error","no access");
                    }
                }
            }else{
                data_storage.setStu__st_courAndMap(strings[0], strings[2], "not exist");
            }
        }
    }
    void lineProcessing(String line){
        strings = line.split(" ");
    }
}
class Inspect_Score extends Score{
    String end_score;
    Inspect_Score(String end_score) {
        this.end_score = end_score;
    }
}
class  Output_Format {
    Calculate_grades calculate = new Calculate_grades();
    String regex_c_test = "^[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s(必修|选修|实验)\\s(考试|考察|实验)\\s((\\d{1,2})|(1-9?))\\s((\\d{1,2})|(1-9?))$";
    String regex_c_test_e = "^[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s(必修|选修|实验)\\s(考试|考察|实验)\\s((0.\\d{1,2})|(1-9?))\\s((0.\\d{1,2})|(1-9?))$";
    String regex_c_inspect = "[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s(必修|选修|实验)\\s(考试|考察|实验)$";
    String regex_c_lab = "^[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s(必修|选修|实验)\\s(考试|考察|实验)\\s[4-9]\\s((0.\\d{1,2})|(1-9?))(\\s((0.\\d{1,2})|(1-9?))){1,10}$";
    String regex_CS = "^\\d{8}\\s+[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s+[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s*((100)|(\\d{1,2})|(0))?\\s+((100)|(\\d{1,2})|(0))$";
    String regex_lab = "^\\d{8}\\s[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s((100)|([1-9]\\d)|\\d)(\\s((100)|([1-9]\\d)|\\d)){1,20}$";
    void outputProcessing(Data_storage data) {
        data.classes.forEach((num,Class)-> Class.students.forEach((name, student)-> calculate.final_score(data,student.num)));
        for(String i:data.output.input){
            String[] tem = i.split(" ");
            if(i.matches(regex_c_test_e)||i.matches(regex_c_test)||i.matches(regex_c_inspect)||i.matches(regex_c_lab)){
                if(tem[1].equals("必修")&&(tem[2].equals("考察")||tem[2].equals("实验"))){
                    data.output.add_output(tem[0] + " : course type & access mode mismatch");
                }else if(tem[1].equals("实验")&&!tem[2].equals("实验")) {
                    data.output.add_output(tem[0] + " : course type & access mode mismatch");
                }else if(tem[1].equals("选修")&&tem[2].equals("实验")) {
                    data.output.add_output(tem[0] + " : course type & access mode mismatch");
                }
                if(tem[1].equals("实验")&&tem[2].equals("实验")) {
                    if(tem.length-4>=4&&tem.length - 4<=9) {
                        if (Integer.parseInt(tem[3]) != tem.length - 4) {
                            data.output.add_output(tem[0] + " : number of scores does not match");
                            data.courses.remove(tem[0]);
                            continue;
                        }
                        float tem_weight = 0;
                        for (int j = 4; j < tem.length; j++) {
                            tem_weight += Float.parseFloat(tem[j]);
                        }
                        if (Math.abs(tem_weight - 1) > 0.0001) {
                            data.output.add_output(tem[0] + " : weight value error");
                            data.courses.remove(tem[0]);
                            continue;
                        }
                    }else{
                        try {
                            if (Integer.parseInt(tem[3]) != tem.length - 4) {
                                data.output.add_output(tem[0] + " : number of scores does not match");
                                data.courses.remove(tem[0]);
                                continue;
                            }
                        } catch (Exception ignored) {

                        }
                    }
                }if((tem[1].equals("必修")||tem[1].equals("选修"))&&tem[2].equals("考试")){
                    if(tem.length-3==2) {
                        float tem_weight = Float.parseFloat(tem[3]) + Float.parseFloat(tem[4]);
                        if (Math.abs(tem_weight - 1) > 0.0001) {
                            data.output.add_output(tem[0] + " : weight value error");
                            data.courses.remove(tem[0]);
                        }
                    }
                }
            }else if(i.matches(regex_CS)||i.matches(regex_lab)) {
                if(!data.courses.containsKey(tem[2])){//不存在
                    data.output.add_output(tem[2]+" does not exist");
                    data.stu__st_cour.get(tem[0]).gradeMap.remove(tem[2]);
                }else{
                    if(data.courses.get(tem[2]).type.equals("必修") && tem.length!=5) {//必修 但是只有期末成绩
                        data.output.add_output(tem[0]+" "+tem[1]+" : access mode mismatch");
                    }else if(data.courses.get(tem[2]).type.equals("选修")) {
                        if ((data.courses.get(tem[2]).test_way.equals("考试") && tem.length != 5) ||
                                (data.courses.get(tem[2]).test_way.equals("考察") && tem.length != 4))
                            data.output.add_output(tem[0] + " " + tem[1] + " : access mode mismatch");
                    }else if(data.courses.get(tem[2]).type.equals("实验")){
                        if(data.courses.get(tem[2]).test_way.equals("实验")&&(tem.length-3<4||tem.length-3>9||tem.length-3!=((Lab_Course) data.courses.get(tem[2])).sub_scores_num))
                            data.output.add_output(tem[0] + " " + tem[1] + " : access mode mismatch");
                    }
                }
            }else if(!i.equals("end")){
                data.output.add_output("wrong format");
            }
        }
        data.classes.forEach((cla_num,Class1)->{//遍历所有班级
            Class1.students.forEach((stu_num,student)->{
                int tem=calculate.stu_all_grades(data,stu_num);
                if(tem>=0)
                    data.output.add_output(stu_num+" "+Class1.students.get(stu_num).name+" "+tem);
                else
                    data.output.add_output(stu_num+" "+Class1.students.get(stu_num).name+" "+"did not take any exams");
            });
        });
        data.courses.forEach((key,value)-> {
            int[] tem = calculate.single_course_grades(data, key);
            if (tem[0] < 0 && tem[1] < 0 && tem[2] < 0) {//三个为- 则没成绩
                data.output.add_output(key + " has no grades yet");
            }else {
                if (value.type.equals("选修") || value.type.equals("必修") || value.type.equals("实验")) {
                    data.output.add_output(key + " " + tem[2]);
                }
            }
        });
        data.classes.forEach((num,Class)->{
            int tem = calculate.Class_grades(data,num);
            if(tem>=0) {
                data.output.add_output(num + " " + tem);
            }else
                data.output.add_output(num+" has no grades yet");
        });
    }
    void output_all(Data_storage data){
        data.output.output.forEach(System.out::println);
    }
}
abstract class Score {
    String total_scores = "-100";
}
class Student {
    String name;
    String num;
    Student(String name, String num) {
        this.name = name;
        this.num = num;
    }
}
class StudentsAll_mes {
    String num;//学生
    TreeMap<String,Score> gradeMap =new TreeMap<>();
    StudentsAll_mes(String stu_name, String course, String normal_score,String test_score){
        this.num = stu_name;
        gradeMap.put(course,new Test_Score(normal_score,test_score));
    }
    StudentsAll_mes(String stu_name, String course, String test_score){
        this.num = stu_name;
        gradeMap.put(course,new Inspect_Score(test_score));
    }

    public StudentsAll_mes() {

    }
    void set_lab_stu_mes(String stu_num,String course,String lab_num,ArrayList<Integer> scores){
        this.num = stu_num;
        gradeMap.put(course,new Lab_Score(lab_num,scores));
    }
    void set_lab_gradeMap(String course,String lab_num,ArrayList<Integer> scores){
        if(!gradeMap.containsKey(course))
            gradeMap.put(course,new Lab_Score(lab_num,scores));
    }
    void setGradeMap(String course, String normal_score,String test_score){
        if(!gradeMap.containsKey(course))
            gradeMap.put(course, new Test_Score(normal_score,test_score));
    }
    void setGradeMap(String course,String test_score){
        if(!gradeMap.containsKey(course))
            gradeMap.put(course,new Inspect_Score(test_score));
    }
}
class Test_Score extends Score{
    String normal_score;
    String end_score;
    Test_Score(String normal_score,String end_score) {
        this.normal_score = normal_score;
        this.end_score = end_score;
    }
}
class Lab_Score extends Score {
    String lab_num;//试验次数
    ArrayList<Integer> scores;
    Lab_Score(String lab_num,ArrayList<Integer> scores){
        this.lab_num = lab_num;
        this.scores = scores;
    }
}
class InAndOut_put {
    List<String> output = new ArrayList<>();
    List<String> input = new ArrayList<>();
    void add_output(String out){
        output.add(out);
    }
    void add_input(String out){
        input.add(out);
    }
}

　　

我的代码中的主要类和功能如下：

• Main类：包含程序的入口方法main，用于接收用户输入、处理数据和输出结果。
• Data_storage类：用于存储数据，包括课程、班级和学生的信息，以及学生的成绩。
• Input_Format类：用于处理用户输入的数据，并根据输入的格式解析和存储相关信息。
• Output_Format类：用于对数据进行计算和格式化输出，包括计算学生平均成绩、课程平均成绩和班级平均成绩等。
• Calculate_grades类：用于计算学生、课程和班级的平均成绩。
• Class类：表示一个班级，包含班级号和学生信息。
• Course类及其子类：表示一个课程，包含课程名称、类型和考试方式等信息。
• Score类及其子类：表示学生的成绩，包括平时成绩、期末考试成绩和总分成绩等。

代码通过读取用户输入的数据，解析并存储到相应的数据结构中。然后根据存储的数据进行成绩计算和格式化输出。其中，成绩计算部分涉及单个学生总课程平均分计算、单门课程成绩计算和班级平均成绩计算。
主要类图如下：

　　从类图可以看出本次代码非常复杂，我彻底改变了课程程序统计程序-2的逻辑结构，改变了原来的输入输出读取方式以及字符匹配模式。

本次代码的圈复杂度如下：

 　　从这个图可以看出，本次代码虽然类很多，但是结构比第二次作业要清晰，代码深度较高，平均的复杂度以及选择分支减少，减少了内存开销。

期末考试

7-1 立体图形问题

分数 10

全屏浏览题目

切换布局

作者 段喜龙

单位 南昌航空大学

编程求得正方体和正三棱锥的表面积和体积，要求必须体现扩展性（继承）和多态性。

类结构如下图所示（参考）：

试编程完成如上类设计，主方法源码如下（可直接拷贝使用）：

 

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner input = new Scanner(System.in);
    double side = input.nextDouble();
        
    display(new Cube(side));
    display(new RegularPyramid(side));
}

其中，display(Solid solid)方法为定义在Main类中的静态方法，作用为体现程序的多态性。

注：正三棱锥的体积计算公式为底面积*高/3。

输入格式:

输入一个实型数，分别作为正方体的边长和正三棱锥的边长。

输出格式:

分别输出正方体的表面积、体积以及正棱锥的表面积和体积。保留两位小数，建议使用String.format(“%.2f”,value)

进行小数位数控制。

输入样例:

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

2.5

输出样例:

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

37.50
15.63
10.83
1.84
这个题目难度不大，主要在于三棱锥的体积与表面积的计算方法以及截断整数那里让我修改了一次。
我的代码如下：

import java.util.Scanner;

abstract class Solid {
    protected double side;

    public Solid(double side) {
        this.side = side;
    }

    public abstract double getSurfaceArea();

    public abstract double getVolume();
}

class Cube extends Solid {
    public Cube(double side) {
        super(side);
    }

    public double getSurfaceArea() {
        return 6 * Math.pow(side, 2);
    }

    public double getVolume() {
        return Math.pow(side, 3);
    }
}

class RegularPyramid extends Solid {
    public RegularPyramid(double side) {
        super(side);
    }

    public double getSurfaceArea() {
        return Math.pow(side, 2) *Math.sqrt(3);
    }

    public double getVolume() {
        return Math.pow(side, 3) / (6 * Math.sqrt(2));
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        double side = input.nextDouble();

        display(new Cube(side));
        display(new RegularPyramid(side));
    }

    public static void display(Solid solid) {
        System.out.println(String.format("%.2f", solid.getSurfaceArea()));
        System.out.println(String.format("%.2f", solid.getVolume()));
    }
}

　　

• Solid是一个抽象类，表示几何体，包含一个受保护的成员变量side表示边长，以及两个抽象方法getSurfaceArea()和getVolume()用于计算几何体的表面积和体积。
• Cube是Solid的子类，表示立方体，通过继承Solid类并实现抽象方法来计算立方体的表面积和体积。
• RegularPyramid也是Solid的子类，表示正四面体，同样通过继承Solid类并实现抽象方法来计算正四面体的表面积和体积。
• Main类包含了程序的入口方法main，在该方法中使用Scanner类获取用户输入的边长，然后创建一个立方体和一个正四面体对象，并调用display方法显示它们的表面积和体积。
• display方法接受一个Solid类型的参数，根据传入的具体几何体对象调用相应的方法来显示它们的表面积和体积。

本次代码的行数以及结构很清晰明了，在此不贴出其类图及复杂度分析。

问题描述：本问题中的魔方有两种，一种是正方体魔方，一种是正三棱锥魔方，其中，正方体或正三棱锥魔方是由单元正方体或正三棱锥组成，单元正方体或正三棱锥的个数由阶数（即层数）决定，即魔方边长=阶数*单元边长。魔方如下图所示：

利用“立体图形”问题源码，实现如下功能：

魔方有三个属性：颜色，阶数，类型（正方体魔方、正三棱锥魔方），程序要求输出魔方的颜色、表面积和体积。参考设计类图如下所示：

主方法部分可参考如下源码（可拷贝直接使用）：

 

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        
        String color = input.next();
        int layer = input.nextInt();
        double side = input.nextDouble();        
        
        RubikCube cube1 = new SquareCube(color, layer,new Cube(side)); 
                
        color = input.next();
        layer = input.nextInt();
        side = input.nextDouble();
        
        RubikCube cube2 = new RegularPyramidCube(color, layer,new RegularPyramid(side));
        display(cube1);
        display(cube2);
    }
}

其中，display(RubikCube cube)方法为Main类中定义的静态方法，用户输出魔方的信息，用于体现多态性。

输入格式:

第一部分：正方体魔方颜色、阶数、单元正方体边长，以空格或回车分隔；

第二部分：正三棱锥魔方颜色、阶数、单元正三棱锥边长，以空格或回车分隔。

输出格式:

正方体魔方颜色

正方体魔方表面积

正方体魔方体积

正三棱锥魔方颜色

正三棱锥魔方表面积
正三棱锥魔方体积

注：小数点保留两位

输入样例:

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

red 3 4.5
black 4 2.1

输出样例:

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

red
1093.50
2460.38
black
122.21
69.85

这道题目只需要在第一道的基础上略微修改计算方式以及添加抽象魔方类即可解决。
代码如下：

import java.util.Scanner;

abstract class Solid {
    protected double side;

    public Solid(double side) {
        this.side = side;
    }

    public abstract double getSurfaceArea();

    public abstract double getVolume();
}

class Cube extends Solid {
    public Cube(double side) {
        super(side);
    }

    public double getSurfaceArea() {
        return 6 * Math.pow(side, 2);
    }

    public double getVolume() {
        return Math.pow(side, 3);
    }
}

class RegularPyramid extends Solid {
    public RegularPyramid(double side) {
        super(side);
    }

    public double getSurfaceArea() {
        return Math.pow(side, 2) *Math.sqrt(3);
    }

    public double getVolume() {
        return Math.pow(side, 3) / (6 * Math.sqrt(2));
    }
}

abstract class RubikCube {
    protected String color;
    protected int layer;
    protected Solid solid;

    public RubikCube(String color, int layer, Solid solid) {
        this.color = color;
        this.layer = layer;
        this.solid = solid;
    }

    public String getColor() {
        return color;
    }

    public abstract double getSurfaceArea();

    public abstract double getVolume();
}

class SquareCube extends RubikCube {
    public SquareCube(String color, int layer, Solid solid) {
        super(color, layer, solid);
    }

    public double getSurfaceArea() {
        return 6 * Math.pow(layer * solid.side, 2);
    }

    public double getVolume() {
        return Math.pow(layer * solid.side, 3);
    }
}

class RegularPyramidCube extends RubikCube {
    public RegularPyramidCube(String color, int layer, Solid solid) {
        super(color, layer, solid);
    }

    public double getSurfaceArea() {
        return layer * layer * solid.getSurfaceArea();
    }

    public double getVolume() {
        return layer * layer * layer * solid.getVolume();
    }
}

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

        String color = input.next();
        int layer = input.nextInt();
        double side = input.nextDouble();

        RubikCube cube1 = new SquareCube(color, layer, new Cube(side));

        color = input.next();
        layer = input.nextInt();
        side = input.nextDouble();

        RubikCube cube2 = new RegularPyramidCube(color, layer, new RegularPyramid(side));
        display(cube1);
        display(cube2);
    }

    public static void display(RubikCube cube) {
        System.out.println(cube.getColor());
        System.out.println(String.format("%.2f", cube.getSurfaceArea()));
        System.out.println(String.format("%.2f", cube.getVolume()));
    }
}

• RubikCube是一个抽象类，表示魔方，包含颜色、层数和几何体对象的信息。它继承自Solid类，并实现了抽象方法getSurfaceArea()和getVolume()来计算魔方的表面积和体积。
• SquareCube是RubikCube的子类，表示正方体魔方。通过继承RubikCube类并实现抽象方法来计算正方体魔方的表面积和体积。
• RegularPyramidCube也是RubikCube的子类，表示正四面体魔方。同样通过继承RubikCube类并实现抽象方法来计算正四面体魔方的表面积和体积。

在Main类中，除了之前的功能外，添加了用户输入魔方的颜色、层数和边长。根据用户输入创建一个正方体魔方对象和一个正四面体魔方对象，并调用display方法显示它们的颜色、表面积和体积。

display方法接受一个RubikCube类型的参数，根据传入的魔方对象调用相应的方法来显示它们的颜色、表面积和体积。

7-3 魔方排序问题

分数 20

全屏浏览题目

切换布局

作者 段喜龙

单位 南昌航空大学

在魔方问题的基础上，重构类设计，实现列表内魔方的排序功能（按照魔方的体积进行排序）。

提示：题目中RubikCube类要实现Comparable接口。

其中，Main类源码如下（可直接拷贝使用）：

 

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        
        String color;
        int layer;
        double side;
        RubikCube cube;
        
        ArrayList<RubikCube> list = new ArrayList<>();
        
        int choice = input.nextInt();
        
        while(choice != 0) {
            switch(choice) {
            case 1://SquareCube
                color = input.next();
                layer = input.nextInt();
                side = input.nextDouble();
                cube = new SquareCube(color, layer,new Cube(side)); 
                list.add(cube);
                break;
            case 2://RegularPyramidCube
                color = input.next();
                layer = input.nextInt();
                side = input.nextDouble();
                cube = new RegularPyramidCube(color, layer,new RegularPyramid(side)); 
                list.add(cube);
                break;
            }
            choice = input.nextInt();
        }
        
        list.sort(Comparator.naturalOrder());//正向排序
        
        for(int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i).getColor() + " " + 
        String.format("%.2f", list.get(i).getArea()) + " " + 
        String.format("%.2f", list.get(i).getVolume()) );
            System.out.println("");
        }            
    }    
}

输入格式:

输入魔方类型（1：正方体魔方；2：正三棱锥魔方；0：结束输入）

魔方颜色、魔方阶数、魔方单元正方体、正三棱锥边长

..循环..

输出格式:

按魔方体积升序输出列表中各魔方的信息（实型数均保留两位小数），输出样式参见输出样例。

输入样例:

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

1 blue 3 4.5
2 red 4 2.1
1 yellow 5 2.3
2 black 4 9.42
1 white 4 5.4423
0

输出样例:

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

red 122.21 69.85
yellow 793.50 1520.88
blue 1093.50 2460.38
black 2459.14 6304.73
white 2843.39 10316.38

这道题目是在魔方问题的基础上，对用户输入的魔方数据的表面和体积进行排序。
我的代码如下：

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Comparator;
abstract class Solid {
    protected double side;

    public Solid(double side) {
        this.side = side;
    }

    public abstract double getSurfaceArea();

    public abstract double getVolume();
}

class Cube extends Solid {
    public Cube(double side) {
        super(side);
    }

    public double getSurfaceArea() {
        return 6 * Math.pow(side, 2);
    }

    public double getVolume() {
        return Math.pow(side, 3);
    }
}

class RegularPyramid extends Solid {
    public RegularPyramid(double side) {
        super(side);
    }

    public double getSurfaceArea() {
        return Math.pow(side, 2) *Math.sqrt(3);
    }

    public double getVolume() {
        return Math.pow(side, 3) / (6 * Math.sqrt(2));
    }
}

abstract class RubikCube implements Comparable<RubikCube> {
    protected String color;
    protected int layer;
    protected Solid solid;

    public RubikCube(String color, int layer, Solid solid) {
        this.color = color;
        this.layer = layer;
        this.solid = solid;
    }

    public String getColor() {
        return color;
    }

    public abstract double getSurfaceArea();

    public abstract double getVolume();

    @Override
    public int compareTo(RubikCube other) {
        return Double.compare(this.getVolume(), other.getVolume());
    }
}
class SquareCube extends RubikCube {
    public SquareCube(String color, int layer, Solid solid) {
        super(color, layer, solid);
    }

    public double getSurfaceArea() {
        return 6 * Math.pow(layer * solid.side, 2);
    }

    public double getVolume() {
        return Math.pow(layer * solid.side, 3);
    }
}

class RegularPyramidCube extends RubikCube {
    public RegularPyramidCube(String color, int layer, Solid solid) {
        super(color, layer, solid);
    }

    public double getSurfaceArea() {
        return layer * layer * solid.getSurfaceArea();
    }

    public double getVolume() {
        return layer * layer * layer * solid.getVolume();
    }
}

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

        String color;
        int layer;
        double side;
        RubikCube cube;

        ArrayList<RubikCube> list = new ArrayList<>();

        int choice = input.nextInt();

        while(choice != 0) {
            switch(choice) {
            case 1://SquareCube
                color = input.next();
                layer = input.nextInt();
                side = input.nextDouble();
                cube = new SquareCube(color, layer,new Cube(side)); 
                list.add(cube);
                break;
            case 2://RegularPyramidCube
                color = input.next();
                layer = input.nextInt();
                side = input.nextDouble();
                cube = new RegularPyramidCube(color, layer,new RegularPyramid(side)); 
                list.add(cube);
                break;
            }
            choice = input.nextInt();
        }

        list.sort(Comparator.naturalOrder());//正向排序

        for(int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i).getColor() + " " + 
        String.format("%.2f", list.get(i).getSurfaceArea()) + " " + 
        String.format("%.2f", list.get(i).getVolume()) );
            System.out.println("");
        }            
    }    
}

这段代码中的类包括：

• Solid：抽象基类，表示一个立体，包含边长属性和计算表面积和体积的抽象方法。
• Cube：继承自Solid，表示一个立方体，实现了计算表面积和体积的方法。
• RegularPyramid：继承自Solid，表示一个正四面体，实现了计算表面积和体积的方法。
• RubikCube：抽象基类，表示一个魔方，包含颜色、层数和实际立体对象的属性，以及计算表面积和体积的抽象方法和比较方法。
• SquareCube：继承自RubikCube，表示一个立方体魔方，实现了计算表面积和体积的方法。
• RegularPyramidCube：继承自RubikCube，表示一个金字塔魔方，实现了计算表面积和体积的方法。
• Main：主类，包含main方法，用于接收用户输入、创建魔方对象、进行排序和打印结果。

用户可以通过输入数字选择魔方类型（1表示立方体魔方，2表示金字塔魔方），然后依次输入颜色、层数和边长。输入0表示结束输入。

最后，程序将根据魔方的体积对魔方列表进行排序，并打印每个魔方的颜色、表面积和体积。

我的代码的类图如下：

 

在原来的魔方问题代码上，我添加了用户选择立体类型以及排序输出部分。

7-4 销售步枪问题（附加题）

分数 10

全屏浏览题目

切换布局

作者 段喜龙

单位 南昌航空大学

前亚利桑那州境内的一位步枪销售商销售密苏里州制造的步枪机（lock）、枪托（stock）和枪管（barrel）。枪机卖45美元，枪托卖30美元，枪管卖25美元。销售商每月至少要售出一支完整的步枪，且生产限额是销售商在一个月内可销售70个枪机、80个枪托和90个枪管。

根据每个月的销售情况，计算销售商的佣金（提成）算法如下：

• 不到（含）1000美元的部分为10%；

• 1000（含）~1800美元的部分为15%；

• 超过1800美元的部分为20%。

佣金程序生成月份销售报告，汇总销售商的销售总额和佣金。

编程要求：必须符合面向对象编程，且保证类设计的单一职责模式，使用面向过程编程判定0分。

提示：可以设置一个销售订单类。参考类图如下：

输入格式:

输入销售商每个月售出枪机、枪托、枪管的数量，可以用空格或者回车分隔。

输出格式:

分别输出销售商在该月的销售额和佣金，中间用空格分开。

输入样例1:

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

30 40 50

输出样例1:

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

3800.00 620.00

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

88 56 98

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

Wrong Format

这是一道简单的题目，我的代码如下：

import java.util.Scanner;

class SalesOrder {
    private int lockCount;
    private int stockCount;
    private int barrelCount;

    private static final int LOCK_PRICE = 45;
    private static final int STOCK_PRICE = 30;
    private static final int BARREL_PRICE = 25;

    public SalesOrder(int lockCount, int stockCount, int barrelCount) {
        if ((lockCount > 70 || stockCount > 80 || barrelCount > 90)||(lockCount<1||stockCount<1||barrelCount<1)) {
            throw new IllegalArgumentException("Wrong Format");
        }
        this.lockCount = lockCount;
        this.stockCount = stockCount;
        this.barrelCount = barrelCount;
    }

    public double calculateTotalSales() {
        return lockCount * LOCK_PRICE + stockCount * STOCK_PRICE + barrelCount * BARREL_PRICE;
    }

    public double calculateCommission() {
        double totalSales = calculateTotalSales();
        if (totalSales <= 1000) {
            return totalSales * 0.10;
        } else if (totalSales <= 1800) {
            return 1000 * 0.10 + (totalSales - 1000) * 0.15;
        } else {
            return 1000 * 0.10 + 800 * 0.15 + (totalSales - 1800) * 0.20;
        }
    }
}

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

        int lockCount = input.nextInt();
        int stockCount = input.nextInt();
        int barrelCount = input.nextInt();

        try {
            SalesOrder order = new SalesOrder(lockCount, stockCount, barrelCount);
            System.out.printf("%.2f %.2f\n", order.calculateTotalSales(), order.calculateCommission());
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}

这是期末考试的附加题，难度不大，只要注意题目的条件控制好输入输出，基本不会出错。

总结：

　　这阶段的题目是PTA的最后一部分题目，题目难度相较于第二次也变小了，最后一阶段的题目加入了很多面向对象java的特点题目，加入了接口，继承多态部分题目，这些题目让我对面向对象java这门语言更加熟悉和了解，PTA的题目让我记忆犹新，我曾因为两道题做出来而窃窃自喜，也曾因为菜单计价系列题目而痛不欲生，这些都使我受益良多，最后一阶段的题目算是对java的学习到了一个新阶段，我开始有意识地理清代码结构以及想办法降低代码复杂度，而不是像以前一样只求做出来，我开始思考题目的需求和哪些方法匹配，字符匹配是否需要用到正则表达式，类的设计是应该继承还是组合，应该用哪种方式来储存数据（链表还是数组)……，这些思考使我的代码能力和设计思维进一步提高，为我以后的工作和学习打下了良好的基础。