526互联

第三次博客作业

发布时间 2023-12-09 20:34:58作者: Nammm

前言

经过一个学期的学习，终于结束了面向对象程序设计这门课程。这次博客主要总结一下最后的几次pta作业以及期末考试。

第七次大作业：这次的大作业题目一共有四道题，题量并不算大，主要的知识点一个是HashMap的运用，另一个就是课程统计程序的迭代。HashMap相对于课程统计程序来说不是特别难，但是课程统计程序的迭代难度相较于上一次难度就直线上升。

第八次大作业：这次作业的核心也是课程统计程序的迭代，其他的一对比就显得容易许多。

期末考试：期末考试的题目难度较小，主要还是涉及到多态和继承的关系，但是在小题目上我的失分比较多，说明我对一些概念理解的还不是很透彻。

设计与分析

第七次大作业

7-1 容器-HashMap-检索
分数 10
作者 蔡轲
单位 南昌航空大学

输入多个学生的成绩信息，包括：学号、姓名、成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

使用HashMap存储学生信息，并实现根据学号的检索功能

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

以“end”为输入结束标志

end之后输入某个学号，执行程序输出该生的详细信息

输出格式:

输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩

如果没有查询到，则输出："The student "+查询的学号+" does not exist"

代码如下：

import java.util.HashMap;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        HashMap<String,String > student=new HashMap<>();
        while(true){
            String mess1=input.nextLine();
            if(mess1.equals("end")){
                break;
            }
            String[] mess2=mess1.split(" ");
            student.put(mess2[0],mess2[1]+" "+mess2[2]);

        }
        String SearchID=input.nextLine();
        String Searchresult=student.get(SearchID);
        if(Searchresult==null){
            System.out.println("The student "+SearchID+" does not exist");
        }else{
            System.out.println(SearchID+" "+Searchresult);
        }

    }
}

这道题目比较简单，只要掌握了HashMap的基本使用方法就基本不会出错，在这里就不做过多的阐述。

7-3 课程成绩统计程序-2
分数 60
作者 蔡轲
单位 南昌航空大学

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

代码如下：

import java.text.Collator;
import java.util.Comparator;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Collections;

public class Main{
    public static void main(String[] args){
        Scanner s=new Scanner(System.in);
        String s_record=s.nextLine();
        ParseInput handle=new ParseInput();
        while(!s_record.equals("end")){
            handle.parseInput(s_record);
            s_record=s.nextLine();
        }
        handle.showStudents();
        handle.showCourses();
        handle.showClasses();
    }
}
class Cls implements Comparable<Cls>{
    String Id;
    ArrayList<Student> listStudent=new ArrayList<>();

    public ArrayList<Student> getListStudent() {
        return listStudent;
    }

    public String getId() {
        return Id;
    }
    void addStudent(Student stu){
        listStudent.add(stu);
    }

    public void setId(String Id) {
        this.Id = Id;
    }
    public Cls(String Id){
        this.Id=Id;
    }
    @Override
    public int compareTo(Cls o){
        return Id.compareTo(o.getId());
    }
}
class Student implements Comparable<Student>{
    String Id;
    Cls cls;
    String name;

    public Student(String name,String Id){
        this.name=name;
        this.Id=Id;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Cls getCls() {
        return cls;
    }

    public void setCls(Cls cls) {
        this.cls = cls;
    }

    public String getId() {
        return Id;
    }

    public void setId(String Id) {
        this.Id = Id;
    }
    @Override
    public int compareTo(Student o){
        return getId().compareTo(o.getId());
    }
}
class ParseInput{
    ArrayList<Course> listCourse=new ArrayList<>();
    ArrayList<Student> listStudent=new ArrayList<>();
    ArrayList<ChooseCourse> listChooseCourse=new ArrayList<>();
    ArrayList<Cls> listCls=new ArrayList<>();
    public void parseInput(String s){
        int i=InputMatching.matchingInput(s);
        String[] items=s.split(" ");
        if(i == 0){
        System.out.println("wrong format");
        return;
        } else if(i == 1){
        parseCourseRecord(items);
        return;
        } else if(i == 2){
        parseScoreRecord(items);
        return;
        }
    }
    Course getCourse(String courseName){
        for (int i=0;i<listCourse.size();i++)
        {
            if(listCourse.get(i).getName().equals(courseName))
                return listCourse.get(i);
        }
        return null;
    }
    Cls getCls(String clsId){
        for(int i=0;i<listCls.size();i++){
            if(listCls.get(i).getId().equals(clsId))
                return listCls.get(i);
        }
        return null;
    }
    Student getStudent(String stuId){
        for(int i=0;i<listStudent.size();i++)
        {
            if(listStudent.get(i).getId().equals(stuId))
            {
                return listStudent.get(i);
            }

        }
        return null;
    }
    private void parseCourseRecord(String[] items){
        String courseName=items[0];
        String courseType=items[1];
        String checkType=items[2];
        Course course=new Course(courseName,courseType,checkType);
        if(!checkCourse(course))
            return;
        if(getCourse(courseName)==null){
            course=new Course(courseName,courseType,checkType);
            listCourse.add(course);
        }
    }
    boolean checkCourse(Course course){
        int courseTp,accessTp;
        if(course.getType().equals("必修")){
        courseTp = 0;
        } else if(course.getType().equals("选修")){
        courseTp = 1;
        } else {
        courseTp = -1;
        }
        
        if(course.getMethod().equals("考试")){
        accessTp = 0;
        } else if(course.getMethod().equals("考察")){
        accessTp = 1;
        } else {
        accessTp = -1;
        }
        if(courseTp==0&&(accessTp==0))
            return true;
        if(courseTp==1&&(accessTp==0||accessTp==1))
            return true;
        System.out.println(course.getName()+" : course type & access mode mismatch");
        return false;
    }
    private void parseScoreRecord(String[] items){
        String stuId=items[0];
        String stuName=items[1];
        String courseName=items[2];
        String clsId=stuId.substring(0,6);
        Cls cls;
        Student stu;
        cls=getCls(clsId);
        if(cls==null){
            cls=new Cls(clsId);
            listCls.add(cls);
        }
        stu=getStudent(stuId);
        if(stu==null){
            stu=new Student(stuName,stuId);
            listStudent.add(stu);
            cls.addStudent(stu);
        }
        stu.setCls(cls);
        Course course=getCourse(courseName);
        if(course==null){
            System.out.println(courseName+" does not exist");
            return;
        }
        if(!checkGrade(items,course))
            return;
        Grade grade;
        if(items.length==4){
            int finalScore=Integer.parseInt(items[3]);
            grade=new AssessmentGrade(finalScore);
        }else {
            int usualScore=Integer.parseInt(items[3]);
            int finalScore=Integer.parseInt(items[4]);
            grade=new ExaminationGrade(usualScore,finalScore);
        }
        if(existChooseCourse(stu,course)) return;
        ChooseCourse chooseCourse=new ChooseCourse(course,stu,grade);
        listChooseCourse.add(chooseCourse);
    }
    boolean existChooseCourse(Student stu,Course course){
        for(int i=0;i<listChooseCourse.size();i++){
            if(listChooseCourse.get(i).getCourse().getName().equals(course.getName())) {
                if (listChooseCourse.get(i).getStudent().getName().equals(stu.getName()))
                    return true;
            }
        }
        return false;
    }
    private boolean checkGrade(String[] items,Course course){
        String courseType=course.getMethod();
        if(courseType.equals("考试")&&items.length==5){
            return true;
        }
        if(courseType.equals("考察")&&items.length==4){
            return true;
        }
        System.out.println(items[0]+" "+items[1]+" : access mode mismatch");

        return false;
    }
    public void showStudents(){
        Collections.sort(listStudent);
        for(int i =0;i<listStudent.size();i++)
        {
            Student stu=listStudent.get(i);
            ArrayList<ChooseCourse> stuCourseSelects =getStudentSelects(stu.getId());
            if(stuCourseSelects.size()!=0)
            {
                System.out.println(stu.getId() + " "+ stu.getName()+" "+getAvgTotalScore(stuCourseSelects));
            }
            else
            {
                System.out.println(stu.getId() +" "+ stu.getName()+" did not take any exams");
            }
        }
    }
    public void showCourses(){
        Collections.sort(listCourse);
        for(int i =0;i<listCourse.size();i++)
        {
            Course course = listCourse.get(i);
            ArrayList<ChooseCourse> courseSelects = getCourseSelects(course.getName());
            if(courseSelects.size()== 0)
            {
                System.out.println(course.getName() + " has no grades yet");
            }
            else {
                if(course.getMethod().equals("考试"))
                {
                    System.out.println(course.getName() + " " +getAvgUsualScore(courseSelects)+ " "+getAvgFinalScore(courseSelects)+ " "+getAvgTotalScore(courseSelects));
                }else{
                    System.out.println(course.getName() + " "+getAvgFinalScore(courseSelects)+ " "+getAvgTotalScore(courseSelects));
                }
            }
        }
    }
    public void showClasses(){
        Collections.sort(listCls);
        for(int i =0;i<listCls.size();i++)
        {
            Cls cls = listCls.get(i);
            ArrayList<ChooseCourse> classCourseSelects = getClassSelects(cls.getId());
            if(classCourseSelects.size()==0){
                System.out.println(cls.getId()+" has no grades yet");
            }
            else{
                System.out.println(cls.getId()+" "+ getAvgTotalScore(classCourseSelects));
            }
        }
    }
    public static int getAvgUsualScore(ArrayList<ChooseCourse> courseSelects)
    {
        int sum = 0;
        for(ChooseCourse cs : courseSelects)
        {
            sum +=((ExaminationGrade) cs.grade).getUsualScore();
        }
        return sum/courseSelects.size();
    }
    public int getAvgTotalScore(ArrayList<ChooseCourse> listChooseCourse)
    {
        int sum =0;
        for(ChooseCourse cs : listChooseCourse)
        {
            sum +=cs.grade.getTotalScore();
        }
        return sum/listChooseCourse.size();
    }
    public int getAvgFinalScore(ArrayList<ChooseCourse> courseSelects)
    {
        int sum =0;
        for(ChooseCourse cs : courseSelects)
        {
            sum +=cs.grade.getFinalScore();
        }
        return sum/courseSelects.size();
    }
    public ArrayList<ChooseCourse> getClassSelects(String className){
        Cls cls=getCls(className);
        ArrayList<ChooseCourse> classSelects = new ArrayList<>();
        for (ChooseCourse cs : listChooseCourse) {
            if (className.equals(cs.getStudent().cls.getId())){
                classSelects.add(cs);
            }
        }
        return classSelects;
    }
    public ArrayList<ChooseCourse> getStudentSelects(String stuId) {
        ArrayList<ChooseCourse> stuSelects = new ArrayList<>();
        for (ChooseCourse cs : listChooseCourse) {
            if (stuId.equals(cs.student.getId())){
                stuSelects.add(cs);
            }
        }
        return stuSelects;
    }
    public ArrayList<ChooseCourse> getCourseSelects(String courseName){
        ArrayList<ChooseCourse> courseSelect=new ArrayList<>();
        for (ChooseCourse cs : listChooseCourse) {
            if (courseName.equals(cs.course.getName())){
                courseSelect.add(cs);
            }
        }
        return courseSelect;
    }

}
class ChooseCourse{
    Course course;
    Student student;
    Grade grade;

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

    public Grade getGrade() {
        return grade;
    }

    public Student getStudent() {
        return student;
    }

    public Course getCourse() {
        return course;
    }
}
class InputMatching {
    static String stuNumMatching = "\\d{8}";
    static String stuNameMatching = "[^ \\t]{1,10}";
    static String scoreMatching = "([1-9]?[0-9]|100)";
    static String courseNameMatching = "[^ \\t]{1,10}";
    static String courseTypeMatching = "(选修|必修)";
    static String checkcourseTypeMatching = "(考试|考察)";
    static String scoreMatching1 = "(\\s([1-9]?[0-9]|100))?";
    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
    static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching + scoreMatching1;
    public static int matchingInput(String s) {
        if (matchingCourse(s)) {
            return 1;
        }
        if (matchingScore(s)) {
            return 2;
        }
        return 0;
    }

    private static boolean matchingCourse(String s) {
        return s.matches(courseInput);
    }

    private static boolean matchingScore(String s) {
        return s.matches(scoreInput);
    }
}
class Course implements Comparable<Course>{
    String name;
    String type;
    String method;

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Course(String name,String type){
        this.type = type;
        this.name = name;
    }
    public Course(String name,String type,String method){
        this.name=name;
        this.type=type;
        this.method=method;
    }
    @Override
    public int compareTo(Course o){
        Comparator<Object> compare=Collator.getInstance(java.util.Locale.CHINA);
        return compare.compare(name,o.getName());
    }
}
abstract class Grade{
    protected int finalScore;
    protected int totalScore;

    public int getTotalScore() {
        return totalScore;
    }

    public int getFinalScore() {
        return finalScore;
    }

    Grade(int finalScore){this.finalScore=finalScore;}
}
class ExaminationGrade extends Grade{
    private int usualScore;

    public int getUsualScore() {
        return usualScore;
    }

    ExaminationGrade(int usualScore, int finalScore){
        super(finalScore);
        this.usualScore=usualScore;
        this.totalScore=(int)(finalScore*0.7+usualScore*0.3);
    }
}
class AssessmentGrade extends Grade{
    AssessmentGrade(int finalScore){
        super(finalScore);
        this.totalScore=finalScore;
    }
}

设计类图如下：

 第八次大作业

 

7-1 容器-ArrayList-排序
分数 12
作者 蔡轲
单位 南昌航空大学

题目描述

编辑

输入多个学生的成绩信息，包括：学号、姓名、数学成绩、物理成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

要求：使用ArrayList存储学生信息。

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+数学成绩+英文空格+物理成绩

以“end”为输入结束标志

输出格式:

按数学/物理成绩之和从高到低的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+数学/物理成绩之和

成绩相同的情况，按输入的先后顺序输出。

 

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

class Student {
    private String id;
    private String name;
    private int Score1;
    private int Score2;

    public Student(String id, String name, int Score1, int Score2) {
        this.id = id;
        this.name = name;
        this.Score1 = Score1;
        this.Score2 = Score2;
    }

    public int getTotalScore() {
        return Score1 + Score2;
    }

    public String toString() {
        return id + " " + name + " " + getTotalScore();
    }
}

class Main {
    public static void main(String[] args) {
        List<Student> studentList = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);

        while (true) {
            String input = scanner.nextLine();
            if (input.equals("end")) {
                break;
            }

            String[] str = input.split(" ");
            String id = str[0];
            String name = str[1];
            int physicsScore = Integer.parseInt(str[3]);
            int mathScore = Integer.parseInt(str[2]);


            Student student = new Student(id, name, mathScore, physicsScore);
            studentList.add(student);
        }

        Collections.sort(studentList, Comparator.comparing(Student::getTotalScore).reversed());

        for (Student student : studentList) {
            System.out.println(student);
        }
    }
}

知识点：

一.ArrayList：ArrayList 类继承了 AbstractList 并实现了 List 接口。 ArrayList 支持可以根据需要增长的动态数组。

   ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

　　import java.util.ArrayList; // 引入 ArrayList 类
　　ArrayList<E> objectName =new ArrayList<E>();　 // 初始化

  • E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
  •  objectName: 对象名

  1. 添加元素： 使用add()方法将元素添加到ArrayList

  2. 删除元素： 使用remove()方法将元素从ArrayList中删除

计算ArrayList大小： 使用size()方法计算ArrayList大小

  1. 查询ArrayList中特定元素： 使用contains()方法ArrayList中是否有某个元素

  2.  查询ArrayList中特定元素的位置： 使用indexOf()方法查询ArrayList中某个元素的位置

  3. 判断集合是否为空： 使用isEmpty()方法判断集合是否为空

  ArrayList与一般数组的区别

  1. 一般数组在创建时就必须确定大小：

            但是对于ArrayList，你只需要创建出此类型的对象即可。它不需要指定大小，因为它会在加入或删除元素时自动调整大小

　　 2.存放对象给一般数组时，必须指定位置

　　　 必须要指定在0到比length小1之间的数字，如果索引值超越了数组的限制（例如数组声明为2，但是指定的数字是3），就会报错。

　　    使用ArrayList时，可以用add(Int, Object)形式的方法来指定索引值，或使用add(Object)形式的方法让它自行管理大小。

 

7-2 课程成绩统计程序-3
分数 64
作者 蔡轲
单位 南昌航空大学

课程成绩统计程序-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"

这次课程统计程序的迭代相较于2来说难度增加了许多，由于时间的关系，这道题没有做出来

期末考试

7-1 立体图形问题
分数 10
作者 段喜龙
单位 南昌航空大学

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

类结构如下图所示（参考）：

image.png
试编程完成如上类设计，主方法源码如下（可直接拷贝使用）：

 
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner input = new Scanner(System.in);
    double side = input.nextDouble();
        
    display(new Cube(side));
    display(new RegularPyramid(side));
}

其中，display(Solid solid)方法为定义在Main类中的静态方法，作用为体现程序的多态性。

注：正三棱锥的体积计算公式为底面积*高/3。

输入格式:

输入一个实型数，分别作为正方体的边长和正三棱锥的边长。

输出格式:

分别输出正方体的表面积、体积以及正棱锥的表面积和体积。保留两位小数，建议使用String.format(“%.2f”,value)

进行小数位数控制。

代码如下：

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));
    }
    public static void display(Solid solid) {
        System.out.println(String.format("%.2f",solid.getArea()));
        System.out.println(String.format("%.2f",solid.getVolume()));
    }
}

class Cube extends Solid{
    Cube(double side){
        this.side = side;
    }
    
    public double getArea() {
        return side*side*6;
    }
    
    public double getVolume() {
        return side*side*side;
    }
}


class RegularPyramid extends Solid{
    RegularPyramid(){
    }
    
    RegularPyramid(double side){
        this.side = side;
    }
    public double getArea() {
        return side*side*Math.sqrt(3);
    }
    
    public double getVolume() {
        return Math.sqrt(6)*side*Math.sqrt(3) * side * side / 36;
    }
}

abstract class Solid {
    protected double side;
    Solid(){
        
    }
    Solid(double side) {
        this.side = side;
    }
    void setside(double side) {
        this.side = side;
    }
    double getside() {
        return side;
    }
    double getArea() {
        return side;
    }
    double getVolume() {
        return side;
    }
}
7-2 魔方问题
作者 段喜龙
单位 南昌航空大学

问题描述：本问题中的魔方有两种，一种是正方体魔方，一种是正三棱锥魔方，其中，正方体或正三棱锥魔方是由单元正方体或正三棱锥组成，单元正方体或正三棱锥的个数由阶数（即层数）决定，

即魔方边长=阶数*单元边长。魔方如下图所示：

image.png


利用“立体图形”问题源码，实现如下功能：

魔方有三个属性：颜色，阶数，类型（正方体魔方、正三棱锥魔方），程序要求输出魔方的颜色、表面积和体积。参考设计类图如下所示：

image.png

主方法部分可参考如下源码（可拷贝直接使用）：


 
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        
        String color = input.next();
        int layer = input.nextInt();
        double side = input.nextDouble();        
        
        RubikCube cube1 = new SquareCube(color, layer,new Cube(side)); 
                
        color = input.next();
        layer = input.nextInt();
        side = input.nextDouble();
        
        RubikCube cube2 = new RegularPyramidCube(color, layer,new RegularPyramid(side));
        display(cube1);
        display(cube2);
    }
}

其中，display(RubikCube cube)方法为Main类中定义的静态方法，用户输出魔方的信息，用于体现多态性。

输入格式:

第一部分：正方体魔方颜色、阶数、单元正方体边长，以空格或回车分隔；

第二部分：正三棱锥魔方颜色、阶数、单元正三棱锥边长，以空格或回车分隔。

输出格式:

正方体魔方颜色

正方体魔方表面积

正方体魔方体积

正三棱锥魔方颜色

正三棱锥魔方表面积
正三棱锥魔方体积

注：小数点保留两位

代码如下：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        
        String color = input.next();
        int layer = input.nextInt();
        double side = input.nextDouble();        
        
        Cube cube = new Cube(color,layer,side);
        double Area1 = cube.getArea();
        double Volume1 = cube.getVolume();
        System.out.println(color);
        System.out.println(String.format("%.2f", Area1));
        System.out.println(String.format("%.2f", Volume1));
                
        color = input.next();
        layer = input.nextInt();
        side = input.nextDouble();
        
        RegularPyramid regularPyramid = new RegularPyramid(color,layer,side);
        double Area2 = regularPyramid.getArea();
        double Volume2 = regularPyramid.getVolume();
        System.out.println(color);
        System.out.println(String.format("%.2f", Area2));
        System.out.println(String.format("%.2f", Volume2));
        
    }
}

class Cube{
    String color;
    int layer;
    double side;
    
    public Cube(String color,int layer,double side) {
        this.color = color;
        this.layer = layer;
        this.side = side;
    }
    
    public double getArea() {
        return side*layer*side*layer*6;
    }
    
    public double getVolume() {
        return side*side*side*layer*layer*layer;
    }
    public String getColor() {
        return color;
    }
}


class RegularPyramid{
    String color;
    int layer;
    double side;
    
    public RegularPyramid(String color,int layer,double side) {
        this.color = color;
        this.layer = layer;
        this.side = side;
    }
    
    public double getArea() {
        return side*layer*side*layer*Math.sqrt(3);
    }
    
    public double getVolume() {
        return Math.sqrt(6)*(side*layer)*Math.sqrt(3) * (side*layer)* (side*layer) / 36;
    }
    public String getColor() {
        return color;
    }
}

 期末考试的几道编程题都比较简单，主要就是接口和继承关系的运用，对我来说比较难的是选择题一些小题的错误比较多。

踩坑心得

这几次的作业主要难度是两个课程统计程序的迭代，课程统计里面的情况比较复杂，需要考虑的情况也比较多，需要提前设计好类图，这样才能在真正编写代码的做到有条不紊，才能在实现功能的时候不会漏考虑一些情况。

总结

经过一段时间的学习，我对于Java这门编程语言有了更深入的理解和掌握。这门课程让我了解了Java的基本语法、面向对象的编程思想、数据结构和算法、以及Java在开发中的应用。通过学习，我不仅掌握了Java的基础知识，还学会了如何使用Java进行实际开发。

在学习过程中，我遇到了一些困难和挑战。例如，对于Java的异常处理机制，我最初有些困惑。但是，通过不断地实践和理解，我逐渐明白了异常处理的重要性以及如何正确地使用它。此外，对于Java的集合框架和多线程编程，我花费了较多的时间来学习和练习。但是，通过这些努力，我能够更好地理解和使用这些重要概念。在学习过程中，我自己意识到对于这门语言的学习仅用一个学期是远远不够的，还需要在以后的学习生涯中不断精进自己的知识，才能对这门语言有更加深刻的理解。

总的来说，这门课程让我受益匪浅。我不仅掌握了Java的基础知识，还学会了如何使用Java进行实际开发。同时，这门课程还让我了解了Java在现实世界中的应用和未来的发展方向。我相信，通过这门课程的学习，我将更好地适应未来的工作和发展。