526互联

OO第三阶段作业总结

发布时间 2023-06-27 00:19:59作者: 一戴饼干

前言：

在第三阶段的pta作业里主要考察继承与多态，类的设计，接口以及集合框架，ArrayList，还有Map类和Set类的使用。每一次的题量不算大，难度时高时低，有一些题目是需要花比较多的时间好好琢磨的。比如说训练集9的统计Java程序中关键词的出现次数，训练集10、11、12里的课程成绩统计程序的系列。

设计与分析：

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

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

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

输入格式:

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

输出格式:

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

输入样例:

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

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

输出样例:

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

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

我的代码如下：
import java.util.*;
public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();
        String sentence = in.nextLine();
        if (sentence.equals("exit")){  //没有输入源码则视为输入非法
            System.out.print("Wrong Format");
            System.exit(0);
        }
        while(!sentence.equals("exit")){  //输入到exit停止
            if(!sentence.isEmpty())
                sb.append(sentence+"\n");
            sentence=in.nextLine();
        }
        Deal deal = new Deal(sb,Keywords());
        deal.getResult();
        deal.Obtain().forEach((String,Integer)->{
            if(!Integer.equals(0))
                System.out.println(Integer+"\t"+String);
        });
    }
    public static TreeMap<String,Integer> Keywords(){
        TreeMap<String,Integer> keywords = new TreeMap<>();
        String[] key = {"abstract","assert","boolean","break","byte","case","catch",
                "char","class","const","continue","default","do","double","else",
                "enum","extends","false","final","finally","float",
                "for","goto","if","implements","import","instanceof",
                "int","interface","long","native","new","null","package",
                "private","protected","public","return","short","static",
                "strictfp","super","switch","synchronized","this","throw",
                "throws","transient","true","try","void","volatile","while"};
        for(int i=0;i<key.length;i++){
            keywords.put(key[i],0 );
        }
        return keywords;
    }
}
class Deal{
    private StringBuilder sb;
    private TreeMap<String, Integer> keywords;
    public Deal(StringBuilder sb, TreeMap<String, Integer> keywords) {
        this.sb = sb;
        this.keywords = keywords;
    }
    public StringBuilder getResult(){
        for(int i=0;i<sb.length();i++){
            String s = String.valueOf(sb.charAt(i));
            if(sb.charAt(i)=='/'&&sb.charAt(i+1)=='/'){  //去掉以‘//’为开头的注释
                for(int j=i+2;j<sb.length();j++){
                    if(sb.charAt(j)=='\n'){
                        sb.delete(i,j+1);
                        i-=1;
                        break;
                    }
                }
                continue;
            }
            if(sb.charAt(i)=='/'&&sb.charAt(i+1)=='*'){
                for(int j=i+2;j<sb.length();j++){
                    if(sb.charAt(j)=='*'&&sb.charAt(j+1)=='/'){  //去掉多行注释
                        sb.delete(i,j+2);
                        i-=1;
                        break;
                    }
                }
                continue;
            }
            if(sb.charAt(i)=='"'){
                for(int j=i+1;j<sb.length();j++){  //去掉字符串
                    if(sb.charAt(j)=='"'){
                        sb.delete(i,j+1);
                        i-=1;
                        break;
                    }
                }
                continue;
            }
            if(s.matches("[\\.\\;\\,\\[\\]\\(\\)\\{\\}\\|\\!\\:\\\\\n]")){
                sb.delete(i,i+1);
                sb.insert(i," ");
            }
            if(s.matches("[//\\>\\<\\=\\*\\+\\-]")){
                sb.delete(i,i+1);
                sb.insert(i,"a");
            }
        }
        return sb;
    }
    public TreeMap Obtain(){  //得到所出现的关键字的次数
        String[] words = sb.toString().split(" ");
        for(int i=0;i<words.length;i++){
            if(keywords.containsKey(words[i].trim())){
                keywords.replace(words[i].trim(), keywords.get(words[i].trim())+1);
            }
        }
        return keywords;
    }
}

主要思路：

首先将关键词放进TreeMap里，TreeMap可以将这些关键字按首字母进行排序。主函数里就是读取所输入的Java程序，直到输入“exit”后停止。然后我创建了一个类名为Deal，主要功能是处理所读取的Java程序，首先是将程序中出现的以“//”开头以及“/**/”所含有的注释给去掉，接着是去掉字符串然后去掉各种符号，并且值得注意的是在去掉的同时加入一个空格符号，就相当于用空格去顶替想要去掉的字符。处理完之后，返回相应的结果。接着就是最后一步的操作，得到所出现的关键词的字数，将上一步过程中所得到的结果用split方法以空格分开放到数组里，遍历所得到的数组与之前存放在TreeMap里的关键词作比对，若存放在数组里的为关键词，则TreeMap里的value值加一，以此类推，从而得到题目的答案。

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

参考类图：


image.png

我的代码如import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String information = in.nextLine();
        ProcessInformation processInformation = new ProcessInformation();
        while(!information.equals("end")){
            processInformation.Deal(information);
            information= in.nextLine();
        }
        processInformation.showStudents();
        processInformation.showCourses();
        processInformation.showClasses();
    }
}
class Student implements Comparable<Student>{
    private String id;  //学生id
    Class aClass;  //学生所在班级
    private String name;  //学生姓名

    public Student() {
    }

    public Student(String name, String id) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Class getaClass() {
        return aClass;
    }

    public void setaClass(Class aClass) {
        this.aClass = aClass;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int compareTo(Student o) {  //按学号进行排序
        return getId().compareTo(o.getId());
    }
}
class Class implements Comparable<Class>{
    private String ID;  //班级ID
    private ArrayList<Student> students=new ArrayList<>();

    public Class() {
    }

    public Class(String ID) {
        this.ID = ID;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public ArrayList<Student> getStudents() {
        return students;
    }

    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }
    public void addStudent(Student student){  //添加学生
        students.add(student);
    }

    @Override
    public int compareTo(Class o) {  //按班级ID进行排序
        return ID.compareTo(o.getID());
    }
}
class Course implements Comparable<Course>{
    private String name;  //课程名称
    private String type;  //课程类型
    private String method;  //考核方式

    public Course() {
    }

    public Course(String name, String type, String method) {
        this.name = name;
        this.type = type;
        this.method = method;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    @Override
    public int compareTo(Course o) {  //按课程名称进行排序英文课程名排在中文课程名之前
        Comparator<Object> compare= Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(name,o.getName());
    }
}
abstract class Score{
    private int finalScore;  //期末成绩
    private int totalScore;  //总成绩

    public Score() {
    }

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

    public int getFinalScore() {
        return finalScore;
    }

    public void setFinalScore(int finalScore) {
        this.finalScore = finalScore;
    }

    public int getTotalScore() {
        return totalScore;
    }

    public void setTotalScore(int totalScore) {
        this.totalScore = totalScore;
    }
}
class ExaminationScore extends Score{
    private int usualScore;

    public int getUsualScore() {
        return usualScore;
    }

    public ExaminationScore(int usualScore,int finalScore) {
        super(finalScore);
        this.usualScore = usualScore;
        this.setTotalScore((int)(finalScore*0.7+usualScore*0.3));
    }
}
class AssessmentScore extends Score{
    public AssessmentScore(int finalScore) {
        super(finalScore);
        this.setTotalScore(finalScore);
    }
}
class CourseSelection{
    private Course course;
    private Student student;
    private Score score;

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

    public Course getCourse() {
        return course;
    }

    public void setCourse(Course course) {
        this.course = course;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public Score getScore() {
        return score;
    }

    public void setScore(Score score) {
        this.score = score;
    }
}
class ProcessInformation{  //处理信息
    ArrayList<Course> courses = new ArrayList<>();
    ArrayList<Student> students = new ArrayList<>();
    ArrayList<CourseSelection> courseSelections = new ArrayList<>();
    ArrayList<Class> classes = new ArrayList<>();

    public Course getCourse(String courseName) {
        for (int i=0;i<courses.size();i++){
            if(courses.get(i).getName().equals(courseName))
                return courses.get(i);
        }
        return null;
    }
    public Class getClass(String classID){
        for(int i=0;i<classes.size();i++){
            if(classes.get(i).getID().equals(classID))
                return classes.get(i);
        }
        return null;
    }
    public Student getStudent(String studentID){
        for(int i=0;i<students.size();i++)
        {
            if(students.get(i).getId().equals(studentID))
            {
                return students.get(i);
            }

        }
        return null;
    }
    public ArrayList<CourseSelection> findClass(String classID){
        Class aclass =getClass(classID);
        ArrayList<CourseSelection> classSelects = new ArrayList<>();
        for(int i=0;i<courseSelections.size();i++){
            if(classID.equals(courseSelections.get(i).getStudent().aClass.getID())){
                classSelects.add(courseSelections.get(i));
            }
        }
        return classSelects;
    }
    public ArrayList<CourseSelection> findStudent(String stuId) {
        ArrayList<CourseSelection> stuSelects = new ArrayList<>();
        for(int i=0;i<courseSelections.size();i++){
            if(stuId.equals(courseSelections.get(i).getStudent().getId())){
                stuSelects.add(courseSelections.get(i));
            }
        }
        return stuSelects;
    }
    public ArrayList<CourseSelection> findCourse(String courseName){
        ArrayList<CourseSelection> courseSelects = new ArrayList<>();
        for(int i=0;i<courseSelections.size();i++){
            if(courseName.equals(courseSelections.get(i).getCourse().getName())){
                courseSelects.add(courseSelections.get(i));
            }
        }
        return courseSelects;
    }
    public boolean CheckCourse(Course course){  //检查课程信息
        int Type,Method;
        if(course.getType().equals("必修"))
            Type=0;
        else if(course.getType().equals("选修"))
            Type=1;
        else Type=-1;

        if(course.getMethod().equals("考试"))
            Method=0;
        else if(course.getMethod().equals("考察"))
            Method=1;
        else Method=-1;

        if(Type==0&&Method==0)
            return true;
        if(Type==1&&(Method==0||Method==1))
            return true;
        System.out.println(course.getName()+" : course type & access mode mismatch");
        return false;
    }
    private boolean CheckGrade(String[] items,Course course){
        String Method=course.getMethod();
        if(Method.equals("考试")&&items.length==5){
            return true;
        }
        if(Method.equals("考察")&&items.length==4) {
            return true;
        }
        System.out.println(items[0]+" "+items[1]+" : access mode mismatch");
        return false;
    }
    boolean existChooseCourse(Student stu,Course course){
        for(int i=0;i<courseSelections.size();i++){
            if(courseSelections.get(i).getCourse().getName().equals(course.getName())) {
                if (courseSelections.get(i).getStudent().getName().equals(stu.getName()))
                    return true;
            }
        }
        return false;
    }
    private void addCourse(String[] word){
        String name=word[0];
        String type=word[1];
        String method=word[2];
        Course course=new Course(name,type,method);
        if(!CheckCourse(course))
            return;
        if(getCourse(name)==null){
            courses.add(course);
        }
    }
    private void addScore(String[] word){
        String stuId=word[0];
        String stuName=word[1];
        String courseName=word[2];
        String classId=stuId.substring(0,6);
        Class cls;
        Student stu;
        cls=getClass(classId);
        if(cls==null){
            cls=new Class(classId);
            classes.add(cls);
        }
        stu=getStudent(stuId);
        if(stu==null){
            stu=new Student(stuName,stuId);
            students.add(stu);
            cls.addStudent(stu);
        }
        stu.setaClass(cls);
        Course course= getCourse(courseName);
        if(course==null){
            System.out.println(courseName+" does not exist");
            return;
        }
        if(!CheckGrade(word,course))
            return;
        Score score;
        if(word.length==4){
            int finalScore=Integer.parseInt(word[3]);
            score=new AssessmentScore(finalScore);
        }
        else {
            int usualScore=Integer.parseInt(word[3]);
            int finalScore=Integer.parseInt(word[4]);
            score=new ExaminationScore(usualScore,finalScore);
        }
        if(existChooseCourse(stu,course)) return;
        CourseSelection courseSelection = new CourseSelection(course,stu,score);
        courseSelections.add(courseSelection);
    }
    public int getAvgUsualScore(ArrayList<CourseSelection> courseSelects) {
        int sum = 0;
        for(CourseSelection cs : courseSelects)
        {
            sum +=((ExaminationScore) cs.getScore()).getUsualScore();
        }
        return sum/courseSelects.size();
    }
    public int getAvgTotalScore(ArrayList<CourseSelection> listChooseCourse) {
        int sum =0;
        for(CourseSelection cs : listChooseCourse)
        {
            sum +=cs.getScore().getTotalScore();
        }
        return sum/listChooseCourse.size();
    }
    public int getAvgFinalScore(ArrayList<CourseSelection> courseSelects) {
        int sum =0;
        for(CourseSelection cs : courseSelects)
        {
            sum +=cs.getScore().getFinalScore();
        }
        return sum/courseSelects.size();
    }
    public int Matching(String s){
        if(s.matches("[^ \\t]{1,10}"+" "+"(选修|必修)"+" "+"(考试|考察)")){
            return 1;  //课程信息
        }
        if(s.matches("\\d{8}"+" "+"[^ \\t]{1,10}"+" "+"[^ \\t]{1,10}"+" "+
                "([1-9]?[0-9]|100)"+"(\\s([1-9]?[0-9]|100))?")){
            return 2;  //成绩信息
        }
        return 0;
    }
    public void Deal(String information){  //对输入的信息进行处理
        String[] word = information.split(" ");
        int key = Matching(information);
        switch (key){
            case 0:
                System.out.println("wrong format");
                break;
            case 1:
                addCourse(word);
                break;
            case 2:
                addScore(word);
                break;
        }

    }
    public void showStudents(){
        Collections.sort(students);
        for(int i =0;i<students.size();i++)
        {
            Student stu=students.get(i);
            ArrayList<CourseSelection> stuCourseSelects =findStudent(stu.getId());
            if(stuCourseSelects.size()!=0)
            {
                System.out.println(stu.getId() + " "+ stu.getName()+" "+getAvgTotalScore(stuCourseSelects));
            }
            else
            {
                System.out.println(stu.getId() +" "+ stu.getName()+" did not take any exams");
            }
        }
    }
    public void showCourses(){
        Collections.sort(courses);
        for(int i =0;i<courses.size();i++)
        {
            Course course = courses.get(i);
            ArrayList<CourseSelection> courseSelects = findCourse(course.getName());
            if(courseSelects.size()== 0)
            {
                System.out.println(course.getName() + " has no grades yet");
            }
            else {
                if(course.getMethod().equals("考试"))
                {
                    System.out.println(course.getName() + " " +getAvgUsualScore(courseSelects)+ " "+getAvgFinalScore(courseSelects)+ " "+getAvgTotalScore(courseSelects));
                }else{
                    System.out.println(course.getName() + " "+getAvgFinalScore(courseSelects)+ " "+getAvgTotalScore(courseSelects));
                }
            }
        }
    }
    public void showClasses(){
        Collections.sort(classes);
        for(int i =0;i<classes.size();i++)
        {
            Class cls = classes.get(i);
            ArrayList<CourseSelection> classCourseSelects = findClass(cls.getID());
            if(classCourseSelects.size()==0){
                System.out.println(cls.getID()+" has no grades yet");
            }
            else{
                System.out.println(cls.getID()+" "+ getAvgTotalScore(classCourseSelects));
            }
        }
    }
}

主要思路：

创建Student类，Class类，Course类，Score类，ExaminationScore类，AssessmentScore类，这两个类都继承Score类，CourseSelection类里的属性包含了Course类、Student类以及Score类，最最最重要的一个类就是ProcessInformation类，负责处理信息

 

上图是我所写代码的类图，类与类之间的调用关系还是比较明确的，这里要重点说明一下ProcessInformation类，这个类里的属性有课程集合，学生集合，班级集合以及选课系统集合，该类里有一个方法叫做Matching，主要是负责对从主函数中所获取的输入的信息进行第一轮的检查，将信息分为三类，一类是课程信息，一类是成绩信息，还有一类是错误信息，分别返回整数1,2,0。其中这个校验比对是通过正则表达式来实现的。进行了第一步的处理之后，方法Deal接收方法Matching所返回的值，分别对应到addCourse方法和addScore方法里去，在addCourse里要对所录入的课程信息进行检查，因为题目中说明了必修类型的科目所对应的必须是考试，根据简单的if语句进行配对和判断即可。并且需要注意的是相同的成绩信息不重复录入。成绩信息同样也不能重复录入，而且根据所输入的长度将成绩信息分为考试型成绩和考察型成绩，不匹配的成绩同要需要输出错误提示。后面的就是一些简单的成绩处理，吧平时成绩和期末成绩放在成绩类里，从而得到对应所需的平均分。此外，就不做过多解释了。

7-3 课程成绩统计程序-2在1的基础上增加了一些要求，具体是在课程性质上增加了实验课，在考核方式上增加了实验，实验的总成绩等于课程每次实验成绩的平均分且实验课的成绩必须为实验。

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

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

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

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

根据上述变化，我的代码也在原有基础上做出了相应的改进，主要是ProcessInformation类有很大的变化，类图其实和第一道题的并没有差别，整体的框架并没有改变，改变的只是类里的内容，具体如下所示：

class ProcessInformation{  //处理信息
    ArrayList<Course> courses = new ArrayList<>();
    ArrayList<Student> students = new ArrayList<>();
    ArrayList<CourseSelection> courseSelections = new ArrayList<>();
    ArrayList<Class> classes = new ArrayList<>();

    public Course getCourse(String courseName) {
        for (int i=0;i<courses.size();i++){
            if(courses.get(i).getName().equals(courseName))
                return courses.get(i);
        }
        return null;
    }
    public Class getClass(String classID){
        for(int i=0;i<classes.size();i++){
            if(classes.get(i).getID().equals(classID))
                return classes.get(i);
        }
        return null;
    }
    public Student getStudent(String studentID){
        for(int i=0;i<students.size();i++)
        {
            if(students.get(i).getId().equals(studentID))
            {
                return students.get(i);
            }

        }
        return null;
    }
    public ArrayList<CourseSelection> findClass(String classID){
        ArrayList<CourseSelection> classSelects = new ArrayList<>();
        for(int i=0;i<courseSelections.size();i++){
            if(classID.equals(courseSelections.get(i).getStudent().aClass.getID())){
                classSelects.add(courseSelections.get(i));
            }
        }
        return classSelects;
    }
    public ArrayList<CourseSelection> findStudent(String stuId) {
        ArrayList<CourseSelection> stuSelects = new ArrayList<>();
        for(int i=0;i<courseSelections.size();i++){
            if(stuId.equals(courseSelections.get(i).getStudent().getId())){
                stuSelects.add(courseSelections.get(i));
            }
        }
        return stuSelects;
    }
    public ArrayList<CourseSelection> findCourse(String courseName){
        ArrayList<CourseSelection> courseSelects = new ArrayList<>();
        for(int i=0;i<courseSelections.size();i++){
            if(courseName.equals(courseSelections.get(i).getCourse().getName())){
                courseSelects.add(courseSelections.get(i));
            }
        }
        return courseSelects;
    }
    public boolean CheckCourse(Course course){  //检查课程信息
        int Type,Method;
        if(course.getType().equals("必修"))
            Type=0;
        else if(course.getType().equals("选修"))
            Type=1;
        else if(course.getType().equals("实验"))
            Type=2;
        else Type=-1;

        if(course.getMethod().equals("考试"))
            Method=0;
        else if(course.getMethod().equals("考察"))
            Method=1;
        else if(course.getMethod().equals("实验"))
            Method=2;
        else Method=-1;

        if(Type==0&&Method==0)
            return true;
        if(Type==1&&(Method==0||Method==1))
            return true;
        if(Type==2&&Method==2)
            return true;
        System.out.println(course.getName()+" : course type & access mode mismatch");
        return false;
    }
    private boolean CheckGrade(String[] items,Course course){
        String Method=course.getMethod();
        if(Method.equals("考试")&&items.length==5){
            return true;
        }
        if(Method.equals("考察")&&items.length==4) {
            return true;
        }
        if(Method.equals("实验")&&items.length==(4+Integer.parseInt(items[3]))){
            return true;
        }
        System.out.println(items[0]+" "+items[1]+" : access mode mismatch");
        return false;
    }
    boolean existChooseCourse(Student stu,Course course){
        for(int i=0;i<courseSelections.size();i++){
            if(courseSelections.get(i).getCourse().getName().equals(course.getName())) {
                if (courseSelections.get(i).getStudent().getId().equals(stu.getId()))
                    return true;
            }
        }
        return false;
    }
    private void addCourse(String[] word){
        String name=word[0];
        String type=word[1];
        String method=word[2];
        Course course=new Course(name,type,method);
        if(!CheckCourse(course))
            return;
        if(getCourse(name)==null){
            courses.add(course);
        }
    }
    private void addScore(String[] word){
        String stuId=word[0];
        String stuName=word[1];
        String courseName=word[2];
        String classId=stuId.substring(0,6);
        Class cls;
        Student stu;
        cls=getClass(classId);
        if(cls==null){
            cls=new Class(classId);
            classes.add(cls);
        }
        stu=getStudent(stuId);
        if(stu==null){
            stu=new Student(stuName,stuId);
            students.add(stu);
            cls.addStudent(stu);
        }
        stu.setaClass(cls);
        Course course= getCourse(courseName);
        if(course==null){
            System.out.println(courseName+" does not exist");
            return;
        }
        if(!CheckGrade(word,course))
            return;
        Score score;
        if(word.length==4){
            int finalScore=Integer.parseInt(word[3]);
            score=new AssessmentScore(finalScore);
        }
        else if(word.length==5){
            int usualScore=Integer.parseInt(word[3]);
            int finalScore=Integer.parseInt(word[4]);
            score=new ExaminationScore(usualScore,finalScore);
        }
        else{
            ArrayList<Float> scores=new ArrayList<>();
            for(int i=4;i<word.length;i++){
                scores.add(Float.valueOf(word[i]));
            }
            score=new ExperimentScore(scores);
        }
        if(existChooseCourse(stu,course)) return;
        CourseSelection courseSelection = new CourseSelection(course,stu,score);
        courseSelections.add(courseSelection);
    }
    public int getAvgUsualScore(ArrayList<CourseSelection> courseSelects) {
        int sum = 0;
        for(CourseSelection cs : courseSelects)
        {
            sum +=((ExaminationScore) cs.getScore()).getUsualScore();
        }
        return sum/courseSelects.size();
    }
    public int getAvgTotalScore(ArrayList<CourseSelection> courseSelections) {
        int sum =0;
        for(CourseSelection cs : courseSelections)
        {
            sum +=cs.getScore().getTotalScore();
        }
        return sum/courseSelections.size();
    }
    public int getAvgFinalScore(ArrayList<CourseSelection> courseSelections) {
        int sum =0;
        for(CourseSelection cs : courseSelections)
        {
            sum +=cs.getScore().getFinalScore();
        }
        return sum/courseSelections.size();
    }
    public int Matching(String s){
        if(s.matches("[^ \\t]{1,10}"+" "+"(选修|必修|实验)"+" "+"(考试|考察|实验)")){
            return 1;  //课程信息
        }
        if(s.matches("\\d{8}"+" "+"[^ \\t]{1,10}"+" "+"[^ \\t]{1,10}"+" "
                +"[4-9]"+"(\\s([1-9]?[0-9]|100)){1,10}")){
            return 3;  //实验成绩信息
        }
        if(s.matches("\\d{8}"+" "+"[^ \\t]{1,10}"+" "+"[^ \\t]{1,10}"+" "+
                "([1-9]?[0-9]|100)"+"(\\s([1-9]?[0-9]|100))?")){
            return 2;  //成绩信息
        }
        return 0;
    }
    public void Deal(String information){  //对输入的信息进行处理
        String[] word = information.split(" ");
        int key = Matching(information);
        switch (key){
            case 0:
                System.out.println("wrong format");
                break;
            case 1:
                addCourse(word);
                break;
            case 2:
                addScore(word);
                break;
            case 3:
                addScore(word);
                break;
        }

    }
    public void showStudents(){
        Collections.sort(students);
        for(int i =0;i<students.size();i++)
        {
            Student stu=students.get(i);
            ArrayList<CourseSelection> stuCourseSelects =findStudent(stu.getId());
            if(stuCourseSelects.size()!=0)
            {
                System.out.println(stu.getId() + " "+ stu.getName()+" "+getAvgTotalScore(stuCourseSelects));
            }
            else
            {
                System.out.println(stu.getId() +" "+ stu.getName()+" did not take any exams");
            }
        }
    }
    public void showCourses(){
        Collections.sort(courses);
        for(int i =0;i<courses.size();i++)
        {
            Course course = courses.get(i);
            ArrayList<CourseSelection> courseSelects = findCourse(course.getName());
            if(courseSelects.size()== 0)
            {
                System.out.println(course.getName() + " has no grades yet");
            }
            else {
                if(course.getMethod().equals("考试"))
                {
                    System.out.println(course.getName() + " " +getAvgUsualScore(courseSelects)+ " "+getAvgFinalScore(courseSelects)+ " "+getAvgTotalScore(courseSelects));
                }
                else if(course.getMethod().equals("考察")){
                    System.out.println(course.getName() + " "+getAvgFinalScore(courseSelects)+ " "+getAvgTotalScore(courseSelects));
                }
                else if(course.getMethod().equals("实验")){
                    System.out.println(course.getName()+" "+getAvgTotalScore(courseSelects));
                }
            }
        }
    }
    public void showClasses(){
        Collections.sort(classes);
        for(int i =0;i<classes.size();i++)
        {
            Class cls = classes.get(i);
            ArrayList<CourseSelection> classCourseSelects = findClass(cls.getID());
            if(classCourseSelects.size()==0){
                System.out.println(cls.getID()+" has no grades yet");
            }
            else{
                System.out.println(cls.getID()+" "+ getAvgTotalScore(classCourseSelects));
            }
        }
    }
}

其实变化的地方也并没有很多，主要就是新增加了实验课，在计算成绩时添加了实验课成绩的计算方法，在信息录入识别的时候添加了检测实验课的正则表达式，简单一句话就是换汤不换药，主要思想一点变化也没有。

相比之下7-2 课程成绩统计程序-3让我一开始有点摸不着头脑

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

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

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

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

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

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

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

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

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

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

1、输入：

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

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

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

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

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

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

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

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

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

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

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

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

要修改类的结构，起初我以为需要做很多重构，并且想象不到修改后类与类之间的调用关系，特别是成绩类之间的组合关系真的是什么头绪也没有，后面经过同学的指点，很快的领悟到了题目的意义所在，知晓了怎么样去修改和调用成绩类，修改后的代码如下所示：

 

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

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String information = in.nextLine();
        ProcessInformation processInformation = new ProcessInformation();
        while(!information.equals("end")){
            processInformation.Deal(information);
            information= in.nextLine();
        }
        processInformation.showStudents();
        processInformation.showCourses();
        processInformation.showClasses();
    }
}
class Student implements Comparable<Student>{
    private String id;  //学生id
    Class aClass;  //学生所在班级
    private String name;  //学生姓名

    public Student() {
    }

    public Student(String name, String id) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Class getaClass() {
        return aClass;
    }

    public void setaClass(Class aClass) {
        this.aClass = aClass;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int compareTo(Student o) {  //按学号进行排序
        return getId().compareTo(o.getId());
    }
}
class Class implements Comparable<Class>{
    private String ID;  //班级ID
    private ArrayList<Student> students=new ArrayList<>();

    public Class() {
    }

    public Class(String ID) {
        this.ID = ID;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public ArrayList<Student> getStudents() {
        return students;
    }

    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }
    public void addStudent(Student student){  //添加学生
        students.add(student);
    }

    @Override
    public int compareTo(Class o) {  //按班级ID进行排序
        return ID.compareTo(o.getID());
    }
}
class Course implements Comparable<Course>{
    private String name;  //课程名称
    private String type;  //课程类型
    private String method;  //考核方式
    private String n;//权重数量
    private ArrayList weights; //课程权重
    public Course() {
    }

    public Course(String name, String type, String method) {
        this.name = name;
        this.type = type;
        this.method = method;
    }
    public Course(String name, String type, String method, ArrayList weights) {
        this.name = name;
        this.type = type;
        this.method = method;
        this.weights = weights;
    }
    public Course(String name, String type, String method, String n, ArrayList weights) {
        this.name = name;
        this.type = type;
        this.method = method;
        this.n = n;
        this.weights = weights;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public String getN() {
        return n;
    }

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

    public ArrayList getWeights() {
        return weights;
    }

    public void setWeights(ArrayList weights) {
        this.weights = weights;
    }

    @Override
    public int compareTo(Course o) {  //按课程名称进行排序英文课程名排在中文课程名之前
        Comparator<Object> compare= Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(name,o.getName());
    }
}
class Score{
    private PartScore partScore;

    public Score() {
    }

    public Score(PartScore partScore) {
        this.partScore = partScore;
    }
    public float getTotal(){
        float sum=0;
        for(int i=0;i<partScore.getWeight().size();i++){
            sum+=Float.parseFloat((String) partScore.getWeight().get(i))*Float.parseFloat((String) partScore.getGrades().get(i));
        }
        return sum;
    }
}
class PartScore{
    private ArrayList grades;
    private ArrayList weight;

    public PartScore() {
    }

    public PartScore(ArrayList grades, ArrayList weight) {
        this.grades = grades;
        this.weight = weight;
    }

    public ArrayList getGrades() {
        return grades;
    }

    public void setGrades(ArrayList grades) {
        this.grades = grades;
    }

    public ArrayList getWeight() {
        return weight;
    }

    public void setWeight(ArrayList weight) {
        this.weight = weight;
    }
}
class CourseSelection{
    private Course course;
    private Student student;
    private Score score;

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

    public Course getCourse() {
        return course;
    }

    public void setCourse(Course course) {
        this.course = course;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public Score getScore() {
        return score;
    }

    public void setScore(Score score) {
        this.score = score;
    }
}
class ProcessInformation{  //处理信息
    ArrayList<Course> courses = new ArrayList<>();
    ArrayList<Student> students = new ArrayList<>();
    ArrayList<CourseSelection> courseSelections = new ArrayList<>();
    ArrayList<Class> classes = new ArrayList<>();

    public Course getCourse(String courseName) {
        for (int i=0;i<courses.size();i++){
            if(courses.get(i).getName().equals(courseName))
                return courses.get(i);
        }
        return null;
    }
    public Class getClass(String classID){
        for(int i=0;i<classes.size();i++){
            if(classes.get(i).getID().equals(classID))
                return classes.get(i);
        }
        return null;
    }
    public Student getStudent(String studentID){
        for(int i=0;i<students.size();i++)
        {
            if(students.get(i).getId().equals(studentID))
            {
                return students.get(i);
            }

        }
        return null;
    }
    public ArrayList<CourseSelection> findClass(String classID){
        ArrayList<CourseSelection> classSelects = new ArrayList<>();
        for(int i=0;i<courseSelections.size();i++){
            if(classID.equals(courseSelections.get(i).getStudent().aClass.getID())){
                classSelects.add(courseSelections.get(i));
            }
        }
        return classSelects;
    }
    public ArrayList<CourseSelection> findStudent(String stuId) {
        ArrayList<CourseSelection> stuSelects = new ArrayList<>();
        for(int i=0;i<courseSelections.size();i++){
            if(stuId.equals(courseSelections.get(i).getStudent().getId())){
                stuSelects.add(courseSelections.get(i));
            }
        }
        return stuSelects;
    }
    public ArrayList<CourseSelection> findCourse(String courseName){
        ArrayList<CourseSelection> courseSelects = new ArrayList<>();
        for(int i=0;i<courseSelections.size();i++){
            if(courseName.equals(courseSelections.get(i).getCourse().getName())){
                courseSelects.add(courseSelections.get(i));
            }
        }
        return courseSelects;
    }
    public boolean CheckCourse(Course course){  //检查课程信息
        int Type,Method;
        if(course.getType().equals("必修"))
            Type=0;
        else if(course.getType().equals("选修"))
            Type=1;
        else if(course.getType().equals("实验"))
            Type=2;
        else Type=-1;

        if(course.getMethod().equals("考试"))
            Method=0;
        else if(course.getMethod().equals("考察"))
            Method=1;
        else if(course.getMethod().equals("实验"))
            Method=2;
        else Method=-1;

        if(Type==0&&Method==0)
            return true;
        if(Type==1&&(Method==0||Method==1))
            return true;
        if(Type==2&&Method==2)
            return true;
        System.out.println(course.getName()+" : course type & access mode mismatch");
        return false;
    }
    public boolean numMatch(Course course){
        if(Integer.parseInt(course.getN())==course.getWeights().size())
            return true;
        System.out.println(course.getName()+" : number of scores does not match");
        return false;
    }
    public boolean weightValue(Course course){
        float sum=0;
        for(int i=0;i<course.getWeights().size();i++){
            sum+=Float.parseFloat(course.getWeights().get(i).toString());
        }
        if(sum>=0.99&&sum<=1.01)
            return true;
        else{
            System.out.println(course.getName()+" : weight value error");
            return false;
        }
    }
    private boolean CheckGrade(String[] items,Course course){
        String Method=course.getMethod();
        if(Method.equals("考试")&&items.length==5){
            return true;
        }
        if(Method.equals("考察")&&items.length==4) {
            return true;
        }
        if(Method.equals("实验")&&items.length==(3+Integer.parseInt(course.getN()))){
            return true;
        }
        System.out.println(items[0]+" "+items[1]+" : access mode mismatch");
        return false;
    }
    boolean existChooseCourse(Student stu,Course course){
        for(int i=0;i<courseSelections.size();i++){
            if(courseSelections.get(i).getCourse().getName().equals(course.getName())) {
                if (courseSelections.get(i).getStudent().getId().equals(stu.getId()))
                    return true;
            }
        }
        return false;
    }
    private void addCourse(String[] word){
        String name=word[0];
        String type=word[1];
        String method=word[2];
        Course course=new Course(name,type,method);
        if(!CheckCourse(course))
            return;
        if(getCourse(name)==null){
            courses.add(course);
        }
    }
    private void addCourse3(String[] word){
        String name=word[0];
        String type=word[1];
        String method=word[2];
        ArrayList<String> arrayList=new ArrayList<>();
        arrayList.add(word[3]);
        arrayList.add(word[4]);
        Course course=new Course(name,type,method,arrayList);
        if(!CheckCourse(course))
            return;
        if(!weightValue(course))
            return;
        if(getCourse(name)==null){
            courses.add(course);
        }
    }
    private void addCourse2(String[] word){
        String name=word[0];
        String type=word[1];
        String method=word[2];
        String n=word[3];
        ArrayList<String> arrayList=new ArrayList<>();
        for(int i=4;i<word.length;i++){
            arrayList.add(word[i]);
        }
        Course course=new Course(name,type,method,n,arrayList);
        if(!CheckCourse(course))
            return;
        if(!numMatch(course))
            return;
        if(!weightValue(course))
            return;
        if(getCourse(name)==null){
            courses.add(course);
        }
    }
    private void addScore(String[] word){
        String stuId=word[0];
        String stuName=word[1];
        String courseName=word[2];
        String classId=stuId.substring(0,6);
        Class cls;
        Student stu;
        cls=getClass(classId);
        if(cls==null){
            cls=new Class(classId);
            classes.add(cls);
        }
        stu=getStudent(stuId);
        if(stu==null){
            stu=new Student(stuName,stuId);
            students.add(stu);
            cls.addStudent(stu);
        }
        stu.setaClass(cls);
        Course course= getCourse(courseName);
        if(course==null){
            System.out.println(courseName+" does not exist");
            return;
        }
        if(!CheckGrade(word,course))
            return;
        Score score;
        PartScore partScore;
        if(word.length==4){
            ArrayList<String> grades=new ArrayList<>();
            grades.add(word[3]);
            ArrayList<String> weights=new ArrayList<>();
            weights.add(String.valueOf(1));
            partScore=new PartScore(grades,weights);
            score=new Score(partScore);
        }
        else if(word.length==5){
            ArrayList<String> grades=new ArrayList<>();
            grades.add(word[3]);
            grades.add(word[4]);
            partScore=new PartScore(grades,course.getWeights());
            score=new Score(partScore);
        }
        else{
            ArrayList<String> grades=new ArrayList<>();
            for(int i=3;i<word.length;i++){
                grades.add(word[i]);
            }
            partScore=new PartScore(grades,course.getWeights());
            score=new Score(partScore);
        }
        if(existChooseCourse(stu,course)) return;
        CourseSelection courseSelection = new CourseSelection(course,stu,score);
        courseSelections.add(courseSelection);
    }
    public int getAvgTotalScore(ArrayList<CourseSelection> courseSelections) {
        int sum =0;
        for(CourseSelection cs : courseSelections)
        {
            sum +=cs.getScore().getTotal();
        }
        return sum/courseSelections.size();
    }

    public int Matching(String s){
        if(s.matches("[^ \\t]{1,10}"+" "+"(选修|必修|实验)"+" "+"(考试|考察|实验)")){
            return 1;  //考察课程信息
        }
        if(s.matches("[^ \\t]{1,10}"+" "+"(选修|必修|实验)"+" "+"(考试|考察|实验)"+" "+"(0\\.[1-9])"+" "+"(0\\.[1-9])"))
            return 4;  //考试课程信息
        if(s.matches("[^ \\t]{1,10}"+" "+"(选修|必修|实验)"+" "+"(考试|考察|实验)"+" "+"[4-9]"
                +"(\\s(0\\.[1-9])){1,10}"))
            return 5;  //实验课程信息
        if(s.matches("\\d{8}"+" "+"[^ \\t]{1,10}"+" "+"[^ \\t]{1,10}"
                +"(\\s([1-9]?[0-9]|100)){1,10}")){
            return 3;  //实验成绩信息
        }
        if(s.matches("\\d{8}"+" "+"[^ \\t]{1,10}"+" "+"[^ \\t]{1,10}"+" "+
                "([1-9]?[0-9]|100)"+"(\\s([1-9]?[0-9]|100))?")){
            return 2;  //成绩信息
        }
        return 0;
    }
    public void Deal(String information){  //对输入的信息进行处理
        String[] word = information.split(" ");
        int key = Matching(information);
        switch (key){
            case 0:
                System.out.println("wrong format");
                break;
            case 1:
                addCourse(word);
                break;
            case 4:
                addCourse3(word);
                break;
            case 5:
                addCourse2(word);
                break;
            case 2:
                addScore(word);
                break;
            case 3:
                addScore(word);
                break;
        }

    }
    public void showStudents(){
        Collections.sort(students);
        for(int i =0;i<students.size();i++)
        {
            Student stu=students.get(i);
            ArrayList<CourseSelection> stuCourseSelects =findStudent(stu.getId());
            if(stuCourseSelects.size()!=0)
            {
                System.out.println(stu.getId() + " "+ stu.getName()+" "+getAvgTotalScore(stuCourseSelects));
            }
            else
            {
                System.out.println(stu.getId() +" "+ stu.getName()+" did not take any exams");
            }
        }
    }
    public void showCourses(){
        Collections.sort(courses);
        for(int i =0;i<courses.size();i++)
        {
            Course course = courses.get(i);
            ArrayList<CourseSelection> courseSelects = findCourse(course.getName());
            if(courseSelects.size()== 0)
            {
                System.out.println(course.getName() + " has no grades yet");
            }
        }
    }
    public void showClasses(){
        Collections.sort(classes);
        for(int i =0;i<classes.size();i++)
        {
            Class cls = classes.get(i);
            ArrayList<CourseSelection> classCourseSelects = findClass(cls.getID());
            if(classCourseSelects.size()==0){
                System.out.println(cls.getID()+" has no grades yet");
            }
            else{
                System.out.println(cls.getID()+" "+ getAvgTotalScore(classCourseSelects));
            }
        }
    }
}

 

修改后的类图如下图所示：

 

 踩坑心得：

选课系统这一系列的题目，在选课系统-1的时候最开始我所写的代码在我看来是没有太大的问题的，但是提交过后发现那些代码完全只是面向样例的，除了所给样例之外的测试点都没有通过，并且还出现了代码超限的问题，到现在我也不知道代码超限具体是什么原因导致的。后面听了室友上课所学到的思路，按部就班的完成代码，才发现自己原来写的代码是有很多漏洞的，可以说如果我不去寻求帮助而只是一味的盯着自己最开始写的代码是解决不了问题的，相当于是被思维定式了一样。不得不说的是老师所讲的这道题的解法真的非常巧妙，要我来想真的根本想不出来这种解法，看来我的Java之路还是路漫漫啊。

选课系统-2是在选课系统-1的基础上进行改善，这道题对于我来说还算顺利，修改并没有花很多的时间，提交也是基本上三四次就通过了。选课系统-3将成绩类的关系改为组合，一开始真是想破了头没明白什么意思，所以说类与类之间的关系还是我需要多多学习以及运用的。

改进建议：

1. 规范化命名：变量、方法、类名应该有意义，能够清晰地表达其作用和含义，避免使用拼音或缩写等不规范的命名方式。

2. 简化代码：尽量避免冗余代码，使用循环、函数等方式简化代码，提高代码的可读性和可维护性。

3. 异常处理：在编写Java代码时，需要考虑到可能出现的异常情况，并进行相应的处理，避免程序崩溃或出现不可预期的结果。

4. 注释：在代码中添加注释，能够让其他人更容易理解代码的作用和实现方式，也方便自己日后的维护和修改。

5. 代码风格：遵循统一的代码风格，如缩进、空格、括号等，能够让代码更加美观、易读。

6. 代码复用：尽量避免重复编写相同的代码，可以将常用的代码封装成函数或类，方便复用。

7. 性能优化：在编写Java代码时，需要考虑到程序的性能问题，尽量避免使用过多的循环、递归等操作，以及避免频繁的IO操作。

总之，编写Java代码需要注重细节，遵循规范，注重代码的可读性和可维护性，同时也要考虑到程序的性能问题。只有这样，才能写出高质量的Java代码。

总结：

Java类与类之间的关系：

在Java中，类与类之间的关系主要有继承、实现接口和关联关系。继承是指一个类可以继承另一个类的属性和方法，从而可以重用代码并扩展功能。实现接口是指一个类可以实现一个或多个接口，从而可以拥有接口中定义的方法。关联关系是指一个类与另一个类之间存在某种关联，如聚合和组合关系。

继承与多态：

继承是Java中实现代码重用的一种方式，子类可以继承父类的属性和方法。多态是指同一种方法可以在不同的对象上产生不同的行为，实现多态的方式有方法重载和方法重写。

接口：

接口是Java中一种重要的抽象概念，它定义了一组方法的签名，但没有实现。接口可以被类实现，从而使得类可以拥有接口中定义的方法。接口的使用可以提高代码的灵活性和可扩展性。

ArrayList：

ArrayList是Java中的一个动态数组，它可以根据需要自动扩展大小。ArrayList可以存储任何类型的对象，可以通过索引访问元素，也可以通过迭代器遍历元素。

Set：

Set是Java中的一个集合，它不允许重复元素。Set中的元素没有顺序，可以通过迭代器遍历元素。Set的实现类有HashSet、TreeSet和LinkedHashSet。

Map：

Map是Java中的一个键值对集合，它可以根据键来访问值。Map中的键不能重复，值可以重复。Map的实现类有HashMap、TreeMap和LinkedHashMap。

总之，Java类与类之间的关系有继承、实现接口和关联关系，继承和多态可以实现代码的重用和灵活性，接口可以提高代码的可扩展性，ArrayList、Set和Map是Java中常用的集合类，它们可以方便地存储和操作数据。

评价：

Java课程的教学理念OBE（基于能力的教育）是一种以学生为中心的教学模式，注重培养学生的实际能力和解决问题的能力。这种教学理念在Java课程中得到了很好的体现，但是在实际教学中，还存在一些问题需要改进。

首先，教学方法边讲边练是非常重要的，但是在实际教学中，有些老师只是简单地讲解知识点，缺乏实际的练习和案例分析。这种教学方法容易导致学生的理论知识掌握不牢固，无法应用到实际问题中。因此，建议老师在讲解知识点的同时，加强实际案例的分析和练习，让学生更好地掌握知识点。

其次，教学组织线上线下混合式教学是一种非常灵活的教学模式，但是在实际教学中，有些老师缺乏对线上教学的有效组织和管理，导致学生的学习效果不佳。因此，建议老师在线上教学中，加强对学生学习情况的跟踪和管理，及时解决学生的问题，提高学生的学习效果。

再次，教学过程PTA题目集驱动是一种非常有效的教学方法，但是在实际教学中，有些老师只是简单地让学生完成题目，缺乏对学生思维方式和解题思路的引导和培养。因此，建议老师在教学过程中，加强对学生思维方式和解题思路的引导和培养，让学生更好地理解和掌握知识点。

最后，教学模式BOPPPS是一种非常全面的教学模式，但是在实际教学中，有些老师只是简单地按照模式进行教学，缺乏对学生个性化需求的考虑。因此，建议老师在教学模式中，加强对学生个性化需求的考虑，让学生更好地适应教学模式。

综上所述，Java课程的教学理念OBE、教学方法边讲边练、教学组织线上线下混合式教学、教学过程PTA题目集驱动和教学模式BOPPPS都是非常好的教学模式，但是在实际教学中，还存在一些问题需要改进。因此，建议老师在教学中加强对学生的引导和培养，注重学生的实际能力和解决问题的能力，提高学生的学习效果。