第三次博客作业

前言

这是第三次博客作业，总结了近三次PTA大作业的完成情况，作业7、8次的大作业的小题目围绕着HashMap、ArrayList和自定义接口来展开，大题目则是课程成绩程序的第二次第三次迭代，因为第一次课程成绩的程序写的结构不太好，于是重新写的，第三次迭代并没有拿到满分，后面也没有时间改了。期末考试则是由29个选择题和四个编程题组成。

关于类和整个程序的设计：

类是面向对象编程中的核心概念，通过类可以定义一组数据和与之相关的操作。在设计程序时，通常需要先考虑需要哪些对象和它们的属性和行为，然后将这些信息组织成类的结构。在类的设计中，需要考虑类的名称、属性、方法、访问权限等方面。

除了类的设计，程序的整体设计也非常重要。程序的整体设计涉及到程序的架构、模块划分、代码组织方式、代码风格等方面。程序的整体设计需要遵循一些基本原则，如低耦合、高内聚、模块化等，以确保程序的可维护性、扩展性和可重用性。

在设计程序时，还需要考虑程序的性能、安全性、可靠性等方面。这些方面的考虑需要在程序开发的不同阶段进行，例如在编码阶段需要考虑程序的性能优化，而在测试阶段需要考虑程序的安全性和可靠性。

三次题目集的知识点、题量、难度等情况：

（对于重难点题目将会给出完整题目）

第七次大作业：

容器-HashMap：

HashMap是Java中常用的容器类之一，它实现了Map接口，用于存储键值对。下面是HashMap的用法：

1. 创建HashMap对象：

   HashMap<Key类型, Value类型> hashMap = new HashMap<>();
   

2. 添加元素：

   hashMap.put(key, value);
   

3. 获取元素：

   Value value = hashMap.get(key);
   

4. 删除元素：

   hashMap.remove(key);
   

5. 判断键是否存在：

   boolean containsKey = hashMap.containsKey(key);
   

6. 判断值是否存在：

   boolean containsValue = hashMap.containsValue(value);
   

7. 获取HashMap的大小：

   int size = hashMap.size();
   

8. 遍历HashMap：

   // 遍历键
   for (Key key : hashMap.keySet()) {
       // 根据键获取值
       Value value = hashMap.get(key);
       // 处理值
   }
   
   // 遍历值
   for (Value value : hashMap.values()) {
       // 处理值
   }
   
   // 遍历键值对
   for (Map.Entry<Key, Value> entry : hashMap.entrySet()) {
       Key key = entry.getKey();
       Value value = entry.getValue();
       // 处理键值对
   }
   

需要注意的是，HashMap中的键是唯一的，如果重复添加相同的键，后面的值会替代前面的值；值可以重复。此外，HashMap是无序的，元素的顺序不保证一致。

除了基本的用法，还可以使用其他方法和构造函数来满足不同的需求，例如通过构造函数指定初始容量和负载因子，使用putAll()方法将另一个Map中的元素添加到当前HashMap中，使用isEmpty()方法判断HashMap是否为空等。

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

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

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

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

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

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

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

1、输入：

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

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

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

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

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

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

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

实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩

实验次数至少4次，不超过9次

实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩

以上信息的相关约束：

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）成绩平均分只取整数部分，小数部分丢弃

参考类图（与第一次相同，其余内容自行补充）：

 

第八次大作业：

容器-ArrayList：

ArrayList是Java中常用的动态数组类，它实现了List接口，用于存储一组有序的元素。下面是ArrayList的用法：

1. 创建ArrayList对象：

   ArrayList<ElementType> arrayList = new ArrayList<>();
   

2. 添加元素：

   arrayList.add(element);
   

   元素将会被添加到ArrayList的尾部。

3. 获取元素：

   ElementType element = arrayList.get(index);
   

   使用索引位置来获取ArrayList中指定位置的元素，索引从0开始。

4. 修改元素：

   arrayList.set(index, newElement);
   

   使用索引位置来替换ArrayList中指定位置的元素。

5. 删除元素：

   arrayList.remove(index);
   

   使用索引位置来删除ArrayList中指定位置的元素。

6. 判断元素是否存在：

   boolean containsElement = arrayList.contains(element);
   

   使用contains()方法来判断ArrayList中是否包含指定元素。

7. 获取ArrayList的大小：

   int size = arrayList.size();
   

   使用size()方法来获取ArrayList的大小。

8. 遍历ArrayList：

   for (ElementType element : arrayList) {
       // 处理元素
   }
   

需要注意的是，ArrayList可以存储任意类型的元素，包括基本类型的包装类和自定义类型。ArrayList的容量会根据需要进行自动扩容，以适应元素的添加。

除了上述基本用法，ArrayList还提供了许多其他方法，如addAll()方法可以将另一个集合中的元素添加到当前ArrayList中，使用isEmpty()方法判断ArrayList是否为空，使用clear()方法清空ArrayList中的所有元素等。

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

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

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

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

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

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

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

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

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

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

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

1、输入：

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

课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。

考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重

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

实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重

实验次数至少4次，不超过9次

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

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

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

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

实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝

实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩

以上信息的相关约束：

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

2）学号由8位数字组成

3）姓名不超过10个字符

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

5）不特别输入班级信息，班级号是学号的前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）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

6）如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"

7）如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"

信息约束：

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

期末考试：

（这里只分析编程题）

前三题均为关于正方形、正三棱锥及其魔方的迭代问题：

在魔方问题的基础上，

重构类设计，实现列表内魔方的排序功能（按照魔方的体积进行排序）。

提示：题目中RubikCube类要实现Comparable接口。

其中，Main类源码如下（可直接拷贝使用）：

 

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        
        String color;
        int layer;
        double side;
        RubikCube cube;
        
        ArrayList<RubikCube> list = new ArrayList<>();
        
        int choice = input.nextInt();
        
        while(choice != 0) {
            switch(choice) {
            case 1://SquareCube
                color = input.next();
                layer = input.nextInt();
                side = input.nextDouble();
                cube = new SquareCube(color, layer,new Cube(side)); 
                list.add(cube);
                break;
            case 2://RegularPyramidCube
                color = input.next();
                layer = input.nextInt();
                side = input.nextDouble();
                cube = new RegularPyramidCube(color, layer,new RegularPyramid(side)); 
                list.add(cube);
                break;
            }
            choice = input.nextInt();
        }
        
        list.sort(Comparator.naturalOrder());//正向排序
        
        for(int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i).getColor() + " " + 
        String.format("%.2f", list.get(i).getArea()) + " " + 
        String.format("%.2f", list.get(i).getVolume()) );
            System.out.println("");
        }            
    }    
}

输入格式:

输入魔方类型（1：正方体魔方；2：正三棱锥魔方；0：结束输入）

魔方颜色、魔方阶数、魔方单元正方体、正三棱锥边长

..循环..

输出格式:

按魔方体积升序输出列表中各魔方的信息（实型数均保留两位小数），输出样式参见输出样例。

输入样例:

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

1 blue 3 4.5
2 red 4 2.1
1 yellow 5 2.3
2 black 4 9.42
1 white 4 5.4423
0

输出样例:

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

red 122.21 69.85
yellow 793.50 1520.88
blue 1093.50 2460.38
black 2459.14 6304.73
white 2843.39 10316.38

7-4 销售步枪问题（附加题）

前亚利桑那州境内的一位步枪销售商销售密苏里州制造的步枪机（lock）、枪托（stock）和枪管（barrel）。枪机卖45美元，枪托卖30美元，枪管卖25美元。销售商每月至少要售出一支完整的步枪，且生产限额是销售商在一个月内可销售70个枪机、80个枪托和90个枪管。

根据每个月的销售情况，计算销售商的佣金（提成）算法如下：

• 不到（含）1000美元的部分为10%；

• 1000（含）~1800美元的部分为15%；

• 超过1800美元的部分为20%。

佣金程序生成月份销售报告，汇总销售商的销售总额和佣金。

编程要求：必须符合面向对象编程，且保证类设计的单一职责模式，使用面向过程编程判定0分。

提示：可以设置一个销售订单类。参考类图如下：

输入格式:输入销售商每个月售出枪机、枪托、枪管的数量，可以用空格或者回车分隔。

输出格式:分别输出销售商在该月的销售额和佣金，中间用空格分开。

输入样例1:

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

输出样例1:

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

输入样例2:
在这里给出一组输入。例如：88 56 98

输出样例2:
在这里给出相应的输出。例如：Wrong Format

设计与分析与主要问题和其解决方法

（这里只会提供重点题目的代码）

第七次大作业：

课程成绩2：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.Collator;
import java.util.*;
import java.util.Comparator;
import java.util.Locale;
import java.util.regex.PatternSyntaxException;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.List;
import java.util.ArrayList;


public class Main {
    public static void main(String[] args) {
    try (BufferedReader in = new BufferedReader(new InputStreamReader(System.in))) {
        MessageGetAndPrint messageGetAndPrint = new MessageGetAndPrint();
        messageGetAndPrint.print = new Print();
        
        in.lines().takeWhile(line -> !line.equals("end")).forEach(messageGetAndPrint::getMessage);
        
        messageGetAndPrint.print.personPrint(messageGetAndPrint.students, messageGetAndPrint.courseSelections);
        messageGetAndPrint.print.coursePrint(messageGetAndPrint.courses, messageGetAndPrint.courseSelections);
        messageGetAndPrint.print.classPrint(messageGetAndPrint.classes, messageGetAndPrint.courseSelections);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}
class Class {
    private String classNum;
    HashMap<String , Student> students;
    Class(String classNum) {
        setClassNum(classNum);
    }
    public void setClassNum(String classNum) {
        this.classNum = classNum;
    }
    public String getClassNum() {
        return classNum;
    }
    public void addStudent(Student student) {
        students.put(student.getStudentNum() , student);
    }
}
class Student {
    private String name;
    private String studentNum;
    Student(String name , String studentNum) {
        setName(name);
        setStudentNum(studentNum);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getStudentNum() {
        return studentNum;
    }
    public void setStudentNum(String studentNum) {
        this.studentNum = studentNum;
    }
}
class Course {
    private String className;
    private int classQuality;
    private int assessmentMethodology;
    Course(String className , int classQuality , int assessmentMethodology) {
        setClassName(className);
        setClassQuality(classQuality);
        setAssessmentMethodology(assessmentMethodology);
    }
    public String getClassName() {
        return className;
    }
    public void setClassName(String className) {
        this.className = className;
    }
    public int getClassQuality() {
        return classQuality;
    }
    public void setClassQuality(int classQuality) {
        this.classQuality = classQuality;
    }
    public int getAssessmentMethodology() {
        return assessmentMethodology;
    }
    public void setAssessmentMethodology(int assessmentMethodology) {
        this.assessmentMethodology = assessmentMethodology;
    }
}
class CourseSelection {
    Student student;
    Course course;
    Grade grade;
}
abstract class Grade {
    int allGrade;
    abstract void getAllGrade();
}
class GradeA extends Grade {//考试
    private int finalGrade;
    private int usualGrade;
    GradeA(int finalGrade , int usualGrade) {
        setFinalGrade(finalGrade);
        setUsualGrade(usualGrade);
    }
    public void setFinalGrade(int finalGrade) {
        this.finalGrade = finalGrade;
    }
    public int getFinalGrade() {
        return finalGrade;
    }
    public void setUsualGrade(int usualGrade) {
        this.usualGrade = usualGrade;
    }
    public int getUsualGrade() {
        return usualGrade;
    }
    @Override
    void getAllGrade() {
        allGrade = (int) (finalGrade*0.7+usualGrade*0.3);
    }
}
class GradeB extends Grade {//考察
    private int finalGrade;
    GradeB(int finalGrade) {
        setFinalGrade(finalGrade);
    }
    public void setFinalGrade(int finalGrade) {
        this.finalGrade = finalGrade;
    }
    public int getFinalGrade() {
        return finalGrade;
    }
    @Override
    void getAllGrade() {
        allGrade = finalGrade;
    }
}
class GradeC extends Grade {//实验
    ArrayList<Integer> usualGrades;
    GradeC(ArrayList<Integer> usualGrades) {
        this.usualGrades = usualGrades;
    }
    @Override
    void getAllGrade() {
        allGrade = 0;
        for(int x:usualGrades){
            allGrade+=x;
        }
        allGrade = allGrade/usualGrades.size();
    }
}
class Print {
    public void personPrint(HashMap<String , Student> students, ArrayList<CourseSelection> courseSelections) {
        students.keySet().stream()
                .sorted()
                .forEach(key -> {
                    Student student = students.get(key); // 获取当前学生信息
                    int[] gradeData = courseSelections.stream()
                            .filter(cs -> cs.student.getStudentNum().equals(student.getStudentNum()))
                            .mapToInt(cs -> {
                                cs.grade.getAllGrade(); // 更新成绩状态
                                return cs.grade.allGrade; // 提取当前的总成绩
                            })
                            .toArray();
                    if (gradeData.length == 0) { // 没有成绩数据
                        System.out.println(student.getStudentNum() + " " + student.getName() + " did not take any exams");
                    } else {
                        // 计算平均分并打印
                        int averageGrade = Arrays.stream(gradeData).sum() / gradeData.length;
                        System.out.println(student.getStudentNum() + " " + student.getName() + " " + averageGrade);
                    }
                });
    }
    public void coursePrint(HashMap<String, Course> courses, ArrayList<CourseSelection> courseSelections) {
        courses.keySet().stream()
                .sorted(new SoftName())
                .forEach(key -> {
                    Course course = courses.get(key);
                    // 根据课程筛选相关的选课记录
                    List<CourseSelection> selected = new ArrayList<>();
for (CourseSelection cs : courseSelections) {
    if (cs.course.getClassName().equals(course.getClassName())) {
        selected.add(cs);
    }
}

                    if (selected.isEmpty()) {
                        System.out.println(course.getClassName() + " has no grades yet");
                        return;
                    }
                    // 计算总分和平均分
                    double allGradesSum = 0;
                    double finalGradeSum = 0;
                    double usualGradeSum = 0;
                    int gradesCount = 0;
                    int usualGradesCount = 0;

                    for (CourseSelection cs : selected) {
                        cs.grade.getAllGrade();
                        allGradesSum += cs.grade.allGrade;
                        if (cs.grade instanceof GradeA) {
                            finalGradeSum += ((GradeA) cs.grade).getFinalGrade(); // Final grade for GradeA
                            usualGradeSum += ((GradeA) cs.grade).getUsualGrade(); // Usual grade for GradeA
                            usualGradesCount++;
                        } else if (cs.grade instanceof GradeB) {
                            finalGradeSum += ((GradeB) cs.grade).getFinalGrade(); // Final grade for GradeB
                        }
                        gradesCount++;
                    }
                    double average = gradesCount > 0 ? allGradesSum / gradesCount : 0;
                    double averageFinal = gradesCount > 0 ? finalGradeSum / gradesCount : 0;
                    double averageUsual = usualGradesCount > 0 ? usualGradeSum / usualGradesCount : 0;
                    String output;
                    if (course.getAssessmentMethodology() == 3) {
                        output = String.format("%s %d", course.getClassName(), (int) average);
                    } else if (usualGradesCount == 0) {
                        output = String.format("%s %d %d", course.getClassName(), (int) averageFinal, (int) average);
                    } else {
                        output = String.format("%s %d %d %d", course.getClassName(), (int) averageUsual, (int) averageFinal, (int) average);
                    }
                    System.out.println(output);
                });
    }
    public void classPrint(HashMap<String, Class> classes, ArrayList<CourseSelection> courseSelections) {
        classes.keySet().stream().sorted().forEach(classKey -> {
            Class c = classes.get(classKey);
            double average = courseSelections.stream()
                    .filter(cs -> c.students.containsKey(cs.student.getStudentNum()))
                    .mapToInt(cs -> cs.grade.allGrade)
                    .average()
                    .orElse(-1);  // 使用 -1 来表示没有成绩的情况

            String output = average == -1 ?
                    c.getClassNum() + " has no grades yet" :
                    c.getClassNum() + " " + (int) average;

            System.out.println(output);
        });
    }
    public void wrongFormat() {
        System.out.println("wrong format");
    }
    public void course_not_Exist(String name) {
        System.out.println(name+" does not exist");
    }
    public void course_not_Match(String studentNum , String studentName) {
        System.out.println(studentNum+" "+studentName+" : access mode mismatch");
    }
    public void course_not_Match(String name) {
        System.out.println(name+" : course type & access mode mismatch");
    }
    static class SoftName implements Comparator<String> {
        private static final Comparator<Object> localeComparator = Collator.getInstance(Locale.CHINA);
        @Override
        public int compare(String name1 , String name2) {
            return localeComparator.compare(name1, name2);
        }
    }
}
class MessageGetAndPrint {
    Print print;
    HashMap<String , Class> classes = new HashMap<>();
    HashMap<String , Student> students = new HashMap<>();
    HashMap<String , Course> courses = new HashMap<>();
    ArrayList<CourseSelection> courseSelections = new ArrayList<>();
    public void getMessage(String getInput) {
        String[] input = getInput.split(" ");
        try {
            if (input.length == 2 && input[1].equals("必修")) {
                String courseName = input[0];
                if(!courses.containsKey(courseName)) {
                    int i = 1, j = 1; // 保留原代码中的变量和逻辑
                    Course course = new Course(courseName, i, j);
                    courses.put(courseName, course);
                }
            }
        } catch (PatternSyntaxException e) {
            // 此处可以处理正则表达式的语法错误，但按照题设这里应该没有异常发生，
            // 所以可以忽略。
        }
        if(getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)$")) {
            String[] courseTypes = {"", "必修", "选修", "实验"};
            String[] examTypes = {"", "考试", "考察", "实验"};
            int courseTypeIndex = -1, examTypeIndex = -1;
            for (int k = 1; k <= 3; k++) {
                if (input[1].equals(courseTypes[k])) {
                    courseTypeIndex = k;
                    break;
                }
            }
            for (int k = 1; k <= 3; k++) {
                if (input[2].equals(examTypes[k])) {
                    examTypeIndex = k;
                    break;
                }
            }
            if (courseTypeIndex == -1 || examTypeIndex == -1) {
                // 未知的课程类型或考试类型，抛出异常或者默认值
                print.wrongFormat();
            }
            if (!((courseTypeIndex == 1 && examTypeIndex == 1)  // 必修+考试
                    || (courseTypeIndex == 2 && examTypeIndex == 2)  // 选修+考察
                    || (courseTypeIndex == 3 && examTypeIndex == 3))) {  // 实验+实验
                print.course_not_Match(input[0]);
                return;
            }
            if(courses.containsKey(input[0])) {
                return;
            }
            Course course = new Course(input[0], courseTypeIndex, examTypeIndex);
            courses.put(input[0], course);
            return;
        }

        if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)( )([0-9]|[1-9][0-9]|100)$")) {
            if (courseSelections.stream().anyMatch(cs -> cs.student.getStudentNum().equals(input[0])
                    && cs.student.getName().equals(input[1])
                    && cs.course.getClassName().equals(input[2])))
                return;

            Student student = new Student(input[1], input[0]);
            students.put(input[0], student);

            String classNum = input[0].substring(0, 6);
            classes.computeIfAbsent(classNum, key -> {
                Class aClass = new Class(key);
                aClass.students = new HashMap<>();
                return aClass;
            }).students.put(input[0], student);

            if (!courses.containsKey(input[2])) {
                print.course_not_Exist(input[2]);
                return;
            }

            if (courses.get(input[2]).getAssessmentMethodology() != 1) {
                print.course_not_Match(input[0], input[1]);
                return;
            }

            Course course = courses.get(input[2]);
            CourseSelection courseSelection = new CourseSelection();
            courseSelection.student = student;
            courseSelection.course = course;
            courseSelection.grade = new GradeA(Integer.parseInt(input[4]), Integer.parseInt(input[3]));
            courseSelections.add(courseSelection);
            return;
        }

        if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|10{2})$")) {
            if (courseSelections.stream().anyMatch(cs ->
                    cs.student.getStudentNum().equals(input[0]) &&
                            cs.student.getName().equals(input[1]) &&
                            cs.course.getClassName().equals(input[2])))
                return;

            Student student = new Student(input[1], input[0]);
            students.put(input[0], student);

            String classNum = input[0].substring(0, 6);
            classes.computeIfAbsent(classNum, key -> {
                Class aClass = new Class(key);
                aClass.students = new HashMap<>();
                return aClass;
            }).addStudent(student);

            if (!courses.containsKey(input[2])) {
                print.course_not_Exist(input[2]);
                return;
            }

            if (courses.get(input[2]).getAssessmentMethodology() != 2) {
                print.course_not_Match(input[0], input[1]);
                return;
            }

            Course course = courses.get(input[2]);
            CourseSelection courseSelection = new CourseSelection();
            courseSelection.student = student;
            courseSelection.course = course;
            int finalGrade = Integer.parseInt(input[3]);
            courseSelection.grade = new GradeB(finalGrade);
            courseSelections.add(courseSelection);
            return;
        }
        if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([4-9])( )((([0-9]|[1-9][0-9]|100)( ))+)([0-9]|[1-9][0-9]|100)$")) {
            boolean selectionExists = courseSelections.stream().anyMatch(courseSelection ->
                    courseSelection.student.getStudentNum().equals(input[0]) &&
                            courseSelection.student.getName().equals(input[1]) &&
                            courseSelection.course.getClassName().equals(input[2])
            );
            if (selectionExists) {
                return;
            }

            Student student = students.computeIfAbsent(input[0], num -> new Student(input[1], num));
            String classNum = input[0].substring(0, 6);
            Class aClass = classes.computeIfAbsent(classNum, num -> {
                Class newClass = new Class(num);
                newClass.students = new HashMap<>();
                return newClass;
            });
            aClass.addStudent(student);

            Course course = courses.get(input[2]);
            if (course == null) {
                print.course_not_Exist(input[2]);
                return;
            }

            if (course.getAssessmentMethodology() != 3) {
                print.course_not_Match(input[0], input[1]);
                return;
            }

            int usualNum = Integer.parseInt(input[3]);
            if (input.length - 4 != usualNum) {
                print.course_not_Match(input[0], input[1]);
                return;
            }
            CourseSelection courseSelection = new CourseSelection();
            courseSelection.student = student;
            courseSelection.course = courses.get(input[2]);

            ArrayList<Integer> usualGrades = IntStream.rangeClosed(1, usualNum)
                    .mapToObj(t -> Integer.parseInt(input[3 + t]))
                    .collect(Collectors.toCollection(ArrayList::new));

            courseSelection.grade = new GradeC(usualGrades);
            courseSelections.add(courseSelection);
            return;
        }
        print.wrongFormat();
    }
}

类图如下：

 

 设计思路：

1. 创建必要的类（Course、Grade、Student、Class）来表示课程和成绩相关的信息，定义合适的属性和方法。

2. 解析输入的课程信息和成绩信息：

   • 通过字符串分割和正则表达式等方式，将输入的信息解析为课程名称、课程性质、考核方式等课程信息。
   • 根据课程性质和考核方式，判断成绩信息应该属于哪种类型（考试、考察、实验）的成绩。
   • 将成绩信息解析为学号、姓名、课程名称、平时成绩、期末成绩等成绩信息。

3. 根据课程信息和成绩信息的约束，进行合法性检查：

   • 检查课程信息中的课程性质和考核方式是否匹配。
   • 检查成绩是否超出范围，例如平时成绩和期末成绩的取值范围是[0,100]。
   • 检查学号、姓名等信息的合法性。

4. 根据解析的数据构建对象并进行数据处理：

   • 创建Course对象，将课程信息存储到HashMap或ArrayList中，用于后续处理和输出。
   • 创建Grade对象，将成绩信息存储到HashMap或ArrayList中，用于后续处理和输出。
   • 创建Student对象，根据成绩信息计算总成绩平均分并存储到学生对象中。
   • 创建Class对象，根据学生信息计算班级总成绩平均分并存储到班级对象中。

5. 处理数据并输出结果：

   • 遍历学生列表，按学号排序，并输出每个学生的学号、姓名、总成绩平均分。
   • 遍历课程列表，按课程名称排序，并输出每门课程的平时成绩平均分、期末考试平均分、总成绩平均分。
   • 遍历班级列表，按班级号排序，并输出每个班级的班级号、总成绩平均分。

6. 处理异常情况：

   • 如果遇到格式错误、数据不合法或者其他异常情况，输出相应的错误提示信息。

第八次大作业：

课程成绩3：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.concurrent.atomic.AtomicReference;


public class Main {
    public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    MessageGetAndPrint messageGetAndPrint = new MessageGetAndPrint();
    messageGetAndPrint.print = new Print();
    
    while (true) {
        String message = in.readLine();
        if ("end".equals(message)) {
            messageGetAndPrint.print.personPrint(messageGetAndPrint.students, messageGetAndPrint.courseSelections);
            messageGetAndPrint.print.coursePrint(messageGetAndPrint.courses, messageGetAndPrint.courseSelections);
            messageGetAndPrint.print.classPrint(messageGetAndPrint.classes, messageGetAndPrint.courseSelections);
            break;
        }
        messageGetAndPrint.getMessage(message);
    }
}
}
class Class {
    private String classNum;
    HashMap<String , Student> students;
    Class(String classNum) {
        setClassNum(classNum);
    }
    public void setClassNum(String classNum) {
        this.classNum = classNum;
    }
    public String getClassNum() {
        return classNum;
    }
    public void addStudent(Student student) {
        students.put(student.getStudentNum() , student);
    }
}
class Student {
    private String name;
    private String studentNum;
    Student(String name , String studentNum) {
        setName(name);
        setStudentNum(studentNum);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getStudentNum() {
        return studentNum;
    }
    public void setStudentNum(String studentNum) {
        this.studentNum = studentNum;
    }
}
class Course {
    private String className;
    private int classQuality;
    private int assessmentMethodology;
    ArrayList<Float> weightFunction = new ArrayList<>();
    Course(String className , int classQuality , int assessmentMethodology) {
        setClassName(className);
        setClassQuality(classQuality);
        setAssessmentMethodology(assessmentMethodology);
    }
    public String getClassName() {
        return className;
    }
    public void setClassName(String className) {
        this.className = className;
    }
    public int getClassQuality() {
        return classQuality;
    }
    public void setClassQuality(int classQuality) {
        this.classQuality = classQuality;
    }
    public int getAssessmentMethodology() {
        return assessmentMethodology;
    }
    public void setAssessmentMethodology(int assessmentMethodology) {
        this.assessmentMethodology = assessmentMethodology;
    }
}
class CourseSelection {
    Student student;
    Course course;
    Grade grade;
}

class Grade {
    SubItemGrades subItemGrades = new SubItemGrades();
    public int getGrade() {
        AtomicReference<Float> allGrades = new AtomicReference<>(0.0f);
        IntStream.range(0, subItemGrades.subItem.size()).forEach(i -> allGrades.updateAndGet(v -> v + subItemGrades.subItem.get(i) * subItemGrades.grades.get(i)));
        return allGrades.get().intValue();
    }
}
class SubItemGrades {
    ArrayList<Integer> grades = new ArrayList<>();
    ArrayList<Float> subItem = new ArrayList<>();
}
class Print {
    public void personPrint(HashMap<String, Student> students, ArrayList<CourseSelection> courseSelections) {
        Map<String, List<CourseSelection>> courseSelectionsByStudent = courseSelections.stream()
                .collect(Collectors.groupingBy(cs -> cs.student.getStudentNum()));

        List<String> sortedStudentKeys = new ArrayList<>(students.keySet());
        Collections.sort(sortedStudentKeys);

        sortedStudentKeys.forEach(key -> {
            StringBuilder output = new StringBuilder(students.get(key).getStudentNum() + " " + students.get(key).getName());
            List<CourseSelection> studentCourseSelections = courseSelectionsByStudent.get(key);

            if (studentCourseSelections == null || studentCourseSelections.isEmpty()) {
                output.append(" did not take any exams");
            } else {
                int averageGrade = studentCourseSelections.stream()
                        .mapToInt(cs -> cs.grade.getGrade())
                        .sum() / studentCourseSelections.size();
                output.append(" ").append(averageGrade);
            }

            System.out.println(output);
        });
    }
    public void coursePrint(HashMap<String, Course> courses, ArrayList<CourseSelection> courseSelections) {
        Map<String, List<CourseSelection>> courseGrades = courseSelections.stream()
                .collect(Collectors.groupingBy(cs -> cs.course.getClassName()));

        courses.values().stream()
                .sorted(Comparator.comparing(Course::getClassName))
                .map(Course::getClassName)
                .forEach(key -> {
                    List<CourseSelection> gradeList = courseGrades.computeIfAbsent(key, k -> new ArrayList<>());
                    int averageGrade;

                    if (!gradeList.isEmpty()) {
                        averageGrade = gradeList.stream()
                                .mapToInt(cs -> cs.grade.getGrade())
                                .sum() / gradeList.size();
                        System.out.printf("%s %d%n", key, averageGrade);
                    } else {
                        System.out.printf("%s has no grades yet%n", key);
                    }
                });
    }
    public void classPrint(HashMap<String, Class> classes, ArrayList<CourseSelection> courseSelections) {
        Map<String, List<CourseSelection>> classGrades = courseSelections.stream()
                .filter(cs -> classes.values().stream()
                        .anyMatch(c -> c.students.containsKey(cs.student.getStudentNum())))
                .collect(Collectors.groupingBy(cs -> classes.values().stream()
                        .filter(c -> c.students.containsKey(cs.student.getStudentNum()))
                        .findFirst().get().getClassNum()));

        classes.values().stream()
                .sorted(Comparator.comparing(Class::getClassNum))
                .map(Class::getClassNum)
                .forEach(key -> {
                    List<CourseSelection> gradeList = classGrades.computeIfAbsent(key, k -> new ArrayList<>());
                    int averageGrade;

                    if (!gradeList.isEmpty()) {
                        averageGrade = gradeList.stream()
                                .mapToInt(cs -> cs.grade.getGrade())
                                .sum() / gradeList.size();
                        System.out.printf("%s %d%n", key, averageGrade);
                    } else {
                        System.out.printf("%s has no grades yet%n", key);
                    }
                });
    }
    public void wrongFormat() {
        System.out.println("wrong format");
    }
    public void courseExist(String name) {
        System.out.println(name+" does not exist");
    }
    public void courseMatch(String studentNum , String studentName) {
        System.out.println(studentNum+" "+studentName+" : access mode mismatch");
    }
    public void courseMatch(String name) {
        System.out.println(name+" : course type & access mode mismatch");
    }
    public void numMatch(String name) {
        System.out.println(name+" : number of scores does not match");
    }
    public void weightValue(String name) {
        System.out.println(name+" : weight value error");
    }
}
class MessageGetAndPrint {
    Print print;
    HashMap<String , Class> classes = new HashMap<>();
    HashMap<String , Student> students = new HashMap<>();
    HashMap<String , Course> courses = new HashMap<>();
    ArrayList<CourseSelection> courseSelections = new ArrayList<>();
    public void getMessage(String getInput) {
        String[] message = getInput.split(" ");
        if(getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)$") ||
                getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )((0.(0)+[1-9]|0.[1-9][0-9]*)( )(0.(0)+[1-9]|0.[1-9][0-9]*)$)") ||
                getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )([4-9])((( )(0.(0)+[1-9]|0.[1-9][0-9]*|1))*)(( )(0.(0)+[1-9]|0.[1-9][0-9]*))$")
        ) {
            int i=0,j=0;
            if (!courses.containsKey(message[0])) {
                switch (message[1]) {
                    case "必修" : i = 1;
                    case "选修" : i = 2;
                    case "实验" : i = 3;
                }
                switch (message[2]) {
                    case "考试":   j = 1;  break;
                    case "考察":   j = 2;  break;
                    case "实验":   j = 3;  break;
                }

                boolean mismatch = (i == 1 && j != 1) || (i == 3 && j != 3) || (i != 3 && j == 3);
                boolean invalidLength = (j == 1 && message.length != 5) ||
                        (j == 2 && message.length != 3) ||
                        (j == 3 && message.length - 4 != Integer.parseInt(message[3]));

                if (mismatch) {
                    print.courseMatch(message[0]);
                } else if (invalidLength) {
                    print.numMatch(message[0]);
                } else {
                    Course course = new Course(message[0], i, j);
                    float sumWeight = 0;

                    if (j == 1 || j == 3) {
                        for (int k = 0; k < (j == 1 ? 2 : Integer.parseInt(message[3])); k++) {
                            float weight = Float.parseFloat(message[4 + k]);
                            sumWeight += weight;
                            course.weightFunction.add(weight);
                        }
                    } else {
                        course.weightFunction.add(1F);
                        sumWeight = 1;
                    }

                    if (Math.abs(sumWeight - 1) > 0.001) {
                        print.weightValue(message[0]);
                    } else {
                        courses.put(message[0], course);
                    }
                }
            }
        }
        else if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)$") ||
                getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)( )([0-9]|[1-9][0-9]|100)$") ||
                getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )((([0-9]|[1-9][0-9]|100)( ))*)([0-9]|[1-9][0-9]|100)$")
        ) {
            boolean courseSelectionExists = courseSelections.stream()
                    .anyMatch(courseSelection -> courseSelection.student.getStudentNum().equals(message[0])
                            && courseSelection.student.getName().equals(message[1])
                            && courseSelection.course.getClassName().equals(message[2]));

            if (courseSelectionExists) {
                return;
            }

            Student student = new Student(message[1], message[0]);
            students.put(message[0] , student);

            String classNum = message[0].substring(0 , 6);

            if (!classes.containsKey(classNum)) {
                Class aClass = new Class(classNum);
                aClass.students = new HashMap<>();
                classes.put(classNum , aClass);
            }

            classes.get(classNum).addStudent(student);

            if (!(courses.containsKey(message[2]))) {
                print.courseExist(message[2]);
            } else {
                if (message.length - 3 != courses.get(message[2]).weightFunction.size()) {
                    print.courseMatch(message[0], message[1]);
                    return;
                }

                CourseSelection courseSelection = new CourseSelection();
                courseSelection.student = student;
                courseSelection.course = courses.get(message[2]);

                Grade grade = new Grade();
                IntStream.range(0, message.length - 3)
                        .forEach(i -> grade.subItemGrades.grades.add(Integer.parseInt(message[3 + i])));

                grade.subItemGrades.subItem = courses.get(message[2]).weightFunction;
                courseSelection.grade = grade;

                courseSelections.add(courseSelection);
            }
        }
        else
            print.wrongFormat();
    }
}

类图如下：

 我并没有通过所有的测试点，以下测试点并没有通过：

题目的分析如下：

这道题目要求修改成绩类的继承关系为组合关系，使用组合关系将课程成绩类和分项成绩类组合起来。还新增了分项成绩的权重属性，并根据权重计算每个分项成绩的总成绩。

首先，需修改类结构如下：

1. 定义一个"Course"类，包含课程名称、课程性质、考核方式和分项成绩数量等属性，并提供相应的构造方法和访问方法。

2. 定义一个"GradeComponent"类，包含分项成绩的分值和权重属性，并提供相应的构造方法和访问方法。

3. 定义一个"CourseGrade"类，包含该门课程的所有分项成绩和所属的课程对象，通过组合关系与"Course"和"GradeComponent"类建立关联。

4. 定义一个"Grade"类，包含学号、姓名、成绩列表（包含"CourseGrade"对象）等属性，并提供相应的构造方法和访问方法。

5. 定义一个"Student"类，包含学号、姓名、成绩列表（包含"CourseGrade"对象）等属性，并提供添加成绩、计算总成绩平均分等方法。

6. 定义一个"Class"类，包含班级号、学生列表等属性，并提供按学号排序、计算班级总成绩平均分等方法。

其次，修改计算总成绩的方式：

1. 考试课总成绩的计算方法不变，仍然为将平时成绩乘以平时成绩的权重再加上期末成绩乘以期末成绩的权重。

2. 实验课总成绩的计算方法变为将每个实验成绩乘以实验成绩的权重，并累加所有分项成绩的总和。

期末考试：

 7-3 魔方排序问题

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Comparator;
import java.math.BigDecimal;
import java.math.RoundingMode;

abstract class RubikCube implements Comparable<RubikCube>{
    protected String Color;
    protected int layer;
    Solid solid;
    @Override
    public int compareTo(RubikCube other) {
        return this.getVolume().compareTo(other.getVolume());
    }
    public RubikCube() {
    }
    public RubikCube(String Color,int layer,Solid solid){
        this.Color = Color;
        this.layer = layer;
        this.solid = solid;
    }

    public void setColor(String color) {
        Color = color;
    }

    public String getColor() {
        return Color;
    }

    public void setLayer(int layer) {
        this.layer = layer;
    }

    public int getLayer() {
        return layer;
    }

    public void setSolid(Solid solid) {
        this.solid = solid;
    }

    public Solid getSolid() {
        return solid;
    }
    public abstract double getArea();
    public abstract BigDecimal getVolume();

}

class SquareCube extends RubikCube {

    public SquareCube(String color, int layer, Solid solid) {
        super(color, layer, solid);
    }

    @Override
    public double getArea() {
        double unitArea = solid.getArea();
        return unitArea *  Math.pow(getLayer(), 2);  // Total surface area
    }

    @Override
    public BigDecimal getVolume() {
        double unitVolume = solid.getVolume();
        BigDecimal value = new BigDecimal(unitVolume * Math.pow(getLayer(), 3));
        BigDecimal rounded = value.setScale(2, RoundingMode.HALF_UP);
        return rounded;  // Total volume
    }
}

class RegularPyramidCube extends RubikCube {

    public RegularPyramidCube(String color, int layer, Solid solid) {
        super(color, layer, solid);
    }

    @Override
    public double getArea() {
        double unitArea = solid.getArea();
        return unitArea *  getLayer() * getLayer();
    }

    @Override
    public BigDecimal getVolume() {
        double unitVolume = solid.getVolume();
        return BigDecimal.valueOf(unitVolume * getLayer() * getLayer()*getLayer());
    }
}
abstract class Solid {
    protected double side;
    public Solid(){
    }

    public void setSide(double side) {
        this.side = side;
    }

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

    public abstract double getArea();

    public abstract double getVolume();
}

class Cube extends Solid {
    public Cube(){
    }
    public Cube(double side) {
        super(side);
    }

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

    @Override
    public double getVolume() {
        return side * side * side;
    }
}

class RegularPyramid extends Solid {
    public RegularPyramid(double side) {
        super(side);
    }

    public RegularPyramid(){
    }
    private double getHeight() {
        return Math.sqrt(side * side - (side / 2) * (side / 2));
    }
    @Override
    public double getArea() {
        return (0.5 * side * side * Math.sin(Math.PI / 3) + (3 * side * getHeight() / 2));
    }

    @Override
    public double getVolume() {
        return (Math.pow(side, 3) * Math.sqrt(2)) / 12;
    }
}

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);

        String color;
        int layer;
        double side;
        RubikCube cube;

        ArrayList<RubikCube> list = new ArrayList<>();

        int choice = input.nextInt();

        while(choice != 0) {
            switch(choice) {
                case 1://SquareCube
                    color = input.next();
                    layer = input.nextInt();
                    side = input.nextDouble();
                    cube = new SquareCube(color, layer,new Cube(side));
                    list.add(cube);
                    break;
                case 2://RegularPyramidCube
                    color = input.next();
                    layer = input.nextInt();
                    side = input.nextDouble();
                    cube = new RegularPyramidCube(color, layer,new RegularPyramid(side));
                    list.add(cube);
                    break;
            }
            choice = input.nextInt();
        }

        list.sort(Comparator.naturalOrder());//正向排序

        for(int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i).getColor() + " " +
                    String.format("%.2f", list.get(i).getArea()) + " " +
                    String.format("%.2f", list.get(i).getVolume()) );
            System.out.println("");
        }
    }
}

这题我并没有拿到满分，后来与同学交流发现可能是因为数据用的double类型，如果将所有的数据类型改变为BigDecimal，就能过了测试点。

​ Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。

​ BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

7-4 销售步枪问题（附加题）

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int lockQuantity = in.nextInt();
        int stockQuantity = in.nextInt();
        int barrelQuantity = in.nextInt();

        try {
            SalesOrder order = new SalesOrder(lockQuantity, stockQuantity, barrelQuantity);
            System.out.printf("%.2f %.2f\n", order.calculateTotalSales(), order.calculateCommission());
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}
class Barrel {
    static  double UNIT_PRICE = 25;
    public Barrel(){
    }
    public Barrel(double UNIT_PRICE){
        this.UNIT_PRICE = UNIT_PRICE;
    }

    public static double getUnitPrice() {
        return UNIT_PRICE;
    }

    public static void setUnitPrice(double unitPrice) {
        UNIT_PRICE = unitPrice;
    }

    static boolean checkOrder(int quantity) {
        return quantity >= 0 && quantity <= 90;
    }

    static double calculatePrice(int quantity) {
        return quantity * UNIT_PRICE;
    }
}

class Stock {
    static  double UNIT_PRICE = 30;
    public static double getUnitPrice() {
        return UNIT_PRICE;
    }

    public Stock(){
    }
    public Stock(double UNIT_PRICE){
        this.UNIT_PRICE = UNIT_PRICE;
    }
    public static void setUnitPrice(double unitPrice) {
        UNIT_PRICE = unitPrice;
    }

    static boolean checkOrder(int quantity) {
        return quantity >= 0 && quantity <= 80;
    }

    static double calculatePrice(int quantity) {
        return quantity * UNIT_PRICE;
    }
}


class Lock {
    static  double UNIT_PRICE = 45;

    public static double getUnitPrice() {
        return UNIT_PRICE;
    }

    public Lock(){
    }
    public Lock(double UNIT_PRICE){
        this.UNIT_PRICE = UNIT_PRICE;
    }
    public static void setUnitPrice(double unitPrice) {
        UNIT_PRICE = unitPrice;
    }
    static boolean checkOrder(int quantity) {
        return quantity >= 0 && quantity <= 70;
    }

    static double calculatePrice(int quantity) {
        return quantity * UNIT_PRICE;
    }
}


class SalesOrder {

    int lockQuantity, stockQuantity, barrelQuantity;

    SalesOrder(int lockQuantity, int stockQuantity, int barrelQuantity) {
        if (!Lock.checkOrder(lockQuantity) || !Stock.checkOrder(stockQuantity) || !Barrel.checkOrder(barrelQuantity)) {
            throw new IllegalArgumentException("Wrong Format");
        }
        this.lockQuantity = lockQuantity;
        this.stockQuantity = stockQuantity;
        this.barrelQuantity = barrelQuantity;
    }

    double calculateTotalSales() {
        return Lock.calculatePrice(lockQuantity) + Stock.calculatePrice(stockQuantity) + Barrel.calculatePrice(barrelQuantity);
    }

    double calculateCommission() {
        double totalSales = calculateTotalSales();
        if (totalSales <= 1000) {
            return totalSales * 0.1;
        } else if (totalSales <= 1800) {
            return 1000 * 0.1 + (totalSales - 1000) * 0.15;
        } else {
            return 1000 * 0.1 + 800 * 0.15 + (totalSales - 1800) * 0.2;
        }
    }
}

这题我也没拿得到满分差了1分，后来结束之后多看了下，发现是枪机的数量范围不应该是0-70而应该是1-70。

 这题的结构照着给出的类图写就好了。

总结

Java大作业终于结束了啊啊啊！不用每个星期都受折磨了TAT。虽然学习Java的过程非常痛苦，但是也学到了很多。其实关于Java还有很多内容没有学习，越学越发现Java真的是一个很好的开发工具，有很多库函数和各种辅助的类。但是我本身感觉只学习到了一点面向对象设计程序的思想，还需要继续努力理解掌握学到的知识和探索学习新的知识。