BLOG-3

这次的pta6-8：Java实现课程成绩统计程序的系列作业是一项非常有意义和实用的任务。通过编写这个程序，我们可以更好地理解和应用Java编程语言的知识，同时也能够提高我们的编程能力和解决问题的能力。 首先，这个程序的主要功能是统计和分析学生的课程成绩。通过输入学生的姓名和成绩，程序可以计算出每个学生的总分、平均分、最高分和最低分，并且可以按照总分进行排序。这样，老师和学生可以更方便地了解每个学生的学习情况，对学生的学习成绩进行评估和分析。 其次，这个程序的实现过程中，我们需要运用到Java编程语言的一些基本知识和技巧。比如，我们需要使用数组来存储学生的姓名和成绩，使用循环结构来遍历数组并进行计算，使用条件语句来判断和处理异常情况等等。通过实际编写代码，我们可以更深入地理解和掌握这些知识和技巧，提高我们的编程能力。 此外，这个程序还可以进行一些扩展和优化。比如，我们可以添加一个功能，让用户可以输入学生的学号和其他相关信息，以便更全面地了解学生的学习情况。我们还可以对程序进行性能优化，比如使用更高效的算法来进行排序，提高程序的执行效率。 总的来说，这次的Java实现课程成绩统计程序的作业是一项非常有意义和实用的任务。通过编写这个程序，我们不仅可以提高我们的编程能力和解决问题的能力，还可以更好地了解和应用Java编程语言的知识。相信通过这样的实践和学习，我们可以在未来的编程工作中取得更好的成果。

除了课程成绩统计程序之外，本篇博客还将对动物发声模拟器（多态）、 jmu-Java-03面向对象基础-05-覆盖题目设计分析。

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

分数 100

作者 蔡轲

单位 南昌航空大学

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

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

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

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

 这个题目涉及到的知识点主要包括Java的输入输出、字符串处理、条件判断、循环、数组、排序等。

首先，需要使用Java的输入输出方法来读取题目给出的输入信息，包括课程信息和课程成绩信息。可以使用Scanner类来读取输入信息，并使用System.out.println()方法来输出结果。
其次，需要对输入的信息进行解析和处理。可以使用字符串的split()方法将输入的字符串按照空格进行分割，得到各个字段的值。然后，根据题目要求进行相应的判断和计算。例如，判断课程性质和考核方式是否匹配，判断成绩是否在合法范围内，计算各个平均分等。
接下来，需要使用条件判断和循环来处理异常情况和计算平均分。根据题目要求，需要判断课程名称是否存在、成绩数量和考核方式是否匹配等异常情况，并输出相应的错误信息。同时，需要使用循环来计算学生课程总成绩平均分、单门课程成绩平均分和班级所有课程总成绩平均分。
最后，需要使用数组和排序来对学生课程总成绩平均分和班级所有课程总成绩平均分进行排序。可以使用数组来存储学生的成绩信息，并使用Arrays.sort()方法对数组进行排序。然后，按照题目要求输出排序后的结果。
总体来说，这个题目的难度适中，需要对输入信息进行解析和处理，并进行相应的计算和判断。同时，还需要使用一些Java的基本知识和方法来完成题目要求。

源码如下：

 

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

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

        while (true) {
            String str1 = input.nextLine();
            if (str1.equals("end")) {
                break;
            }
            String[] token = str1.split(" ");
            if (token.length == 3 && isValidCourse(token)) {
                if (schedule.searchCourseByName(token[0]) == -1) {
                    schedule.addACourse(token[0], token[1], token[2]);
                }
            } else if (token.length >= 4 && isValidStudent(token)) {
                String classNum = token[0].substring(0, 6);
                int classNumInGrade = grade.searchClassByNum(classNum);
                if (classNumInGrade == -1) {
                    grade.addAClass(classNum);
                    grade.classes.get(grade.classes.size() - 1).addAStudent(token, schedule);
                } else {
                    int studentNumInClass = grade.classes.get(classNumInGrade).searchStudentByID(token[0]);
                    if (studentNumInClass == -1) {
                        grade.classes.get(classNumInGrade).addAStudent(token, schedule);
                    } else {
                        grade.classes.get(classNumInGrade).addACourseToStudent(studentNumInClass, token, schedule);
                    }
                }
            } else {
                System.out.println("wrong format");
            }
        }

        grade.showStudentScores();
        grade.getSumUp();
        schedule.getEndScores();
        schedule.showEndScores();
        grade.showClassScores();
    }

    private static boolean isValidCourse(String[] token) {
        return token[1].equals("必修") || token[1].equals("选修") && token[2].equals("考试") || token[2].equals("考察");
    }

    private static boolean isValidStudent(String[] token) {
        return token[0].matches("[\\d]{8}") && token[3].matches("[0-9]{1,4}");
    }
}

class Course {
    public String name;
    public String type;
    public String assessMode;
    public int midScore;
    public double midScorePercent = 0.3;
    public int finalScore;
    public double finalScorePercent = 0.7;
    public int endScore;
    public int gradeNum = 0;

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

    public String getName() {
        return name;
    }

    public void getEndScore() {
        if (gradeNum == 0) return;
        midScore = (int) Math.floor(midScore / gradeNum);
        finalScore = (int) Math.floor(finalScore / gradeNum);
        endScore = assessMode.equals("考察") ? finalScore : (int) Math.floor(midScore * midScorePercent + finalScore * finalScorePercent);
    }

    public void showEndScore() {
        if (endScore == 0) {
            System.out.println(name + " has no grades yet");
        } else {
            System.out.println(name + " " + (assessMode.equals("考察") ? finalScore : midScore + " " + finalScore) + " " + endScore);
        }
    }
}

class Schedule {
    public ArrayList<Course> courses = new ArrayList<>();

    public void addACourse(String name, String quality, String assessMode) {
        if (quality.equals("必修") && assessMode.equals("考察")) {
            System.out.println(name + " : course type & access mode mismatch");
            return;
        }
        courses.add(new Course(name, quality, assessMode));
    }

    public int searchCourseByName(String name) {
        for (int i = 0; i < courses.size(); i++) {
            if (courses.get(i).getName().equals(name)) {
                return i;
            }
        }
        return -1;
    }

    public void getEndScores() {
        for (Course course : courses) {
            course.getEndScore();
        }
    }

    public void showEndScores() {
        courses.sort(Comparator.comparing(Course::getName, Collator.getInstance(java.util.Locale.CHINA)));
        for (Course course : courses) {
            course.showEndScore();
        }
    }
}


class Student {
    String studentID;
    String name;
    int midScore;
    int finalScore;
    int endScore;
    Course learnedCourse;
    ArrayList<String> hasLearnedCourse = new ArrayList<>();
    int hasLearned = 0;

    public void getSum() {
        if (learnedCourse == null) {
            endScore = 0;
            return;
        }
        if (learnedCourse.assessMode.equals("考察")) {
            endScore += finalScore;
        } else {
            endScore += (int) Math.floor(midScore * learnedCourse.midScorePercent + finalScore * learnedCourse.finalScorePercent);
        }
        midScore = 0;
        finalScore = 0;
        learnedCourse = null;
    }

    public void showScore() {
        if (hasLearned != 0) {
            endScore /= hasLearned;
        }
        if (endScore == 0) {
            System.out.println(studentID + " " + name + " " + "did not take any exams");
        } else {
            System.out.println(studentID + " " + name + " " + endScore);
        }
    }

    public void addACourse(String[] token, Schedule schedule) {
        if (schedule.searchCourseByName(token[2]) == -1) {
            System.out.println(token[2] + " does not exist");
            return;
        }
        Course nowCourse = schedule.courses.get(schedule.searchCourseByName(token[2]));
        learnedCourse = nowCourse;
        if ((nowCourse.assessMode.equals("考察") && token.length > 4) || (nowCourse.assessMode.equals("考试") && token.length < 5)) {
            System.out.println(studentID + " " + name + " " + ": access mode mismatch");
            return;
        }
        if (learnedCourse.assessMode.equals("考察")) {
            if (Integer.parseInt(token[3]) > 100) {
                System.out.println("wrong format");
                return;
            }
            finalScore = Integer.parseInt(token[3]);
            nowCourse.finalScore += Integer.parseInt(token[3]);
        } else {
            if (Integer.parseInt(token[3]) > 100 || Integer.parseInt(token[4]) > 100) {
                System.out.println("wrong format");
                return;
            }
            midScore = Integer.parseInt(token[3]);
            nowCourse.midScore += Integer.parseInt(token[3]);
            finalScore = Integer.parseInt(token[4]);
            nowCourse.finalScore += Integer.parseInt(token[4]);
        }
        nowCourse.gradeNum++;
        hasLearned++;
        hasLearnedCourse.add(token[2]);
        getSum();
    }

    boolean ifHasLearned(String course) {
        return hasLearnedCourse.contains(course);
    }
}

class Class {
    String classNum;
    ArrayList<Student> students = new ArrayList<>();
    int stuNum = 0;
    int AverageScore;

    public void addAStudent(String[] token, Schedule schedule) {
        Student temp = new Student();
        temp.studentID = token[0];
        temp.name = token[1];
        temp.addACourse(token, schedule);
        students.add(temp);
    }

    public int searchStudentByID(String studentID) {
        for (int i = 0; i < students.size(); i++) {
            if (students.get(i).studentID.equals(studentID)) {
                return i;
            }
        }
        return -1;
    }

    public void addACourseToStudent(int i, String[] token, Schedule schedule) {
        Student temp = students.get(i);
        if (temp.ifHasLearned(token[2])) {
            return;
        }
        temp.addACourse(token, schedule);
    }

    public void getSumUp() {
        for (Student student : students) {
            AverageScore += student.endScore;
            if (student.endScore != 0) stuNum++;
        }
        if (stuNum != 0) {
            AverageScore /= stuNum;
        }
    }

    public void showStudentScore() {
        students.sort(Comparator.comparing(o -> o.studentID));
        for (Student student : students) {
            student.showScore();
        }
    }

    public void showClassScore() {
        if (AverageScore == 0) {
            System.out.println(classNum + " has no grades yet");
        } else {
            System.out.println(classNum + " " + AverageScore);
        }
    }
}

class Grade {
    ArrayList<Class> classes = new ArrayList<>();

    public int searchClassByNum(String classNum) {
        for (int i = 0; i < classes.size(); i++) {
            if (classes.get(i).classNum.equals(classNum)) {
                return i;
            }
        }
        return -1;
    }

    public void addAClass(String classNum) {
        Class temp = new Class();
        temp.classNum = classNum;
        classes.add(temp);
    }

    public void getSumUp() {
        for (Class aClass : classes) {
            aClass.getSumUp();
        }
    }

    public void showStudentScores() {
        classes.sort(Comparator.comparing(o -> o.classNum));
        for (Class aClass : classes) {
            aClass.showStudentScore();
        }
    }

    public void showClassScores() {
        classes.sort(Comparator.comparing(o -> o.classNum));
        for (Class aClass : classes) {
            aClass.showClassScore();
        }
    }
}

 

类图：

 

 

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

分数 60

作者 蔡轲

单位 南昌航空大学

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

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

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

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

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

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

 

这道题目涉及到的知识点主要包括字符串处理、条件判断、循环、数组、排序等。其中，字符串处理主要用于解析输入的信息，包括课程信息和成绩信息；条件判断用于判断输入的信息是否符合要求，如成绩是否在范围内、课程性质和考核方式是否匹配等；循环用于遍历成绩信息和课程信息，计算总成绩和平均分；数组用于存储成绩和课程信息；排序用于按学号和班级号进行排序。

难点和易错点主要包括以下几个方面：

1. 输入信息的解析：需要正确解析输入的字符串，提取出学号、姓名、课程名称、成绩等信息，并进行相应的类型转换。

2. 条件判断和错误处理：需要根据题目要求进行条件判断，如判断成绩是否在范围内、课程性质和考核方式是否匹配等。同时，还需要处理各种异常情况，如格式错误、重复的课程/成绩信息等。

3. 平均分的计算：需要正确计算各种平均分，包括学生课程总成绩平均分、单门课程成绩平均分、班级所有课程总成绩平均分。在计算平均分时，需要注意取整数部分，丢弃小数部分。

代码可以改进的地方包括：

1. 使用合适的数据结构：可以使用HashMap来存储课程信息和成绩信息，以便快速查找和更新。

2. 优化算法：在计算平均分时，可以使用累加的方式，避免重复遍历成绩信息和课程信息。

3. 代码重用：可以将一些重复的代码封装成函数或方法，提高代码的可读性和可维护性。 总之，这道题目需要对输入信息进行解析和处理，根据题目要求进行条件判断和错误处理，最后计算各种平均分并按要求输出。在实现代码时，需要注意处理各种异常情况，并尽可能优化算法和代码结构。

源码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;


public class Main {
    public static void main(String[] args)
    {
        Scanner in=new Scanner(System.in);
        int d=0;
        int g=0;
        HashMap<String,Course> allcourse=new HashMap<String,Course>();//总课程，String存课程名称
        HashMap<String,Student> allstudent=new HashMap<String,Student>();//总学生，String存学号
        HashSet<Control> selection=new HashSet<Control>();//总选课系统
        HashMap<String,Class> allclass=new HashMap<String,Class>();//总班级，String存班号
        while(true)
        {
            String a=in.nextLine();
            if(a.equals("end"))//结束
                break;
            String[] b=a.split(" ");
            //输入课程信息
            if(a.matches("(\\S{1,10})( )(必修|选修|实验)(( )(考试|考察|实验))?"))
            {
                if (b.length == 2) {
                if (b[1].equals("选修") || b[1].equals("实验")) {
                    System.out.println(b[0] + " : 课程类型与考核方式不匹配");
                } else if (allcourse.containsKey(b[0])) {
                    // 重复输入忽略本条
                    continue;
                } else if (b[1].equals("必修")) {
                    // 正常输入必修课
                    Course course = new RequiredCourse(b[0]);
                    allcourse.put(b[0], course);
                } else if (b[1].equals("实验")) {
                    // 正常输入实验课
                    Course course = new Experimentallesson(b[0]);
                    allcourse.put(b[0], course);
                }
            } else if (b.length == 3) {
                if ((b[1].equals("必修") && !b[2].equals("考试"))
                        || (b[1].equals("实验") && !b[2].equals("实验"))
                        || (b[1].equals("选修") && b[2].equals("实验"))) {
                    System.out.println(b[0] + " : course type & access mode mismatch");
                } else if (allcourse.containsKey(b[0])) {
                    // 重复输入课程
                    continue;
                } else if (b[1].equals("必修")) {
                    // 正常输入必修课
                    Course course = new RequiredCourse(b[0]);
                    allcourse.put(b[0], course);
                } else if (b[1].equals("选修")) {
                    // 正常输入选修课
                    Course course = new OptionalCourse(b[0], b[2]);
                    allcourse.put(b[0], course);
                } else if (b[1].equals("实验")) {
                    // 正常输入实验课
                    Course course = new Experimentallesson(b[0]);
                    allcourse.put(b[0], course);
                }
                }
            }
            //输入考试/考察成绩信息
            else if(a.matches("(\\d{8})( )(\\S{1,10})( )(\\S{1,10})( )(\\d{1,2}|(100))(( )(\\d{1,2}|(100)))?"))
            {
                if (!allcourse.containsKey(b[2])) {
                System.out.println(b[2] + " does not exist");
                if (!allstudent.containsKey(b[0])) {
                    Student student = new Student(b[1], b[0]);
                    allstudent.put(b[0], student);
                    String classId = b[0].substring(0, 6);
                    if (!allclass.containsKey(classId)) {
                        Class cla = new Class();
                        cla.addnum(classId);
                        allclass.put(classId, cla);
                    }
                    allclass.get(classId).addstu(student);
                }
            }
                if (b.length == 4 && allcourse.get(b[2]).getAssess().equals("考试") || b.length == 5 && allcourse.get(b[2]).getAssess().equals("考察")) {
                    System.out.println(b[0] + " " + b[1] + " : access mode mismatch");
                    if (allstudent.get(b[0]) == null) {
                        Student student = new Student(b[1], b[0]);
                        allstudent.put(b[0], student);
                        String classId = b[0].substring(0, 6);
                        if (allclass.get(classId) == null) {
                            Class cla = new Class();
                            cla.addnum(classId);
                            allclass.put(classId, cla);
                        }
                        allclass.get(classId).addstu(student);
                    }
                }
                else if (judge(selection, allstudent.get(b[0]), allcourse.get(b[2]))) { // 重复的成绩信息
                    continue;
                } else if (allcourse.get(b[2]).getAssess().equals("考试")) { // 输入考试课成绩信息
                    Achievement achievement = new Text(Integer.parseInt(b[3]), Integer.parseInt(b[4]));
                    Student student = allstudent.getOrDefault(b[0], new Student(b[1], b[0]));
                    allstudent.put(b[0], student);
                    Class cla = allclass.getOrDefault(b[0].substring(0, 6), new Class());
                    cla.addnum(b[0].substring(0, 6));
                    cla.addstu(student);
                    allclass.put(b[0].substring(0, 6), cla);
                    Control control = new Control();
                    control.setMessage(student, allcourse.get(b[2]), achievement);
                    selection.add(control);
                }

                else//输入考察课成绩信息
                {

                    Achievement achievement = new Examine(Integer.parseInt(b[3]));
                    Control control = new Control();

// 判断学生是否已经存在
                    if (!allstudent.containsKey(b[0])) {
                        // 学生不存在，创建新的学生对象并添加到allstudent中
                        Student student = new Student(b[1], b[0]);
                        allstudent.put(b[0], student);

                        // 判断班级是否已经存在
                        String classId = b[0].substring(0, 6);
                        if (!allclass.containsKey(classId)) {
                            // 班级不存在，创建新的班级对象并添加到allclass中
                            Class cla = new Class();
                            cla.addnum(classId);
                            allclass.put(classId, cla);
                        }

                        // 将学生添加到班级中
                        allclass.get(classId).addstu(student);
                    }

// 将成绩信息添加到Control对象中
                    control.setMessage(allstudent.get(b[0]), allcourse.get(b[2]), achievement);

// 将Control对象添加到selection中
                    selection.add(control);
                }
            }
            //输入实验成绩
            else if(a.matches("(\\d{8})( )(\\S{1,10})( )(\\S{1,10})( )([4-9])( )((\\d{1,2}|(100))( ))*(\\d{1,2}|(100)*)"))
            {
                if(!allcourse.containsKey(b[2])) {//课程名称不在已输入的课程列表中
                    System.out.println(b[2] + " does not exist");
                    if(!allstudent.containsKey(b[0])) {
                        Student student = new Student(b[1], b[0]);
                        allstudent.put(b[0], student);
                        String classId = b[0].substring(0, 6);
                        if(!allclass.containsKey(classId)) {
                            Class cla = new Class();
                            cla.addnum(classId);
                            allclass.put(classId, cla);
                        }
                        allclass.get(classId).addstu(student);
                    }
                }
                else if (b.length - 4 != Integer.parseInt(b[3])) {
                System.out.println(b[0] + " " + b[1] + " : access mode mismatch");
                Student student = allstudent.getOrDefault(b[0], new Student(b[1], b[0]));
                allstudent.put(b[0], student);
                Class cla = allclass.getOrDefault(b[0].substring(0, 6), new Class());
                cla.addnum(b[0].substring(0, 6));
                cla.addstu(student);
                allclass.put(b[0].substring(0, 6), cla);
            }
                else if(judge(selection,allstudent.get(b[0]),allcourse.get(b[2])));
                else//输入实验成绩信息
                {
                    int[] e = new int[b.length - 4];
                    for (int i = 0; i < e.length; i++) {
                        e[i] = Integer.parseInt(b[i + 4]);
                    }
                    Achievement achievement = new Experimental(e.length, e);
                    Control control = new Control();
                    String studentId = b[0];
                    if (!allstudent.containsKey(studentId)) {
                        Student student = new Student(b[1], studentId);
                        allstudent.put(studentId, student);
                        String classId = studentId.substring(0, 6);
                        if (!allclass.containsKey(classId)) {
                            Class cla = new Class();
                            cla.addnum(classId);
                            allclass.put(classId, cla);
                        }
                        allclass.get(classId).addstu(student);
                    }
                    control.setMessage(allstudent.get(studentId), allcourse.get(b[2]), achievement);
                    selection.add(control);
                }
            }
            else
                System.out.println("wrong format");
        }
        List<Student> mapValues = new ArrayList<>(allstudent.values());
        Collections.sort(mapValues);
        for (Student i : mapValues) {
            int totalScore = 0;
            int examCount = 0;
            for (Control control : selection) {
                if (i.equals(control.getStudent())) {
                    totalScore += control.getTotalScore();
                    examCount++;
                }
            }
            if (examCount == 0) {
                System.out.println(i.getNumber() + " " + i.getName() + " did not take any exams");
            } else {
                int averageScore = totalScore / examCount;
                System.out.println(i.getNumber() + " " + i.getName() + " " + averageScore);
            }
        }
        List<Course> courseValues = new ArrayList<>(allcourse.values());
        Collections.sort(courseValues,new SortName());
        for(Course i:courseValues)
        {
            int u=0;//平时
            int f=0;//期末
            int s=0;//总
            int n=0;
            for(Control j:selection)
                if(i==j.getCourse())
                {if ("考试".equals(i.getAssess())) {
                    u += j.getScore().getUsualPerformance();
                    f += j.getScore().getFinalGrade();
                } else if ("考察".equals(i.getAssess())) {
                    f += j.getScore().getFinalGrade();
                }
                    s += j.getScore().getTotalScore();
                    n++;
                }
            if(n==0)
                System.out.println(i.getName()+" has no grades yet");
            else
            {
                System.out.print(i.getName());
                s /= n;
                String assess = i.getAssess();
                if (assess.equals("考试")) {
                    u /= n;
                    f /= n;
                    System.out.println(" " + u + " " + f + " " + s);
                } else if (assess.equals("考察")) {
                    f /= n;
                    System.out.println(" " + f + " " + s);
                } else {
                    System.out.println(" " + s);
                }
            }
        }
//        for(Class i:allclass.values())
        //        i.gettotalscore(selection);
        List<Class> classValues = new ArrayList<>(allclass.values());
        Collections.sort(classValues);
        for (Class i : classValues) {
            String message = i.hasGrades(selection) ? i.getNum() + " " + i.getTotalScore(selection) : i.getNum() + " has no grades yet";
            System.out.println(message);
        }
    }
    public static boolean judge(HashSet<Control> o,Student s,Course c)
    {
        return o.stream().anyMatch(i -> i.getStudent() == s && i.getCourse() == c);
    }
}

//每门课程
abstract class Course {
    private String name;
    private String assess;

    public Course() {
        this.name = name;
        this.assess = assess;
    }

    public String getName() {
        return name;
    }

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

    public String getAssess() {
        return assess;
    }

    public void setAssess(String assess) {
        this.assess = assess;
    }
}
//必修课
class RequiredCourse extends Course
{
    RequiredCourse(String name)
    {
        super();
        setName(name);
        setAssess("考试");
    }

}
//选修课
class OptionalCourse extends Course
{
    OptionalCourse(String name,String b)
    {
        setName(name);
        setAssess(b);
    }
}
//实验课
class Experimentallesson extends Course
{
    Experimentallesson(String name)
    {
        setName(name);
        setAssess("实验");
    }
}
//学生

class Student implements Comparable<Student> {
    private final String name;
    private final String number;

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

    public String getName() {
        return name;
    }

    public String getNumber() {
        return number;
    }

    @Override
    public int compareTo(Student o) {
        return this.number.compareTo(o.getNumber());
    }
}
//选课中心

class Control {
    private Student student;
    private Course course;
    private Achievement score;

    public Control() {
        this.student = student;
        this.course = course;
        this.score = score;
    }

    public int getTotalScore() {
        return score.getTotalScore();
    }

    public Student getStudent() {
        return student;
    }

    public Course getCourse() {
        return course;
    }

    public Achievement getScore() {
        return score;
    }

    public void setMessage(Student student, Course course, Achievement score) {
        this.student = student;
        this.course = course;
        this.score = score;
    }
}
//成绩


abstract class Achievement {
    private int finalGrade; // 期末成绩
    private int usualPerformance; // 平时成绩

    public Achievement() {
        this.finalGrade = finalGrade;
        this.usualPerformance = usualPerformance;
    }

    public void setFinalGrade(int finalGrade) {
        this.finalGrade = finalGrade;
    }

    public void setUsualPerformance(int usualPerformance) {
        this.usualPerformance = usualPerformance;
    }

    public int getFinalGrade() {
        return finalGrade;
    }

    public int getUsualPerformance() {
        return usualPerformance;
    }

    public abstract int getTotalScore(); // 计算总成绩
}

// 考试成绩
class Text extends Achievement {
    public Text(int usual, int fina) {
        super();
    }

    @Override
    public int getTotalScore() {
        return (int) (getUsualPerformance() * 0.3 + getFinalGrade() * 0.7);
    }
}

// 考察成绩
class Examine extends Achievement {
    public Examine(int finalGrade) {
        super();
    }

    @Override
    public int getTotalScore() {
        return getFinalGrade();
    }
}

class Experimental extends Achievement {
    private int time;//实验次数
    private List<Integer> scores;//每次实验成绩

    public Experimental(int time, int[] score) {
        super();
        this.time = time;
        this.scores = new ArrayList<>();
        for (int s : score) {
            scores.add(s);
        }
    }

    @Override
    public int getTotalScore() {
        int totalScore = 0;
        for (int s : scores) {
            totalScore += s;
        }
        return totalScore / time;
    }
}
//班

class Class implements Comparable<Class>
{
    private String num;//班级序号
    private HashSet<Student> students=new HashSet<Student>();//学生
    void addnum(String num)
    {
        this.num=num;
    }
    String getNum()
    {
        return num;
    }
    void addstu(Student student)
    {
        students.add(student);
    }
    boolean hasGrades(HashSet<Control> o)//判断该班是否有成绩
    {
        int n=0;
        for(Student a:this.students)
            for(Control b:o)
            {
                if(b.getStudent()==a)
                    n++;
            }
        if(n==0)
            return false;
        return true;
    }
    public int getTotalScore(HashSet<Control> controls) {
        int totalScore = 0;
        int studentCount = 0;
        int controlCount = 0;
        for (Student student : this.students) {
            int studentTotalScore = 0;
            int studentControlCount = 0;
            for (Control control : controls) {
                if (control.getStudent() == student) {
                    studentTotalScore += control.getTotalScore();
                    studentControlCount++;
                }
            }
            if (studentControlCount > 0) {
                totalScore += studentTotalScore / studentControlCount;
                studentCount++;
            }
            controlCount += studentControlCount;
        }
        if (studentCount > 0) {
            return totalScore / studentCount;
        } else {
            return 0;
        }
    }

    @Override
    public int compareTo(Class otherClass) {
        return this.num.compareTo(otherClass.getNum());
    }
}
class SortName implements Comparator<Course>
{
    @Override
public int compare(Course o, Course o1) {
    return o.getName().compareTo(o1.getName());
}
}

类图：

 

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

分数 64

作者 蔡轲

单位 南昌航空大学

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

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

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

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

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

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

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

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

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

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

 

这个题目涉及的知识点主要包括Java的输入输出、字符串处理、条件判断、循环、数组、排序等基础知识。难点在于解析输入的字符串信息，根据题目要求进行相应的计算和处理，并输出符合要求的结果。 首先，需要解析输入的课程信息和成绩信息。可以使用字符串的split方法将输入的字符串按照空格进行分割，得到相应的课程名称、课程性质、考核方式、权重等信息。然后，根据不同的考核方式进行相应的计算和处理。对于考试课，需要解析学号、姓名、平时成绩和期末成绩等信息；对于考察课，只需要解析学号、姓名和期末成绩；对于实验课，需要解析学号、姓名和每次实验成绩等信息。 在计算总成绩时，需要根据权重值进行相应的计算。对于考试课和考察课，直接将期末成绩作为总成绩；对于实验课，需要将每次实验成绩乘以相应的权重后累加得到总成绩。 在输出结果时，需要按照题目要求进行排序和格式化输出。可以使用数组或集合来存储学生和课程的成绩信息，然后进行排序和输出。同时，需要注意处理异常情况，如课程名称不匹配、成绩数量不匹配、权重值错误等，按照题目要求输出相应的错误信息。 代码可以改进的地方包括使用合适的数据结构来存储成绩信息，提高代码的可读性和可维护性；使用正则表达式来匹配和解析输入的字符串，简化代码逻辑；使用自定义的类来表示课程和成绩信息，提高代码的可扩展性和复用性。 总之，这个题目需要对输入的字符串进行解析和处理，根据题目要求进行相应的计算和输出。需要注意处理异常情况，并对代码进行适当的优化和改进。

源码如下：

import java.text.Collator;
import java.util.*;
import java.util.ArrayList;
public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String s_record = s.nextLine();
        ParseInput handle=new ParseInput();
        while (!s_record.equals("end")) {
            handle.parseInput(s_record);//解析用户输入的每一行数据
            s_record = s.nextLine();
        }
        handle.showStudents();
        handle.showCourses();
        handle.showClasses();
    }
}
class ParseInput{
    ArrayList<Student> listStudent=new ArrayList<>();
    ArrayList<Course> listCourse=new ArrayList<>();
    ArrayList<Class> listClass=new ArrayList<>();
    ArrayList<ChooseCourse> listChooseCourse=new ArrayList<>();

    public void parseInput(String str){
        InputMatching mat=new InputMatching();
        int flag=mat.matchingInput(str);
        switch (flag){
            case 0:System.out.println("wrongformat");
                break;
            //课程信息
            case 1:courseMessage(str);
                break;
            //成绩信息
            case 2:gradeMessage(str);
                break;
        }
    }
    public void courseMessage(String str) {
        String[] letters = str.split(" ");
        String courseName = letters[0];
        String type = letters[1];
        String testType = letters[2];
        float totalPower = 0;
        int num = Integer.parseInt(letters[3]);
        if ((letters.length - 4) != num) {
            System.out.println(courseName + " : number of scores does not match");
        } else {
            for (int i = 4; i < letters.length; i++) {
                totalPower += Float.parseFloat(letters[i]);
            }
            if (totalPower != 1.0) {
                System.out.println(courseName + " : weight value error");
            } else {
                ArrayList<String> power = new ArrayList<>();
                for (int i = 4; i < letters.length; i++) {
                    power.add(letters[i]);
                }
                Course course = new Course(courseName, type, testType, power);
                if (checkCourse(course) && searchCourse(courseName) == null) {
                    listCourse.add(course);
                }
            }
        }
    }
    public void gradeMessage(String str){
        String letters[]=str.split(" ");

        String stuId= letters[0];//学生学号
        String classID= letters[0].substring(0,6);
        String name=letters[1];//学生姓名
        String courseName=letters[2];//课程名字

        //如果该班级第一次出现
        if(searchClass(classID)==null){
            Class cla=new Class(classID);
            listClass.add(cla);
        }

        Student stu=new Student(classID,stuId,name);

        if(!searchStudent(stuId))
            listStudent.add(stu);//将学生加入列表中

        //课程是否存在
        if(searchCourse(courseName)==null){
            System.out.println(courseName+" "+"does not exist");
        }

        //当课程存在时
        else if(searchCourse(courseName)!=null){
            Course course=searchCourse(courseName);
            //考察
            if(letters.length==4&&course.testType.equals("考察")){
                int finalGrade= Integer.parseInt(letters[3]);
                AssessGrade assessGrade=new AssessGrade(finalGrade);
                ChooseCourse chooseCourse=new ChooseCourse(course,stu,assessGrade);
                if(!searchChooseCourse(name,courseName))
                    listChooseCourse.add(chooseCourse);
            }
            //考试
            else if(letters.length==5&&course.testType.equals("考试")){
                int usualGrade= Integer.parseInt(letters[3]);
                int finalGrade= Integer.parseInt(letters[4]);
                ExamGrade examGrade=new ExamGrade(usualGrade,finalGrade,course.powers);
                ChooseCourse chooseCourse=new ChooseCourse(course,stu,examGrade);
                listChooseCourse.add(chooseCourse);
            }
            else if(letters.length>5&&course.testType.equals("实验")){
                int exNum= course.powers.size();
                if(exNum!=letters.length-3){
                    //20201103 张三 : access mode mismatch
                    System.out.println(stuId+" "+name+" "+": access mode mismatch");
                    return;
                }
                ArrayList<Integer> scores = new ArrayList<>();
                /**实验课程信息格式：0学号+英文空格+1姓名+英文空格+2课程名称+英文空格+3实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩*/
                for(int i=3;i<letters.length;i++){
                    scores.add(Integer.parseInt(letters[i]));
                }
                ExperimentGrade experimentGrade=new ExperimentGrade(scores,course.powers);
                ChooseCourse chooseCourse=new ChooseCourse(course,stu,experimentGrade);
                listChooseCourse.add(chooseCourse);
            }
            else{
                //学号+英文空格+姓名+英文空格+": access mode mismatch"
                System.out.println(stuId+" "+name+" "+": access mode mismatch");
            }
        }
    }

    public boolean checkCourse(Course course){
        String type = course.getType();
        String testType = course.getTestType();
        if(type.equals("必修") && testType.equals("考试")){
            return true;
        }
        if(type.equals("选修") && (testType.equals("考试") || testType.equals("考察"))){
            return true;
        }
        if(type.equals("实验") && testType.equals("实验")){
            return true;
        }
        System.out.println(course.getCourseName()+" : course type & access mode mismatch");
        return false;
    }
    public Class searchClass(String classId){
        return listClass.stream()
                .filter(cls -> cls.getClassId().equals(classId))
                .findFirst()
                .orElse(null);
    }

    public Course searchCourse(String name){
        return listCourse.stream()
                .filter(course -> course.getCourseName().equals(name))
                .findFirst()
                .orElse(null);
    }
    public boolean searchStudent(String id){
        return listStudent.stream().anyMatch(stu -> stu.getId().equals(id));
    }
    //查找是否有重复选课成绩
    public boolean searchChooseCourse(String stuName,String courseName){
        return listChooseCourse.stream().anyMatch(cs -> cs.student.getStuName().equals(stuName) && cs.course.getCourseName().equals(courseName));
    }
    public void showStudents(){
        listStudent.sort(Comparator.naturalOrder());
        for(Student stu : listStudent){
            ArrayList<ChooseCourse> stuCourseSelects = getStudentSelects(stu.getId());
            if(!stuCourseSelects.isEmpty()) {
                System.out.println(stu.getId() + " " + stu.getStuName() + " " + getAvgTotalScore(stuCourseSelects));
            }
            else {
                System.out.println(stu.getId() + " " + stu.getStuName() + " did not take any exams");
            }
        }
    }
    //java 选修 考察
    public void showCourses() {
        Collections.sort(listCourse);
        for (Course course : listCourse) {
            ArrayList<ChooseCourse> stuCourseSelects = getCourseSelects(course.getCourseName());
            if (!stuCourseSelects.isEmpty()) {
                switch (course.getTestType()) {
                    case "考试":
                    case "考察":
                    case "实验":
                        System.out.println(course.getCourseName() + " " + getAvgTotalScore(stuCourseSelects));
                        break;
                    default:
                        break;
                }
            } else {
                System.out.println(course.getCourseName() + " " + "has no grades yet");
            }
        }
    }
    public void showClasses(){
        listClass.sort(Comparator.naturalOrder());
        for(Class cls : listClass){
            ArrayList<ChooseCourse> stuCourseSelects = getClassSelects(cls.getClassId());
            if(!stuCourseSelects.isEmpty()){
                System.out.println(cls.getClassId() + " " + getAvgTotalScore(stuCourseSelects));
            }
            else{
                System.out.println(cls.getClassId() + " " + "has no grades yet");
            }
        }
    }
    public ArrayList<ChooseCourse> getStudentSelects(String id){
        ArrayList<ChooseCourse> choose=new ArrayList<>();
        for(ChooseCourse cos:listChooseCourse) {
            if (cos.student.getId().equals(id))
                choose.add(cos);
        }
        return choose;
    }
    public ArrayList<ChooseCourse> getCourseSelects(String courseName){
        ArrayList<ChooseCourse> choose=new ArrayList<>();
        for(ChooseCourse cos:listChooseCourse) {
            if (cos.course.getCourseName().equals(courseName))
                choose.add(cos);
        }
        return choose;
    }
    public ArrayList<ChooseCourse> getClassSelects(String clsId){
        ArrayList<ChooseCourse> choose =new ArrayList<>();
        for(ChooseCourse cos:listChooseCourse) {
            if (cos.student.getClsId().equals(clsId))
                choose.add(cos);
        }
        return choose;
    }
    public int getAvgTotalScore(ArrayList<ChooseCourse> cs){
        int sum=0;
        for(ChooseCourse c:cs){
            sum+=c.grade.getTotalGrade();
        }
        return (int)(sum/cs.size());
    }

}
class ChooseCourse{
    Course course;
    Student student;
    Grade grade;

    public ChooseCourse(Course course,Student student,Grade grade) {
        this.course = course;
        this.student=student;
        this.grade=grade;
    }
}
class Student implements Comparable<Student> {
    private String stuName;
    private String id;
    private String clsId;

    public String getId() {
        return id;
    }

    public String getStuName() {
        return stuName;
    }

    public String getClsId() {
        return clsId;
    }

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

    @Override
    public int compareTo(Student stu) {
        return this.id.compareTo(stu.getId());
    }
}
class Course implements Comparable<Course>{
    String courseName;
    String type;
    String testType;
    ArrayList<String> powers =new ArrayList<>();


    public Course(String courseName, String type, String testType, ArrayList<String> powers) {
        this.courseName = courseName;
        this.type = type;
        this.testType = testType;
        this.powers = powers;
    }

    public String getCourseName(){
        return courseName;
    }
    public String getType(){
        return type;
    }
    public String getTestType(){
        return  testType;
    }
    @Override
    public int compareTo(Course o) {
        Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(courseName,o.getCourseName());
    }

}
class Class implements Comparable<Class>{
    String classId;

    public Class() {
    }

    public String getClassId(){
        return classId;
    }
    public Class(String classId) {
        this.classId = classId;
    }
    @Override
    public int compareTo(Class o) {
        return getClassId().compareTo(o.getClassId());
    }
}
abstract class Grade{
    int finalGrade;
    ArrayList<String> powers=new ArrayList<>();
    public Grade() {
    }
    public abstract int getUsualGrade();
    public abstract int getTotalGrade();
}
class ExamGrade extends Grade{
    int usualGrade;

    float usualPower;
    float finalPower;
    ArrayList<Float> powers=new ArrayList<>();
    public ExamGrade(int usualGrade,int finalGrade,ArrayList<String> powers) {
        super.finalGrade=finalGrade;
        this.usualGrade = usualGrade;
        super.powers=powers;
    }

    public int getUsualGrade(){
        return usualGrade;
    }
    public int getTotalGrade(){
        return (int)(usualGrade*powers.get(0)+finalGrade*powers.get(1));
    }
}
class AssessGrade extends Grade{

    public AssessGrade(int finalGrade) {
        this.finalGrade=finalGrade;
    }

    @Override
    public int getUsualGrade() {
        return 0;
    }

    public int getTotalGrade(){
        return finalGrade;
    }
}
class ExperimentGrade extends Grade{
    ArrayList<Integer> exGrade=new ArrayList<>();//成绩
    public ExperimentGrade(ArrayList<Integer> scores,ArrayList<String> powers) {
        exGrade = scores;
        super.powers=powers;
    }
    public int getUsualGrade() {
        return 0;
    }
    public int getTotalGrade(){
        float sum=0;
        for(int i=0;i<exGrade.size();i++){
            sum=sum+exGrade.get(i)*Float.parseFloat(powers.get(i));
        }
        return (int)sum;
    }
}
class InputMatching {
    static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
    static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String scoreMatching = "([1-9]?[0-9]|100)";
    static String experimentNum="^[4-9]$";
    static String coursePowerNum="[1-9]";
    static String powerNum="(^[0-9]*\\.([0-9]{1}\\d*)$)|[1]";//小于或等于1的数
    static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String courseTypeMatching = "(选修|必修|实验)";
    static String checkCourseTypeMatching = "(考试|考察|实验)";
    //courseInput用于定义课程信息模式（正则表达式）
    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
    //scoreInput用于定义成绩信息模式（正则表达式）
    static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching ;
    static String scoreInput2=  stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching + " " +scoreMatching;
    static String scoreInput3=  stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            experimentNum;
    public InputMatching() {
    }
    public  int matchingInput(String s) {

        if (matchingCourse(s))
            return 1;
        if (matchingScore(s)|| isExScoreValid(s))
            return 2;
        return 0;

    }

    //课程信息
    private static boolean matchingCourse(String s) {
        String letters[]=s.split(" ");
        if(letters[0].matches(courseNameMatching)&&letters[1].matches(courseTypeMatching)
                &&letters[2].matches(checkCourseTypeMatching)&&letters[3].matches(coursePowerNum))
        {
            if(letters[2].equals("实验")&&(!letters[3].matches(experimentNum)))
                return false;
            for(int i=4;i<letters.length;i++){
                if(!letters[i].matches(powerNum))
                    return false;
            }
            return true;
        }
        return false;
    }
    //成绩信息
    private static boolean matchingScore(String s) {
        //System.out.println(match);
        if(s.matches(scoreInput1)||s.matches(scoreInput2))
            return true;
        return false;
    }
    //实验课信息
    private static boolean isExScoreValid(String s) {
        String[] info = s.split(" ");
        String stuNumPattern = "\\d{8}"; // 学号格式为8位数字
        String stuNamePattern = "[\\u4e00-\\u9fa5]{2,4}"; // 姓名格式为2-4个汉字
        String courseNamePattern = "[a-zA-Z]+"; // 课程名称格式为英文字母
        String scorePattern = "\\d{1,2}|100"; // 成绩格式为1-2位数字或100
        if (info.length < 6 || info.length > 13) { // 实验次数至少4次，不超过9次，因此长度应该在6-13之间
            return false;
        }
        if (!info[0].matches(stuNumPattern) || !info[1].matches(stuNamePattern) || !info[2].matches(courseNamePattern)) {
            return false;
        }
        for (int i = 3; i < info.length; i++) {
            if (!info[i].matches(scorePattern)) {
                return false;
            }
        }
        return true;
    }

}

类图：

 

7-4 动物发声模拟器（多态）

分数 20

作者 刘凤良

单位 天津仁爱学院

设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩

其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。

源码：

//动物发生模拟器
public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
        Goat goat = new Goat();
        speak(cat);
        speak(dog);
        speak(goat);
    }
    //定义静态方法speak()
    public static void speak(Animal animal){
        System.out.println(animal.getAnimalClass()+"的叫声："+animal.shout());
    }
}

//定义抽象类Animal
abstract class Animal{
    public abstract String getAnimalClass();
    public abstract String shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
    public String getAnimalClass(){
        return "猫";
    }
    public String shout(){
        return "喵喵";
    }
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal{
    public String getAnimalClass(){
        return "狗";
    }
    public String shout(){
        return "汪汪";
    }
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{
    public String getAnimalClass(){
        return "山羊";
    }
    public String shout(){
        return "咩咩";
    }
}

 

这段代码是一个动物发声模拟器，主要涉及到面向对象的知识点，包括抽象类、继承、多态等。 首先，在主函数中创建了一个猫对象、一个狗对象和一个山羊对象，并分别调用了speak方法来输出它们的叫声。 在抽象类Animal中定义了两个抽象方法getAnimalClass和shout，分别用于获取动物的类别和发出叫声。这样做的好处是可以统一处理不同种类的动物，而无需为每个动物类都写一个speak方法。 然后，分别创建了猫类、狗类和山羊类，它们都继承自Animal类，并重写了父类的两个抽象方法。在每个子类中，getAnimalClass方法返回了该动物的类别，shout方法返回了该动物的叫声。 最后，在speak方法中，通过传入Animal类型的参数，实现了多态。无论传入的是猫对象、狗对象还是山羊对象，都可以调用各自类中重写的shout方法，实现了不同动物的发声。 这段代码的难点在于理解抽象类和多态的概念，以及如何正确使用。抽象类是一种不能被实例化的类，只能被继承，用于定义一些共性的方法和属性。多态是指同一个方法在不同的对象上有不同的实现，通过父类的引用指向子类的对象，可以实现对不同子类的统一处理。 代码的改进之处可以考虑增加更多的动物类，以及为每个动物类添加更多的属性和方法，使模拟器更加完善。另外，可以考虑将动物类的属性和方法封装起来，提供更好的访问控制和代码复用性。 总结起来，这段代码通过抽象类和多态的运用，实现了一个动物发声模拟器，展示了面向对象的编程思想。对于初学者来说，理解抽象类和多态的概念是关键，通过实践和不断的练习，可以更好地掌握这些知识点。

类图：

 

7-5 jmu-Java-03面向对象基础-05-覆盖

分数 5

作者 郑如滨

单位 集美大学

Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。

1. 新建PersonOverride类

a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。

b. 有参构造方法，参数为name, age, gender

c. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true

d.toString()方法返回格式为：name-age-gender

e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.

2. main方法

2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。

提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。

源码：

import java.util.*;
import java.lang.reflect.*;

class PersonOverride {
    private String name;
    private int age;
    private boolean gender;

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public boolean isGender() {
        return gender;
    }

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

    public void setAge(int age) {
        this.age = age;
    }

    public void setGender(boolean gender) {
        this.gender = gender;
    }

    public String toString() {
        return name + "-" + age + "-" + gender;
    }

    public boolean equals(Object obj) {
        if (obj instanceof PersonOverride) {
            PersonOverride other = (PersonOverride) obj;
            return name.equals(other.name) && age == other.age && gender == other.gender;
        }
        return false;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n1 = Integer.parseInt(scanner.nextLine());
        ArrayList<PersonOverride> persons1 = new ArrayList<>();
        for (int i = 0; i < n1; i++) {
            persons1.add(new PersonOverride());
        }
        int n2 = Integer.parseInt(scanner.nextLine());
        ArrayList<PersonOverride> persons2 = new ArrayList<>();
        for (int i = 0; i < n2; i++) {
            String[] parts = scanner.nextLine().split(" ");
            String name = parts[0];
            int age = Integer.parseInt(parts[1]);
            boolean gender = Boolean.parseBoolean(parts[2]);
            PersonOverride person = new PersonOverride(name, age, gender);
            if (!persons2.contains(person)) {
                persons2.add(person);
            }
        }
        for (PersonOverride person : persons1) {
            System.out.println(person);
        }
        for (PersonOverride person : persons2) {
            System.out.println(person);
        }
        System.out.println(persons2.size());

        Constructor<?>[] constructors = PersonOverride.class.getDeclaredConstructors();
        Arrays.sort(constructors, Comparator.comparing(Constructor::getParameterCount));

        System.out.println(Arrays.toString(constructors));
    }
}

 

这段代码是一个简单的Java程序，主要涉及到类的定义、构造函数、成员变量、方法、ArrayList的使用、Scanner的使用等知识点。 首先，代码定义了一个名为PersonOverride的类，该类有三个私有成员变量name、age和gender，以及一个构造函数和一些getter和setter方法。还有一个重写了toString()方法和equals()方法的方法。 在Main类的main方法中，首先通过Scanner获取输入的n1和n2的值，分别表示要创建的PersonOverride对象的数量。然后使用一个for循环创建n1个默认的PersonOverride对象，并将它们添加到persons1列表中。接着使用另一个for循环创建n2个自定义的PersonOverride对象，并将它们添加到persons2列表中。在创建自定义对象时，通过split()方法将输入的字符串按空格分割成三部分，分别表示name、age和gender的值，然后使用这些值创建PersonOverride对象。在添加到persons2列表之前，通过contains()方法判断该对象是否已经存在于列表中，如果不存在则添加。 这段代码的难点和易错点在于对类的定义和使用的理解，以及对ArrayList和Scanner的使用的熟悉程度。在创建自定义对象时，需要注意输入的格式和类型的转换。另外，equals()方法的重写需要注意对象类型的判断和成员变量的比较。 代码可以改进的地方包括： 1. 可以在PersonOverride类中添加一个构造函数，接收一个字符串作为参数，用于解析字符串并初始化对象的成员变量。 2. 可以在PersonOverride类中添加一个静态方法，用于从控制台获取用户输入并创建PersonOverride对象。 3. 可以在Main类中使用try-catch语句来处理输入错误或格式错误的异常，提高代码的健壮性。 4. 可以在Main类中添加一些其他的操作，例如对persons1和persons2列表的遍历和操作。 总结来说，这段代码涉及到了Java基础的类的定义和使用、ArrayList的使用、Scanner的使用等知识点。难点和易错点在于对类的定义和使用的理解，以及对ArrayList和Scanner的使用的熟悉程度。代码可以改进的地方包括添加更多的功能和异常处理。

类图：

PTA6-8题目集总结：

在完成课程成绩统计程序等题目过程中，我学到了很多关于软件开发的知识和技能。首先，我学会了如何进行需求分析和系统设计。在项目开始之前，我和团队成员一起进行了需求分析，明确了项目的功能和需求。然后，我们进行了系统设计，确定了系统的架构和模块划分。通过这个过程，我学会了如何将抽象的需求转化为具体的系统设计，这对于实际的软件开发非常重要。

其次，我学习了如何使用Java编程语言进行软件开发。在项目中，我使用Java编写了成绩统计程序的各个模块，包括学生信息管理、成绩录入和查询等功能。通过这个过程，我巩固了之前学习的Java知识，并且学会了如何将这些知识应用到实际的项目中。

另外，我还学习了如何进行软件测试和调试。在项目完成之后，我进行了系统测试，确保程序的功能和性能符合需求。在测试过程中，我发现了一些问题，并且通过调试和修复来解决这些问题。通过这个过程，我学会了如何进行软件测试和调试，提高了程序的质量和稳定性。

在项目中，我也遇到了一些挑战和困难。首先，需求的变化和调整是一个挑战。在项目进行过程中，我们发现一些需求需要进行调整和修改，这要求我们及时进行沟通和协调，确保项目的顺利进行。其次，团队合作和沟通也是一个挑战。在项目中，我们需要与团队成员进行有效的沟通和协作，确保项目的进展和质量。

总的来说，通过完成课程成绩统计程序的题目等，我学到了很多关于软件开发的知识和技能，包括需求分析和系统设计、Java编程、软件测试和调试等。同时，我也面对了一些挑战和困难，但通过团队合作和努力，最终完成了项目。这个项目经验对于我今后的软件开发和项目管理都非常有帮助，我相信我能够在实际的工作中运用这些知识和技能，取得更好的成绩。

 

对于三个题目集方面，我有以下改进建议和意见：

1. 提供更详细的题目说明：有时候题目的表述可能不够清晰，容易引起理解上的困惑。建议在题目中提供更详细的说明和示例，以帮助学生更好地理解题意。

2. 强调编码规范和最佳实践：在题目的要求中可以加入对编码规范和最佳实践的要求，例如命名规范、注释要求、代码风格等。这有助于培养良好的编码习惯和提高代码的可读性和可维护性。

3. 提供范例代码和解析：对于每个题目，可以提供范例代码和解析，以便学生参考和学习。这有助于学生理解问题的解决思路和方法。

 

综合性总结： 

这段时间学习Java，我收获了很多知识和技能。首先，我学会了Java的基本语法和面向对象的编程思想。通过学习Java的数据类型、控制流程、数组、类和对象等基础知识，我能够编写简单的Java程序，并且能够理解和分析他人编写的代码。

其次，我学习了Java的核心类库和常用API。Java的标准类库提供了丰富的功能和工具，如集合框架、IO操作、多线程、网络编程等。通过学习这些类库和API，我能够更高效地开发Java应用程序，并且能够解决一些常见的编程问题。

另外，我也学习了Java的异常处理机制和文件操作。异常处理是Java中重要的编程概念，通过学习异常处理，我能够编写更健壮的程序，并且能够更好地处理程序中可能出现的错误。文件操作是Java中常用的功能之一，通过学习文件操作，我能够读写文件、创建目录、删除文件等，这对于实际开发中的数据存储和读取非常有用。

在学习过程中，我也发现了一些需要进一步学习和研究的地方。首先，我需要深入学习Java的多线程编程。多线程是Java中重要的特性之一，通过使用多线程，可以实现程序的并发执行，提高程序的性能。但是多线程编程也存在一些问题，如线程安全、死锁等，我需要进一步学习和理解这些问题，并且学会如何解决它们。

其次，我还需要学习Java的网络编程和数据库操作。网络编程是现代应用开发中不可或缺的一部分，通过学习网络编程，我能够实现网络通信、数据传输等功能。数据库操作是Java应用开发中常用的功能之一，通过学习数据库操作，我能够实现数据的存储和读取，并且能够使用数据库来支持应用程序的功能。

总的来说，这段时间学习Java让我对这门语言有了更深入的了解，我学会了Java的基本语法和面向对象的编程思想，掌握了Java的核心类库和常用API，也学习了Java的异常处理和文件操作。但是我也意识到还有很多需要进一步学习和研究的地方，如多线程编程、网络编程和数据库操作等。通过不断学习和实践，我相信我能够更好地掌握Java编程技术，并且能够在实际开发中运用自如。

 

意见与建议：

作为学生，我对Java课程的教师、课程内容、作业、实验以及课上和课下的组织方式有一些改进建议和意见。

首先，关于教师方面，我认为教师应该具备扎实的Java编程知识和丰富的实践经验。他们应该能够清晰地传授Java的基本概念和核心知识，并能够引导学生进行实际的编程练习和项目开发。此外，教师应该积极与学生互动，鼓励学生提问和参与讨论，以激发学生的学习兴趣和思考能力。

其次，关于课程内容方面，我建议在设计课程大纲时，应该充分考虑到学生的实际需求和就业市场的需求。课程内容应该包括Java语言的基础知识、面向对象编程、数据结构与算法、多线程编程、网络编程等方面的内容。同时，可以适当引入一些实际应用案例，让学生能够将所学知识应用到实际项目中。

第三，关于作业和实验方面，我认为应该注重实践能力的培养。作业和实验应该具有一定的难度和挑战性，能够让学生运用所学知识解决实际问题。同时，作业和实验应该有明确的要求和评分标准，以便学生能够清楚地知道自己的学习进展和不足之处。

第四，关于课上和课下的组织方式，我建议采用多种教学方法和手段。除了传统的讲授和演示，可以引入案例分析、小组讨论、编程实践等方式，以提高学生的学习效果和参与度。此外，可以利用在线学习平台和资源，提供课程资料、习题和编程练习等，方便学生在课下进行自主学习和巩固。

总之，我希望Java课程能够更加注重实践能力的培养，教师能够具备扎实的专业知识和教学经验，课程内容能够紧密结合实际应用，作业和实验能够有针对性和挑战性，课上和课下的组织方式能够多样化和灵活性。相信通过这些改进和优化，Java课程将能够更好地满足学生的学习需求，提高学生的编程能力和就业竞争力。

 

这段时间学习Java，我收获了很多知识和技能。首先，我学会了Java的基本语法和面向对象的编程思想。通过学习Java的数据类型、控制流程、数组、类和对象等基础知识，我能够编写简单的Java程序，并且能够理解和分析他人编写的代码。 其次，我学习了Java的核心类库和常用API。Java的标准类库提供了丰富的功能和工具，如集合框架、IO操作、多线程、网络编程等。通过学习这些类库和API，我能够更高效地开发Java应用程序，并且能够解决一些常见的编程问题。 另外，我也学习了Java的异常处理机制和文件操作。异常处理是Java中重要的编程概念，通过学习异常处理，我能够编写更健壮的程序，并且能够更好地处理程序中可能出现的错误。文件操作是Java中常用的功能之一，通过学习文件操作，我能够读写文件、创建目录、删除文件等，这对于实际开发中的数据存储和读取非常有用。 在学习过程中，我也发现了一些需要进一步学习和研究的地方。首先，我需要深入学习Java的多线程编程。多线程是Java中重要的特性之一，通过使用多线程，可以实现程序的并发执行，提高程序的性能。但是多线程编程也存在一些问题，如线程安全、死锁等，我需要进一步学习和理解这些问题，并且学会如何解决它们。 其次，我还需要学习Java的网络编程和数据库操作。网络编程是现代应用开发中不可或缺的一部分，通过学习网络编程，我能够实现网络通信、数据传输等功能。数据库操作是Java应用开发中常用的功能之一，通过学习数据库操作，我能够实现数据的存储和读取，并且能够使用数据库来支持应用程序的功能。 总的来说，这段时间学习Java让我对这门语言有了更深入的了解，我学会了Java的基本语法和面向对象的编程思想，掌握了Java的核心类库和常用API，也学习了Java的异常处理和文件操作。但是我也意识到还有很多需要进一步学习和研究的地方，如多线程编程、网络编程和数据库操作等。通过不断学习和实践，我相信我能够更好地掌握Java编程技术，并且能够在实际开发中运用自如。