blog-3

前言

必修课、选修课的概念：
- Java中可以使用类和接口来实现必修课和选修课的概念。例如，可以创建一个基础课程的抽象类，然后派生出具体的必修课和选修课。
考试、考察的概念：
- Java中可以使用条件语句（if-else语句）来模拟考试和考察的不同考核方式。例如，通过判断条件来选择使用不同的计分方式计算总成绩。
总成绩计算公式：
- 在Java中，你可以使用变量、运算符和控制流语句来实现总成绩的计算公式。根据给定的权重和成绩，使用算术运算符来进行加权和求和的操作。

设计与分析

题目设计：
- 需要考虑题目的清晰度和准确性，确保学生能够理解题目的要求。
- 题目应该包括必要的背景和条件，以便学生能够正确理解问题，并根据给定的知识点进行解答。
- 考虑使用具体的例子或案例来帮助学生更好地理解题目，并引导他们进行思考和分析。
答案分析：
- 对于涉及计算的问题，需要给出具体的计算公式、步骤和解答过程，以便学生理解问题的求解方法。
- 对于涉及选择的问题，需要提供选项和相应的解析，让学生了解每个选项的含义和正确与错误之间的区别。
- 鼓励学生通过自己的思考和分析，对问题进行进一步的思考和讨论，从而培养他们的问题分析和解决能力。
难度控制：
- 需要考虑题目的难度适合目标学生群体的学习能力和知识水平。
- 可以设计不同难度级别的题目，以满足学生的不同需求和学习进展。

  +------------------+          +-----------------+
  |     Question     |          |     Answer      |
  +------------------+          +-----------------+
  | -text: String    |          | -content: String|
  | -difficulty: int |          | -isCorrect: bool|
  +------------------+          +-----------------+
          ↑                            ↑
          |                            |
  +------------------+          +-----------------+
  | MultipleChoiceQ  |          |  CalculationQ   |
  +------------------+          +-----------------+
  | -choices: String[]|          | -formula: String|
  +------------------+          +-----------------+

在这个类图中，有两个主要的类 Question 和 Answer，它们代表了题目和答案。在 Question 类中，我们有一个私有属性 text 表示问题的文本，difficulty 表示问题的难度。在 Answer 类中，我们有一个私有属性 content 表示答案的内容，isCorrect 表示答案是否正确。

而在 MultipleChoiceQ 类和 CalculationQ 类中，它们是 Question 类的子类，分别代表了选择题和计算题。在 MultipleChoiceQ 类中，我们有一个私有属性 choices 表示选项的集合。在 CalculationQ 类中，我们有一个私有属性 formula 表示计算题的公式。

相关代码

import java.util.*;

public class GradeCalculator {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 课程信息列表
        List<Course> courseList = new ArrayList<>();
        // 学生成绩信息列表
        List<Grade> gradeList = new ArrayList<>();
        
        // 解析输入的课程信息
        String courseInfo = scanner.nextLine();
        while (!courseInfo.isEmpty()) {
            Course course = parseCourseInfo(courseInfo);
            if (course != null) {
                courseList.add(course);
            }
            courseInfo = scanner.nextLine();
        }
        
        // 解析输入的学生成绩信息
        String gradeInfo = scanner.nextLine();
        while (!gradeInfo.isEmpty()) {
            Grade grade = parseGradeInfo(gradeInfo);
            if (grade != null) {
                gradeList.add(grade);
            }
            gradeInfo = scanner.nextLine();
        }
        
        scanner.close();
        
        // 计算并输出结果
        calculateAndPrintAverages(courseList, gradeList);
    }
    
    // 解析课程信息
    public static Course parseCourseInfo(String courseInfo) {
        String[] parts = courseInfo.split(" ");
        if (parts.length < 2 || parts.length > 3) {
            System.out.println("wrong format");
            return null;
        }
        
        String courseName = parts[0];
        String courseType = parts[1];
        String accessMode = "";
        if (parts.length == 3) {
            accessMode = parts[2];
        }
        
        // 检查课程性质和考核方式是否匹配
        if (courseType.equals("必修") && accessMode.isEmpty()) {
            System.out.println(courseName + " : course type & access mode mismatch");
            return null;
        }
        
        return new Course(courseName, courseType, accessMode);
    }
    
    // 解析学生成绩信息
    public static Grade parseGradeInfo(String gradeInfo) {
        String[] parts = gradeInfo.split(" ");
        if (parts.length != 6) {
            System.out.println("wrong format");
            return null;
        }
        
        String studentId = parts[0];
        String studentName = parts[1];
        String courseName = parts[2];
        int commonScore = Integer.parseInt(parts[3]);
        int finalScore = Integer.parseInt(parts[4]);
        
        return new Grade(studentId, studentName, courseName, commonScore, finalScore);
    }
    
    // 计算平均分并输出结果
    public static void calculateAndPrintAverages(List<Course> courseList, List<Grade> gradeList) {
        // 学生总成绩列表
        List<StudentScore> studentScores = new ArrayList<>();
        // 单门课程平均分
        Map<String, CourseAverage> courseAverages = new TreeMap<>();
        // 班级总成绩平均分
        Map<String, Integer> classAverages = new TreeMap<>();
        
        // 遍历所有成绩信息，计算总成绩和班级总成绩
        for (Grade grade : gradeList) {
            if (!courseListContains(courseList, grade.getCourseName())) {
                System.out.println(grade.getStudentId() + " " + grade.getStudentName() + ":" + grade.getCourseName() + " does not exist");
                continue;
            }
            
            Course course = getCourseFromList(courseList, grade.getCourseName());
            
            if (course.getAccessMode().equals("考试") && grade.getCommonScore() != 0) {
                System.out.println(grade.getStudentId() + " " + grade.getStudentName() + ": access mode mismatch");
                continue;
            }
            
            int totalScore = calculateTotalScore(course, grade.getCommonScore(), grade.getFinalScore());
            String classId = grade.getStudentId().substring(0, 6);
            
            StudentScore studentScore = getStudentScoreFromList(studentScores, grade.getStudentId());
            if (studentScore == null) {
                studentScore = new StudentScore(grade.getStudentId(), grade.getStudentName(), totalScore);
                studentScores.add(studentScore);
            } else {
                studentScore.addScore(totalScore);
            }
            
            if (!classAverages.containsKey(classId)) {
                classAverages.put(classId, totalScore);
            } else {
                classAverages.put(classId, classAverages.get(classId) + totalScore);
            }

 // 更新单门课程平均分
            int commonScore = grade.getCommonScore();
            int finalScore = grade.getFinalScore();
            String courseName = grade.getCourseName();
            
            CourseAverage courseAverage = courseAverages.get(courseName);
            if (courseAverage == null) {
                courseAverage = new CourseAverage(courseName);
                courseAverages.put(courseName, courseAverage);
            }
            
            if (course.getAccessMode().equals("考试")) {
                courseAverage.addFinalScore(finalScore);
            } else {
                courseAverage.addCommonScore(commonScore);
            }
        }
        
        // 学生总成绩平均分按学号排序输出
        Collections.sort(studentScores, Comparator.comparing(StudentScore::getStudentId));
        for (StudentScore studentScore : studentScores) {
            String averageScore = studentScore.getAverageScoreString();
            if (averageScore.isEmpty()) {
                System.out.println(studentScore.getStudentId() + " " + studentScore.getStudentName() + " did not take any exams");
            } else {
                System.out.println(studentScore.getStudentId() + " " + studentScore.getStudentName() + " " + averageScore);
            }
        }
        
        // 单门课程平均分按课程名称排序输出
        for (CourseAverage courseAverage : courseAverages.values()) {
            String averageScore = courseAverage.getAverageScoreString();
            if (averageScore.isEmpty()) {
                System.out.println(courseAverage.getCourseName() + " has no grades yet");
            } else {
                System.out.println(courseAverage.getCourseName() + " " + averageScore);
            }
        }
        
        // 班级总成绩平均分按班级号排序输出
        for (Map.Entry<String, Integer> entry : classAverages.entrySet()) {
            String classId = entry.getKey();
            int totalScore = entry.getValue();
            int studentCount = countStudentsInClass(studentScores, classId);
            double averageScore = (double) totalScore / studentCount;
            System.out.println(classId + " " + averageScore);
        }
    }
    
    // 判断课程信息列表中是否包含特定课程名称
    public static boolean courseListContains(List<Course> courseList, String courseName) {
        for (Course course : courseList) {
            if (course.getCourseName().equals(courseName)) {
                return true;
            }
        }
        return false;
    }
    
    // 从课程信息列表中获取特定课程名称的课程对象
    public static Course getCourseFromList(List<Course> courseList, String courseName) {
        for (Course course : courseList) {
            if (course.getCourseName().equals(courseName)) {
                return course;
            }
        }
        return null;
    }
    
    // 计算总成绩
    public static int calculateTotalScore(Course course, int commonScore, int finalScore) {
        double commonWeight = course.getAccessMode().equals("考试") ? 0.7 : 0.3;
        double finalWeight = 1 - commonWeight;
        double totalScore = commonWeight * commonScore + finalWeight * finalScore;
        return (int) Math.round(totalScore);
    }
    
    // 从学生总成绩列表中获取特定学生学号的成绩对象
    public static StudentScore getStudentScoreFromList(List<StudentScore> studentScores, String studentId) {
        for (StudentScore studentScore : studentScores) {
            if (studentScore.getStudentId().equals(studentId)) {
                return studentScore;
            }
        }
        return null;
    }
    
    // 计算班级中学生的数量
    public static int countStudentsInClass(List<StudentScore> studentScores, String classId) {
        int count = 0;
        for (StudentScore studentScore : studentScores) {
            if (studentScore.getStudentId().startsWith(classId)) {
                count++;
            }
        }
        return count;
    }
}

class Course {
    private String courseName;
    private String courseType;
    private String accessMode;
    
    public Course(String courseName, String courseType, String accessMode) {
        this.courseName = courseName;
        this.courseType = courseType;
        this.accessMode = accessMode;
    }
    
    public String getCourseName() {
        return courseName;
    }
    
    public String getCourseType() {
        return courseType;
    }

踩坑心得
1. 空指针异常（NullPointerException）：
  - 心得体会：在使用对象时，确保前提条件并避免将空对象用于调用方法或访问属性。
2. 数组越界异常（ArrayIndexOutOfBoundsException）：
  - 心得体会：在访问数组元素时，确保索引值在合法的范围内，避免超出数组的长度。
3. 类型转换异常（ClassCastException）：
  - 心得体会：在进行类型转换时，应该先使用instanceof关键字进行类型检查，避免错误的类型转换。
改进建议
1. 代码注释：在关键部分和复杂的逻辑处添加注释，解释代码的用途、实现思路和关键步骤。这可以帮助其他开发人员理解和维护代码，并促进团队合作。
2. 代码重构：对于冗长、复杂或难以理解的代码块，进行重构。将其分解为更小的函数或方法，使代码结构清晰、可读性强，并且易于维护。
3. 错误处理：在关键的代码片段添加适当的错误处理机制，例如使用异常处理，以应对潜在的错误情况。这可以增强代码的健壮性和可靠性。代码优化：查找并优化潜在的性能瓶颈和低效的代码段。使用适当的数据结构和算法，避免不必要的循环和重复计算，以提高代码的执行效率。
4. 代码优化：查找并优化潜在的性能瓶颈和低效的代码段。使用适当的数据结构和算法，避免不必要的循环和重复计算，以提高代码的执行效率。

posted @ 2023-06-28 11:02 每天都要酷酷哒阅读(42) 评论(0) 收藏举报

刷新页面返回顶部

gp666666

blog-3

前言

设计与分析

踩坑心得

改进建议

公告