一、前言

1. 三次题目集涉及的的知识点：
第三阶段为本学期最后一个学习阶段，至此，课程内面向对象的考试范围已经全部学完，涉及到的作业集为7、8、9、10、11。涉及到的知识点有接口、集合框架。其中集合框架是较为庞大的一部分，涉及到的方法比较多，一方面是熟练掌握Collection下子类的各种方法的用法，另一方面更重要的是能在不同场景下灵活运用各种容器，本次blog将针对题目中出现的各种场景分析何时使用何种容器

2. 题量、难度情况
本阶段是课程内面向对象的最终阶段，题目难度和题量相较之前都有显著提升

二、设计与分析

该部分将对涉及到的场景进行简单分析
1
卡片分类排序
该题目要求运用多态，继承和接口；卡片具有不同形状，但是面积是他们的共同属性，而不同的图形计算面积的方法也不尽相同，因此可以抽象出图形类（Shape），该类应该具有一个getArea（）抽象方法，不同的图形将继承Shape类，并实现getArea（）方法，另外需要根据图形的面积进行排序，则要求Shape类实现Comparable接口，以允许不同的图形之间能进行比较和排序

2

本题需求比较简单，将非字母字符替换成特定字符，再用split分割后与预设关键字逐个对比即可，需要用到正则表达式

3

本题只是让我们尝试使用HashMap，利用Hash不重复的特点进行存储

4

5

本题需要了解Object类中的方法后写出一个它的子类，并覆写其在父类中已有的方法，本题让我们更加深入的理解继承与覆写

三、踩坑心得

题目1：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

public class Main {
   //在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
//使用Main.input.next…即可（避免采坑）
   public static Scanner input = new Scanner(System.in);

   public static void main(String[] args){
       ArrayList<Integer> list = new ArrayList<Integer>();

       int num = input.nextInt();

       while(num != 0){
           if(num < 0 || num > 4){
               System.out.println("Wrong Format");
               System.exit(0);
           }
           list.add(num);
           num = input.nextInt();
       }

       DealCardList dealCardList = new DealCardList(list);

       if(!dealCardList.validate()){
           System.out.println("Wrong Format");
           System.exit(0);
       }
       dealCardList.showResult();
       input.close();
   }
}
class Card implements Comparable<Card>{
   private Shape shape;

   public Card(Shape shape) {
       this.shape = shape;
   }
   @Override
   public int compareTo(Card card){
       if(card.getShape().getArea() == shape.getArea()){
           return 0;
       }else if(card.getShape().getArea() < shape.getArea()){
           return -1;
       }else{
           return 1;
       }
   }
   public Shape getShape() {
       return shape;
   }

   public void setShape(Shape shape) {
       this.shape = shape;
   }
}
class DealCardList {
   ArrayList<Card> cardList = new ArrayList<>();

   public DealCardList(ArrayList<Integer> list) {
       for(Object A:list){
           if((int)A == 1){
               double R = Main.input.nextDouble();
               cardList.add(new Card(new Circle(R)));
           }
           if((int)A == 2){
               double W,L;
               W = Main.input.nextDouble();
               L = Main.input.nextDouble();
               cardList.add(new Card(new Rectangle(W,L)));
           }
           if((int)A == 3){
               double a,b,c;
               a = Main.input.nextDouble();
               b = Main.input.nextDouble();
               c = Main.input.nextDouble();
               cardList.add(new Card(new Triangle(a,b,c)));
           }
           if((int)A == 4){
               double sd,xd,gao;
               sd = Main.input.nextDouble();
               xd = Main.input.nextDouble();
               gao = Main.input.nextDouble();
               cardList.add(new Card(new Trapezoid(sd,xd,gao)));
           }
       }
   }

   public void showResult(){
       System.out.println("The original list:");
   for(Card a:cardList){
       System.out.printf("%s:%.2f ",a.getShape().getShapeName(),a.getShape().getArea());
   }
   System.out.println("\nThe sorted list:");
   Collections.sort(cardList);
   for(Card a:cardList){
       System.out.printf("%s:%.2f ",a.getShape().getShapeName(),a.getShape().getArea());
   }
   double sum = 0;
   for(Card a:cardList){
       sum = sum + a.getShape().getArea();
   }
   System.out.printf("\nSum of area:%.2f",sum);
   }
   public boolean validate(){
   boolean result = true;
   for(Card a:cardList){
       if(!a.getShape().validate()){
           return false;
       }
   }
   return result;
   }
}

abstract class Shape{
   private String shapeName;
   public Shape() {
   }
   public double getArea(){
       return 0;
   }
   public boolean validate(){
       return false;
   }

   public Shape(String shapeName) {
       this.shapeName = shapeName;
   }

   public String getShapeName() {
       return shapeName;
   }

   public void setShapeName(String shapeName) {
       this.shapeName = shapeName;
   }
}
class Circle extends Shape{
   private double radius;
   @Override
   public boolean validate(){
       if(radius <= 0){
           return false;
       }else{
           return true;
       }
   }

   public Circle(double radius) {
       this.radius = radius;
       super.setShapeName("Circle");
   }
   @Override
   public double getArea(){
       return Math.PI*radius*radius;
   }

   public double getRadius() {
       return radius;
   }

   public void setRadius(double radius) {
       this.radius = radius;
   }
}
class Rectangle extends Shape{
   private double width,length;
   @Override
   public boolean validate(){
   if(width > 0 && length >0){
       return true;
   }else{
       return false;
   }
}
   public Rectangle(double width, double length) {
       this.width = width;
       this.length = length;
       super.setShapeName("Rectangle");
   }
   @Override
   public double getArea(){
       return width*length;
   }
   public double getWidth() {
       return width;
   }

   public void setWidth(double width) {
       this.width = width;
   }

   public double getLength() {
       return length;
   }

   public void setLength(double length) {
       this.length = length;
   }
}
class Triangle extends Shape{
   private double side1,side2,side3;
   @Override
   public boolean validate(){
       if(side1 > 0 && side2 > 0 && side3 > 0){
           return true;
       }else{
           return false;
       }
   }
   @Override
   public double getArea(){
       double p = (side1+side2+side3)/2;
       return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
   }
   public double getSide1() {
       return side1;
   }

   public void setSide1(double side1) {
       this.side1 = side1;
   }

   public double getSide2() {
       return side2;
   }

   public void setSide2(double side2) {
       this.side2 = side2;
   }

   public double getSide3() {
       return side3;
   }

   public void setSide3(double side3) {
       this.side3 = side3;
   }

   public Triangle(double side1, double side2, double side3) {
       this.side1 = side1;
       this.side2 = side2;
       this.side3 = side3;
       super.setShapeName("Triangle");
   }
}
class Trapezoid extends Shape{
   private double topSide;
   private double bottomSide;
   private double height;

   public Trapezoid(double topSide, double bottomSide, double height) {
       this.topSide = topSide;
       this.bottomSide = bottomSide;
       this.height = height;
       super.setShapeName("Trapezoid");
   }
   @Override
   public double getArea(){
       return (topSide+bottomSide)*height/2;
   }
   @Override
   public boolean validate(){
       if(topSide > 0 && bottomSide >0 && height > 0){
           return true;
       }else{
           return false;
       }
   }
   public double getTopSide() {
       return topSide;
   }

   public void setTopSide(double topSide) {
       this.topSide = topSide;
   }

   public double getBottomSide() {
       return bottomSide;
   }

   public void setBottomSide(double bottomSide) {
       this.bottomSide = bottomSide;
   }

   public double getHeight() {
       return height;
   }

   public void setHeight(double height) {
       this.height = height;
   }
}

在实现Comparable接口时要注意在尖括号中填写泛型，否则使用的是Object类的排序

题目2：
提交代码：

import java.util.*;
class Main{
    public static String[] deleteChar(String text){
        String texts = text.replaceAll("/\\*{1,2}[\\s\\S]*?\\*/\n","");
        texts = texts.replaceAll("//[\\s\\S]*?\\n","");
        texts = texts.replaceAll("^\\s*\\n\n","");

        texts = texts.replaceAll("[\"].+[\"]","");
        texts = texts.replaceAll("=[a-z]{1,5}","");
        texts = texts.replaceAll(" +", " ");
        String[] words = texts.split("[\\W]");
        return words;
    }
    public static void main(String[] args) throws Exception {
        String text = inputText();
        countKeywords(text.toString());
    }

    public static void countKeywords(String text) throws Exception {
        // Array of all Java keywords + true, false and null
        String[] keywordString = {"abstract", "assert", "boolean",
                "break", "byte", "case", "catch", "char", "class", "const",
                "continue", "default", "do", "double", "else", "enum",
                "extends", "for", "final", "finally", "float", "goto",
                "if", "implements", "import", "instanceof", "int",
                "interface", "long", "native", "new", "package", "private",
                "protected", "public", "return", "short", "static",
                "strictfp", "super", "switch", "synchronized", "this",
                "throw", "throws", "transient", "try", "void", "volatile",
                "while", "true", "false", "null"};
       String[] words = deleteChar(text);
        ArrayList<String> arrayList = new ArrayList<>(Arrays.asList(words));
        TreeMap<String, Integer> textS = new TreeMap<>();
        for(int i = 0; i < 53 ; i++){
            textS.put(keywordString[i],0);
        }
        int times = arrayList.size();
        for(int i = 0; i < times;i++){
            arrayList.remove("");
        }
        ArrayList<String> keywordList = new ArrayList<>(Arrays.asList(keywordString));

        for(String A:arrayList){
            if(keywordList.contains(A)){
                for(String keyword:keywordList){
                    if(keyword.equals(A)){
                        textS.put(A,textS.get(A)+1);
                        break;
                    }
                }
            }
        }

        for (Map.Entry<String, Integer> entry : textS.entrySet()) {
            if(entry.getValue()!=0) {
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(value + "\t" + key);
            }
        }
    }
    public static String inputText(){
        Scanner input = new Scanner(System.in);
        StringBuilder text = new StringBuilder();
        int i = 0;
        while(true){

            String word = input.nextLine();
            if(word.equals("exit")){
                break;
            }else{
                i++;
                text.append(word);
                text.append("\n");
            }
        }
        if(i==0){
            System.out.println("Wrong Format");
            System.exit(0);
        }
        return text.toString();
    }
}

除了常见的非字母字符，可能出现 int a =this.xxx ，这样等号和关键字、标点和关键字直接连接的地方需要单独处理

题目3
提交代码：

import java.text.Collator;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        /*
          courses : 课程列表<Course>
          classes : 班级列表<Classes>
          students : 全体学生<Student>
          selectCourse : 成绩记录列表<SelectCourse>
         */
        TreeSet<Course> courses = new TreeSet<>();
        TreeSet<SelectCourse> selectCourse = new TreeSet<>();
        TreeSet<Classes> classes= new TreeSet<>();
        TreeSet<Student> students = new TreeSet<>();
        getInputCourse(courses,selectCourse,classes,students);
        OutputRecord(courses, classes,students);
    }

    static void getInputCourse(TreeSet<Course> courses, TreeSet<SelectCourse> selectCourses,TreeSet<Classes> classes,TreeSet<Student>students){
        Scanner input = new Scanner(System.in);
        String massage;
        String[] datas;

        while(true) {
            // 处理课程信息输入↓
            massage = input.nextLine();
            if (massage.equals("end")) {
                return;
            }
            datas = massage.split(" ");
            // 检查还没到输入学生成绩信息部分
            if (datas[0].matches("[0-9]{8}")) {
                break;
            }
            if(datas.length > 3){
                System.out.println("wrong format");
                continue;
            }
            // 检查输入正确
            if (checkCourseInput(datas)) {
                courses.add(new Course(getName(datas[0]), getMandtory(datas[1]), getMethod(datas[2])));// 创建课程对象
            }
        }
        boolean isFirst = true;
        while(true){
            if(!isFirst){// 第一次进入时不需要输入
                massage = input.nextLine();
                datas = massage.split(" ");
            }else{
                isFirst = false;
            }
            if(datas[0].equals("end")){
                return;
            }
            if(datas.length == 4 || datas.length == 5){
                if(datas[0].matches("\\D")){
                    System.out.println("wrong format");
                    continue;
                }else if(datas[2].length() > 10){
                    System.out.println("wrong format");
                    continue;
                }
            }else{
                System.out.println("wrong format");
                continue;
            }
            // 确认已录入该门课程
            boolean isCourseHas = false;
            for(Course hasCourse: courses){
                if(hasCourse.getName().equals(datas[2])){
                    isCourseHas = true;
                }
            }
            if(!isCourseHas){
                System.out.println(datas[2]+" does not exist");
            }
            if(datas.length == 5 ){
                int peacetTime = Integer.parseInt(datas[3]);
                int exam = Integer.parseInt(datas[4]);
                if(peacetTime > 100 || peacetTime < 0 || exam >100 || exam < 0){
                    System.out.println("wrong format");
                    continue;
                }
            }else if(datas.length == 4){
                int peacetTime = Integer.parseInt(datas[3]);
                if(peacetTime > 100 || peacetTime < 0){
                    System.out.println("wrong format");
                    continue;
                }
            }
            // 遍历学生列表，如果存在该学生就不再创建
            Student student = null;
            for(Student stu:students){
                if(stu.getStudentID().equals(datas[0]) && stu.getName().equals(datas[1])){
                    student = stu;
                }
            }
            if(student == null){
                student =  new Student(datas[1],datas[0]);// 创建学生对象
            }
            classes.add(new Classes(student.getStudentID().substring(0,6)));// 根据学生学号前六位创建班级
            students.add(student);// 加入学生列表
            // 遍历班级列表，将学生添加到对应班级
            for(Classes classes1: classes){
                if(classes1.getClassID().equals(student.getStudentID().substring(0,6))){
                    classes1.getStudents().add(student);
                }
            }
            if(!isCourseHas){
                continue;
            }
            boolean isNotValid = false;
            // 遍历课程列表进行操作
            for(Course C:courses ){
                if(C.getName().equals(datas[2])){
                    if(datas.length == 5 && C.getAssessmentMethod() == 0){
                        System.out.println(datas[0]+" "+datas[1]+" : access mode mismatch");
                        isNotValid = true;
                        continue;
                    }else if(datas.length == 4 && C.getAssessmentMethod() == 1){
                        System.out.println(datas[0]+" "+datas[1]+" : access mode mismatch");
                        isNotValid = true;
                        continue;
                    }

                    // 创建成绩记录
                    boolean needBreak = false;
                    SelectCourse selectCourse = null;
                    // 无平时成绩
                    if(datas.length == 4){
                        int exam = Integer.parseInt(datas[3]);
                        selectCourse = new SelectCourse(C,student,new InspectScore(exam),exam);
                        // 遍历已存放的记录，用于去重
                        for(SelectCourse s:selectCourses){
                            if(s.getStudent().getStudentID().equals(selectCourse.getStudent().getStudentID()) &&
                                    s.getCourse().getName().equals(selectCourse.getCourse().getName())){
                                needBreak = true;
                            }
                        }

                        if(!needBreak){
                            // 计入学生个人成绩
                            student.setTotalScore(student.getTotalScore() + exam);
                            student.setSTUcountOfRecord(student.getSTUcountOfRecord() + 1);
                            // 计入课程累计成绩
                            C.setTotalAssessScore(C.getTotalAssessScore() + exam);
                        }
                        // 含平时成绩
                    } else if(datas.length == 5){
                        int peacetTime = Integer.parseInt(datas[3]);
                        int exam = Integer.parseInt(datas[4]);
                        selectCourse = new SelectCourse(C,student,new ExamScore(exam),peacetTime);
                        // 遍历选课记录并比对，防止出现重复
                        for (SelectCourse s:selectCourses){
                            if(s.getStudent().getStudentID().equals(selectCourse.getStudent().getStudentID()) &&
                                    s.getCourse().getName().equals(selectCourse.getCourse().getName())){
                                needBreak = true;
                            }
                        } if(!needBreak){
                            // 计入学生个人成绩
                            student.setTotalScore(student.getTotalScore() + Integer.parseInt(datas[4])*0.7);
                            student.setTotalScore(student.getTotalScore() + Integer.parseInt(datas[3])*0.3);
                            student.setSTUcountOfRecord(student.getSTUcountOfRecord() + 1);
                            // 计入课程累计成绩
                            C.setTotalAssessScore(C.getTotalAssessScore() + Integer.parseInt(datas[4]));
                            C.setTotalPeaceTimeScore(C.getTotalPeaceTimeScore() + Integer.parseInt(datas[3]));
                        }
                    }
                    // 无重复且数据有效，则计入课程记录数
                    if(!needBreak && !isNotValid){
                        C.setCountOfRecord(C.getCountOfRecord() + 1);
                        selectCourses.add(selectCourse);
                    }
                }
            }
        }
        // 处理输入↑
    }
    static void OutputRecord(TreeSet<Course> courses, TreeSet<Classes> classes, TreeSet<Student> students){
        // 输出学生个人成绩
        for(Student stu:students){
            stu.output();
        }
        // 输出课程平均分
        for(Course course:courses){
            course.output();
        }
        // 输出班级平均分
        for(Classes cla: classes){
            cla.output();
        }
    }
    static String getName(String name){
        return name;
    }
    static int getMethod(String Method){
        if(Method.equals("考试")){
            return 1;
        }else{
            return 0;
        }
    }
    static boolean getMandtory(String data){
        if(data.equals("必修")){
            return true;
        }else{
            return false;
        }
    }
    static boolean checkCourseInput(String[] strings){
        boolean f = true;
        if(strings.length < 3){
            f=false;
        }else if(strings[0].length() > 10){
            f=false;
        }else if(!strings[1].equals("必修") && !strings[1].equals("选修")){
            f=false;
        }else if(!strings[2].equals("考试") && !strings[2].equals("考察")){
            f=false;
        }else if(strings[1].equals("必修") && strings[2].equals("考察")){
            System.out.println(strings[0]+" : course type & access mode mismatch");
            return false;
        }
        if(!f){
            System.out.println("wrong format");
        }
        return f;
    }

}
class SelectCourse extends Score implements Comparable<SelectCourse>{
    private Course course;
    private Student student;

    public SelectCourse(Course course, Student student,ExamScore examScore,int peaceTimeScore) {
        super(examScore,peaceTimeScore);
        this.course = course;
        this.student = student;
    }
    public SelectCourse(Course course, Student student, InspectScore inspectScore, int peaceTimeScore){
        super(inspectScore, peaceTimeScore);
        this.course = course;
        this.student = student;
    }

    public Student getStudent() {

        return student;
    }

    public Course getCourse() {
        return course;
    }

    @Override
    public int compareTo(SelectCourse o) {
        if(Integer.parseInt(o.getStudent().getStudentID()) > Integer.parseInt(this.getStudent().getStudentID())){
            return -1;
        }else if(Integer.parseInt(o.getStudent().getStudentID()) < Integer.parseInt(this.getStudent().getStudentID())){
            return 1;
        }else{
            return 0;
        }
    }
}
class Classes implements Comparable<Classes>{
    TreeSet<Student> students = new TreeSet<>();
    private String classID;

    public int getClassScore(){
        int result = 0;
        for(Student stu:students){
            result = result + stu.getInttotalScore();
        }
        int recordNum = 0;
        for(Student student:students){
            recordNum = recordNum + student.getSTUcountOfRecord();
        }
        if(students.size()!=0){
            result = result / recordNum;
        }
        return result;
    }
    public void output(){
        int recordNum = 0;
        for(Student student:students){
            recordNum = recordNum + student.getSTUcountOfRecord();
        }
        if(recordNum!= 0){
            System.out.println(classID+" "+getClassScore());
        }else{
            System.out.println(this.classID+" has no grades yet");
        }

    }
    public Classes(String classID) {
        this.classID = classID;
    }

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

    public String getClassID() {
        return classID;
    }

    @Override
    public int compareTo(Classes o) {
        return this.classID.compareTo(o.getClassID());
    }
}
class   Student implements Comparable<Student>{
    private String name;
    private String StudentID;
    private double totalScore;
    private int STUcountOfRecord = 0;

    public void output(){
        if(STUcountOfRecord != 0){
            System.out.println(StudentID+" "+name+" "+ (this.getInttotalScore()/STUcountOfRecord));
        }else{
            System.out.println(StudentID+" "+name+" did not take any exams");
        }
    }

    public int getSTUcountOfRecord() {
        return STUcountOfRecord;
    }

    public void setSTUcountOfRecord(int STUcountOfRecord) {
        this.STUcountOfRecord = STUcountOfRecord;
    }

    public int getInttotalScore(){
        return (int) totalScore;
    }
    public double getTotalScore() {
        return totalScore;
    }

    public void setTotalScore(double totalScore) {
        this.totalScore = totalScore;
    }

    public Student(String name, String studentID) {
        this.name = name;
        StudentID = studentID;

    }

    public String getName() {
        return name;
    }

    public String getStudentID() {
        return StudentID;
    }


    @Override
    public int compareTo(Student o) {
        return this.getStudentID().compareTo(o.getStudentID());
    }
}
class Course implements Comparable<Course>{
    private String name;
    private boolean isMandatory;
    private int AssessmentMethod;// 1是考试 0是考察
    private int CountOfRecord = 0;// 成绩记录数目

    private int totalAssessScore = 0;// 累计考核成绩
    private int totalPeaceTimeScore = 0;// 累计平时成绩

    public int getAssessScore(){ // 获取考察/考试成绩
        return totalAssessScore;
    }
    public int getPeaceTimeScore(){ // 获取平时成绩
        return totalPeaceTimeScore;
    }
    public int getTotalScore(){// 获取总成绩
        if(CountOfRecord != 0){
            if(this.AssessmentMethod == 0){
                totalPeaceTimeScore = totalAssessScore;
            }
            return (int)((getAssessScore()*0.7 + getPeaceTimeScore() * 0.3) / CountOfRecord);
        }else{
            return 0;
        }
    }
    public void output(){
        if(this.CountOfRecord == 0){
            System.out.println(getName()+" has no grades yet");
        }else if(AssessmentMethod == 1){
            System.out.println(this.name + " "  + getPeaceTimeScore()/getCountOfRecord() +" "+ getAssessScore()/getCountOfRecord()+" " + getTotalScore());
        }else if(AssessmentMethod == 0){
            System.out.println(this.name+" "+ getTotalScore()+" "+ getTotalScore());
        }
    }
    public Course(String name, boolean isMandatory, int assessmentMethod) {
        this.name = name;
        this.isMandatory = isMandatory;
        AssessmentMethod = assessmentMethod;
        if(name.length() > 10){
            System.out.println("wrong format");

        }
        if(assessmentMethod != 1 && assessmentMethod != 0){
            System.out.println("wrong format");

        }
    }

    public int getTotalAssessScore() {
        return totalAssessScore;
    }

    public void setTotalAssessScore(int totalAssessScore) {
        this.totalAssessScore = totalAssessScore;
    }

    public int getTotalPeaceTimeScore() {
        return totalPeaceTimeScore;
    }

    public void setTotalPeaceTimeScore(int totalPeaceTimeScore) {
        this.totalPeaceTimeScore = totalPeaceTimeScore;
    }

    public int getCountOfRecord() {
        return CountOfRecord;
    }

    public void setCountOfRecord(int countOfRecord) {
        CountOfRecord = countOfRecord;
    }

    public String getName() {
        return name;
    }

    public int getAssessmentMethod() {
        return AssessmentMethod;
    }


    @Override
    public int compareTo(Course o) {

        return Collator.getInstance(Locale.CHINA).compare(this.name,o.getName());
    }
}
abstract class Score {
    private ExamScore examScore;
    private InspectScore inspectScore;
    private int peaceTimeScore;


    public Score(ExamScore examScore, int peaceTimeScore) {
        this.examScore = examScore;
        this.peaceTimeScore = peaceTimeScore;
    }

    public Score(InspectScore inspectScore, int peaceTimeScore) {
        this.inspectScore = inspectScore;
        this.peaceTimeScore = peaceTimeScore;
    }

}
class InspectScore{
    private int value;


    public InspectScore(int value) {
        this.value = value;
    }
}
class ExamScore {
    private int value;

    public ExamScore(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

}

本题踩坑点非常多，首先提示反馈多种多样，输出反馈时不应出现错误的反馈，其次对于输入的判断，应该在输入后根据输入内容创建对应对象，然后将每个对象都和容器中的进行比对。
首先，让我们简要地了解一下题目中给出的类图的作用。

从类图中我们可以看出，选课事件是整个课程系统的核心，通过记录所有选课事件，可以获得每次课程、学生和分数的相关信息。

根据题目的输出要求，我们需要完成以下任务：

计算每个学生的平均分。
计算每门课程的平均平时分和期末分。
计算每个班级的平均分。
此外，输出还需要按照规则进行排序。
为了满足输出要求，我们可以使用多个 TreeMap 容器来存储各类信息，并且进行排序。例如，我们可以使用 TreeMap<Student, Integer> 来存储学生的平均分，代码如下：

TreeMap<Student, Integer> studentAverageScore = new TreeMap<Student, Integer>();

现在，我们可以开始编写各个类。首先是 Student 类，其属性包括 id 和 name。

然后是 Score 类，它是一个抽象类，由 ExamScore 和 ExamineScore 继承，其中需要重写 getGrade() 方法。

接下来是 Course 类，其属性包括 type 和 name。

最后是 CourseSelect 类，其属性包括 student、grade 和 course。

现在，让我们考虑一些细节部分。这道题的细节比较多，我们可以重新梳理一遍题目以确保理解。必修课只能选考试，因此我们需要特别处理输入的成绩数量和考核方式。

选修课的成绩信息可能只包括期末分，不需要输入平时分。这个变化会影响最后计算课程平均分的输出。

班级号由学号的前 6 位组成，这意味着我们需要使用 HashMap 记录每个人的前 6 位学号，并将其分组成班级集合。

最重要的细节在于何时加入课程或学生信息，何时不加入。其中关键在于区分"wrong format"和其他异常。只要出现"wrong format"，我们可以直接跳到下一次循环；如果是其他异常情况，我们需要考虑是否要加入课程或学生信息。

另外，课程信息不仅仅按照 ASCII 码排序，而是按照中文拼音进行排序，因此我们需要重写排序规则。

设计类图：

在处理字符串转整数的过程中，直接使用Integer.parseInt()可能存在问题。当括号中的内容是一个文本段落时，直接使用该方法会导致非数字字符的存在，从而抛出异常。因此，在使用该方法之前，应该先对字符串进行判断，可以使用matches()方法来检测是否为数字。

在计算分数时，有些选修课可能没有平时成绩，因此我们需要在计算平均分时对这种情况进行特殊处理。可以通过设定一个初始值sum=0来表示没有平时成绩的情况，在计算平均分时需要判断sum的值是否为零，避免出现除以零的错误。这种特殊情况需要根据课程的考核类型进行特殊处理。

在进行浮点数相加时，由于计算机的浮点数表示存在精度误差，我们需要考虑设置一个误差范围。典型的例子是等腰直角三角形，当两个直角边的长度相等时，按照理论应该得到斜边长度为根号2倍直角边的长度，但由于浮点数精度问题，实际计算结果可能存在略微的偏差。因此，在进行浮点数相加时，需要考虑误差范围，以适当处理精度误差带来的影响

总结

通过学习，巩固了面向对象的基础知识，如继承、多态和接口。
掌握了进阶的面向对象概念，如覆盖和常用的容器。
通过实践和练习，提高了代码的可读性、可维护性和复用性。
在进行复杂输入处理时进行异常的抛出和处理能够提升程序的健壮性

学习方向：
深入理解和应用设计原则和模式：希望进一步学习和实践各种设计原则和模式，以便在实际项目中能够更好地设计和组织代码结构。
深入学习语言特性和工具库：为了更好地使用面向对象编程，计划进一步学习编程语言的高级特性和相关的工具库，以便更加高效地开发和解决问题。
对Java程序设计课的感受与建议：

关于教学理念（OBE）：认为需要进一步明确学习成果的具体内容和评估方式，以确保学生能够真正掌握和应用所学的知识和技能。
关于教学方法（减少讲解、增加练习难度）：本课程中学生在很大程度上是自主学习，因此可以减少讲解的部分，并增加练习的难度，如果条件允许，我希望教室可以在课余时间对已经完成的题目提供一些解答，以帮助学生更好的自身的不足。
关于教学组织（深入发掘线上平台的互动功能）：建议更加深入地发掘线上平台的互动功能，以促进学生之间和学生与教师之间的交流和合作。
关于教学过程（增加开放性问题和案例分析）：认为PTA题目集驱动的教学过程可以进一步增加开放性问题和案例分析的比重，以帮助学生更全面地思考和解决实际问题，培养独立思考和创新能力。
总体而言，以上是一些需要改进和加强的方面。通过改进教学理念的明确性、提高实践的难度和深度、衔接线上线下教学、增加开放性问题和案例分析、加强学生反馈和评估等，可以进一步提升Java课程的教学质量和学生的学习效果。

本栏目推荐文章
• FIFO设计
• 深入探索JVM：理解Java程序在虚拟机中的存储和管理
• 从C++CLI工程的依赖库引用问题看.Net加载程序集机制
• 微信小程序 wxs的概念
• spring与设计模式之三代理模式
• jQuery自动加载更多程序
• 微信小程序 取列表的for循环的第一个值
• NUS CS1101S：SICP JavaScript 描述：三、模块化、对象和状态
• 各种语言版本的“Hello, world”程序汇总
• CS5569芯片,CS556,设计资料,CS5569规格书,CS5569原理图,typec转HDMI 8K带PD方案

程序设计 对象 阶段 程序 PTA程序设计 对象 程序pta 程序设计 程序 平台pta 题目 阶段pta 阶段性 阶段pta 电网 阶段 代码 程序 题解 程序设计pta-python题目 阶段 模型 场景 程序 程序设计 对象 阶段 程序 阶段 程序 框架 阶段 能源 程序