第三阶段BLOG

OOP10-16周总结

22201303-范宇

前言

这几周主要学习了java的集合框架一系列知识，如，HashSet，HashMap，TreeMap等，以及对该知识的应用。

这几周的作业让我们进一步掌握OOP的继承和多态性，而其中具有代表性的就是课程成绩统计系统。因此，这次blog就围绕课程成绩统计系统展开。

设计与分析

课程成绩统计系统进行了三次迭代

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

 

设计分析：

首先对输入数据进行区分。输入数据分为两种，一种是课程信息导入，一种是成绩信息导入，每条信息都只有一行。先对输入信息进行处理，课程信息与成绩信息最大的区别就是：课程信息第一个字符串是不超过10个字符的课程名称（包括中文字符和英文字符），而成绩信息第一个字符串一定是八个数字，由此可以将两种信息区分开。

接着对数据进行异常分析，判断数据的合理性，根据题目的要求，合理分析并处理异常的数据；

然后对输入数据进行储存。这里创建了三个动态数组ArrayList<Course> courseArrayList; ArrayList<Student> studentArrayList ;ArrayList<Score> scoreArrayList; 在判断信息无误后，将处理后的数据存入三个动态数组。

最后通过三个数组创建SelectCourse对象，并调用其方法对信息进行处理后输出。

类图如下：

SelectCourse类：选课系统，

Student类：创建学生对象；

ClassRoom类：创建班级对象；

ScoreComparator类：Score类成绩比较，实现Comparator接口；

Score抽象类：成绩对象；

InspectScore类：考察成绩对象，继承自Score类；

ExamScore类：考试成绩对象，继承自Score类；

Course类：课程类，创建课程对象；

import java.text.Collator;
import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        ArrayList<Course> courseArrayList = new ArrayList<>();
        ArrayList<Student> studentArrayList = new ArrayList<>();
        ArrayList<Score> scoreArrayList = new ArrayList<>();
        while (!s.equals("end")) {
            String[] strings = s.split(" ");
            if (strings.length >= 3 && strings[0].matches("[0-9]{8}") && strings[1].matches("\\S{1,10}") && strings[2].matches("\\S{1,10}")) {
                if (scoreIsRepeated(strings[0], strings[1], strings[2], studentArrayList, scoreArrayList)) {
                    Score score = null;
                    int f = 1;
                    for (int i = 3; i < strings.length; i++) {
                        if (!strings[i].matches("([1-9]?[0-9]|100)")) {
                            f = 0;
                            break;
                        }
                    }
                    if (f == 1) {
                        int t = 1;
                        int flag = 0;
                        for (Course course : courseArrayList) {
                            if (course.getName().equals(strings[2])) {
                                flag = 1;
                                if (course.getMode().equals("考试")) {
                                    if (strings.length == 5) {
                                        score = new ExamScore(strings[2], Integer.parseInt(strings[3]), Integer.parseInt(strings[4]));
                                    } else if (strings.length == 4){
                                        System.out.println(strings[0] + " " + strings[1] + " : access mode mismatch");
                                    }else {
                                        t = 0;
                                        System.out.println("wrong format");
                                    }
                                } else if (course.getMode().equals("考察")) {
                                    if (strings.length == 4) {
                                        score = new InspectScore(strings[2], -1, Integer.parseInt(strings[3]));
                                    } else if (strings.length == 5){
                                        System.out.println(strings[0] + " " + strings[1] + " : access mode mismatch");
                                    }else {
                                        t = 0;
                                        System.out.println("wrong format");
                                    }
                                } else if (course.getMode().equals("实验")) {
                                    if (Integer.parseInt(strings[3]) >= 4 && Integer.parseInt(strings[3]) <= 9) {
                                        if ((strings.length - 4) == Integer.parseInt(strings[3])) {
                                            int sum = 0;
                                            for (int i = 0; i < strings.length - 4; i++) {
                                                sum += Integer.parseInt(strings[4 + i]);
                                            }
                                            int grade = sum / Integer.parseInt(strings[3]);
                                            score = new ExperimentScore(strings[2], -2, grade);
                                        } else
                                            System.out.println(strings[0] + " " + strings[1] + " : access mode mismatch");
                                    } else {
                                        t = 0;
                                        System.out.println("wrong format");
                                    }
                                }
                            }
                        }
                        if (t == 1) {
                            scoreArrayList.add(score);
                            Student student = new Student(strings[0], strings[1]);
                            studentArrayList.add(student);
                        }
                        if (flag == 0) {
                            System.out.println(strings[2] + " does not exist");
                        }
                    } else
                        System.out.println("wrong format");
                }
            } else if (strings.length == 3 && strings[0].matches("\\S{1,10}") && (strings[1].matches("(选修|必修|实验)")) && (strings[2].matches("(考试|考察|实验)"))) {
                if (courseIsRepeated(strings[0], courseArrayList)) {
                    if (courseIsMatched(strings[1], strings[2])) {
                        Course course = new Course(strings[0], strings[1], strings[2]);
                        courseArrayList.add(course);
                    } else
                        System.out.println(strings[0] + " : course type & access mode mismatch");
                }
            } else if (strings.length == 2 && strings[0].matches("\\S{1,10}") && strings[1].equals("必修")) {
                if (courseIsRepeated(strings[0], courseArrayList)) {
                    Course course = new Course(strings[0], strings[1], "考试");
                    courseArrayList.add(course);
                }
            } else {
                System.out.println("wrong format");
            }
            s = input.nextLine();
        }
        SelectCourse selectCourse = new SelectCourse(courseArrayList, studentArrayList, scoreArrayList);
        for (Student student : selectCourse.student_sort()) {
            if (student.getScore() == -1)
                System.out.println(student.getNumber() + " " + student.getName() + " did not take any exams");
            else
                System.out.println(student.getNumber() + " " + student.getName() + " " + student.getScore());
        }
        for (Map.Entry<Score, Integer> entry : selectCourse.scoreIntegerMap().entrySet()) {
            if (entry.getKey().getPerformance() == -1 && entry.getKey().getGrade() == -1 && entry.getKey().allGrade() == -1) {
                System.out.println(entry.getKey().getCourse() + " has no grades yet");
            } else if (entry.getKey().getPerformance() == -1)
                System.out.println(entry.getKey().getCourse() + " " + entry.getKey().getGrade() + " " + entry.getValue());
            else if (entry.getKey().getPerformance() == -2)
                System.out.println(entry.getKey().getCourse() + " " + entry.getValue());
            else
                System.out.println(entry.getKey().getCourse() + " " + entry.getKey().getPerformance() + " " + entry.getKey().getGrade() + " " + entry.getValue());
        }
        for (ClassRoom classRoom : selectCourse.classHashSet()) {
            if (classRoom.getScore() == -1)
                System.out.println(classRoom.getNum() + " has no grades yet");
            else
                System.out.println(classRoom.getNum() + " " + classRoom.getScore());
        }
    }
 
    public static boolean courseIsMatched(String character, String mode) {
        if (character.equals("实验") && !mode.equals("实验"))
            return false;
        else if (character.equals("必修") && mode.matches("(考察|实验)"))
            return false;
        else if (character.equals("选修") && mode.matches("(实验)"))
            return false;
        else
            return true;
    }
 
    public static boolean courseIsRepeated(String name, ArrayList<Course> courseArrayList) {
        int flag = 1;
        for (Course course : courseArrayList) {
            if (name.equals(course.getName())) {
                flag = 0;
                break;
            }
        }
        return flag != 0;
    }
 
    public static boolean scoreIsRepeated(String number, String name, String course, ArrayList<Student> studentArrayList, ArrayList<Score> scoreArrayList) {
        int flag = 1;
        int i = 0;
        for (Student student : studentArrayList) {
            if (student.getNumber().equals(number) && student.getName().equals(name)) {
                i = studentArrayList.indexOf(student);
                flag = 0;
            }
        }
        if (flag == 1)
            return true;
        else {
            if (scoreArrayList.get(i) == null) {
                return true;
            } else {
                return !scoreArrayList.get(i).getCourse().equals(course);
            }
        }
    }
}
 
class SelectCourse {
    private ArrayList<Course> courseArrayList;
    private ArrayList<Student> studentArrayList;
    private ArrayList<Score> scoreArrayList;
 
    public SelectCourse(ArrayList<Course> courseArrayList, ArrayList<Student> studentArrayList, ArrayList<Score> scoreArrayList) {
        this.courseArrayList = courseArrayList;
        this.studentArrayList = studentArrayList;
        this.scoreArrayList = scoreArrayList;
    }
 
    public ArrayList<ClassRoom> classHashSet() {
        ArrayList<ClassRoom> classArrayList = new ArrayList<>();
        ArrayList<ClassRoom> classHashSet = new ArrayList<>();
        ArrayList<Student> studentHashSet = student_sort();
 
        for (Student student : studentHashSet) {
            int flag = 1;
            String num = student.getNumber().substring(0, 6);
            ClassRoom classRoom = new ClassRoom(num);
            for (ClassRoom classRoom0 : classHashSet) {
                if (classRoom0.isSame(classRoom))
                    flag = 0;
            }
            if (flag == 1)
                classHashSet.add(classRoom);
            ClassRoom classRoom1 = new ClassRoom(student.getScore(), num);
            classArrayList.add(classRoom1);
        }
        for (ClassRoom classRoom : classHashSet) {
            int score = 0;
            int count = 0;
            for (ClassRoom classRoom1 : classArrayList) {
                if (classRoom.isSame(classRoom1)) {
                    if (classRoom1.getScore() != -1) {
                        score += classRoom1.getScore();
                        count++;
                    }
                }
            }
            if (count != 0) {
                score = score / count;
                classRoom.setScore(score);
            } else {
                classRoom.setScore(-1);
            }
        }
        classHashSet.sort(ClassRoom::compareTo);
        return classHashSet;
    }
 
    public Map<Score, Integer> scoreIntegerMap() {
        Map<Score, Integer> scoreIntegerMap = new TreeMap<>(new ScoreComparator());
        for (Course course : courseArrayList) {
            int aver_grade = 0;
            int aver_performance = 0;
            int allGrade = 0;
            int count = 0;
            for (Score score : scoreArrayList) {
                if (score != null) {
                    if (score.getCourse().equals(course.getName())) {
                        aver_performance += score.getPerformance();
                        aver_grade += score.getGrade();
                        allGrade += score.allGrade();
                        count++;
                    }
                }
 
            }
            if (count != 0) {
                aver_grade = aver_grade / count;
                aver_performance = aver_performance / count;
                allGrade = allGrade / count;
                Score score = new ExamScore(course.getName(), aver_performance, aver_grade);
                scoreIntegerMap.put(score, allGrade);
            } else {
                Score score = new ExamScore(course.getName(), -1, -1);
                scoreIntegerMap.put(score, -1);
            }
        }
        return scoreIntegerMap;
    }
 
    public ArrayList<Student> student_sort() {
        HashSet<Student> studentHashSet = new HashSet<>();
        for (Student student : studentArrayList) {
            int flag = 1;
            for (Student student1 : studentHashSet) {
                if (student.isSame(student1)) {
                    flag = 0;
                }
            }
            if (flag == 1)
                studentHashSet.add(student);
        }
        ArrayList<Student> student_sort = new ArrayList<>();
        for (Student student : studentHashSet) {
            int score = 0;
            int count = 0;
            for (int i = 0; i < studentArrayList.size(); i++) {
                if (student.isSame(studentArrayList.get(i))) {
                    if (scoreArrayList.get(i) != null) {
                        if (scoreArrayList.get(i).allGrade() != -1) {
                            score += scoreArrayList.get(i).allGrade();
                            count++;
                        }
                    }
                }
            }
            if (count != 0) {
                score = score / count;
                student.setScore(score);
            } else {
                student.setScore(-1);
            }
            student_sort.add(student);
        }
        student_sort.sort(Student::compareTo);
        return student_sort;
    }
}
 
 
class Student implements Comparable<Student> {
    private final String number;
    private final String name;
 
    private int score;
 
    public Student(String number, String name) {
        this.number = number;
        this.name = name;
    }
 
    public boolean isSame(Student student) {
        return this.number.equals(student.getNumber()) && this.name.equals(student.getName());
    }
 
    public int getScore() {
        return score;
    }
 
    public void setScore(int score) {
        this.score = score;
    }
 
    public String getNumber() {
        return number;
    }
 
    public String getName() {
        return name;
    }
 
    @Override
    public int compareTo(Student o) {
        return Integer.compare(number.compareTo(o.getNumber()), 0);
    }
}
 
class ClassRoom implements Comparable<ClassRoom> {
    private int score;
    private final String num;
 
    public ClassRoom(String num) {
        this.num = num;
    }
 
    public ClassRoom(int score, String num) {
        this.score = score;
        this.num = num;
    }
 
    public boolean isSame(ClassRoom classRoom) {
        return this.num.equals(classRoom.getNum());
    }
 
    public int getScore() {
        return score;
    }
 
    public void setScore(int score) {
        this.score = score;
    }
 
    public String getNum() {
        return num;
    }
 
    @Override
    public int compareTo(ClassRoom o) {
        return num.compareTo(o.getNum());
    }
}
 
class ScoreComparator implements Comparator<Score> {
 
    @Override
    public int compare(Score o1, Score o2) {
        Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(o1.getCourse(), o2.getCourse());
    }
}
 
abstract class Score {
    private final String course;
    private int grade;
    private int performance;
 
    public Score(String course, int performance, int grade) {
        this.course = course;
        this.grade = grade;
        this.performance = performance;
    }
 
    public String getCourse() {
        return course;
    }
 
    public int getGrade() {
        return grade;
    }
 
    public void setGrade(int grade) {
        this.grade = grade;
    }
 
    public int getPerformance() {
        return performance;
    }
 
    public abstract int allGrade();
}
 
class InspectScore extends Score {
 
    public InspectScore(String course, int performance, int grade) {
        super(course, performance, grade);
    }
 
    public int allGrade() {
        return super.getGrade();
    }
}
 
class ExamScore extends Score {
 
    public ExamScore(String course, int performance, int grade) {
        super(course, performance, grade);
    }
 
    public int allGrade() {
        return (int) (super.getGrade() * 0.7 + super.getPerformance() * 0.3);
    }
}
 
class ExperimentScore extends Score {
 
    public ExperimentScore(String course, int performance, int grade) {
        super(course, performance, grade);
    }
 
    public int allGrade() {
        return super.getGrade();
    }
}
 
class Course {
    private final String name;
    private final String character;//性质
    private final String mode;//考核方式
 
    public Course(String name, String character, String mode) {
        this.name = name;
        this.character = character;
        this.mode = mode;
    }
 
    public String getName() {
        return name;
    }
 
    public String getMode() {
        return mode;
    }
}

 

课程成绩统计程序-2

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

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

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

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

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

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

1、输入：

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

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

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

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

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

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

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

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

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

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

以上信息的相关约束：

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

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

3）学号由8位数字组成

4）姓名不超过10个字符

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

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

2、输出：

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

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

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

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

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

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

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

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

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

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

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

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

异常情况：

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

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

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

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

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

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

信息约束：

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

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


e724fa4193aa9ee32e78a68cd96fd6df_22401e04-c501-4b28-bb65-dabe39d374e7.png

设计分析：

这次迭代主要在信息输入上，这次多了实验课，而且实验课的成绩形式也与之前不同，实验次数至少4次，不超过9次，每次实验都有成绩，最终成绩为每次成绩的平均值。

这次改进在判断信息合理性上加入了实验课，并且还加入了判断试验次数与实验成绩个数是否匹配，如果信息无误，则直接保存最终成绩。

import java.text.Collator;
import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        ArrayList<Course> courseArrayList = new ArrayList<>();
        ArrayList<Student> studentArrayList = new ArrayList<>();
        ArrayList<Score> scoreArrayList = new ArrayList<>();
        while (!s.equals("end")) {
            String[] strings = s.split(" ");
            if (strings.length >= 3 && strings[0].matches("[0-9]{8}") && strings[1].matches("\\S{1,10}") && strings[2].matches("\\S{1,10}")) {
                if (scoreIsRepeated(strings[0], strings[1], strings[2], studentArrayList, scoreArrayList)) {
                    Score score = null;
                    int f = 1;
                    for (int i = 3; i < strings.length; i++) {
                        if (!strings[i].matches("([1-9]?[0-9]|100)")) {
                            f = 0;
                            break;
                        }
                    }
                    if (f == 1) {
                        int t = 1;
                        int flag = 0;
                        for (Course course : courseArrayList) {
                            if (course.getName().equals(strings[2])) {
                                flag = 1;
                                if (course.getMode().equals("考试")) {
                                    if (strings.length == 5) {
                                        score = new ExamScore(strings[2], Integer.parseInt(strings[3]), Integer.parseInt(strings[4]));
                                    } else if (strings.length == 4){
                                        System.out.println(strings[0] + " " + strings[1] + " : access mode mismatch");
                                    }else {
                                        t = 0;
                                        System.out.println("wrong format");
                                    }
                                } else if (course.getMode().equals("考察")) {
                                    if (strings.length == 4) {
                                        score = new InspectScore(strings[2], -1, Integer.parseInt(strings[3]));
                                    } else if (strings.length == 5){
                                        System.out.println(strings[0] + " " + strings[1] + " : access mode mismatch");
                                    }else {
                                        t = 0;
                                        System.out.println("wrong format");
                                    }
                                } else if (course.getMode().equals("实验")) {
                                    if (Integer.parseInt(strings[3]) >= 4 && Integer.parseInt(strings[3]) <= 9) {
                                        if ((strings.length - 4) == Integer.parseInt(strings[3])) {
                                            int sum = 0;
                                            for (int i = 0; i < strings.length - 4; i++) {
                                                sum += Integer.parseInt(strings[4 + i]);
                                            }
                                            int grade = sum / Integer.parseInt(strings[3]);
                                            score = new ExperimentScore(strings[2], -2, grade);
                                        } else
                                            System.out.println(strings[0] + " " + strings[1] + " : access mode mismatch");
                                    } else {
                                        t = 0;
                                        System.out.println("wrong format");
                                    }
                                }
                            }
                        }
                        if (t == 1) {
                            scoreArrayList.add(score);
                            Student student = new Student(strings[0], strings[1]);
                            studentArrayList.add(student);
                        }
                        if (flag == 0) {
                            System.out.println(strings[2] + " does not exist");
                        }
                    } else
                        System.out.println("wrong format");
                }
            } else if (strings.length == 3 && strings[0].matches("\\S{1,10}") && (strings[1].matches("(选修|必修|实验)")) && (strings[2].matches("(考试|考察|实验)"))) {
                if (courseIsRepeated(strings[0], courseArrayList)) {
                    if (courseIsMatched(strings[1], strings[2])) {
                        Course course = new Course(strings[0], strings[1], strings[2]);
                        courseArrayList.add(course);
                    } else
                        System.out.println(strings[0] + " : course type & access mode mismatch");
                }
            } else if (strings.length == 2 && strings[0].matches("\\S{1,10}") && strings[1].equals("必修")) {
                if (courseIsRepeated(strings[0], courseArrayList)) {
                    Course course = new Course(strings[0], strings[1], "考试");
                    courseArrayList.add(course);
                }
            } else {
                System.out.println("wrong format");
            }
            s = input.nextLine();
        }
        SelectCourse selectCourse = new SelectCourse(courseArrayList, studentArrayList, scoreArrayList);
        for (Student student : selectCourse.student_sort()) {
            if (student.getScore() == -1)
                System.out.println(student.getNumber() + " " + student.getName() + " did not take any exams");
            else
                System.out.println(student.getNumber() + " " + student.getName() + " " + student.getScore());
        }
        for (Map.Entry<Score, Integer> entry : selectCourse.scoreIntegerMap().entrySet()) {
            if (entry.getKey().getPerformance() == -1 && entry.getKey().getGrade() == -1 && entry.getKey().allGrade() == -1) {
                System.out.println(entry.getKey().getCourse() + " has no grades yet");
            } else if (entry.getKey().getPerformance() == -1)
                System.out.println(entry.getKey().getCourse() + " " + entry.getKey().getGrade() + " " + entry.getValue());
            else if (entry.getKey().getPerformance() == -2)
                System.out.println(entry.getKey().getCourse() + " " + entry.getValue());
            else
                System.out.println(entry.getKey().getCourse() + " " + entry.getKey().getPerformance() + " " + entry.getKey().getGrade() + " " + entry.getValue());
        }
        for (ClassRoom classRoom : selectCourse.classHashSet()) {
            if (classRoom.getScore() == -1)
                System.out.println(classRoom.getNum() + " has no grades yet");
            else
                System.out.println(classRoom.getNum() + " " + classRoom.getScore());
        }
    }
 
    public static boolean courseIsMatched(String character, String mode) {
        if (character.equals("实验") && !mode.equals("实验"))
            return false;
        else if (character.equals("必修") && mode.matches("(考察|实验)"))
            return false;
        else if (character.equals("选修") && mode.matches("(实验)"))
            return false;
        else
            return true;
    }
 
    public static boolean courseIsRepeated(String name, ArrayList<Course> courseArrayList) {
        int flag = 1;
        for (Course course : courseArrayList) {
            if (name.equals(course.getName())) {
                flag = 0;
                break;
            }
        }
        return flag != 0;
    }
 
    public static boolean scoreIsRepeated(String number, String name, String course, ArrayList<Student> studentArrayList, ArrayList<Score> scoreArrayList) {
        int flag = 1;
        int i = 0;
        for (Student student : studentArrayList) {
            if (student.getNumber().equals(number) && student.getName().equals(name)) {
                i = studentArrayList.indexOf(student);
                flag = 0;
            }
        }
        if (flag == 1)
            return true;
        else {
            if (scoreArrayList.get(i) == null) {
                return true;
            } else {
                return !scoreArrayList.get(i).getCourse().equals(course);
            }
        }
    }
}
 
class SelectCourse {
    private ArrayList<Course> courseArrayList;
    private ArrayList<Student> studentArrayList;
    private ArrayList<Score> scoreArrayList;
 
    public SelectCourse(ArrayList<Course> courseArrayList, ArrayList<Student> studentArrayList, ArrayList<Score> scoreArrayList) {
        this.courseArrayList = courseArrayList;
        this.studentArrayList = studentArrayList;
        this.scoreArrayList = scoreArrayList;
    }
 
    public ArrayList<ClassRoom> classHashSet() {
        ArrayList<ClassRoom> classArrayList = new ArrayList<>();
        ArrayList<ClassRoom> classHashSet = new ArrayList<>();
        ArrayList<Student> studentHashSet = student_sort();
 
        for (Student student : studentHashSet) {
            int flag = 1;
            String num = student.getNumber().substring(0, 6);
            ClassRoom classRoom = new ClassRoom(num);
            for (ClassRoom classRoom0 : classHashSet) {
                if (classRoom0.isSame(classRoom))
                    flag = 0;
            }
            if (flag == 1)
                classHashSet.add(classRoom);
            ClassRoom classRoom1 = new ClassRoom(student.getScore(), num);
            classArrayList.add(classRoom1);
        }
        for (ClassRoom classRoom : classHashSet) {
            int score = 0;
            int count = 0;
            for (ClassRoom classRoom1 : classArrayList) {
                if (classRoom.isSame(classRoom1)) {
                    if (classRoom1.getScore() != -1) {
                        score += classRoom1.getScore();
                        count++;
                    }
                }
            }
            if (count != 0) {
                score = score / count;
                classRoom.setScore(score);
            } else {
                classRoom.setScore(-1);
            }
        }
        classHashSet.sort(ClassRoom::compareTo);
        return classHashSet;
    }
 
    public Map<Score, Integer> scoreIntegerMap() {
        Map<Score, Integer> scoreIntegerMap = new TreeMap<>(new ScoreComparator());
        for (Course course : courseArrayList) {
            int aver_grade = 0;
            int aver_performance = 0;
            int allGrade = 0;
            int count = 0;
            for (Score score : scoreArrayList) {
                if (score != null) {
                    if (score.getCourse().equals(course.getName())) {
                        aver_performance += score.getPerformance();
                        aver_grade += score.getGrade();
                        allGrade += score.allGrade();
                        count++;
                    }
                }
 
            }
            if (count != 0) {
                aver_grade = aver_grade / count;
                aver_performance = aver_performance / count;
                allGrade = allGrade / count;
                Score score = new ExamScore(course.getName(), aver_performance, aver_grade);
                scoreIntegerMap.put(score, allGrade);
            } else {
                Score score = new ExamScore(course.getName(), -1, -1);
                scoreIntegerMap.put(score, -1);
            }
        }
        return scoreIntegerMap;
    }
 
    public ArrayList<Student> student_sort() {
        HashSet<Student> studentHashSet = new HashSet<>();
        for (Student student : studentArrayList) {
            int flag = 1;
            for (Student student1 : studentHashSet) {
                if (student.isSame(student1)) {
                    flag = 0;
                }
            }
            if (flag == 1)
                studentHashSet.add(student);
        }
        ArrayList<Student> student_sort = new ArrayList<>();
        for (Student student : studentHashSet) {
            int score = 0;
            int count = 0;
            for (int i = 0; i < studentArrayList.size(); i++) {
                if (student.isSame(studentArrayList.get(i))) {
                    if (scoreArrayList.get(i) != null) {
                        if (scoreArrayList.get(i).allGrade() != -1) {
                            score += scoreArrayList.get(i).allGrade();
                            count++;
                        }
                    }
                }
            }
            if (count != 0) {
                score = score / count;
                student.setScore(score);
            } else {
                student.setScore(-1);
            }
            student_sort.add(student);
        }
        student_sort.sort(Student::compareTo);
        return student_sort;
    }
}
 
 
class Student implements Comparable<Student> {
    private final String number;
    private final String name;
 
    private int score;
 
    public Student(String number, String name) {
        this.number = number;
        this.name = name;
    }
 
    public boolean isSame(Student student) {
        return this.number.equals(student.getNumber()) && this.name.equals(student.getName());
    }
 
    public int getScore() {
        return score;
    }
 
    public void setScore(int score) {
        this.score = score;
    }
 
    public String getNumber() {
        return number;
    }
 
    public String getName() {
        return name;
    }
 
    @Override
    public int compareTo(Student o) {
        return Integer.compare(number.compareTo(o.getNumber()), 0);
    }
}
 
class ClassRoom implements Comparable<ClassRoom> {
    private int score;
    private final String num;
 
    public ClassRoom(String num) {
        this.num = num;
    }
 
    public ClassRoom(int score, String num) {
        this.score = score;
        this.num = num;
    }
 
    public boolean isSame(ClassRoom classRoom) {
        return this.num.equals(classRoom.getNum());
    }
 
    public int getScore() {
        return score;
    }
 
    public void setScore(int score) {
        this.score = score;
    }
 
    public String getNum() {
        return num;
    }
 
    @Override
    public int compareTo(ClassRoom o) {
        return num.compareTo(o.getNum());
    }
}
 
class ScoreComparator implements Comparator<Score> {
 
    @Override
    public int compare(Score o1, Score o2) {
        Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(o1.getCourse(), o2.getCourse());
    }
}
 
abstract class Score {
    private final String course;
    private int grade;
    private int performance;
 
    public Score(String course, int performance, int grade) {
        this.course = course;
        this.grade = grade;
        this.performance = performance;
    }
 
    public String getCourse() {
        return course;
    }
 
    public int getGrade() {
        return grade;
    }
 
    public void setGrade(int grade) {
        this.grade = grade;
    }
 
    public int getPerformance() {
        return performance;
    }
 
    public abstract int allGrade();
}
 
class InspectScore extends Score {
 
    public InspectScore(String course, int performance, int grade) {
        super(course, performance, grade);
    }
 
    public int allGrade() {
        return super.getGrade();
    }
}
 
class ExamScore extends Score {
 
    public ExamScore(String course, int performance, int grade) {
        super(course, performance, grade);
    }
 
    public int allGrade() {
        return (int) (super.getGrade() * 0.7 + super.getPerformance() * 0.3);
    }
}
 
class ExperimentScore extends Score {
 
    public ExperimentScore(String course, int performance, int grade) {
        super(course, performance, grade);
    }
 
    public int allGrade() {
        return super.getGrade();
    }
}
 
class Course {
    private final String name;
    private final String character;//性质
    private final String mode;//考核方式
 
    public Course(String name, String character, String mode) {
        this.name = name;
        this.character = character;
        this.mode = mode;
    }
 
    public String getName() {
        return name;
    }
 
    public String getMode() {
        return mode;
    }
}

课程成绩统计程序-3

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

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

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

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

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

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

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

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

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

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

1、输入：

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

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

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

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

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

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

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

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

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

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

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

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

以上信息的相关约束：

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

2）学号由8位数字组成

3）姓名不超过10个字符

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

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

2、输出：

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

为避免四舍五入误差，

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

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

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

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

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

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

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

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

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

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

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

异常情况：

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

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

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

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

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

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

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

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

信息约束：

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

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

fdada4ca193119ee30531ab82ffebbfa_9dbcf4e8-1627-4cf6-8764-cccf44947e2a.png

设计分析：

这次迭代修改了成绩的计算方式，输入的数据比之前多了权重这一数据。

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

 

PartScore类：分项成绩类，由成绩分值和权重两个属性构成；

Score类：由PartScore类动态数组和课程名称两个属性构成；

import java.text.Collator;
import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        ArrayList<Course> courseArrayList = new ArrayList<>();
        ArrayList<Student> studentArrayList = new ArrayList<>();
        ArrayList<Score> scoreArrayList = new ArrayList<>();
        while (!s.equals("end")) {
            String[] strings = s.split(" ");
            if (strings.length >= 3 && strings[0].matches("[0-9]{8}") && strings[1].matches("\\S{1,10}") && strings[2].matches("\\S{1,10}")) {
                if (scoreIsRepeated(strings[0], strings[1], strings[2], studentArrayList, scoreArrayList)) {
                    ArrayList<PartScore> partScoreArrayList = new ArrayList<>();
                    //Score score = null;
                    int f = 1;
                    for (int i = 3; i < strings.length; i++) {
                        if (!strings[i].matches("([1-9]?[0-9]|100)")) {
                            f = 0;
                            break;
                        }
                    }
                    if (f == 1) {
                        int t = 1;
                        int flag = 0;
                        for (Course course : courseArrayList) {
                            if (course.getName().equals(strings[2])) {
                                flag = 1;
                                if (course.getMode().equals("考试")) {
                                    if (strings.length == 5) {
                                        PartScore partScore1 = new PartScore(strings[2],Integer.parseInt(strings[3]),course.getWeights().get(0));
                                        partScoreArrayList.add(partScore1);
                                        PartScore partScore2 = new PartScore(strings[2],Integer.parseInt(strings[4]),course.getWeights().get(1));
                                        partScoreArrayList.add(partScore2);
                                        //score = new ExamScore(strings[2], Integer.parseInt(strings[3]), Integer.parseInt(strings[4]));
                                    } else {
                                        System.out.println(strings[0] + " " + strings[1] + " : access mode mismatch");
                                    }
                                } else if (course.getMode().equals("考察")) {
                                    if (strings.length == 4) {
                                        PartScore partScore1 = new PartScore(strings[2],Integer.parseInt(strings[3]),course.getWeights().get(0));
                                        partScoreArrayList.add(partScore1);
                                        //score = new InspectScore(strings[2], -1, Integer.parseInt(strings[3]));
                                    } else {
                                        System.out.println(strings[0] + " " + strings[1] + " : access mode mismatch");
                                    }
                                } else if (course.getMode().equals("实验")) {
 
                                        if (course.getWeights().size() == strings.length-3) {
                                            for (int i = 0; i < strings.length - 3; i++) {
                                                PartScore partScore1 = new PartScore(strings[2],Integer.parseInt(strings[3 + i]),course.getWeights().get(i));
                                                partScoreArrayList.add(partScore1);
                                            }
                                            //score = new ExperimentScore(strings[2], -2, grade);
                                        } else
                                            System.out.println(strings[0] + " " + strings[1] + " : access mode mismatch");
                                }
                            }
                        }
                        if (t == 1) {
                            Score score1 = new Score(strings[2],partScoreArrayList);
                            scoreArrayList.add(score1);
                            Student student = new Student(strings[0], strings[1]);
                            studentArrayList.add(student);
                        }
                        if (flag == 0) {
                            System.out.println(strings[2] + " does not exist");
                        }
                    } else
                        System.out.println("wrong format");
                }
            }else if(strings.length == 3 && strings[0].matches("\\S{1,10}") && (strings[1].matches("(选修|必修|实验)")) && (strings[2].matches("(考试|考察|实验)"))){
                if (courseIsRepeated(strings[0], courseArrayList)) {
                    if (strings[2].equals("考试")) {
                        if (courseIsMatched(strings[1], strings[2])) {
                            ArrayList<Float> weights = new ArrayList<>();
                            weights.add(0.3F);
                            weights.add(0.7F);
                            Course course = new Course(strings[0], strings[1], strings[2], weights);
                            courseArrayList.add(course);
 
                        } else
                            System.out.println(strings[0] + " : course type & access mode mismatch");
                    }
                    if (strings[2].equals("考察")) {
                        if (courseIsMatched(strings[1], strings[2])) {
                            ArrayList<Float> weights = new ArrayList<>();
                            weights.add(1.0F);
                            Course course = new Course(strings[0], strings[1], strings[2], weights);
                            courseArrayList.add(course);
 
                        } else
                            System.out.println(strings[0] + " : course type & access mode mismatch");
                    }
                }
            }
            else if (strings.length > 3 && strings[0].matches("\\S{1,10}") && (strings[1].matches("(选修|必修|实验)")) && (strings[2].matches("(考试|考察|实验)"))) {
                if (courseIsRepeated(strings[0], courseArrayList)) {
                    if(strings[2].equals("考试")){
                        if (courseIsMatched(strings[1], strings[2])) {
                                ArrayList<Float> weights = new ArrayList<>();
                                weights.add(Float.parseFloat(strings[3]));
                                weights.add(Float.parseFloat(strings[4]));
                                float sum = Float.parseFloat(strings[3])+Float.parseFloat(strings[4]);
                                if(sum==1) {
                                    Course course = new Course(strings[0], strings[1], strings[2], weights);
                                    courseArrayList.add(course);
                                }else
                                    System.out.println(strings[0] + " : weight value error");
 
                        } else
                            System.out.println(strings[0] + " : course type & access mode mismatch");
                    }
                    if(strings[2].equals("考察")){
                        if (courseIsMatched(strings[1], strings[2])) {
                            ArrayList<Float> weights = new ArrayList<>();
                            weights.add(Float.parseFloat(strings[3]));
                            if(Float.parseFloat(strings[3])==1) {
                                Course course = new Course(strings[0], strings[1], strings[2], weights);
                                courseArrayList.add(course);
                            }else
                                System.out.println(strings[0] + " : weight value error");
 
                        } else
                            System.out.println(strings[0] + " : course type & access mode mismatch");
                    }
                    if(strings[2].equals("实验")) {
                        if (Integer.parseInt(strings[3]) >= 4 && Integer.parseInt(strings[3]) <= 9) {
                            if (courseIsMatched(strings[1], strings[2])) {
                                int n = Integer.parseInt(strings[3]);
                                if (n + 4 == strings.length) {
                                    ArrayList<Float> weights = new ArrayList<>();
                                    float sum = 0;
                                    for (int i = 0; i < n; i++) {
                                        Float weight = Float.parseFloat(strings[4 + i]);
                                        sum += weight;
                                        weights.add(weight);
                                    }
                                    if (sum != 1) {
                                        System.out.println(strings[0] + " : weight value error");
                                    } else {
                                        Course course = new Course(strings[0], strings[1], strings[2], weights);
                                        courseArrayList.add(course);
                                    }
                                } else
                                    System.out.println(strings[0] + " : number of scores does not match");
                            } else
                                System.out.println(strings[0] + " : course type & access mode mismatch");
                        } else {
                            System.out.println("wrong format");
                        }
                    }
                }
            } else if (strings.length == 2 && strings[0].matches("\\S{1,10}") && strings[1].equals("必修")) {
                if (courseIsRepeated(strings[0], courseArrayList)) {
                    ArrayList<Float> weights = new ArrayList<>();
                    weights.add(0.3F);
                    weights.add(0.7F);
                    Course course = new Course(strings[0], strings[1], "考试",weights);
                    courseArrayList.add(course);
                }
            } else {
                System.out.println("wrong format");
            }
            s = input.nextLine();
        }
        SelectCourse selectCourse = new SelectCourse(courseArrayList, studentArrayList, scoreArrayList);
        for (Student student : selectCourse.student_sort()) {
            if (student.getScore() == -1)
                System.out.println(student.getNumber() + " " + student.getName() + " did not take any exams");
            else
                System.out.println(student.getNumber() + " " + student.getName() + " " + student.getScore());
        }
        for (Map.Entry<String, Integer> entry : selectCourse.scoreIntegerMap().entrySet()) {
            if (entry.getValue() == -1) {
                System.out.println(entry.getKey() + " has no grades yet");
            } else
                System.out.println(entry.getKey() + " " + entry.getValue());
 
        }
        for (ClassRoom classRoom : selectCourse.classHashSet()) {
            if (classRoom.getScore() == -1)
                System.out.println(classRoom.getNum() + " has no grades yet");
            else
                System.out.println(classRoom.getNum() + " " + classRoom.getScore());
        }
    }
 
    public static boolean courseIsMatched(String character, String mode) {
        if (character.equals("实验") && !mode.equals("实验"))
            return false;
        else if (character.equals("必修") && mode.matches("(考察|实验)"))
            return false;
        else if (character.equals("选修") && mode.matches("(实验)"))
            return false;
        else
            return true;
    }
 
    public static boolean courseIsRepeated(String name, ArrayList<Course> courseArrayList) {
        int flag = 1;
        for (Course course : courseArrayList) {
            if (name.equals(course.getName())) {
                flag = 0;
                break;
            }
        }
        return flag != 0;
    }
 
    public static boolean scoreIsRepeated(String number, String name, String course, ArrayList<Student> studentArrayList, ArrayList<Score> scoreArrayList) {
        int flag = 1;
        int i = 0;
        for (Student student : studentArrayList) {
            if (student.getNumber().equals(number) && student.getName().equals(name)) {
                i = studentArrayList.indexOf(student);
                flag = 0;
            }
        }
        if (flag == 1)
            return true;
        else {
            if (scoreArrayList.get(i) == null) {
                return true;
            } else {
                return !scoreArrayList.get(i).getCourse().equals(course);
            }
        }
    }
}
 
class SelectCourse {
    private ArrayList<Course> courseArrayList;
    private ArrayList<Student> studentArrayList;
    private ArrayList<Score> scoreArrayList;
 
    public SelectCourse(ArrayList<Course> courseArrayList, ArrayList<Student> studentArrayList, ArrayList<Score> scoreArrayList) {
        this.courseArrayList = courseArrayList;
        this.studentArrayList = studentArrayList;
        this.scoreArrayList = scoreArrayList;
    }
 
    public ArrayList<ClassRoom> classHashSet() {
        ArrayList<ClassRoom> classArrayList = new ArrayList<>();
        ArrayList<ClassRoom> classHashSet = new ArrayList<>();
        ArrayList<Student> studentHashSet = student_sort();
 
        for (Student student : studentHashSet) {
            int flag = 1;
            String num = student.getNumber().substring(0, 6);
            ClassRoom classRoom = new ClassRoom(num);
            for (ClassRoom classRoom0 : classHashSet) {
                if (classRoom0.isSame(classRoom))
                    flag = 0;
            }
            if (flag == 1)
                classHashSet.add(classRoom);
            ClassRoom classRoom1 = new ClassRoom(student.getScore(), num);
            classArrayList.add(classRoom1);
        }
        for (ClassRoom classRoom : classHashSet) {
            int score = 0;
            int count = 0;
            for (ClassRoom classRoom1 : classArrayList) {
                if (classRoom.isSame(classRoom1)) {
                    if (classRoom1.getScore() != -1) {
                        score += classRoom1.getScore();
                        count++;
                    }
                }
            }
            if (count != 0) {
                score = score / count;
                classRoom.setScore(score);
            } else {
                classRoom.setScore(-1);
            }
        }
        classHashSet.sort(ClassRoom::compareTo);
        return classHashSet;
    }
 
    public Map<String, Integer> scoreIntegerMap() {
        Map<String, Integer> scoreIntegerMap = new TreeMap<>(new ScoreComparator());
        for (Course course : courseArrayList) {
            int allGrade = 0;
            int count = 0;
            for (Score score : scoreArrayList) {
                if (score != null) {
                    if (score.getCourse().equals(course.getName())) {
                        allGrade += score.getAllGrade();
                        count++;
                    }
                }
 
            }
            if (count != 0) {
                allGrade = allGrade / count;
                scoreIntegerMap.put(course.getName(), allGrade);
            } else {
                scoreIntegerMap.put(course.getName(), -1);
            }
        }
        return scoreIntegerMap;
    }
 
    public ArrayList<Student> student_sort() {
        HashSet<Student> studentHashSet = new HashSet<>();
        for (Student student : studentArrayList) {
            int flag = 1;
            for (Student student1 : studentHashSet) {
                if (student.isSame(student1)) {
                    flag = 0;
                }
            }
            if (flag == 1)
                studentHashSet.add(student);
        }
        ArrayList<Student> student_sort = new ArrayList<>();
        for (Student student : studentHashSet) {
            int score = 0;
            int count = 0;
            for (int i = 0; i < studentArrayList.size(); i++) {
                if (student.isSame(studentArrayList.get(i))) {
                    if (scoreArrayList.get(i) != null) {
                        if (scoreArrayList.get(i).getAllGrade() != -1) {
                            score += scoreArrayList.get(i).getAllGrade();
                            count++;
                        }
                    }
                }
            }
            if (count != 0) {
                score = score / count;
                student.setScore(score);
            } else {
                student.setScore(-1);
            }
            student_sort.add(student);
        }
        student_sort.sort(Student::compareTo);
        return student_sort;
    }
}
 
 
class Student implements Comparable<Student> {
    private final String number;
    private final String name;
 
    private int score;
 
    public Student(String number, String name) {
        this.number = number;
        this.name = name;
    }
 
    public boolean isSame(Student student) {
        return this.number.equals(student.getNumber()) && this.name.equals(student.getName());
    }
 
    public int getScore() {
        return score;
    }
 
    public void setScore(int score) {
        this.score = score;
    }
 
    public String getNumber() {
        return number;
    }
 
    public String getName() {
        return name;
    }
 
    @Override
    public int compareTo(Student o) {
        return Integer.compare(number.compareTo(o.getNumber()), 0);
    }
}
 
class ClassRoom implements Comparable<ClassRoom> {
    private int score;
    private final String num;
 
    public ClassRoom(String num) {
        this.num = num;
    }
 
    public ClassRoom(int score, String num) {
        this.score = score;
        this.num = num;
    }
 
    public boolean isSame(ClassRoom classRoom) {
        return this.num.equals(classRoom.getNum());
    }
 
    public int getScore() {
        return score;
    }
 
    public void setScore(int score) {
        this.score = score;
    }
 
    public String getNum() {
        return num;
    }
 
    @Override
    public int compareTo(ClassRoom o) {
        return num.compareTo(o.getNum());
    }
}
 
class ScoreComparator implements Comparator<String> {
 
    @Override
    public int compare(String o1, String o2) {
        Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(o1, o2);
    }
}
 
class Score{
    private String course;
    private ArrayList<PartScore> partScoreArrayList;
 
    public Score(ArrayList<PartScore> partScoreArrayList) {
        this.partScoreArrayList = partScoreArrayList;
    }
 
    public Score(String course, ArrayList<PartScore> partScoreArrayList) {
        this.course = course;
        this.partScoreArrayList = partScoreArrayList;
    }
 
    public ArrayList<PartScore> getPartScoreArrayList() {
        return partScoreArrayList;
    }
 
    public void setPartScoreArrayList(ArrayList<PartScore> partScoreArrayList) {
        this.partScoreArrayList = partScoreArrayList;
    }
 
    public String getCourse() {
        return course;
    }
 
    public int getAllGrade(){
        float sum=0;
        if(partScoreArrayList.size()==0){
            sum=-1;
        }
        for(PartScore partScore:partScoreArrayList){
                sum+=partScore.allGrade();
        }
        return (int)sum;
    }
}
 
class PartScore{
    private String course;
    private int score;
    private Float w;
 
    public PartScore(String course, int score, Float w) {
        this.course = course;
        this.score = score;
        this.w = w;
    }
 
    public String getCourse() {
        return course;
    }
 
    public PartScore(Float w) {
        this.w = w;
    }
 
    public int getScore() {
        return score;
    }
 
    public void setScore(int score) {
        this.score = score;
    }
 
    public Float getW() {
        return w;
    }
 
    public void setW(Float w) {
        this.w = w;
    }
 
    public Float allGrade(){
        return score*w;
    }
}
 
 
 
 
class Course {
    private final String name;
    private final String character;//性质
    private final String mode;//考核方式
    private ArrayList<Float> weights;
 
    public Course(String name, String character, String mode) {
        this.name = name;
        this.character = character;
        this.mode = mode;
    }
 
    public Course(String name, String character, String mode, ArrayList<Float> weights) {
        this.name = name;
        this.character = character;
        this.mode = mode;
        this.weights = weights;
    }
 
    public String getName() {
        return name;
    }
 
    public String getMode() {
        return mode;
    }
 
    public ArrayList<Float> getWeights() {
        return weights;
    }
 
    public void setWeights(ArrayList<Float> weights) {
        this.weights = weights;
    }
}

 

踩坑心得

1.使用正则表达式要细心，在判断学号是否匹配时，正则表达式应该是[0-9]{8}但是我误写成了[0-8]{8}，这个错误找了我一个多小时；

2.main方法太冗长，模块化没有做好；

3.没有成绩和零分没有做好区分，程序里没有成绩默认为0，而零分也为0，为了区分二者，强制令没有成绩时成绩为-1，这样就不会混淆两种情况；

4.冗长的if判断条件有时可以使用正则表达式代替；

改进建议

main方法模块化，数据的输入，数据的处理都可以分离出来，最好实现MVC模式；

灵活使用正则表达式，在一些情况下，使用正则表达式会比if判断简单得多；

总结

这几周的作业，明显感觉到自己对集合框架的知识愈发熟悉，比如ArrayList,HashMap,HashSet等，以及对他们的排序等一些处理。

在设计课程成绩统计系统时，我发现最开始非常困难，有一种无从下手的无力感，后来走一步看一步，先把基本的几个类写好，然后再看需要输入哪些信息以及需要进行哪些相应的处理，可能也正是因为这样不合理的设计步骤，导致最后信息的输入以及处理全都堆积再main方法里。以后应该试着改变一下切入点，应该先研究输入信息，设计相关类对输入的信息进行处理和存储，最后再思考如何得到输出。

在第三次系统迭代的过程中，要求把成绩类由继承关系改成组合关系，继承和组合在大部分情况下是可以互相转换的，他们各有各的优势，也各有各的缺点，继承最大的一个好处就是代码复用，但继承层次过深、过复杂，也会影响到代码的可维护性，所以在设计的时候到底使用继承还是组合要考虑清楚。

posted @   B饭老司机  阅读(17)  评论(0)  编辑  收藏  举报
相关博文：
· OOP前三次作业总结BLOG
· OOP4-6次作业总结BLOG
· OOP作业总结三
· OOP面向对象第三阶段学习总结
· 成绩计算系列blog
阅读排行：
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
点击右上角即可分享
微信分享提示