关于PTA大作业第三次总结

1.前言

这一阶段的题目难度更大，而且都是实现某一功能的完整的小程序的题目，让程序设计更加复杂，题目量适中；基本都是在考察继承与多态这两大技术特性;同时还对类的设计有要求；java类的七大设计原则：单一职责原则等。这一阶段的题目主要锻炼对类结构的设计。

2.设计与分析

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）成绩平均分只取整数部分，小数部分丢弃

我的代码如下：

import java.text.Collator;
import java.util.ArrayList;
import java.util.Locale;
import java.util.Scanner;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        ArrayList<Course> courses = new ArrayList<>();//课程清单
        ArrayList<Student> stu = new ArrayList<>();//学生清单
        ArrayList<Class> classes = new ArrayList<>();//班级清单
        while (true) {
            String string = in.nextLine();
            String[] temp = string.split(" ");
            if (string.contains("end")) {
                break;
            }
            
            else if (temp.length == 2 && temp[1].equals("必修")) {//必修课，省略考核方式
                boolean flag = false;//判断是否有这门课 没有
                for(Course e : courses){//不含该课程
                    if(e.getName().equals(temp[0])){//有这门课
                        flag = true;
                        break;
                    }
                }
                if(flag == false){//没有这门课
                    Course course = new Course(temp[0], temp[1], "考试");//课程名称，性质，考核方式
                    courses.add(course);
                }
                else if(temp[1].equals("选修") )  {//性质为选修
                    System.out.println(temp[0] + " : course type & access mode mismatch");
                }
            }
            else if (temp.length == 3) {//课程信息
                boolean flag = false;//设没有这门课
                for(Course e: courses) {
                    if(e.getName().equals(temp[0])) {
                        flag = true;
                        break;
                    }
                }
                if(flag == false) {//没有这门课
                    if((temp[1].equals("必修") && temp [2].equals("考察")) ) {//考试性质 与 考察方式 不匹配
                        System.out.println(temp[0] + " : course type & access mode mismatch");//不匹配
                    }
                    else {//匹配
                        Course course = new Course(temp[0], temp[1], temp[2]);//课程名称，性质，考核方式
                        courses.add(course);
                    }
                }
            }
           else if (string.matches("[\\d]{8}(\\s([\\u4e00-\\u9fa5]|[\\w]){1,10}){2}(\\s([\\d]{1,2}|100)){1,2}")) {//
                int i ,n ,j = 0;// i 是班级的下标 j是班级中 学生的线下标 n是课程的下标
               for( i = 0 ; i < classes.size() ; i++){
                   if(temp[0].contains(classes.get(i).getName())){//找到了班级
                       break;
                   }
               }
               if(i == classes.size()){//班级不存在
                   Class class1 = new Class(temp[0].substring(0,6));
                   classes.add(class1);
               }
                for (j = 0; j < classes.get(i).students.size(); j++) {
                    if (classes.get(i).searchStudent(temp[0],temp[1])) {
                        break;//学生存在
                    }
                }
                if (j == classes.get(i).students.size()) {//学生不存在
                    Student student = new Student(temp[0],temp[1]);
                    classes.get(i).students.add(student);
                }
                if(temp.length == 4){
                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        int m = 0;
                        if (flag == 0) {//有课的情况
                            if (courses.get(n).getInvestigationMethod().equals("考察")) {//这节课的是考察
                                if(courses.get(n).getCourseNature().equals("选修")){
                                    int x = Integer.parseInt(temp[3]);
                                    courses.get(n).setScore2(x);
                                    courses.get(n).setScore3(x);
                                    classes.get(i).getStudents().get(j).setScore3(x);
                                }
                            } else {
                                System.out.println(temp[0] + " " +
                                        temp[1] + " : " + "access mode mismatch");
                            }
                        }
                    }
                }
                if(temp.length == 5){
                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        int m = 0;
                        if (flag == 0) {//有课的情况
                            if (!courses.get(n).getInvestigationMethod().equals("考察")) {//这节课的是考察
                                    int x = Integer.parseInt(temp[3]);
                                    int y = Integer.parseInt(temp[4]);
                                    int z = (int)(0.3* x + 0.7 *y);
                                    courses.get(n).setScore1(x);
                                    courses.get(n).setScore2(y);
                                    courses.get(n).setScore3(z);
                                    classes.get(i).getStudents().get(j).setScore3(z);

                            } else {
                                System.out.println(temp[0] + " " +
                                        temp[1] + " : " + "access mode mismatch");
                            }
                        }
                    }

                }


            }
            else
                System.out.println("wrong format");

        }

        Collections.sort(classes);
        for(Class e:classes){
            e.printScore();
        }
        courses.sort((Course o1,Course o2)->{
            Collator instance = Collator.getInstance(Locale.CHINA);
            return instance.compare(o1.getName(),o2.getName());
        });
        for(Course e : courses){
            int n = e.getNum();
            if(e.getCourseNature().equals("必修") || e.getCourseNature().equals("选修") && e.getInvestigationMethod().equals("考试")) {
                if(e.getNum() == 0){
                    System.out.println(e.getName() + " " +"has no grades yet");
                }
                else
                    System.out.println(e.getName() + " " + e.getScore1()/ n + " " + e.getScore2()/ n+ " " + e.getScore3()/ n);
            }
            else {
                if(e.getNum() == 0){
                    System.out.println(e.getName() + " "+ "has no grades yet");
                }
                else
                    System.out.println(e.getName() +" " + e.getScore2()/n + " " + e.getScore3()/ n);
            }
        }
        for(Class e:classes){
            e.pScore();
        }

    }
}
 class Class implements Comparable<Class>{
    private String name;
    ArrayList<Student> students =new ArrayList<>();
    public Class(String name) {
        this.name = name;
    }
    public ArrayList<Student> getStudents() {
        return students;
    }
    public String getName() {
        return name;
    }
    public boolean searchStudent(String num,String name){
        for(Student e:students){
            if(e.getName().equals(name) && e.getStudentNumber().equals(num))
                return true;
        }
        return false;
    }
    public Student getStudent(String num,String name){
       for(int i = 0; i<students.size();i++){
           if(students.get(i).getName().equals(name) && students.get(i).getStudentNumber().equals(num))
               return students.get(i);
       }
       return null;
    }
      @Override
    public int compareTo(Class o) {
        return (int)(this.name.compareTo(o.getName()));
    }
    public void printScore(){
         Collections.sort(students);
        for(Student e: students){
            e.printScore();
        }
    }
    public void pScore(){
        int sum  = 0;
        for(Student e :students){
            sum += e.getScore3();
        }
        int n = 0;
        for(int i = 0; i < students.size() ; i++){
            n = n + students.get(i).getNum();
        }
        if(n != 0)
        sum = sum / n;
        if(sum != 0){
            System.out.println(name + " " + sum );
        }
        if(sum == 0){
            System.out.println(name + " " + "has no grades yet");
        }
    }
}
class Course {
    private String name ;
    private String Nature;
    private String Method;
    private int score1 = 0;
    private int score2 = 0;
    private int score3 = 0;
    private Score score;
    private int num = 0;

    public Course() {
    }

    public Course(String name, String Nature, String Method) {
        this.name = name;
        this.Nature = Nature;
        this.Method = Method;

    }

    public String getName() {
        return name;
    }

    public String getCourseNature() {
        return Nature;
    }

    public String getInvestigationMethod() {
        return Method;
    }


    public int getScore1() {
        return score1;
    }

    public void setScore1(int score1) {
        this.score1 += score1;
    }

    public int getScore2() {
        return score2;
    }

    public void setScore2(int score2) {
        this.score2 += score2;
    }

    public int getScore3() {
        return score3;
    }
    public void setScore3(int score3){
        this.num++;
        this.score3 += score3;

    }

    public int getNum() {
        return num;
    }
    
}
 class ExamineScore extends Score{
    private int totalScore;

    public ExamineScore() {
    }

    public int getTotalScore() {
        return totalScore;
    }

    public void setTotalGrade(int totalScore) {
        this.totalScore= totalScore;
    }

}
 abstract class Score {
    private int score1;//平时成绩
    private int score2;//期末成绩
    private int score3;//总成绩

    public Score(){

    }
    public int getScore1() {
        return score1;
    }

    public void setScore1(int score1) {
        this.score1 = score1;
    }

    public int getScore2() {
        return score2;
    }

    public void setScore2(int score2) {
        this.score2 = score2;
    }

    public int getScore3() {
        return score3;
    }

    public void setScore3(int score3) {
        this.score3 = score3;
    }

}

 class Student implements Comparable<Student>{
    private String name ;
    private String Number;

    private int score3 = 0;
    private int num  = 0 ;
    public Student() {

    }
    public Student(String Number, String name) {
        this.name = name;
        this.Number = Number;
    }
    public Student(String studentNumber, String name, int score3) {
        this.name = name;
        this.Number = studentNumber;
        this.score3 += score3;
        if(score3 != 0)
            this.num++;
    }
    public String getName() {
        return name;
    }

    public String getStudentNumber() {
        return Number;
    }

    public int getScore3() {
        return score3;
    }

    public void setScore3(int score3) {
        if(score3 != 0)
            num ++;
        this.score3 += score3;
    }
      @Override
    public int compareTo(Student o) {
        return (int)(this.getStudentNumber().compareTo(o.getStudentNumber()));
    }
    public void printScore(){

        if(this.num != 0)
            System.out.println(Number + " " + name + " " + this.score3 / num);
        else
            System.out.println(Number + " " + name + " " + "did not take any exams");
    }
      public int getNum() {
        return num;
    }
}
 class TestScore extends Score {
    private int score1;
    private int score2;
    private int score3;

    @Override
    public int getScore1() {
        return score1;
    }

    @Override
    public void setScore1(int score1) {
        this.score1 = score1;
    }

    @Override
    public int getScore2() {
        return score2;
    }

    @Override
    public void setScore2(int score2) {
        this.score2 = score2;
    }

    @Override
    public int getScore3() {
        return score3;
    }

    @Override
    public void setScore3(int score3) {
        this.score3 = score3;
    }
}
 class Selection {//选课类
    private Course course  = new Course();
    private Student student = new Student();
    private Score score;

    public Selection() {
    }

    public Selection(Course course, Student student, Score score) {
        this.course = course;
        this.student = student;
        this.score = score;
    }
}

生成的类图如下：

 

 

这里，主要就是Score类包含了ExaminScore 和 TestScore;然后Class一个班里有很多学生，一个学生有很多门课；这样就可以求得班级的总成绩，学生的总成绩以及每个课程的总成绩；

这里我的题测部分都过了；但是还有一些测试点没过；当时时间也截止了，就没有把错误的改过来。这里我没有对管错误的课程信息，所以就没有过这两个测试点。这里主函数中的代码很长，并且实现的功能很多，并没有实现单一职责原则。

 

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

分数 100

全屏浏览题目

切换布局

作者 段喜龙

单位 南昌航空大学

编写程序统计一个输入的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.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> keyWords = new HashMap<>(); 
        Set<String> information = new HashSet<>();
        String[] keyWord = {"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 input = new Scanner(System.in);
        String str = input.nextLine();//输入的一行
        StringBuilder line = new StringBuilder(" ");
        while (!str.equals("exit")) {
            line.append(str.replaceAll("//.*", " ").replaceAll("\".*\"", " "));
            str = input.nextLine();
        }
        str = line.toString();
        if (str.length() == 0) {
            System.out.println("Wrong Format");
            return;
        }
        str = delete("\"(.*?)\"", str);
        str = delete("/\\**(.*?)/", str);
        str = str.replace("=","a");
        str = str.replaceAll("[\\pP+~$`^=|<>～｀＄＾＋｜＜＞￥×]" , " ");
        str = str.replaceAll("[^a-zA-Z]", " ");
         for (int i = 0; i < 53; i++) {
            Pattern pattern = Pattern.compile("\\b" + keyWord[i] + "\\b");
            Matcher matcher = pattern.matcher(str);
            while (matcher.find())
                if (information.contains(keyWord[i]))
                    keyWords.replace(keyWord[i], keyWords.get(keyWord[i]) + 1);
                else {
                    keyWords.put(keyWord[i], 1);
                    information.add(keyWord[i]);
                }
        }
        Set set = keyWords.keySet();
        Object[] arr = set.toArray();
        Arrays.sort(arr);
        for (Object i : arr)
            System.out.println(keyWords.get(i) + "\t" + i);
    }
     public static String delete(String pattern, String str) {
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(str);
        while (m.find()) {
            str = str.replace(m.group(), " ");
            m = p.matcher(str);
        }
        return str;
    }
}

这道题是统计给定的源码中java关键字的数量；解题思路是：先把java中53个关键字放在一个字符串数组里，然后对提供的源码进行逐行分析：先判断有没有注释的标记如“//”或“\*”等，用一个容器StringBuilder来存放去掉了注释之后的源码；然后再对剩下的源码进行分析：将所有的非英文字符都换成空格，最后用Pattern来判断是否匹配该种模式。

总的来说，这道题的思路不是很复杂，但是难点在于怎么用代码实现这些相应的功能，要选择相应的容器才能更好地实现这些功能。

 

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）成绩平均分只取整数部分，小数部分丢弃

 代码如下：

import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Locale;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        ArrayList<Course> courses = new ArrayList<>();//课程清单
        ArrayList<Class> classes = new ArrayList<>();//班级清单
        while (true) {
            String string = in.nextLine();
            String[] temp = string.split(" ");
            if (string.contains("end")) {
                break;
            }

            else if (temp.length == 5 && (temp[1].equals("必修") || temp[1].equals("选修")) && temp[2].equals("考试")) {//考试的课程，选修或必修都行
               
                 boolean flag = false;//判断是否有这门课 没有
                for(Course e : courses){//不含该课程
                    if(e.getName().equals(temp[0])){//有这门课
                        flag = true;
                        break;
                    }
                }
                if(flag == false){//没有这门课
                    double weightSum = 0;//权重和
                    for(int b = 0 ; b < 2 ; b ++){//看权重之和是否为1
                        double h = Double.parseDouble(temp[3 + b]);
                        weightSum += h;
                    }
                    if(!(Math.abs(weightSum - 1.0) <= 0.000001)){//权重之和不为1
                        System.out.println(temp[0] + " : weight value error");
                    }
                    else {
                        Course course = new Course(temp[0], temp[1], "考试",2);//课程名称，性质，考核方式
                        for(int i = 0 ; i < 2; i++){
                            course.getScore().getWeight().add(Double.parseDouble(temp[3+i]));//设置权重
                        }
                        courses.add(course);
                    }
                }

            }
            else if (temp.length == 3) {//考察的课程
                boolean flag = false;//设没有这门课
                for(Course e: courses) {
                    if(e.getName().equals(temp[0])) {
                        flag = true;
                        break;
                    }
                }
                if(flag == false) {//没有这门课
                    if((temp[1].equals("必修") && temp [2].equals("考察") ) ) {//考试性质 与 考察方式 不匹配
                        System.out.println(temp[0] + " : course type & access mode mismatch");//不匹配
                    }
                    else if(temp[1].equals("必修") && temp[2].equals("实验") ){
                        System.out.println(temp[0] + " : course type & access mode mismatch");//不匹配
                    }
                    else if(temp[1].equals("选修") && temp[2].equals("实验")){
                        System.out.println(temp[0] + " : course type & access mode mismatch");//不匹配
                    }
                    else {//匹配
                        Course course = new Course(temp[0], temp[1], temp[2],1);//课程名称，性质，考核方式,成绩数量
                        course.getScore().getWeight().add(1.0);//设置权重
                        courses.add(course);
                    }
                }
            }
            else if(temp[2].equals("实验") && temp[1].equals("实验") && string.matches("(([\\u4e00-\\u9fa5[\\w]]){1,10}\\s)实验\\s实验\\s[4-9](\\s0\\.\\d+)+") ){//实验课程的处理
                int num = Integer.parseInt(temp[3]);//次数
                    boolean flag = false;//设没有这门课
                            for(Course e: courses) {
                                if(e.getName().equals(temp[0])) {
                                    flag = true;
                                    break;
                                }
                            }
                            if(flag == false){
                                if(temp.length == (4 + num)){//权重数量匹配
                                    double weightSum = 0;
                                    for(int b = 0 ; b < num ; b ++){//看权重之和是否为1
                                     double h = Double.parseDouble(temp[4 + b]);
                                     weightSum += h;
                                    }
                                    if(!(Math.abs(weightSum - 1.0) < 0.000001)){//权重之和不为1
                                        System.out.println(temp[0] + " : weight value error");
                                    }
                                    else {
                                        Course course = new Course(temp[0],temp[1],temp[2],Integer.parseInt(temp[3]));
                                        for(int i = 0; i < num ; i ++){
                                        course.getScore().getWeight().add(Double.parseDouble(temp[4+i]));//设置权重
                                        }
                                        courses.add(course);
                                    }
                                }
                                else{//数量不匹配
                                    System.out.println(temp[0] + " : number of scores does not match");//数量不匹配
                                }
                            }
            }
            else if (string.matches("[\\d]{8}(\\s([\\u4e00-\\u9fa5]|[\\w]){1,10}){2}(\\s([\\d]{1,2}|100)){1,2}")) {//选修必修课程成绩处理
                int i ,n ,j = 0;// i 是班级的下标 j是班级中 学生的线下标 n是课程的下标
                for( i = 0 ; i < classes.size() ; i++){
                    if(temp[0].contains(classes.get(i).getName())){//找到了班级
                        break;
                    }
                }
                if(i == classes.size()){//班级不存在
                    Class class1 = new Class(temp[0].substring(0,6));
                    classes.add(class1);
                }
                for (j = 0; j < classes.get(i).students.size(); j++) {
                    if (classes.get(i).searchStudent(temp[0],temp[1])) {
                        break;//学生存在
                    }
                }
                if (j == classes.get(i).students.size()) {//学生不存在
                    Student student = new Student(temp[0],temp[1]);
                    classes.get(i).students.add(student);
                }
                if(temp.length == 4){//选修课
                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        int m = 0;
                        if (flag == 0) {//有课的情况
                            if (courses.get(n).getInvestigationMethod().equals("考察")) {//这节课的是考察
                                if(courses.get(n).getCourseNature().equals("选修")){
                                    double x = Double.parseDouble(temp[3]);//选修的成绩
                                    courses.get(n).getScore().getScores().add(x);
//                                    courses.get(n).setScore3(x);
                                    courses.get(n).getSumScore();
                                    classes.get(i).getStudents().get(j).setScore3(x);
                                    
                                }
                            } else {
                                System.out.println(temp[0] + " " +
                                        temp[1] + " : " + "access mode mismatch");
                            }
                        }
                    }
                }
                if(temp.length == 5){//选修 或 必修的考试
                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        int m = 0;
                        if (flag == 0) {//有课的情况
                            if (!courses.get(n).getInvestigationMethod().equals("考察")) {//这节课的是考察
                                double x = Double.parseDouble(temp[3]);
                                double y = Double.parseDouble(temp[4]);
//                              
                                courses.get(n).getScore().getScores().add(x);
                                courses.get(n).getScore().getScores().add(y);
//                              
                                courses.get(n).getSumScore();
                                classes.get(i).getStudents().get(j).setScore3(courses.get(n).getScore().getSum());
                                  courses.get(n).getScore().getScores().clear();
                            } else {
                                System.out.println(temp[0] + " " +
                                        temp[1] + " : " + "access mode mismatch");
                            }
                        }
                    }

                }
            }
            else if(string.matches("[\\d]{8}(\\s([\\u4e00-\\u9fa5[\\w]]){1,10}){2}(\\s([\\d]{1,2}|100))+")){//实验成绩的处理
                int num = 0;
                for(int p = 0 ; p < courses.size() ; p++){
                    if(courses.get(p).getName().equals(temp[2])){//有这门课
                        num = courses.get(p).getScore().getWeight().size();//成绩数量
                    }
                }
                //int num= Integer.parseInt(temp[3]);//出现的次数
                if(temp.length - 3 == num){//成绩数量匹配
                    int i ,n ,j = 0;// i 是班级的下标 j是班级中 学生的线下标 n是课程的下标
                    for( i = 0 ; i < classes.size() ; i++){
                        if(temp[0].contains(classes.get(i).getName())){//找到了班级
                            break;
                        }
                    }
                    if(i == classes.size()){//班级不存在
                        Class class1 = new Class(temp[0].substring(0,6));
                        classes.add(class1);
                    }
                    for (j = 0; j < classes.get(i).students.size(); j++) {
                        if (classes.get(i).searchStudent(temp[0],temp[1])) {
                            break;//学生存在
                        }
                    }
                    if (j == classes.get(i).students.size()) {//学生不存在
                        Student student = new Student(temp[0],temp[1]);
                        classes.get(i).students.add(student);
                    }
                    int flag = 0;//判断有没有课
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        int m = 0;
                        if (flag == 0) {//有课的情况
                            if (courses.get(n).getInvestigationMethod().equals("实验")) {//这节课的
                                if(courses.get(n).getCourseNature().equals("实验")){
                                    for (int a = 0 ; a < num ; a ++){
                                        courses.get(n).getScore().getScores().add(Double.parseDouble(temp[3 + a]));
                                    }
                                    courses.get(n).getSumScore();
                                    classes.get(i).getStudents().get(j).setScore3(courses.get(n).getScore().getSum());
                                    courses.get(n).getScore().getScores().clear();
                                }
                            }
                            else {
                                System.out.println(temp[0] + " " +
                                        temp[1] + " : " + "access mode mismatch");
                            }
                        }
                    }
                }
                else {//成绩数量不匹配
                    int i ,n ,j = 0;// i 是班级的下标 j是班级中 学生的线下标 n是课程的下标
                    for( i = 0 ; i < classes.size() ; i++){
                        if(temp[0].contains(classes.get(i).getName())){//找到了班级
                            break;
                        }
                    }
                    if(i == classes.size()){//班级不存在
                        Class class1 = new Class(temp[0].substring(0,6));
                        classes.add(class1);
                    }
                    for (j = 0; j < classes.get(i).students.size(); j++) {
                        if (classes.get(i).searchStudent(temp[0],temp[1])) {
                            break;//学生存在
                        }
                    }
                    if (j == classes.get(i).students.size()) {//学生不存在
                        Student student = new Student(temp[0],temp[1]);
                        classes.get(i).students.add(student);
                    }
                    int flag = 0;//判断有没有课
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            System.out.println(temp[0] + " " +
                                    temp[1] + " : " + "access mode mismatch");
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                }
            }
            else
                System.out.println("wrong format");
        }

        Collections.sort(classes);
    
        for(Class e:classes){
            e.printScore();
        }
        courses.sort((Course o1,Course o2)->{
            Collator instance = Collator.getInstance(Locale.CHINA);
            return instance.compare(o1.getName(),o2.getName());
        });
        for(Course e : courses){
            int n = e.getNum();
            if(e.getCourseNature().equals("必修") || e.getCourseNature().equals("选修") && e.getInvestigationMethod().equals("考试")) {
                if(e.getNum() == 0){
                    System.out.println(e.getName() + " " +"has no grades yet");
                }
                else
                    System.out.println(e.getName() + " " + e.getGrade());
            }
            else if(e.getCourseNature().equals("实验") && e.getInvestigationMethod().equals("实验")){//实验成绩的输出
                if(e.getNum() == 0){
                    System.out.println(e.getName() + " " + "has no grades yet");
                }
                else
                    System.out.println(e.getName() + " " + e.getGrade());
            }
            else {
                if(e.getNum() == 0){
                    System.out.println(e.getName() + " "+ "has no grades yet");
                }
                else
                    System.out.println(e.getName() +" " + e.getGrade());
            }
        }
        for(Class e:classes){
            e.pScore();
        }

    }
}
class Class implements Comparable<Class>{
    private String name;
    ArrayList<Student> students =new ArrayList<>();
    public Class(String name) {
        this.name = name;
    }
    public ArrayList<Student> getStudents() {
        return students;
    }
    public String getName() {
        return name;
    }
    public boolean searchStudent(String num,String name){
        for(Student e:students){
            if(e.getName().equals(name) && e.getStudentNumber().equals(num))
                return true;
        }
        return false;
    }
    public Student getStudent(String num,String name){
        for(int i = 0; i<students.size();i++){
            if(students.get(i).getName().equals(name) && students.get(i).getStudentNumber().equals(num))
                return students.get(i);
        }
        return null;
    }
    @Override
    public int compareTo(Class o) {
        return (int)(this.name.compareTo(o.getName()));
    }
    public void printScore(){
        Collections.sort(students);
        for(Student e: students){
            e.printScore();
        }
    }
    public void pScore(){//输出班级的分数
        int sum  = 0;
        for(Student e :students){
            sum += e.getScore3();
        }
        int n = 0;
        for(int i = 0; i < students.size() ; i++){
            n = n + students.get(i).getNum();
        }
        if(n != 0)
            sum = sum / n;
        if(sum != 0){
            System.out.println(name + " " + sum );
        }
        if(sum == 0){
            System.out.println(name + " " + "has no grades yet");
        }
    }
}
class Course {
    private String name ;
    private String Nature;
    private String Method;
    private double sumScore;
    private Score score = new Score();
    private int num = 0;//该课程学生的数量

    public Course() {
    }

    public Course(String name, String Nature, String Method,int n) {
        this.name = name;
        this.Nature = Nature;
        this.Method = Method;
        this.score.setN(n);
    }

    public String getName() {
        return name;
    }

    public String getCourseNature() {
        return Nature;
    }

    public String getInvestigationMethod() {
        return Method;
    }


    public Score getScore() {
        return score;
    }

    public int getNum() {
        return num;
    }

    public double getSumScore() {
        sumScore += this.score.getSum();
        this.num++;
        return this.sumScore;
    }

    public void setSumScore(double sumScore) {
        this.sumScore =(int) sumScore;
    }
    public int getGrade(){
        
        return (int)(this.sumScore) / this.num;
    }
}
class ExamineScore extends Score{
    private int totalScore;

    public ExamineScore() {
    }

    public int getTotalScore() {
        return totalScore;
    }

    public void setTotalGrade(int totalScore) {
        this.totalScore= totalScore;
    }

}
 class Score {
    int n = 0;//成绩数量
    ArrayList<Double> scores = new ArrayList<>();//分项成绩
    ArrayList<Double> weight = new ArrayList<>();//权重
    private double sum  = 0;
    public Score(){

    }

    public Score(int n) {
        this.n = n;
    }

    public int getN() {
        return n;
    }

    public void setN(int n) {
        this.n = n;
    }

    public ArrayList<Double> getScores() {
        return scores;
    }

    public void setScores(ArrayList<Double> scores) {
        this.scores = scores;
    }

    public ArrayList<Double> getWeight() {
        return weight;
    }

    public void setWeight(ArrayList<Double> weight) {
        this.weight = weight;
    }

    public double getSum(){
        this.sum = 0;
        if(n != 0)
        for(int i = 0 ; i < n ; i ++){
            sum += scores.get(i) * weight.get(i);
        }
        return sum;
    }
}

class Student implements Comparable<Student>{
    private String name ;
    private String Number;

    private double score3 = 0;
    private int num  = 0 ;
    public Student() {

    }
    public Student(String Number, String name) {
        this.name = name;
        this.Number = Number;
    }
    public Student(String studentNumber, String name, int score3) {
        this.name = name;
        this.Number = studentNumber;
        this.score3 += score3;
        if(score3 != 0)
            this.num++;
    }
    public String getName() {
        return name;
    }

    public String getStudentNumber() {
        return Number;
    }

    public double getScore3() {
        return score3;
    }

    public void setScore3(double score3) {
        if(score3 != 0)
            num ++;
        this.score3 += score3;
    }
    @Override
    public int compareTo(Student o) {
       return (int)(this.getStudentNumber().compareTo(o.getStudentNumber()));
    }
    public void printScore(){

        if(this.num != 0)
            System.out.println(Number + " " + name + " " + (int)(this.score3) / num);
        else
            System.out.println(Number + " " + name + " " + "did not take any exams");
    }
    public int getNum() {
        return num;
    }
}
class TestScore extends Score {
    private int score1;
    private int score2;
    private int score3;


}
class Selection {//选课类
    private Course course  = new Course();
    private Student student = new Student();
    private Score score;

    public Selection() {
    }

    public Selection(Course course, Student student, Score score) {
        this.course = course;
        this.student = student;
        this.score = score;
    }
}

这道题在之前题目的基础上，添加了实验课这门课程，但是题目的测试点少了很多异常情况，总体难度我感觉比第一次的难度下降了。题目的重点在于正则表达式的使用，如何利用正则表达式快速地区分各种情况；例如

这是我在题目中对实验成绩的处理；用一个正则表达式来判断是否满足实验成绩的格式。

总体的情况与第一次相比就是在课程方面多加了一个实验课，其他的情况都差不多。

 

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）成绩平均分只取整数部分，小数部分丢弃

 代码如下：

import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Locale;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        ArrayList<Course> courses = new ArrayList<>();//课程清单
        ArrayList<Class> classes = new ArrayList<>();//班级清单
        while (true) {
            String string = in.nextLine();
            String[] temp = string.split(" ");
            if (string.contains("end")) {
                break;
            }

            else if (temp.length == 5 && (temp[1].equals("必修") || temp[1].equals("选修")) && temp[2].equals("考试")) {//考试的课程，选修或必修都行
               
                 boolean flag = false;//判断是否有这门课 没有
                for(Course e : courses){//不含该课程
                    if(e.getName().equals(temp[0])){//有这门课
                        flag = true;
                        break;
                    }
                }
                if(flag == false){//没有这门课
                    double weightSum = 0;//权重和
                    for(int b = 0 ; b < 2 ; b ++){//看权重之和是否为1
                        double h = Double.parseDouble(temp[3 + b]);
                        weightSum += h;
                    }
                    if(!(Math.abs(weightSum - 1.0) <= 0.000001)){//权重之和不为1
                        System.out.println(temp[0] + " : weight value error");
                    }
                    else {
                        Course course = new Course(temp[0], temp[1], "考试",2);//课程名称，性质，考核方式
                        for(int i = 0 ; i < 2; i++){
                            course.getScore().getWeight().add(Double.parseDouble(temp[3+i]));//设置权重
                        }
                        courses.add(course);
                    }
                }

            }
            else if (temp.length == 3) {//考察的课程
                boolean flag = false;//设没有这门课
                for(Course e: courses) {
                    if(e.getName().equals(temp[0])) {
                        flag = true;
                        break;
                    }
                }
                if(flag == false) {//没有这门课
                    if((temp[1].equals("必修") && temp [2].equals("考察") ) ) {//考试性质 与 考察方式 不匹配
                        System.out.println(temp[0] + " : course type & access mode mismatch");//不匹配
                    }
                    else if(temp[1].equals("必修") && temp[2].equals("实验") ){
                        System.out.println(temp[0] + " : course type & access mode mismatch");//不匹配
                    }
                    else if(temp[1].equals("选修") && temp[2].equals("实验")){
                        System.out.println(temp[0] + " : course type & access mode mismatch");//不匹配
                    }
                    else {//匹配
                        Course course = new Course(temp[0], temp[1], temp[2],1);//课程名称，性质，考核方式,成绩数量
                        course.getScore().getWeight().add(1.0);//设置权重
                        courses.add(course);
                    }
                }
            }
            else if(temp[2].equals("实验") && temp[1].equals("实验") && string.matches("(([\\u4e00-\\u9fa5[\\w]]){1,10}\\s)实验\\s实验\\s[4-9](\\s0\\.\\d+)+") ){//实验课程的处理
                int num = Integer.parseInt(temp[3]);//次数
                    boolean flag = false;//设没有这门课
                            for(Course e: courses) {
                                if(e.getName().equals(temp[0])) {
                                    flag = true;
                                    break;
                                }
                            }
                            if(flag == false){
                                if(temp.length == (4 + num)){//权重数量匹配
                                    double weightSum = 0;
                                    for(int b = 0 ; b < num ; b ++){//看权重之和是否为1
                                     double h = Double.parseDouble(temp[4 + b]);
                                     weightSum += h;
                                    }
                                    if(!(Math.abs(weightSum - 1.0) < 0.000001)){//权重之和不为1
                                        System.out.println(temp[0] + " : weight value error");
                                    }
                                    else {
                                        Course course = new Course(temp[0],temp[1],temp[2],Integer.parseInt(temp[3]));
                                        for(int i = 0; i < num ; i ++){
                                        course.getScore().getWeight().add(Double.parseDouble(temp[4+i]));//设置权重
                                        }
                                        courses.add(course);
                                    }
                                }
                                else{//数量不匹配
                                    System.out.println(temp[0] + " : number of scores does not match");//数量不匹配
                                }
                            }
            }
            else if (string.matches("[\\d]{8}(\\s([\\u4e00-\\u9fa5]|[\\w]){1,10}){2}(\\s([\\d]{1,2}|100)){1,2}")) {//选修必修课程成绩处理
                int i ,n ,j = 0;// i 是班级的下标 j是班级中 学生的线下标 n是课程的下标
                for( i = 0 ; i < classes.size() ; i++){
                    if(temp[0].contains(classes.get(i).getName())){//找到了班级
                        break;
                    }
                }
                if(i == classes.size()){//班级不存在
                    Class class1 = new Class(temp[0].substring(0,6));
                    classes.add(class1);
                }
                for (j = 0; j < classes.get(i).students.size(); j++) {
                    if (classes.get(i).searchStudent(temp[0],temp[1])) {
                        break;//学生存在
                    }
                }
                if (j == classes.get(i).students.size()) {//学生不存在
                    Student student = new Student(temp[0],temp[1]);
                    classes.get(i).students.add(student);
                }
                if(temp.length == 4){//选修课
                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        int m = 0;
                        if (flag == 0) {//有课的情况
                            if (courses.get(n).getInvestigationMethod().equals("考察")) {//这节课的是考察
                                if(courses.get(n).getCourseNature().equals("选修")){
                                    double x = Double.parseDouble(temp[3]);//选修的成绩
                                    courses.get(n).getScore().getScores().add(x);
//                                    courses.get(n).setScore3(x);
                                    courses.get(n).getSumScore();
                                    classes.get(i).getStudents().get(j).setScore3(x);
                                    
                                }
                            } else {
                                System.out.println(temp[0] + " " +
                                        temp[1] + " : " + "access mode mismatch");
                            }
                        }
                    }
                }
                if(temp.length == 5){//选修 或 必修的考试
                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        int m = 0;
                        if (flag == 0) {//有课的情况
                            if (!courses.get(n).getInvestigationMethod().equals("考察")) {//这节课的是考察
                                double x = Double.parseDouble(temp[3]);
                                double y = Double.parseDouble(temp[4]);
//                              
                                courses.get(n).getScore().getScores().add(x);
                                courses.get(n).getScore().getScores().add(y);
//                              
                                courses.get(n).getSumScore();
                                classes.get(i).getStudents().get(j).setScore3(courses.get(n).getScore().getSum());
                                  courses.get(n).getScore().getScores().clear();
                            } else {
                                System.out.println(temp[0] + " " +
                                        temp[1] + " : " + "access mode mismatch");
                            }
                        }
                    }

                }
            }
            else if(string.matches("[\\d]{8}(\\s([\\u4e00-\\u9fa5[\\w]]){1,10}){2}(\\s([\\d]{1,2}|100))+")){//实验成绩的处理
                int num = 0;
                for(int p = 0 ; p < courses.size() ; p++){
                    if(courses.get(p).getName().equals(temp[2])){//有这门课
                        num = courses.get(p).getScore().getWeight().size();//成绩数量
                    }
                }
                //int num= Integer.parseInt(temp[3]);//出现的次数
                if(temp.length - 3 == num){//成绩数量匹配
                    int i ,n ,j = 0;// i 是班级的下标 j是班级中 学生的线下标 n是课程的下标
                    for( i = 0 ; i < classes.size() ; i++){
                        if(temp[0].contains(classes.get(i).getName())){//找到了班级
                            break;
                        }
                    }
                    if(i == classes.size()){//班级不存在
                        Class class1 = new Class(temp[0].substring(0,6));
                        classes.add(class1);
                    }
                    for (j = 0; j < classes.get(i).students.size(); j++) {
                        if (classes.get(i).searchStudent(temp[0],temp[1])) {
                            break;//学生存在
                        }
                    }
                    if (j == classes.get(i).students.size()) {//学生不存在
                        Student student = new Student(temp[0],temp[1]);
                        classes.get(i).students.add(student);
                    }
                    int flag = 0;//判断有没有课
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        int m = 0;
                        if (flag == 0) {//有课的情况
                            if (courses.get(n).getInvestigationMethod().equals("实验")) {//这节课的
                                if(courses.get(n).getCourseNature().equals("实验")){
                                    for (int a = 0 ; a < num ; a ++){
                                        courses.get(n).getScore().getScores().add(Double.parseDouble(temp[3 + a]));
                                    }
                                    courses.get(n).getSumScore();
                                    classes.get(i).getStudents().get(j).setScore3(courses.get(n).getScore().getSum());
                                    courses.get(n).getScore().getScores().clear();
                                }
                            }
                            else {
                                System.out.println(temp[0] + " " +
                                        temp[1] + " : " + "access mode mismatch");
                            }
                        }
                    }
                }
                else {//成绩数量不匹配
                    int i ,n ,j = 0;// i 是班级的下标 j是班级中 学生的线下标 n是课程的下标
                    for( i = 0 ; i < classes.size() ; i++){
                        if(temp[0].contains(classes.get(i).getName())){//找到了班级
                            break;
                        }
                    }
                    if(i == classes.size()){//班级不存在
                        Class class1 = new Class(temp[0].substring(0,6));
                        classes.add(class1);
                    }
                    for (j = 0; j < classes.get(i).students.size(); j++) {
                        if (classes.get(i).searchStudent(temp[0],temp[1])) {
                            break;//学生存在
                        }
                    }
                    if (j == classes.get(i).students.size()) {//学生不存在
                        Student student = new Student(temp[0],temp[1]);
                        classes.get(i).students.add(student);
                    }
                    int flag = 0;//判断有没有课
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            System.out.println(temp[0] + " " +
                                    temp[1] + " : " + "access mode mismatch");
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                }
            }
            else
                System.out.println("wrong format");
        }

        Collections.sort(classes);
    
        for(Class e:classes){
            e.printScore();
        }
        courses.sort((Course o1,Course o2)->{
            Collator instance = Collator.getInstance(Locale.CHINA);
            return instance.compare(o1.getName(),o2.getName());
        });
        for(Course e : courses){
            int n = e.getNum();
            if(e.getCourseNature().equals("必修") || e.getCourseNature().equals("选修") && e.getInvestigationMethod().equals("考试")) {
                if(e.getNum() == 0){
                    System.out.println(e.getName() + " " +"has no grades yet");
                }
                else
                    System.out.println(e.getName() + " " + e.getGrade());
            }
            else if(e.getCourseNature().equals("实验") && e.getInvestigationMethod().equals("实验")){//实验成绩的输出
                if(e.getNum() == 0){
                    System.out.println(e.getName() + " " + "has no grades yet");
                }
                else
                    System.out.println(e.getName() + " " + e.getGrade());
            }
            else {
                if(e.getNum() == 0){
                    System.out.println(e.getName() + " "+ "has no grades yet");
                }
                else
                    System.out.println(e.getName() +" " + e.getGrade());
            }
        }
        for(Class e:classes){
            e.pScore();
        }

    }
}
class Class implements Comparable<Class>{
    private String name;
    ArrayList<Student> students =new ArrayList<>();
    public Class(String name) {
        this.name = name;
    }
    public ArrayList<Student> getStudents() {
        return students;
    }
    public String getName() {
        return name;
    }
    public boolean searchStudent(String num,String name){
        for(Student e:students){
            if(e.getName().equals(name) && e.getStudentNumber().equals(num))
                return true;
        }
        return false;
    }
    public Student getStudent(String num,String name){
        for(int i = 0; i<students.size();i++){
            if(students.get(i).getName().equals(name) && students.get(i).getStudentNumber().equals(num))
                return students.get(i);
        }
        return null;
    }
    @Override
    public int compareTo(Class o) {
        return (int)(this.name.compareTo(o.getName()));
    }
    public void printScore(){
        Collections.sort(students);
        for(Student e: students){
            e.printScore();
        }
    }
    public void pScore(){//输出班级的分数
        int sum  = 0;
        for(Student e :students){
            sum += e.getScore3();
        }
        int n = 0;
        for(int i = 0; i < students.size() ; i++){
            n = n + students.get(i).getNum();
        }
        if(n != 0)
            sum = sum / n;
        if(sum != 0){
            System.out.println(name + " " + sum );
        }
        if(sum == 0){
            System.out.println(name + " " + "has no grades yet");
        }
    }
}
class Course {
    private String name ;
    private String Nature;
    private String Method;
    private double sumScore;
    private Score score = new Score();
    private int num = 0;//该课程学生的数量

    public Course() {
    }

    public Course(String name, String Nature, String Method,int n) {
        this.name = name;
        this.Nature = Nature;
        this.Method = Method;
        this.score.setN(n);
    }

    public String getName() {
        return name;
    }

    public String getCourseNature() {
        return Nature;
    }

    public String getInvestigationMethod() {
        return Method;
    }


    public Score getScore() {
        return score;
    }

    public int getNum() {
        return num;
    }

    public double getSumScore() {
        sumScore += this.score.getSum();
        this.num++;
        return this.sumScore;
    }

    public void setSumScore(double sumScore) {
        this.sumScore =(int) sumScore;
    }
    public int getGrade(){
        
        return (int)(this.sumScore) / this.num;
    }
}
class ExamineScore extends Score{
    private int totalScore;

    public ExamineScore() {
    }

    public int getTotalScore() {
        return totalScore;
    }

    public void setTotalGrade(int totalScore) {
        this.totalScore= totalScore;
    }

}
 class Score {
    int n = 0;//成绩数量
    ArrayList<Double> scores = new ArrayList<>();//分项成绩
    ArrayList<Double> weight = new ArrayList<>();//权重
    private double sum  = 0;
    public Score(){

    }

    public Score(int n) {
        this.n = n;
    }

    public int getN() {
        return n;
    }

    public void setN(int n) {
        this.n = n;
    }

    public ArrayList<Double> getScores() {
        return scores;
    }

    public void setScores(ArrayList<Double> scores) {
        this.scores = scores;
    }

    public ArrayList<Double> getWeight() {
        return weight;
    }

    public void setWeight(ArrayList<Double> weight) {
        this.weight = weight;
    }

    public double getSum(){
        this.sum = 0;
        if(n != 0)
        for(int i = 0 ; i < n ; i ++){
            sum += scores.get(i) * weight.get(i);
        }
        return sum;
    }
}

class Student implements Comparable<Student>{
    private String name ;
    private String Number;

    private double score3 = 0;
    private int num  = 0 ;
    public Student() {

    }
    public Student(String Number, String name) {
        this.name = name;
        this.Number = Number;
    }
    public Student(String studentNumber, String name, int score3) {
        this.name = name;
        this.Number = studentNumber;
        this.score3 += score3;
        if(score3 != 0)
            this.num++;
    }
    public String getName() {
        return name;
    }

    public String getStudentNumber() {
        return Number;
    }

    public double getScore3() {
        return score3;
    }

    public void setScore3(double score3) {
        if(score3 != 0)
            num ++;
        this.score3 += score3;
    }
    @Override
    public int compareTo(Student o) {
       return (int)(this.getStudentNumber().compareTo(o.getStudentNumber()));
    }
    public void printScore(){

        if(this.num != 0)
            System.out.println(Number + " " + name + " " + (int)(this.score3) / num);
        else
            System.out.println(Number + " " + name + " " + "did not take any exams");
    }
    public int getNum() {
        return num;
    }
}
class TestScore extends Score {
    private int score1;
    private int score2;
    private int score3;


}
class Selection {//选课类
    private Course course  = new Course();
    private Student student = new Student();
    private Score score;

    public Selection() {
    }

    public Selection(Course course, Student student, Score score) {
        this.course = course;
        this.student = student;
        this.score = score;
    }
}

题目要求将类结构由继承改为组合的结构，并且新增了权重和分值的概念。这里我的思路是在成绩类中添加分值和权重两个属性，并且分别放在一个ArrayList里面，这样就能一对一地进行分数的计算。新增了异常：权重之和等于1。但是因为权重都是浮点数，所以改为权重之和与1作差后要小于一个很小的数。而其他情况与上一次相比没有多加其他的异常。题目重点也在于正则表达式的使用，利用正则表达式来快速区分各种成绩情况。

 3.踩坑心得

1.没有利用正则表达式，我一开始写第一次额作业时没有想过用正则表达式：

而是根据长度来判断，导致我第一次提交时，只有一点点分。而用了正则表达式之后就可以很清楚地分明各个情况。所以要常常使用正则表达式，来更清楚地判断各个情况。

2. 对异常的判断错误。有的时候明明要输出java has no grades yet这句话，可是我的程序却会输出Wrong Format.这就是对异常的判断有问题。这些问题往往都要在某一种情况种新添对异常的判定，或者是多加或者少加一个if语句。

 

4 .改进建议

1.题目集一：应该注意类与类之间的关系，实现单一职责原则，这样才能更利于程序的维护和调试。

2.题目集二：

相应代码如下：

 

if (string.matches("[\\d]{8}(\\s([\\u4e00-\\u9fa5]|[\\w]){1,10}){2}(\\s([\\d]{1,2}|100)){1,2}")) {//选修必修课程成绩处理
                int i ,n ,j = 0;// i 是班级的下标 j是班级中 学生的线下标 n是课程的下标
                for( i = 0 ; i < classes.size() ; i++){
                    if(temp[0].contains(classes.get(i).getName())){//找到了班级
                        break;
                    }
                }
                if(i == classes.size()){//班级不存在
                    Class class1 = new Class(temp[0].substring(0,6));
                    classes.add(class1);
                }
                for (j = 0; j < classes.get(i).students.size(); j++) {
                    if (classes.get(i).searchStudent(temp[0],temp[1])) {
                        break;//学生存在
                    }
                }
                if (j == classes.get(i).students.size()) {//学生不存在
                    Student student = new Student(temp[0],temp[1]);
                    classes.get(i).students.add(student);
                }
                if(temp.length == 4){//选修课
                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        int m = 0;
                        if (flag == 0) {//有课的情况
                            if (courses.get(n).getInvestigationMethod().equals("考察")) {//这节课的是考察
                                if(courses.get(n).getCourseNature().equals("选修")){
                                    double x = Double.parseDouble(temp[3]);//选修的成绩
                                    courses.get(n).getScore().getScores().add(x);
//                                    courses.get(n).setScore3(x);
                                    courses.get(n).getSumScore();
                                    classes.get(i).getStudents().get(j).setScore3(x);
                                    
                                }
                            } else {
                                System.out.println(temp[0] + " " +
                                        temp[1] + " : " + "access mode mismatch");
                            }
                        }
                    }
                }
                if(temp.length == 5){//选修 或 必修的考试
                    int flag = 0;
                    for (n = 0; n < courses.size(); n++) {//有这门课
                        if (courses.get(n).getName().equals(temp[2])) {
                            break;
                        }
                    }
                    if (n == courses.size()) {//没有这门课
                        System.out.println(temp[2] + " does not exist");
                        flag = 1;
                    }
                    if (courses.size() > 0) {
                        int m = 0;
                        if (flag == 0) {//有课的情况
                            if (!courses.get(n).getInvestigationMethod().equals("考察")) {//这节课的是考察
                                double x = Double.parseDouble(temp[3]);
                                double y = Double.parseDouble(temp[4]);
//                              
                                courses.get(n).getScore().getScores().add(x);
                                courses.get(n).getScore().getScores().add(y);
//                              
                                courses.get(n).getSumScore();
                                classes.get(i).getStudents().get(j).setScore3(courses.get(n).getScore().getSum());
                                  courses.get(n).getScore().getScores().clear();
                            } else {
                                System.out.println(temp[0] + " " +
                                        temp[1] + " : " + "access mode mismatch");
                            }
                        }
                    }

                }
            }

 

这里代码有重复的部分，可以先进行查找班级和学生的操作，在分别对考试和考察的情况进行分析。这样就可以简化代码，程序更易于阅读。

5.总结  

1.通过这一阶段的学习，我重点掌握了正则表达式的使用，通过运用正则表达式，可以快速地对所需的字符串进行判定。从而达到区分各种情况的目的。

2.Comparable的使用，在期中考试的时候，考到了Comparable接口，用于排序。在Conllection的子类中，都可以有sort方法，而只需让需要排序的类重写Comparable接口里的CompareTo()方法，就可以了。这个排序方法用的比较多，用起来也十分方便。

3.HashMap的使用，HashMap作为一种特殊的容器，存放的都是一个个键值对，但是键不能重复，值可以重复。HahMap的索引是通过键来找到值的，map.get()的方法十分简便。必要时，也可以获得HashMap里值的集合。例如： List<Map.Entry<String,Student>> list = new ArrayList<>(map.entrySet());来获得一个列表，该列表的元素全是Student的对象。

4.equals的覆盖.

 

 

 

这里的obj需要向下转型，才能使用PersonOverride里的isGender()和getAge（）方法，不然无法实现equals()的覆盖。

5.建议：在每次写完PTA的题目，可以发一份参考的代码，或者时让获得满分的同学分享一下解题思路，并且可以展示他们的代码写的优秀的地方。促进大家的交流合作，以获得更好的进步。

 

二．评价

1.教学方法（边讲边练）：有些没太听懂的地方，练起来就无从下手。所以希望讲的时候能讲的更清楚一些，让同学们理解。

2.教学组织（线上线下教学）：学习通的网课开通时间太短了，每次想看的时候都发现第一节已经关课了，就会有一些课看不到。希望时间可以更长。

3.教学过程（PTA题目驱动）：写PTA当然是好的，但是每次写完PTA之后，都不知道自己还有哪些可以改进的地方（尤其是对于还没有满分的同学），希望就是每次写完一次作业集都可以发一下参考答案（参考的代码）。让同学们看看哪些地方需要改进。