526互联

南昌航空大学BLOG-2Java最后几次作业总结

发布时间 2023-12-07 21:03:42作者: 梦lin

一、前言

　　这几次作业主要是对课程成绩统计程序的完善，第七次作业中的课程成绩统计程序2在原来课程成绩统计程序1的基础上添加了实验课，由于实验课的考核次数在一开始是不能确定的，故如何对实验课的成绩进行存储便成为了难度，这次作业的难度相较于课程成绩统计程序1也有了很大的提高。第八次作业中的课程成绩统计程序3则是在课程成绩统计程序2的基础上添加了输入分数占比的要求，在课程成绩统计程序2的框架搭好的情况下完善此要求，难度比重新构建一个类结构要小得多。期末考试考察的时对一系列魔方问题，主要是对继承类掌握的考察。

二、设计与分析

1、课程成绩统计程序-2

 题目要求：课程成绩统计程序-2在第一次的基础上增加了实验课，某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。考察的总成绩直接等于期末成绩。实验的总成绩等于课程每次实验成绩的平均分。必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
类图设计：

 源码分析：

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

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        SelectMenu selectMenu = new SelectMenu();
        CourseMenu courseMenu = new CourseMenu();
        StudentMenu studentMenu = new StudentMenu();
        while (!s.equals("end")){
            boolean flag1 = s.matches("[\\S]{1,10}\\s[\\S]{2}\\s[\\S]{2}");
            boolean flag2 = s.matches("\\d{8}\\s[\\S]{1,10}\\s[\\S]{1,10}\\s(\\d{1,2}||100)");
            boolean flag3 = s.matches("\\d{8}\\s[\\S]{1,10}\\s[\\S]{1,10}\\s(\\d{1,2}||100)\\s(\\d{1,2}||100)");
            boolean flag4 = s.matches("\\d{8}\\s[\\S]{1,10}\\s[\\S]{1,10}\\s[4-9](\\s(\\d{1,2}||100)){2,9}");
            if(flag1){
                String[] strings = s.split(" ");
                Course course = new Course(strings[0],strings[1],strings[2]);
                if(strings[1].equals("必修")&&!strings[2].equals("考试")){
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                }
                else if(strings[1].equals("选修")&&strings[2].equals("实验")){
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                }
                else if(strings[1].equals("实验")&&!strings[2].equals("实验")){
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                }
               else {
                   courseMenu.addCourse(course);
                }
            }
            else if(flag2){
                String[] strings = s.split(" ");
                String sno = strings[0];
                String sname = strings[1];
                String cname = strings[2];
                String cno = sno.substring(0,6);
                int score = Integer.parseInt(strings[3]);
                Student student = new Student(sno,sname,cno);
                studentMenu.addStudent(student);
                selectMenu.addClass(cno);
                Course course = courseMenu.serchCourse(cname);
                 if(course==null){
                    course = new Course();
                }
                Inves inves = new Inves(score);
                if(course.cmode.equals("考察")){
                    SelectCourse selectCourse = new SelectCourse(student,course,inves);
                    selectMenu.addSelect(selectCourse,courseMenu);
                }else {
                    System.out.println(sno + " " + sname +" : access mode mismatch");
                }
            }
            else if(flag3){
                String[] strings = s.split(" ");
                String sno = strings[0];
                String sname = strings[1];
                String cname = strings[2];
                String cno = sno.substring(0,6);
                int nomalscore = Integer.parseInt(strings[3]);
                int lastscore = Integer.parseInt(strings[4]);
                Student student = new Student(sno,sname,cno);
                studentMenu.addStudent(student);
                selectMenu.addClass(cno);
                Course course = courseMenu.serchCourse(cname);
                 if(course==null){
                    course = new Course();
                }
                Exam exam = new Exam(nomalscore,lastscore);
                if(course.cmode.equals("考试")){
                    SelectCourse selectCourse = new SelectCourse(student,course,exam);
                    selectMenu.addSelect(selectCourse,courseMenu);
                }else {
                    System.out.println(sno + " " + sname +" : access mode mismatch");
                }
            }
            else if(flag4){
                String[] strings = s.split(" ");
                String sno = strings[0];
                String sname = strings[1];
                String cname = strings[2];
                String cno = sno.substring(0,6);
                int num = Integer.parseInt(strings[3]);
                Student student = new Student(sno,sname,cno);
                studentMenu.addStudent(student);
                selectMenu.addClass(cno);
                Course course = courseMenu.serchCourse(cname);
                 if(course==null){
                    course = new Course();
                }
                Test test = new Test();
                test.num = num;
                if(strings.length == (num+4)){
                    for (int i = 0; i < num; i++) {
                        test.score+=Integer.parseInt(strings[4+i]);
                    }
                    SelectCourse selectCourse = new SelectCourse(student,course,test);
                    selectMenu.addSelect(selectCourse,courseMenu);
                }else {
                    System.out.println(sno + " " + sname +" : access mode mismatch");
                }
            }
            else {
                System.out.println("wrong format");
            }
            s = sc.nextLine();
        }
        selectMenu.caculateClassScore(studentMenu.students);
        selectMenu.printStudent(studentMenu.students);
        selectMenu.printCourse(courseMenu.courses);
        selectMenu.printClass();
    }
}
class Course implements Comparable<Course>{
    String cname;
    String ctype;
    String cmode;

    public Course() {
    }

    public Course(String cname, String ctype, String cmode) {
        this.cname = cname;
        this.ctype = ctype;
        this.cmode = cmode;
    }

    @Override
    public int compareTo(Course o) {
        Comparator<Object> compare = Collator.getInstance(Locale.CHINA);
        return compare.compare(cname,o.cname);
    }
}
class CourseMenu{
    ArrayList<Course> courses = new ArrayList<>();
    void addCourse(Course course){
        for (int i = 0; i < courses.size(); i++) {
            if(courses.get(i).cname.equals(course.cname)){
                return;
            }
        }
        courses.add(course);
    }
    boolean isCourseExist(String cname){
        for (int i = 0; i < courses.size(); i++) {
            if(courses.get(i).cname.equals(cname)){
                return true;
            }
        }
        return false;
    }
    Course serchCourse(String cname){
        for (int i = 0; i < courses.size(); i++) {
            if(courses.get(i).cname.equals(cname)){
                return courses.get(i);
            }
        }
        return null;
    }
}
class Student{
    String sno;
    String sname;
    String classid;
    public Student() {
    }

    public Student(String sno, String sname, String classid) {
        this.sno = sno;
        this.sname = sname;
        this.classid = classid;
    }
}
class StudentMenu{
    ArrayList<Student> students = new ArrayList<>();
    void addStudent(Student student){
        for (Student student1 : students) {
            if(student1.sno.equals(student.sno)){
                return;
            }
        }
        students.add(student);
    }
}
class SelectCourse{
    Student student;
    Course course;
    Grade grade;

    public SelectCourse() {
    }

    public SelectCourse(Student student, Course course, Grade grade) {
        this.student = student;
        this.course = course;
        this.grade = grade;
    }
}
class SelectMenu{
    ArrayList<SelectCourse> selectCourses = new ArrayList<>();
    ArrayList<Class> classes = new ArrayList<>();
    void addSelect(SelectCourse selectCourse,CourseMenu courseMenu){
        if(courseMenu.isCourseExist(selectCourse.course.cname)) {
            selectCourses.add(selectCourse);
        }
        else {
            System.out.println(selectCourse.student.sno + " " + selectCourse.student.sname + " :" + selectCourse.course.cname + " does not exist");
        }
    }
    void addClass(String cno){
        for (int i = 0; i < classes.size(); i++) {
            if(classes.get(i).cno.equals(cno)){
                return;
            }
        }
        Class c = new Class(cno,0);
        classes.add(c);
    }
    int getStudentScore(Student student){
        int all = 0;
        int count = 0;
        for (int i = 0; i < selectCourses.size(); i++) {
            if(selectCourses.get(i).student.sno.equals(student.sno)){
                all+=selectCourses.get(i).grade.getAverage();
                count++;
            }
        }
        if(count!=0) {
            return all / count;
        }
        return 0;
    }
    int getCourseAverageScore(Course course){
        int all = 0;
        int count = 0;
        for (int i = 0; i < selectCourses.size(); i++) {
            if(selectCourses.get(i).course.cname.equals(course.cname)){
                all+=selectCourses.get(i).grade.getAverage();
                count++;
            }
        }
        if(count!=0) {
            return all / count;
        }
        return 0;
    }
    int getCourseNomalScore(Course course){
        int all = 0;
        int count = 0;
        for (int i = 0; i < selectCourses.size(); i++) {
            if(selectCourses.get(i).course.cname.equals(course.cname)){
                Exam exam = (Exam)selectCourses.get(i).grade;
                all+=exam.nonalscore;
                count++;
            }
        }
        if(count!=0) {
            return all / count;
        }
        return 0;
    }
    int getCourselastScore(Course course){
        int all = 0;
        int count = 0;
        for (int i = 0; i < selectCourses.size(); i++) {
            if(selectCourses.get(i).course.cname.equals(course.cname)){
                Exam exam = (Exam)selectCourses.get(i).grade;
                all+=exam.lastscore;
                count++;
            }
        }
        if(count!=0) {
            return all / count;
        }
        return 0;
    }
    int getCoursetestScore(Course course){
        int all = 0;
        int count = 0;
        for (int i = 0; i < selectCourses.size(); i++) {
            if(selectCourses.get(i).course.cname.equals(course.cname)){
                Test test = (Test) selectCourses.get(i).grade;
                all+=test.score;
                count+=test.num;
            }
        }
        if(count!=0) {
            return all / count;
        }
        return 0;
    }
    void caculateClassScore(ArrayList<Student> students){
        for (Class aClass : classes) {
            int count = 0;
            for (Student student : students) {
                if(student.classid.equals(aClass.cno)){
                    aClass.acore+=getStudentScore(student);
                    count++;
                }
            }
            aClass.acore/=count;
        }
    }
    void printStudent(ArrayList<Student> students){
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.sno.compareTo(o2.sno);
            }
        });
        for (Student student : students) {
            int score = getStudentScore(student);
            if(score!=0){
                System.out.println(student.sno + " " + student.sname + " " + score);
            }else {
                System.out.println(student.sno + " " + student.sname + " did not take any exams");
            }
        }
    }
    void printCourse(ArrayList<Course> courses){
        Collections.sort(courses);
        for (Course cours : courses) {
            int avera = getCourseAverageScore(cours);
            if(avera!=0) {
                if (cours.cmode.equals("考察")) {
                    System.out.println(cours.cname + " " + avera + " " + avera);
                }
                else if(cours.cmode.equals("考试")){
                    System.out.println(cours.cname + " " + getCourseNomalScore(cours) + " " + getCourselastScore(cours) + " " + avera);
                }
                else if(cours.cmode.equals("实验")){
                    System.out.println(cours.cname + " " + getCoursetestScore(cours));
                }
            }else {
                System.out.println(cours.cname + " has no grades yet");
            }
        }
    }
    void printClass(){
        Collections.sort(classes, new Comparator<Class>() {
            @Override
            public int compare(Class o1, Class o2) {
                return o1.cno.compareTo(o2.cno);
            }
        });
        for (Class aClass : classes) {
            if(aClass.acore!=0){
                System.out.println(aClass.cno + " " + aClass.acore);
            }else {
                System.out.println(aClass.cno + " has no grades yet");
            }
        }
    }

}
class Grade{
    int  getAverage(){
        return 0;
    }
}
class Exam extends Grade{
    int nonalscore;
    int lastscore;

    public Exam() {
    }

    public Exam(int nonalscore, int lastscore) {
        this.nonalscore = nonalscore;
        this.lastscore = lastscore;
    }

    @Override
    int getAverage() {
        return (int)(nonalscore*0.3+lastscore*0.7);
    }
}
class Inves extends Grade{
    int lastscore;

    public Inves() {
    }

    public Inves(int lastscore) {
        this.lastscore = lastscore;
    }

    @Override
    int getAverage() {
        return lastscore;
    }
}
class Test extends Grade{
    int num;
    int score;

    @Override
    int getAverage() {

        return score/num;
    }
}
class Class{
    String cno;
    int acore;

    public Class() {
    }

    public Class(String cno, int acore) {
        this.cno = cno;
        this.acore = acore;
    }
}

 本体设计用Course类记录单个课程基本信息，如课程名称、课程性质、课程考核方法；Student类记录单个学生基本信息，如学生学号、学生姓名、学生所在班级；Class类用来记录每个班级的班级号和班级平均分；定义Grade类作为父类，以Exam类、Inves类、Test类为子类，分别存放考试成绩、考核成绩和实验成绩，且每个子类继承父类的计算平均成绩的方法。用CourseMenu类存放所有符合条件的课程信息；StudentMenu类存放所有不同的学生基本信息；SelectCourse类用来记录单个的选课记录，里面包括学生的基本信息、所选课程的基本信息以及对应的成绩。SelectMenu类用来存放所有的选课信息和所有的班级信息。SelectMenu类中的getStudentScore()方法用来计算学生的平均成绩，getCourseAverageScore()方法计算课程的平均成绩，getCourseNomalScore()方法用来计算考核方式为考试的平时的平均成绩，getCourselastScore()方法用来计算考核方式为考试的平时的期末成绩，getCoursetestScore()方法用来计算考核方式为实验的平时的平均成绩，caculateClassScore()方法用来计算班级的平均成绩。

void caculateClassScore(ArrayList<Student> students){
        for (Class aClass : classes) {
            int count = 0;
            for (Student student : students) {
                if(student.classid.equals(aClass.cno)){
                    aClass.acore+=getStudentScore(student);
                    count++;
                }
            }
            aClass.acore/=count;
        }
    }

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

题目：

课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。

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

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

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

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

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

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

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

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

类图设计：

 源码分析：

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

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        SelectMenu selectMenu = new SelectMenu();
        CourseMenu courseMenu = new CourseMenu();
        StudentMenu studentMenu = new StudentMenu();
        while (!s.equals("end")){
            boolean flag1 = s.matches("[\\S]{1,10}\\s[\\S]{2}\\s[\\S]{2}");
            boolean flag2 = s.matches("\\d{8}\\s[\\S]{1,10}\\s[\\S]{1,10}\\s(\\d{1,2}||100)");
            boolean flag3 = s.matches("\\d{8}\\s[\\S]{1,10}\\s[\\S]{1,10}\\s(\\d{1,2}||100)\\s(\\d{1,2}||100)");
            boolean flag4 = s.matches("\\d{8}\\s[\\S]{1,10}\\s[\\S]{1,10}(\\s(\\d{1,2}||100)){4,9}");
            boolean flag5 = s.matches("[\\S]{1,10}\\s[\\S]{2}\\s[\\S]{2}\\s[4-9](\\s(\\S)*)*");
            boolean flag6 = s.matches("[\\S]{1,10}\\s[\\S]{2}\\s[\\S]{2}(\\s(\\S)*){2}");
            if(flag1){
                String[] strings = s.split(" ");
                Course course = new Course(strings[0],strings[1],strings[2]);
                if (strings[1].equals("必修") && !strings[2].equals("考试")) {
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                } else if (strings[1].equals("选修") && strings[2].equals("实验")) {
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                } else if (strings[1].equals("实验") && !strings[2].equals("实验")) {
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                } else {
                    courseMenu.addCourse(course);
                }
            }
            else if(flag5){
                String[] strings = s.split(" ");
                Course course = new Course(strings[0],strings[1],strings[2]);
                if (strings[1].equals("必修") && !strings[2].equals("考试")) {
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                } else if (strings[1].equals("选修") && strings[2].equals("实验")) {
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                } else if (strings[1].equals("实验") && !strings[2].equals("实验")) {
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                } else {
                    int num = Integer.parseInt(strings[3]);
                    if (strings.length == (num + 4)) {
                        course.num = num;
                        double weight = 0;
                        for (int i = 0; i < num; i++) {
                            course.weight.add(Double.parseDouble(strings[4 + i]));
                            weight += Double.parseDouble(strings[4 + i]);
                        }
                        if (Math.abs(weight - 1) < 0.0000001) {
                            courseMenu.addCourse(course);
                        } else {
                            System.out.println(strings[0] + " : weight value error");
                        }
                    } else {
                        System.out.println(strings[0] + " : number of scores does not match");
                    }
                }
            }
            else if(flag6){
                String[] strings = s.split(" ");
                Course course = new Course(strings[0],strings[1],strings[2]);
                if (strings[1].equals("必修") && !strings[2].equals("考试")) {
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                } else if (strings[1].equals("选修") && strings[2].equals("实验")) {
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                } else if (strings[1].equals("实验") && !strings[2].equals("实验")) {
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                } else {
                    course.num = 2;
                    double weight = 0;
                    for (int i = 0; i < 2; i++) {
                        course.weight.add(Double.parseDouble(strings[3 + i]));
                        weight += Double.parseDouble(strings[3 + i]);
                    }
                    if (weight == 1) {
                        courseMenu.addCourse(course);
                    } else {
                        System.out.println(strings[0] + " : weight value error");
                    }
                }
            }
            else if(flag2){
                String[] strings = s.split(" ");
                String sno = strings[0];
                String sname = strings[1];
                String cname = strings[2];
                String cno = sno.substring(0,6);
                int score = Integer.parseInt(strings[3]);
                Student student = new Student(sno,sname,cno);
                studentMenu.addStudent(student);
                selectMenu.addClass(cno);
                Course course = courseMenu.serchCourse(cname);
                if(course==null){
                    course = new Course();
                }
                Inves inves = new Inves(score);
                if(course.cmode.equals("考察")){
                    SelectCourse selectCourse = new SelectCourse(student,course,inves);
                    selectMenu.addSelect(selectCourse,courseMenu);
                }else {
                    System.out.println(sno + " " + sname +" : access mode mismatch");
                }
            }
            else if(flag3){
                String[] strings = s.split(" ");
                String sno = strings[0];
                String sname = strings[1];
                String cname = strings[2];
                String cno = sno.substring(0,6);
                int nomalscore = Integer.parseInt(strings[3]);
                int lastscore = Integer.parseInt(strings[4]);
                Student student = new Student(sno,sname,cno);
                studentMenu.addStudent(student);
                selectMenu.addClass(cno);
                Course course = courseMenu.serchCourse(cname);
                if(course==null){
                    course = new Course();
                }
                Exam exam = new Exam(nomalscore,lastscore);
                if(course.cmode.equals("考试")){
                    SelectCourse selectCourse = new SelectCourse(student,course,exam);
                    selectMenu.addSelect(selectCourse,courseMenu);
                }else {
                    System.out.println(sno + " " + sname +" : access mode mismatch");
                }
            }
            else if(flag4){
                String[] strings = s.split(" ");
                String sno = strings[0];
                String sname = strings[1];
                String cname = strings[2];
                String cno = sno.substring(0,6);
                Student student = new Student(sno,sname,cno);
                studentMenu.addStudent(student);
                selectMenu.addClass(cno);
                Course course = courseMenu.serchCourse(cname);
                if(course==null){
                    System.out.println(cname + " does not exist");
                }else {
                    Test test = new Test();
                    if (strings.length == (course.num + 3)) {
                        for (int i = 0; i < course.num; i++) {
                            test.score += Integer.parseInt(strings[3 + i]) * course.weight.get(i);
                        }
                        if(test.score-(int)test.score>0.999999){
                            test.score++;
                        }
                        SelectCourse selectCourse = new SelectCourse(student, course, test);
                        selectMenu.addSelect(selectCourse, courseMenu);
                    } else {
                        System.out.println(sno + " " + sname + " : access mode mismatch");
                    }
                }
            }
            else {
                System.out.println("wrong format");
            }
            s = sc.nextLine();
        }
        selectMenu.caculateClassScore(studentMenu.students);
        selectMenu.printStudent(studentMenu.students);
        selectMenu.printCourse(courseMenu.courses);
        selectMenu.printClass();
    }
}
class Course implements Comparable<Course>{
    String cname;
    String ctype;
    String cmode;
    int num;
    ArrayList<Double> weight = new ArrayList<>();
    public Course() {
    }

    public Course(String cname, String ctype, String cmode) {
        this.cname = cname;
        this.ctype = ctype;
        this.cmode = cmode;
    }

    @Override
    public int compareTo(Course o) {
        Comparator<Object> compare = Collator.getInstance(Locale.CHINA);
        return compare.compare(cname,o.cname);
    }
}
class CourseMenu{
    ArrayList<Course> courses = new ArrayList<>();
    void addCourse(Course course){
        for (int i = 0; i < courses.size(); i++) {
            if(courses.get(i).cname.equals(course.cname)){
                return;
            }
        }
        courses.add(course);
    }
    boolean isCourseExist(String cname){
        for (int i = 0; i < courses.size(); i++) {
            if(courses.get(i).cname.equals(cname)){
                return true;
            }
        }
        return false;
    }
    Course serchCourse(String cname){
        for (int i = 0; i < courses.size(); i++) {
            if(courses.get(i).cname.equals(cname)){
                return courses.get(i);
            }
        }
        return null;
    }
}
class Student{
    String sno;
    String sname;
    String classid;
    public Student() {
    }

    public Student(String sno, String sname, String classid) {
        this.sno = sno;
        this.sname = sname;
        this.classid = classid;
    }
}
class StudentMenu{
    ArrayList<Student> students = new ArrayList<>();
    void addStudent(Student student){
        for (Student student1 : students) {
            if(student1.sno.equals(student.sno)){
                return;
            }
        }
        students.add(student);
    }
}
class SelectCourse{
    Student student;
    Course course;
    Grade grade;

    public SelectCourse() {
    }

    public SelectCourse(Student student, Course course, Grade grade) {
        this.student = student;
        this.course = course;
        this.grade = grade;
    }
}
class SelectMenu{
    ArrayList<SelectCourse> selectCourses = new ArrayList<>();
    ArrayList<Class> classes = new ArrayList<>();
    void addSelect(SelectCourse selectCourse,CourseMenu courseMenu){
        if(courseMenu.isCourseExist(selectCourse.course.cname)) {
            selectCourses.add(selectCourse);
        }
        else {
            System.out.println(selectCourse.student.sno + " " + selectCourse.student.sname + " :" + selectCourse.course.cname + " does not exist");
        }
    }
    void addClass(String cno){
        for (int i = 0; i < classes.size(); i++) {
            if(classes.get(i).cno.equals(cno)){
                return;
            }
        }
        Class c = new Class(cno,0);
        classes.add(c);
    }
    int getStudentScore(Student student){
        int all = 0;
        int count = 0;
        for (int i = 0; i < selectCourses.size(); i++) {
            if(selectCourses.get(i).student.sno.equals(student.sno)){
                if(selectCourses.get(i).course.cmode.equals("考试")){
                    Exam exam = (Exam)selectCourses.get(i).grade;
                    all+=exam.nonalscore*selectCourses.get(i).course.weight.get(0) + exam.lastscore*selectCourses.get(i).course.weight.get(1);
                }else {
                    all += selectCourses.get(i).grade.getAverage();
                }
                count++;
            }
        }
        if(count!=0) {
            return all / count;
        }
        return 0;
    }
    int getCourseAverageScore(Course course){
        int all = 0;
        int count = 0;
        for (int i = 0; i < selectCourses.size(); i++) {
            if(selectCourses.get(i).course.cname.equals(course.cname)){
                all+=selectCourses.get(i).grade.getAverage();
                count++;
            }
        }
        if(count!=0) {
            return all / count;
        }
        return 0;
    }
    int getExamCourseAverageScore(Course course){
        double all = 0;
        int count = 0;
        for (int i = 0; i < selectCourses.size(); i++) {
            if(selectCourses.get(i).course.cname.equals(course.cname)){
                Exam exam = (Exam)selectCourses.get(i).grade;
                all+=exam.nonalscore*course.weight.get(0) + exam.lastscore*course.weight.get(1);
                count++;
            }
        }
        if(count!=0) {
            return ((int)all) / count;
        }
        return 0;
    }
    int getCoursetestScore(Course course){
        int all = 0;
        int count = 0;
        for (int i = 0; i < selectCourses.size(); i++) {
            if(selectCourses.get(i).course.cname.equals(course.cname)){
                Test test = (Test) selectCourses.get(i).grade;
                all+=test.score;
                count++;
            }
        }
        if(count!=0) {
            return all / count;
        }
        return 0;
    }
    void caculateClassScore(ArrayList<Student> students){
        for (Class aClass : classes) {
            int count = 0;
            for (Student student : students) {
                if(student.classid.equals(aClass.cno)){
                    if(getStudentScore(student)!=0) {
                        aClass.acore += getStudentScore(student);
                        count++;
                    }
                }
            }
            if(count!=0) {
                aClass.acore /= count;
            }

        }
    }
    void printStudent(ArrayList<Student> students){
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.sno.compareTo(o2.sno);
            }
        });
        for (Student student : students) {
            int score = getStudentScore(student);
            if(score!=0){
                System.out.println(student.sno + " " + student.sname + " " + score);
            }else {
                System.out.println(student.sno + " " + student.sname + " did not take any exams");
            }
        }
    }
    void printCourse(ArrayList<Course> courses){
        Collections.sort(courses);
        for (Course cours : courses) {
            int avera = getCourseAverageScore(cours);
            if(avera!=0) {
                if (cours.cmode.equals("考察")) {
                    System.out.println(cours.cname + " " + avera);
                }
                else if(cours.cmode.equals("考试")){
                    avera = getExamCourseAverageScore(cours);
                    System.out.println(cours.cname + " " + avera);
                }
                else if(cours.cmode.equals("实验")){
                    System.out.println(cours.cname + " " + getCoursetestScore(cours));
                }
            }else {
                System.out.println(cours.cname + " has no grades yet");
            }
        }
    }
    void printClass(){
        Collections.sort(classes, new Comparator<Class>() {
            @Override
            public int compare(Class o1, Class o2) {
                return o1.cno.compareTo(o2.cno);
            }
        });
        for (Class aClass : classes) {
            if(aClass.acore!=0){
                System.out.println(aClass.cno + " " + aClass.acore);
            }else {
                System.out.println(aClass.cno + " has no grades yet");
            }
        }
    }

}
class Grade{
    int  getAverage(){
        return 0;
    }
}
class Exam extends Grade{
    int nonalscore;
    int lastscore;

    public Exam() {
    }

    public Exam(int nonalscore, int lastscore) {
        this.nonalscore = nonalscore;
        this.lastscore = lastscore;
    }

    @Override
    int getAverage() {
        return (int)(nonalscore*0.3+lastscore*0.7);
    }
}
class Inves extends Grade{
    int lastscore;

    public Inves() {
    }

    public Inves(int lastscore) {
        this.lastscore = lastscore;
    }

    @Override
    int getAverage() {
        return lastscore;
    }
}
class Test extends Grade{
    double score;

    @Override
    int getAverage() {

        return ((int)score);
    }
}
class Class{
    String cno;
    int acore;

    public Class() {
    }

    public Class(String cno, int acore) {
        this.cno = cno;
        this.acore = acore;
    }
}

课程成绩统计程序3是在课程成绩统计程序2的基础上进行修改，因此与课程成绩统计程序2的类图设计并无太大的区别。主要是在课程类中添加了考核次数和成绩占比的属性。考核次数属性主要是用来保存考核方式为实验时的实验次数，成绩占比属性则是用来保存考核方式为考试的平时成绩和期末成绩的成绩占比以及考核方式为实验的每次实验的成绩占比。

class Course implements Comparable<Course>{
    String cname;
    String ctype;
    String cmode;
    int num;
    ArrayList<Double> weight = new ArrayList<>();
    public Course() {
    }

    public Course(String cname, String ctype, String cmode) {
        this.cname = cname;
        this.ctype = ctype;
        this.cmode = cmode;
    }

    @Override
    public int compareTo(Course o) {
        Comparator<Object> compare = Collator.getInstance(Locale.CHINA);
        return compare.compare(cname,o.cname);
    }
}

剩下的相较于课程成绩统计程序2主要是对输入的判断进行的改变，添加了一些正则表达式对输入的数据进行判断。

boolean flag1 = s.matches("[\\S]{1,10}\\s[\\S]{2}\\s[\\S]{2}");
            boolean flag2 = s.matches("\\d{8}\\s[\\S]{1,10}\\s[\\S]{1,10}\\s(\\d{1,2}||100)");
            boolean flag3 = s.matches("\\d{8}\\s[\\S]{1,10}\\s[\\S]{1,10}\\s(\\d{1,2}||100)\\s(\\d{1,2}||100)");
            boolean flag4 = s.matches("\\d{8}\\s[\\S]{1,10}\\s[\\S]{1,10}(\\s(\\d{1,2}||100)){4,9}");
            boolean flag5 = s.matches("[\\S]{1,10}\\s[\\S]{2}\\s[\\S]{2}\\s[4-9](\\s(\\S)*)*");
            boolean flag6 = s.matches("[\\S]{1,10}\\s[\\S]{2}\\s[\\S]{2}(\\s(\\S)*){2}");

3、期末考试

 题目：编程求得正方体和正三棱锥的表面积和体积，要求必须体现扩展性（继承）和多态性。

类图设计：

 源码分析：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        double side = input.nextDouble();

        display(new Cube(side));
        display(new RegularPyramid(side));

    }
    private static void display(Solid solid){
        System.out.println(String.format("%.2f",solid.getArea()));
        System.out.println(String.format("%.2f",solid.getVolume()));
    }
}
class Solid{
    double side;
    double getArea(){
        return 0;
    }
    double getVolume(){
        return 0;
    }

    public Solid(double side) {
        this.side = side;
    }

    public Solid() {
    }

    public double getSide() {
        return side;
    }

    public void setSide(double side) {
        this.side = side;
    }
}
class Cube extends Solid{
    public Cube(double side) {
        super(side);
    }

    public Cube() {
    }

    @Override
    double getArea() {
        return this.side * this.side * 6;
    }

    @Override
    double getVolume() {
        return this.side * this.side * this.side;
    }
}
class RegularPyramid extends Solid{
    public RegularPyramid(double side) {
        super(side);
    }

    public RegularPyramid() {
    }

    @Override
    double getArea() {
        return (this.side * this.side * Math.sqrt(3) );
    }

    @Override
    double getVolume() {
        return (this.side * this.side * this.side  /(6 * Math.sqrt(2)));
    }
}

 正方体类和正三棱锥类都继承图形类。主要的难点是确定正三棱锥的体积计算公式。

三、采坑心得

1、课程成绩统计程序-2

输入处理没有处理的好，导致有错误输入样例的测试点过不了。

 

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

 对占比不同的成绩的整合处理以及对double类型的数据对小数计算的不切当，导致有一个测试点始终过不去。

 放宽判断条件即可成功。

 

3、期末考试

最后一题销售步枪问题时，没有考虑到每一样配件的销售量不能小于1的情况。

 添加判断条件即可解决问题。

 

四、改进建议

类的设计可能并没有做到最合理，更加合理的类设计可能可以大大的简化代码量；对各种异常的处理比较分散，如何能够做到对所有的异常类进行统一处理可能不仅能简化代码，还能通过原来没通过的测试点。对方法的设计不够完美，每当添加了新的要求时，都不可避免的会对方法的变量、内容进行修改，如果能进行更好的方法设计，或许就能解决这些问题。

五、总结

通过这几次作业，加深了我对类的设计的理解，以及提高了我对处理几个类之间关系的能力。但应对一些异常情况的能力还明显不足。

通过期末测试，让我明白了我在接口部分的薄弱以及在一些理论部分的不足。

此外，基本上在数据处理的部分，都用到了正则表达式，加深了我对正则表达式的理解。