标签：return String int BLOG score 成绩 public

一.前言

题目集1：

这个题目集主要侧重于基本的编程知识和概念，涵盖了数据类型、运算符、条件语句、循环结构等基础内容。题目数量适中，足够帮助我巩固基本的编程技能。

难度方面，大部分题目相对简单，适合编程入门的学生。但也有一些稍微复杂的问题，需要深入理解条件语句和循环结构的运用。

题目集2：

这个题目集更加侧重于面向对象编程和类的应用，其中包括了学生信息管理、成绩计算、日期处理、数据去重等多个方面的题目。通过解决这些问题，我学会了如何设计和使用类，以及如何进行数据封装和处理。

题目数量适中，不仅有编程任务，还要求我思考如何设计合适的类和方法。这提高了我的面向对象编程能力。难度有所提升，但通过逐步解决问题，我感到更加自信和熟练。

题目集3：

这个题目集是最具挑战性的，涵盖了日期处理、成绩统计、面向对象编程等。题目数量适中，但问题更加综合和复杂。

在解决这些问题时，我需要运用前两个题目集中学到的知识，并深入理解面向对象编程的原理。这帮助我提高了问题解决能力和编程技能。

这三个题目集的知识点和难度逐渐升级，很好地满足了我的学习需求。它们不仅提高了我的编程能力，还让我更加熟悉不同领域的编程任务。我相信这些经验将在我的编程学习中起到重要作用。

二.设计与分析

1.第二次作业的 7-1 成绩计算-1-类、数组的基本运用

创建学生类，包含

属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）

方法：计算总分、计算平均分

输入5个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

 

注意：未用学生类对象封装数据的，本题计0分

输入格式:

5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80

22201312 黄昊 66 82 81

22201313 李少辰 77 76 80

22201314 袁婷 62 79 90

22201315 朱哲一 74 98 94

输出格式:

5个学生信息，每个学生信息格式：

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

例如：

22201311 张琳 240 80.00

22201312 黄昊 229 76.33

22201313 李少辰 233 77.67

22201314 袁婷 231 77.00

22201315 朱哲一 266 88.67

import java.util.Scanner;
import java.text.DecimalFormat;

public class Main {
    public static void main(String []args) {
        Scanner scanner = new Scanner(System.in);
        DecimalFormat df = new DecimalFormat("#.00");
        
        Student[] students = new Student[5];
        
        for(int i = 0; i < 5; i++) {
            String studentID = scanner.next();
            String studentName = scanner.next();
            int score_Chi = scanner.nextInt();
            int score_math = scanner.nextInt();
            int score_physics = scanner.nextInt();
            students[i] = new Student(studentID, studentName, score_Chi, score_math, score_physics);
        }
        for(int i = 0; i < 5; i++)    {
        double ave = students[i].ave_score();
        int sum = students[i].sum_score();
        System.out.println(students[i].studentID + " " + students[i].studentName + 
                " " + sum + " " + df.format(ave));
        }
        scanner.close();
    }
    
    public static class Student{
        String studentID;
        String studentName;
        int score_Chi;
        int score_math;
        int score_physics;
        
        public Student(String studentID, String studentName, int score_Chi,int score_math,int score_physics) {
            this.studentID = studentID;
            this.studentName = studentName;
            this.score_Chi = score_Chi;
            this.score_math = score_math;
            this.score_physics = score_physics;
        }
    
        public double ave_score(){
            double sum = score_Chi + score_math + score_physics;
            return sum / 3.0;
        }
        public int sum_score() {
            int sum = score_Chi + score_math + score_physics;
            return sum;
        }
    }
}

1. 导入必要的库：

   你导入了java.util.Scanner和java.text.DecimalFormat两个库，分别用于输入数据和格式化输出。

2. 创建学生数组：

   你创建了一个长度为5的学生数组，用于存储学生对象的信息。

3. 输入学生信息：

   使用for循环，你通过Scanner类从标准输入中读取了5个学生的信息，包括学号、姓名、语文成绩、数学成绩和物理成绩，然后将这些信息用于创建Student对象，并将这些对象存储在学生数组中。

4. 计算并输出学生信息：

   通过另一个for循环，你遍历了学生数组中的每个学生对象，然后分别计算了每个学生的总分和平均分，并使用DecimalFormat格式化平均分的输出，最后按照指定格式输出了每个学生的信息。

5. 关闭Scanner：

   在程序的末尾，你使用了scanner.close()来关闭Scanner对象，以释放资源。

代码包含一个名为Student的内部静态类，该类用于表示学生对象。它包含了学号、姓名、语文成绩、数学成绩和物理成绩等属性，并提供了计算平均分和总分的方法。

 由于这道题比较简单，所以代码没有很多，主要包含输入、处理和输出三个基本部分，因此圈复杂度很低。整个程序没有循环嵌套，所以代码的复杂性也很低。

 2.第二次作业的7-2 成绩计算-2-关联类

创建成绩类，包含：

属性：平时成绩（int）、期末成绩（int）

方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）

创建学生类，包含：

属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）

方法：计算总分、计算平均分

输入3个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365

注意：未用学生类对象封装数据的，本题计0分

输入格式:

依次输入3个学生的每门课成绩，每个学生成绩信息格式：

学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致

例如：
22201311 张琳 语文 70 80

22201311 张琳 数学 85 89

22201311 张琳 物理 75 83

22201312 黄昊 语文 66 78

22201312 黄昊 数学 76 82

22201312 黄昊 物理 83 82

22201313 李少辰 语文 86 76

22201313 李少辰 数学 78 76

22201313 李少辰 物理 87 76

输出格式:

3个学生信息，每个学生信息格式：

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

例如：

22201311 张琳 242 80.67

22201312 黄昊 234 78.00

22201313 李少辰 236 78.67

输入样例:

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

22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76

输出样例:

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

22201311 张琳 242 76.67 84.00 80.67
22201312 黄昊 234 75.00 80.67 78.00
22201313 李少辰 236 83.67 76.00 78.6

这道题是相当坑人呀，输出格式没有讲清楚这个输出的平均分到底是什么，后面听了同学说才知道分别要输出的是总分，平时分平均分，期末分平均分，总分平均分......

import java.util.Scanner;

public class Main {
    public static void main(String []args) {
        Scanner scanner = new Scanner(System.in);
        //创建学生信息
        Student[] students = new Student[3];
        for(int i = 0; i < 3; i++)
        students[i] = new Student();
        for(int i = 0; i < 9; i++) {
            String studentID = scanner.next();
            String studentName = scanner.next();
            String subject = scanner.next();
            int score1,score2,j = i / 3;
            score1 = scanner.nextInt();
            score2 = scanner.nextInt();
            students[j].studentID = studentID;    
            students[j].studentName = studentName;    
            if(subject.equals("语文")) {
                students[j].set_score_Chi(score1, score2);
            }
            else if(subject.equals("数学")) {
                students[j].set_score_math(score1, score2);
            }
            else if(subject.equals("物理")) {
                students[j].set_score_physics(score1, score2);
            }    
        }
        
        for(int i = 0; i < 3; i++) {
            double sum_tsc = students[i].sum_total_score();
            double usual_tsc = students[i].ave_usual_scores();
            double final_tsc = students[i].ave_final_scores();
            System.out.print(students[i].studentID + " " + students[i].studentName + " ");
            System.out.print(String.format("%.0f ",sum_tsc));
            System.out.print(String.format("%.2f ",usual_tsc));
            System.out.print(String.format("%.2f ",final_tsc));
            System.out.print(String.format("%.2f\n",sum_tsc / 3.0));
        }
        
        scanner.close();
}
    
        public static class scores {
        int usual_score;
        int final_score;

        public scores(int usual_score, int final_score) {
            this.usual_score = usual_score;
            this.final_score = final_score;
        }

        public double cal_total_Score() {
            double total_score = usual_score * 0.4 + final_score * 0.6;
            return Math.floor(total_score);
        }
    }
    
    public static class Student {
        String studentID;
        String studentName;
        scores score_Chi;
        scores score_math;
        scores score_physics;
        
        public Student(){
            this.studentID = new String(" ");
            this.studentName = new String(" ");
            this.score_Chi = new scores(0, 0);
            this.score_math = new scores(0, 0);
            this.score_physics = new scores(0, 0);
        }
        
        public void set_score_Chi(int usual_score, int final_score) {
            score_Chi = new scores(usual_score, final_score);
        }
        
        public void set_score_math(int usual_score, int final_score) {
            score_math = new scores(usual_score, final_score);
        }
        
        public void set_score_physics(int usual_score, int final_score) {
            score_physics = new scores(usual_score, final_score);
        }
        
        public double sum_total_score() {
            double sum = score_Chi.cal_total_Score() + score_math.cal_total_Score()
                      + score_physics.cal_total_Score();
            return sum;
        }
        
        public double ave_usual_scores() {
            double ave = (score_Chi.usual_score + score_math.usual_score + 
                    score_physics.usual_score) / 3.0;
            return ave;
        }
        public double ave_final_scores() {
            double ave = (score_Chi.final_score + score_math.final_score + 
                    score_physics.final_score) / 3.0;
            return ave;
    }
}
}

1. 导入必要的库：

   你导入了java.util.Scanner库，用于从标准输入中读取数据。

2. 创建学生和成绩对象数组：

   你创建了一个包含3个学生对象的数组。每个学生对象都包含学号、姓名和各科成绩，以及一个scores对象来表示各科成绩的平时分和期末分。

3. 输入学生信息和成绩：

   使用两个嵌套的for循环，你首先读取学生的学号、姓名和学科信息（语文、数学、物理），然后读取各科的平时分和期末分。根据学科信息，你将平时分和期末分设置给相应的scores对象，并将这些信息保存在学生对象中。

4. 计算并输出学生信息和成绩：

   通过另一个for循环，你遍历了学生数组中的每个学生对象，并计算了每个学生的总分、平时分平均值、期末分平均值和总平均分。使用String.format方法格式化输出，并按指定格式输出了每个学生的信息和成绩。

5. scores内部类：

   在Student类内部，你创建了一个名为scores的内部类，该类用于表示学科的平时分和期末分。这个内部类还包含了一个计算总分的方法cal_total_Score()。

代码包含两个类：Student和scores

Student类表示学生，包括学号、姓名和三门学科的成绩。

scores类表示学科的平时分和期末分。

代码相对简单，没有复杂的逻辑结构。主要的循环是两个嵌套的for循环，因此圈复杂度并不高。

 3.第三次作业的 7-2 课程成绩统计程序-1

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

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

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

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

1、输入：

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

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

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

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

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

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

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

以上信息的相关约束：

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

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

3）学号由8位数字组成

4）姓名不超过10个字符

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

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

2、输出：

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

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

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

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

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

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

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

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

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

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

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

异常情况：

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

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

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

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

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

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

信息约束：

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

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

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ScoreProcessor processor = new ScoreProcessor();
        
        //循环输入并处理信息
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("end")) {
                break;
            }
            processor.processInput(input);
        }
        
        //处理后输出信息
        processor.outputStudentInfo();
        processor.outputCourseInfo();
        processor.outputClassInfo();
    }
}

class ScoreProcessor {
    // 存储学生、课程、班级和选课信息的集合
    private ArrayList<Student> students = new ArrayList<>();
    private ArrayList<Course> courses = new ArrayList<>();
    private ArrayList<Class> classes = new ArrayList<>();
    private ArrayList<chs_Cos> chs_Coss = new ArrayList<>();
    
    // 处理输入信息
    public void processInput(String input) {
        content_Mch matcher = new content_Mch();
        int flag = matcher.match_con(input);

        if (flag == 0) {
            System.out.println("wrong format"); // 格式错误
        } else if (flag == 1) {
            pro_Cou_input(input); // 处理课程信息
        } else if (flag == 2) {
            pro_Gd_input(input); // 处理成绩信息
        }
    }


    // 处理课程信息
    private void pro_Cou_input(String input) {
        String[] tokens = input.split(" ");
        if (tokens.length != 3) {
            System.out.println("wrong format");
        }

        String cou_Nam = tokens[0];
        String tp = tokens[1];
        String test_Tp = tokens[2];

        Course course = new Course(cou_Nam, tp, test_Tp);

        if (ck_Cou(course)) {
            if (sc_Cou(cou_Nam) == null) {
                courses.add(course);
            }
        }
    }
    
    // 处理成绩信息
    private void pro_Gd_input(String input) {
        String[] tokens = input.split(" ");
        if (tokens.length != 4 && tokens.length != 5) {
            System.out.println("wrong format");

        }

        String stu_ID = tokens[0];
        String cl_ID = stu_ID.substring(0, 6);
        String stu_Name = tokens[1];
        String cou_Nam = tokens[2];

        if (sc_Cls(cl_ID) == null) {
            Class cls = new Class(cl_ID);
            classes.add(cls);
        }

        Student student = new Student(cl_ID, stu_ID, stu_Name);
        if (!serc_Stu(stu_ID)) {
            students.add(student);
        }

        Course course = sc_Cou(cou_Nam);

        if (course == null) {
            System.out.println(cou_Nam + " does not exist");
        } else {
            if (tokens.length == 4 && course.gettest_Tp().equals("考察")) {
                int fin_Gd = Integer.parseInt(tokens[3]);
                as_Gr as_Gr = new as_Gr(fin_Gd);
                chs_Cos chs_Cos = new chs_Cos(course, student, as_Gr);
                if (!serc_Cos(stu_Name, cou_Nam)) {
                    chs_Coss.add(chs_Cos);
                }
            } else if (tokens.length == 5 && course.gettest_Tp().equals("考试")) {
                int usl_Gd = Integer.parseInt(tokens[3]);
                int fin_Gd = Integer.parseInt(tokens[4]);
                ex_Gd ex_Gd = new ex_Gd(usl_Gd, fin_Gd);
                chs_Cos chs_Cos = new chs_Cos(course, student, ex_Gd);
                chs_Coss.add(chs_Cos);
            } else {
                System.out.println(stu_ID + " " + stu_Name + " : access mode mismatch");
            }
        }
    }
    
 // 检查课程是否符合规定的性质和考核方式
    public boolean ck_Cou(Course course) {
        int flag1, flag2;

        if (course.get_Tp().equals("必修")) {
            flag1 = 0;
        } else if (course.get_Tp().equals("选修")) {
            flag1 = 1;
        } else {
            flag1 = -1;
        }

        if (course.gettest_Tp().equals("考试")) {
            flag2 = 0;
        } else if (course.gettest_Tp().equals("考察")) {
            flag2 = 1;
        } else {
            flag2 = -1;
        }

        if (flag1 == 0 && flag2 == 0)
            return true;
        if (flag1 == 1 && (flag2 == 0 || flag2 == 1))
            return true;
        
        System.out.println(course.getcou_Nam() + " : course type & access mode mismatch");
        return false;
    }

    
    // 根据班级号查找班级对象
    public Class sc_Cls(String cl_ID) {
        return classes.stream()
                .filter(cls -> cls.getcl_ID().equals(cl_ID))
                .findFirst()
                .orElse(null);
    }

    
    // 根据课程名称查找课程对象
    public Course sc_Cou(String cou_Name) {
        return courses.stream()
                .filter(course -> course.getcou_Nam().equals(cou_Name))
                .findFirst()
                .orElse(null);
    }

    
    // 根据学号查找学生是否存在
    public boolean serc_Stu(String id) {
        return students.stream().anyMatch(stu -> stu.get_ID().equals(id));
    }

    // 检查学生是否已选过某门课程
    public boolean serc_Cos(String stustu_Name, String cou_Nam) {
        return chs_Coss.stream()
                .anyMatch(cs -> cs.get_Stu().getStu_Name().equals(stustu_Name) && cs.get_Cou().getcou_Nam().equals(cou_Nam));
    }
    
    // 输出学生信息
    public void outputStudentInfo() {
        Collections.sort(students);
        for (Student student : students) {
            ArrayList<chs_Cos> stu_Cou_Sels = get_Stu_Sels(student.get_ID());
            if (!stu_Cou_Sels.isEmpty()) {
                System.out.println(student.get_ID() + " " + student.getStu_Name() + " " + get_Avg_ToSco(stu_Cou_Sels));
            } else {
                System.out.println(student.get_ID() + " " + student.getStu_Name() + " " + "did not take any exams");
            }
        }
    }
    
    // 输出课程信息
    public void outputCourseInfo() {
        Collections.sort(courses);
        for (Course course : courses) {
            ArrayList<chs_Cos> stu_Cou_Sels = get_CouSelects(course.getcou_Nam());
            if (!stu_Cou_Sels.isEmpty()) {
                if (course.gettest_Tp().equals("考试")) {
                    System.out.println(course.getcou_Nam() + " " + get_Avg_UsSco(stu_Cou_Sels) + " " +
                            get_Avg_FiSco(stu_Cou_Sels) + " " + get_Avg_ToSco(stu_Cou_Sels));
                } else if (course.gettest_Tp().equals("考察")) {
                    System.out.println(course.getcou_Nam() + " " + get_Avg_FiSco(stu_Cou_Sels) + " " +
                            get_Avg_ToSco(stu_Cou_Sels));
                }
            } else {
                System.out.println(course.getcou_Nam() + " " + "has no grades yet");
            }
        }
    }
    

    // 输出班级信息
    public void outputClassInfo() {
        Collections.sort(classes);
        for (Class cls : classes) {
            ArrayList<chs_Cos> stu_Cou_Sels = get_Cls_Sels(cls.getcl_ID());
            if (!stu_Cou_Sels.isEmpty()) {
                System.out.println(cls.getcl_ID() + " " + get_Avg_ToSco(stu_Cou_Sels));
            } else {
                System.out.println(cls.getcl_ID() + " " + "has no grades yet");
            }
        }
    }


    // 获取某个学生所选的课程列表
    public ArrayList<chs_Cos> get_Stu_Sels(String id) {
        ArrayList<chs_Cos> cse = new ArrayList<>();
        for (chs_Cos cos : chs_Coss) {
            if (cos.get_Stu().get_ID().equals(id))
                cse.add(cos);
        }
        return cse;
    }

    // 获取某门课程的所有选修学生列表
    public ArrayList<chs_Cos> get_CouSelects(String cou_Nam) {
        ArrayList<chs_Cos> cse = new ArrayList<>();
        for (chs_Cos cos : chs_Coss) {
            if (cos.get_Cou().getcou_Nam().equals(cou_Nam))
                cse.add(cos);
        }
        return cse;
    }

 // 获取某个班级的所有选修学生列表
    public ArrayList<chs_Cos> get_Cls_Sels(String clsId) {
        ArrayList<chs_Cos> cse = new ArrayList<>();
        for (chs_Cos cos : chs_Coss) {
            if (cos.get_Stu().getcl_ID().equals(clsId))
                cse.add(cos);
        }
        return cse;
    }
   
    // 计算某门课程所有学生的总成绩平均分
    public int get_Avg_ToSco(ArrayList<chs_Cos> dsp) {
        int ave = 0;
        int sum = 0;
        int size = dsp.size(); // 获取列表大小
        for (int i = 0; i < size; i++) {
            chs_Cos ck = dsp.get(i);
            sum += ck.get_Grd().get_Total_Gd();
        }
        if (size > 0) {
            ave = sum / size; // 使用整数除法得到平均分数
        }
        return ave;
    }


    // 计算某门课程所有学生的平时成绩平均分
    public int get_Avg_UsSco(ArrayList<chs_Cos> sb) {
        int ave = 0;
        int sum = 0;
        int size = sb.size(); // 获取列表大小
        for (int i = 0; i < size; i++) {
            chs_Cos ck = sb.get(i);
            if (ck.get_Cou().gettest_Tp().equals("考试")) {
                sum += ck.get_Grd().getusl_Gd();
            }
        }
        if (size > 0) {
            ave = sum / size; // 使用整数除法得到平均分数
        }
        return ave;
    }


    // 计算某门课程所有学生的期末考试平均分
    public int get_Avg_FiSco(ArrayList<chs_Cos> cs) {
        int ave = 0;
        int sum = 0;
        int size = cs.size(); // 获取列表大小
        for (int i = 0; i < size; i++) {
            chs_Cos c = cs.get(i);
            sum += c.get_Grd().getfin_Gd();
        }
        if (size > 0) {
            ave = sum / size; // 使用整数除法得到平均分数
        }
        return ave;
    }

}
     
//选课信息类
class chs_Cos {
    private Course course;
    private Student student;
    private Grade grade;

    public chs_Cos(Course course, Student student, Grade grade) {
        this.course = course;
        this.student = student;
        this.grade = grade;
    }

    public Course get_Cou() {
        return course;
    }

    public Student get_Stu() {
        return student;
    }

    public Grade get_Grd() {
        return grade;
    }
}

//学生信息类
class Student implements Comparable<Student> {
    private String stustu_Name;
    private String id;
    private String cl_ID;

    public String get_ID() {
        return id;
    }

    public String getStu_Name() {
        return stustu_Name;
    }

    public String getcl_ID() {
        return cl_ID;
    }

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

    @Override
    public int compareTo(Student stu) {
        return get_ID().compareTo(stu.get_ID());
    }
}

//课程信息类
class Course implements Comparable<Course> {
    private String cou_Nam;
    private String tp;
    private String test_Tp;

    public Course(String cou_Nam, String tp, String test_Tp) {
        this.cou_Nam = cou_Nam;
        this.tp = tp;
        this.test_Tp = test_Tp;
    }

    public String getcou_Nam() {
        return cou_Nam;
    }

    public String get_Tp() {
        return tp;
    }

    public String gettest_Tp() {
        return test_Tp;
    }

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

//班级信息类
class Class implements Comparable<Class> {
    private String cl_ID;

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

    public String getcl_ID() {
        return cl_ID;
    }

    @Override
    public int compareTo(Class o) {
        return getcl_ID().compareTo(o.getcl_ID());
    }
}

//成绩抽象类
abstract class Grade {
    int fin_Gd;

    public abstract int getusl_Gd();

    public abstract int getfin_Gd();

    public abstract int get_Total_Gd();
}

//期末考试成绩类
class ex_Gd extends Grade {
    private int usl_Gd;

    public ex_Gd(int usl_Gd, int fin_Gd) {
        this.usl_Gd = usl_Gd;
        this.fin_Gd = fin_Gd;
    }

    @Override
    public int getusl_Gd() {
        return usl_Gd;
    }

    @Override
    public int getfin_Gd() {
        return fin_Gd;
    }

    @Override
    public int get_Total_Gd() {
        return (int) (usl_Gd * 0.3 + fin_Gd * 0.7);
    }
}

//考察成绩类
class as_Gr extends Grade {
    public as_Gr(int fin_Gd) {
        this.fin_Gd = fin_Gd;
    }

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

    @Override
    public int getfin_Gd() {
        return fin_Gd;
    }

    @Override
    public int get_Total_Gd() {
        return fin_Gd;
    }
}

//内容匹配类
class content_Mch {
    static String stu_Num_Mch = "[0-9]{8}"; // 学号匹配规则
    static String stu_Name_Mch = ".{1,10}"; // 姓名匹配规则
    static String cou_Name_Mch = ".{1,10}"; // 课程名称匹配规则
    static String uslSco_Mch = "[0-9]{1,2}"; // 平时成绩匹配规则
    static String finSco_Mch = "[0-9]{1,2}"; // 期末成绩匹配规则

    public int match_con(String input) {
        String[] tokens = input.split(" ");
        int tokenLen = tokens.length;

        if (tokenLen == 3) { // 课程信息输入
            if (!tokens[0].matches(cou_Name_Mch)) {
                return 0; // 课程名称不匹配
            }
            if (!tokens[1].equals("必修") && !tokens[1].equals("选修")) {
                return 0; // 课程性质不匹配
            }
            if (!tokens[2].equals("考试") && !tokens[2].equals("考察")) {
                return 0; // 考核方式不匹配
            }
            return 1;
        } else if (tokenLen == 4 || tokenLen == 5) { // 成绩信息输入
            if (!tokens[0].matches(stu_Num_Mch)) {
                return 0; // 学号不匹配
            }
            if (!tokens[1].matches(stu_Name_Mch)) {
                return 0; // 姓名不匹配
            }
            if (!tokens[2].matches(cou_Name_Mch)) {
                return 0; // 课程名称不匹配
            }
            if (tokenLen == 4) { // 考察成绩输入
                if (!tokens[3].matches(finSco_Mch)) {
                    return 0; // 期末成绩不匹配
                }
                return 2;
            } else { // 期末考试成绩输入
                if (!tokens[3].matches(uslSco_Mch)) {
                    return 0; // 平时成绩不匹配
                }
                if (!tokens[4].matches(finSco_Mch)) {
                    return 0; // 期末成绩不匹配
                }
                return 2;
            }
        } else {
            return 0; // 输入信息格式错误
        }
    }
}

1. 主程序：

   • 主程序中使用一个while循环，允许用户连续输入信息，直到输入"end"为止，这样可以方便地添加多个学生和成绩信息。
   • 程序创建了一个ScoreProcessor对象，用于处理输入的信息。
   • 主程序使用processInput方法来处理用户输入的信息，并将其分为课程信息和成绩信息。

2. ScoreProcessor类：

   • ScoreProcessor类用于管理学生、课程、班级和选课信息，以及处理输入信息。
   • 定义了四个集合分别用于存储学生、课程、班级和选课信息：students、courses、classes和chs_Coss。
   • processInput方法根据输入的内容判断是课程信息还是成绩信息，并分别调用pro_Cou_input和pro_Gd_input方法进行处理。
   • pro_Cou_input方法用于处理课程信息，将合法的课程信息添加到courses集合中。
   • pro_Gd_input方法用于处理成绩信息，将合法的成绩信息添加到students、classes和chs_Coss集合中。
   • ck_Cou方法用于检查课程是否符合规定的性质和考核方式。
   • 提供了多个方法用于根据不同条件查找学生、课程、班级和选课信息。
   • 提供了方法用于计算平均分和输出学生、课程和班级信息。

3. 其他类：（下图为代码的类图）

   • 除了ScoreProcessor类，还定义了其他类用于表示学生、课程、班级和成绩信息，以及一个辅助类content_Mch用于匹配输入的内容。
   • chs_Cos类表示选课信息，包含一个课程、一个学生和一个成绩对象。
   • Student类表示学生信息，包括学号、姓名和班级。
   • Course类表示课程信息，包括课程名称、性质和考核方式。
   • Class类表示班级信息，包括班级编号。
   • Grade类是一个抽象类，表示成绩信息，有两个子类ex_Gd和as_Gr，分别表示期末考试成绩和考察成绩。

     

     

     

     代码使用了多个方法来分解不同的任务，有助于降低圈复杂度。主要的圈复杂度可能集中在processInput方法的条件判断上，因为它需要根据输入的内容执行不同的操作。

三.踩坑心得

1.在第一次作业的第一题中，明明已经在eclipse中通过了测试，但在pta中缺发生了报错

 后面才发现原来是PTA的平台问题：

http://www.cnblogs.com/zhrb/p/6347738.html

 

 类名和文件名都得是 Main，最后完成了这道题目。

 

2.运算中，float c = (float) b / a; 是先强制类型转换还是先计算？ 

public static void main(String[] args) {
    int a = 3;
    int b = 10;
    float c = (float) b / a;
    System.out.println(c);
}

写代码的时候，突然想到这个问题，这个代码中的float c = (float) b / a; 是先计算还是先强制类型转换？ 

结论：是先强制类型转换再计算，但是计算前也会强制类型转换（由低→ 高）。这里其实考验了的是两个问题，算符优先级和计算过程中转换的问题。 

分析原因：float c = (float) b / a;　　首先，因为a，b都是int类型，因此在开始前，会先把b的值进行类型转化为float类型的值(b的数据类型不会变，只是临时另外创建了一个float类型的值)，然后在计算前，这时候，分子是float类型 ，分母是int类型，所以又悄眯的进行类型转换，并且由低转高，分母也被强制类型转为float类型了。因此最终的输出结果是3.3333333.（因为在计算中，不同类型的数据先转化为同一类型，然后才进行运算。）相同的，如果是float c = b / (float) a; 这时候呢？是先计算还是先强制类型转换？结论也是一样的，只不过这次是先强制类型转换的是a的值罢了。

 

3.Exception in thread "main" java.lang.Error: Unresolved compilation problem: at l.Main.main(Main.java:5)

单纯的编译错误没有其他含义，在输入语句时错误的写成int race = new scanner.nextInt();

正确的则为int race = scanner.nextInt();

 

4.在第一次作业的7-7 判断三角形类型中，在判断直角三角形，则输出“Right-angled triangle”，不能通过简单的（a*a + b*b） == c*c来判断是否为之间三角形，因为还有带根号的情况！！！！！！所以在这里的判断条件需要a*a + b*b - c*c < 0.1 || b*b + c*c - a*a < 0.1 || a*a + c*c - b*b < 0.1即可

 

四.主要困难及改进建议

写的代码的注释不多，类的复用性很差,可以说基本复用不了。对于题目集一和题目集二我认为可以加强代码的优化，让代码的复杂度降低。对于精度问题还是不是很在行，基本上都是挨个方法试，看哪个能过。

五.总结

首先在这里我使用了新的知识java，同时也学到了如何使用字符串中的方法，同时还学到了创建一个新的类，对我在这几道题的帮助特别大，同时我还需要继续学习父类和子类之间如何使用的，同时老师在对我们学习这方面帮助很大，期待在未来的学习中不断提高自己的编程技能，解决更复杂的问题，并参与更多的编程项目。

标签：return,String,int,BLOG,score,成绩,public
From： https://www.cnblogs.com/zzz3898/p/17747269.html