第三次博客作业

一：前言

这三次作业主要内容为课程成绩统计程序的代码实现，代码难度由简到难。第一次作业主要目的是了解这类题型的思路代码书写以及功能，面向对象体现得淋漓尽致。第二次作业则开始做非常牛逼哄哄的键值对（HashMap），并进一步实现课程成绩统计程序功能的完善。第三次作业是在前两次作业的基础上进行代码功能的优化，难度逐渐叠加。

二：设计与分析

第一次作业：没啥好说的，细心的把各个类建好。注意坑。　　

第二次作业：键值对需要好好学习，非常的厉害。然后就是课程成绩统计程序升级，注意题目要求的变化并逐一实现即可。第四题就是继承和多态。

第三次作业：除课程成绩统计程序题型外的四个题目都不难，好好理解题意即可。至于课程成绩统计程序的第二次升级，那就确实难啦。

三：踩坑心得

1.1：题目冗杂，一定要好好读题。分析号每个需求。

2.1：注意好键值对的每一个键只能对应一个值，但是一个值可以对应多个键。

2.2：多了个排序的方法:Comparator.reverseOrder()。

2.3：就是课程成绩统计程序升级咯，这倒没啥坑呢。

2.4：注意speak()是静态方法。

3.1：容器-ArrayList-排序并不难。

3.2：课程成绩统计程序终于要结束了 ，好难啊。

3.3：可以去搜索如何获取身份证的生日数字。

3.4：理解栈的原理就好做咯。　　

3.5：建议直接就用Arraylist,不用数组。谁用谁知道有多香。

四：主要困难以及改进建议

 第一次题目集“课程成绩统计程序-1”要好好规划好如何建类以及方法。

第二次题目集HashMap注意好：以“end”为输入结束标志，end之后输入某个学号，执行程序输出该生的详细信息 ，就可以啦。

第三次题目集题意不太好掌握，要细品。

五：心得

第一次题目集总体还是不难的，好好写就行；

第二次总体难度上升，也开始了菜单计价，还是比较繁琐滴。

第三次菜单太难了，顶不住。其他题目倒还能做（一定要细心）。

六：题目集

一.题目名称：

①.7-1 课程成绩统计程序-1

②.7-1 容器-HashMap-检索，7- 2容器-HashMap-排序，7-3 课程成绩统计程序-2，7-4 动物发声模拟器（多态）

③.7-1 容器-ArrayList-排序，7-2 课程成绩统计程序-3，7-3 jmu-Java-02基本语法-03-身份证排序，7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack，7-5 jmu-Java-03面向对象基础-05-覆盖。

二.题目内容及要求：

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

七：代码

7-1 课程成绩统计程序-1：

import java.text.Collator;
import java.util.*;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        ArrayList<Course> Courses = new ArrayList<>();
        ArrayList<Classroom> Classrooms = new ArrayList<>();
        String Label = in.nextLine();
        while (!Label.equals("end")) {
            String Line[] = Label.split(" ");
            if (Line.length == 3 ) {
                Course course;
                if(Line.length == 3)
                    course = new Course(Line[0],Line[1],Line[2]);
                else 
                    course = new Course(Line[0],Line[1],"考试");
                if (course.Error) {
                    course = null;
                }
                else {
                    boolean search = false;
                    for (Course course1 : Courses) {
                        if (course1.getCourse_Name().equals(course.getCourse_Name()))
                        {
                            search = true;
                            break;
                        }
                    }
                    if (!search)
                        Courses.add(course);
                }
            }
            else if(Line.length == 4 || Line.length == 5) { //读入学生的成绩，不包括平时分
                Student student;
                if (Line.length == 4)
                    student = new Student(Line[0],Line[1],Line[2],"0",Line[3],Courses,Classrooms);
                else
                    student = new Student(Line[0],Line[1],Line[2],Line[3],Line[4],Courses,Classrooms);
                if (!student.course_exist){
                    System.out.println(Line[2] +" does not exist");
                }
                //这里的error是用来判读这个课程是不是有问题，有问题的话，课程加不进去
                boolean error = false;
                int number = 1;
                if (Line.length == 5) 
                    number = 2;
                /*注意这里的判断方法，在error1和error2都存在的情况下，会报错*/
                if (student.courses.size()==0) {  //没有找到该课程和格式错误
                    error = true;
                }
                else if ((student.courses.get(student.courses.size()-1)).getExam_Way()==number){  //输入数据
                    student.courses.removeAll(student.courses);
                    error = true;
                    System.out.println(student.getNum() +" "+ student.getName() + " : access mode mismatch");
                }
                boolean same =false;
                if (!student.wrong) {
                    int Class_number = Integer.parseInt(Line[0])/100;   //获得学生的班级号
                    Classroom classroom = new Classroom(Class_number);   //初始化一个班级
                    if (Classrooms.size()==0) {   //学生信息没有错，在没有一个班级的情况下新建添加学生
                        Student student_ppp;
                        if (Line.length == 4)
                            student_ppp = new Student(Line[0],Line[1],Line[2],"0",Line[3],Courses,Classrooms);
                        else
                            student_ppp = new Student(Line[0],Line[1],Line[2],Line[3],Line[4],Courses,Classrooms);
                        if (student.courses.size()==0){
                            student_ppp.courses.removeAll(student_ppp.courses);
                        }
                        classroom.students.add(student_ppp);
                        Classrooms.add(classroom);
                    }
                    else{   //学生信息没有错，在查找不到和查找得到的情况下添加学生
                        for (int i = 0 ; i < Classrooms.size() ; i++){   //遍历查找班级是否存在
                            if (Classrooms.get(i).getClass_Number() == Class_number){   //如果存在，判断该学生是否存在
                                Student pp = Classrooms.get(i).search_class(student.getName());   //返回班级里查找的学生
                                /*如果不存在就加进去*/
                                if(pp==null) {
                                    Classrooms.get(i).students.add(student);
                                }
                                /*如果存在，那就不加进去*/
                                else {
                                    /*要把重复的成绩信息，忽略掉*/
                                    same = pp.Same_Student(student);
                                    if (!same) {
                                        pp.courses.add(student.courses.get((student.courses.size() - 1)));
                                    }
                                }
                                break;
                            }
                            else if (i==Classrooms.size()-1){ //不存在就在班级表上添加该班级
                                classroom.students.add(student);
                                Classrooms.add(classroom);
                                break;
                            }
                        }
                    }
                }
                /*以下为添加Courses的student*/
                if (!error && !same) {
                    for (Course course : Courses) {
                        String name = student.courses.get(student.courses.size()-1).getCourse_Name();
                        String name1 = course.getCourse_Name();
                        if (name.equals(name1)) {
                            course.students.add(student);
                            break;
                        }
                    }
                }
            }
            Label = in.nextLine();
        }
        Collections.sort(Classrooms);
        for (Classroom classroom : Classrooms) {
            classroom.Show_Students();
        }
        Comparator<Object> com = Collator.getInstance(java.util.Locale.CHINA);
        String[] newArray = new String[Courses.size()];
        for (int i = 0 ; i < Courses.size() ; i++) {
            newArray[i] = Courses.get(i).getCourse_Name();
        }
        List<String> list = Arrays.asList(newArray);
        Collections.sort(list,com);
        for (String i : list) {
            for (Course course : Courses) {
                    if (course.students.size()==0) {
                        System.out.println(i + " " + "has no grades yet");
                        break;
                    }
                    else if (course.getCourse_Name().equals(i)){
                        course.show_Grade();
                        break;
                    }
            }
        }
        for (Classroom classroom : Classrooms) {
            classroom.show_Classroom();
        }
    }
    public boolean search_Name_Course (String name, ArrayList<Course> Courses) {
        for (Course course : Courses) {
            if (course.getCourse_Name().equals(name)) {
                return true;
            }
        }
        return false;
    }
}
class Student implements Comparable<Student>{
    private int Class_number;
    private String name;
    private int grade_Daily;
    private int grade_Exam;
    private int num;
    boolean course_exist = true;
    boolean wrong = false;
    ArrayList<Course> courses = new ArrayList<>();
    Student( String num, String name, String course_name ,String grade_Daily,String grade_Exam, ArrayList<Course> courses, ArrayList<Classroom> classrooms){
        Course pp = new Course();
        Course pp_0 = null;
        try {
            this.num = Integer.parseInt(num);
            this.name = name;
            for (Course course : courses) {
                if (course.getCourse_Name().equals(course_name)){
                    pp_0 = course;
                    pp = course.Clone();
                    this.grade_Daily = Integer.parseInt(grade_Daily);
                    this.grade_Exam = Integer.parseInt(grade_Exam);

                    pp.setScour_Exam(Integer.parseInt(grade_Exam));
                    pp.setScour_Daily(Integer.parseInt(grade_Daily));
                    break;
                }
            }
        }
        catch (Exception e) {
            System.out.println("wrong format");
            wrong = true;
        }
        if (pp_0!=null) {
            if (this.grade_Exam<0 || this.grade_Exam>100 || this.grade_Daily<0 || this.grade_Daily>100)
            {
                System.out.println("wrong format");
                wrong = true;
            }
            else if (num.length()!=8 || name.length()>10 || course_name.length()>10) {
                System.out.println("wrong format");
                wrong = true;
            }
            else{
                this.courses.add(pp);
            }
        }
        else {
            course_exist = false;
        }
    }
    public int getClass_number() {
        return Class_number;
    }
    public int totalGrade() {
        double total = 0;
        for (Course course : courses) {
            if (course.getExam_Way() == 2) {
                total += course.getScour_Exam();
            } else {
                total += course.getScour_Daily() * 0.3 + course.getScour_Exam() * 0.7;
            }
        }
        return (int)total;
    }
    public int dailyGrade() {
        double total = 0;
        for (Course course : courses) {
            total += course.getScour_Daily();
        }
        return (int)total;
    }
    public int examGrade() {
        double total = 0;
        for (Course course : courses) {
            total += course.getScour_Exam();
        }
        return (int)total;
    }
    public int compareTo(Student p) {
        return (this.getNum() - p.getNum());
    }
    public int getGrade_Daily() {
        return grade_Daily;
    }
    public int getGrade_Exam() {
        return grade_Exam;
    }
    public int getNum() {
        return num;
    }
    public String getName() {
        return name;
    }
    public boolean Same_Student(Student student) {
        for (int i = 0 ; i < this.courses.size() ; i++) {
            if (this.courses.get(i).getCourse_Name().equals(student.courses.get(student.courses.size()-1).getCourse_Name())) {
                return true;
            }
        }
        return false;
    }
}
class Course {
    private String Course_Name;
    private boolean Choose;
    private int Scour_Daily;
    private int Scour_Exam;
    private int Exam_Way = 0;
    boolean Error = false;
    ArrayList<Student> students = new ArrayList<>();
    Course() {
    }
    Course(String Course_Name, String Choose, String Exam_Way) {
        this.Course_Name = Course_Name;
        if (Choose.equals("必修")) {
            this.Choose = false;
        }
        else {
            this.Choose = true;
        }
        if(Exam_Way.equals("考试")) {
            this.Exam_Way = 1;
        }
        else {
            this.Exam_Way = 2;
        }
        if (!this.Choose && this.Exam_Way == 2) {
            Error = true;
            System.out.println(this.Course_Name +" : course type & access mode mismatch");
        }
    }
    public void show_Grade() {
        int total_Grade = 0;
        int daily_Grade = 0;
        int Exam_Grade = 0;
        for (Student student : students) {
            total_Grade += student.totalGrade();
            daily_Grade += student.dailyGrade();
            Exam_Grade += student.examGrade();
        }
        total_Grade = (int)(1.0*total_Grade)/students.size();
        daily_Grade = (int)(1.0*daily_Grade)/students.size();
        Exam_Grade = (int)(1.0*Exam_Grade)/students.size();
        if (this.Exam_Way==1)
            System.out.println(this.Course_Name + " " + daily_Grade + " " + Exam_Grade + " " + total_Grade);
        else
            System.out.println(this.Course_Name + " " + Exam_Grade + " " + total_Grade);
    }
    public void setScour_Daily(int Scour_Daily) {
        this.Scour_Daily = Scour_Daily;
    }
    public void setScour_Exam(int Scour_Exam) {
        this.Scour_Exam = Scour_Exam;
    }
    public int getScour_Daily() {
        //得考虑里面还要放啥
        return Scour_Daily;
    }
    public int getScour_Exam() {
        //得考虑里面还要放啥
        return Scour_Exam;
    }
    public String getCourse_Name() {
        return Course_Name;
    }
    public int getExam_Way() {
        return Exam_Way;
    }
    public boolean getChoose() {
        return Choose;
    }
    public Course Clone() {
        String choose = "必修";
        if (this.Choose) {
            choose = "选修";
        }
        String Exam_Way = "考察";
        if (this.Exam_Way==1) {
            Exam_Way = "考试";
        }
        return  new Course(this.Course_Name, choose, Exam_Way);
    }
}
class Classroom implements Comparable<Classroom>{
    private int Class_Number;
    ArrayList<Student> students = new ArrayList<>();
    Classroom(int Class_Number) {
        this.Class_Number = Class_Number;
    }
    public int getClass_Number() {
        return Class_Number;
    }
    public void Show_Students() {
        Collections.sort(students);
        for (Student student : students) {
            if (student.courses.size()==0) {
                System.out.println(student.getNum() + " " + student.getName() + " did not take any exams");
            }
            else {
                System.out.println(student.getNum() + " " + student.getName() + " " + (int)(1.0*student.totalGrade()/student.courses.size()));
            }
        }
    }
    public int compareTo(Classroom o) {
        return (int)(this.Class_Number - o.Class_Number);
    }
    public int Total_Grade_Classroom () {
        int total = 0;
        for (Student student : students) {
            total += (int)(1.0*student.totalGrade()/student.courses.size());
        }
        return total;
    }
    public void show_Classroom() {
        if (this.Course_exist())
            System.out.println(Class_Number + " " + (int)(1.0*Total_Grade_Classroom())/(this.students.size()));
        else {
            System.out.println(Class_Number + " has no grades yet");
        }
    }
    public Student search_class(String name) {
        for (Student student : students) {
            if (name.equals(student.getName())) {
                return student;
            }
        }
        return null;
    }
    public boolean Course_exist(){
        int num = 0;
        for (Student student : students) {
            num += student.courses.size();
        }
        if (num==0) {
            return false;
        }
        else {
            return true;
        }
    }
}

 

7-1 容器-HashMap-检索：

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

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        StudentStorage handle = new StudentStorage();
        while (!string.equals("end")) {
            String inputs[] = string.split(" ");
            Student student = new Student(inputs[0], inputs[1], Integer.parseInt(inputs[2]));
            handle.addStudent(inputs[0], student);
            string = scanner.nextLine();
        }
        String string1 = scanner.nextLine();
        if (handle.getStudent(string1)==null)
            System.out.println("The student "+string1+" does not exist");
        else System.out.println(handle.getStudent(string1).id+" "+handle.getStudent(string1).name+" "+handle.getStudent(string1).grade);
    }
}

class Student {
    String id;
    String name;
    int grade;

    public Student() {
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }
}

class StudentStorage {
    public HashMap<String, Student> storage = new HashMap<>();

    // 添加学生信息
    public void addStudent(String id, Student student) {
        storage.put(id, student);
    }

    // 根据学号获取学生信息
    public Student getStudent(String id) {
        return storage.get(id);
    }

    // 删除学生信息
    public void removeStudent(String id) {
        storage.remove(id);
    }
}

7- 2容器-HashMap-排序

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        StudentStorage handle = new StudentStorage();
        while (!string.equals("end")) {
            String inputs[] = string.split(" ");
            Student student = new Student(inputs[0], inputs[1], Integer.parseInt(inputs[2]));
            handle.addStudent(inputs[0], student);
            string = scanner.nextLine();
        }
        for (String key : handle.storage.keySet()) {
            System.out.println(key+" "+handle.storage.get(key).name+" "+handle.storage.get(key).grade);
        }
    }
}

class Student  {
    String id;
    String name;
    int grade;

    public Student() {
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }

}

class StudentStorage {
   public Map<String, Student> storage = new TreeMap<>(Comparator.reverseOrder());

    // 添加学生信息
    public void addStudent(String id, Student student) {
        storage.put(id, student);
    }

    // 根据学号获取学生信息
    public Student getStudent(String id) {
        return storage.get(id);
    }

    // 删除学生信息
    public void removeStudent(String id) {
        storage.remove(id);
    }

}

7-4 动物发声模拟器（多态）：

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
        Goat goat = new Goat();
        speak(cat);
        speak(dog);
        speak(goat);
    }

    //定义静态方法speak()
    public static void speak(Animal animal) {
        animal.shout();
    }
}

abstract class Animal {
    abstract Animal getAnimalClass();

    abstract void shout();
}

class Dog extends Animal {
    Dog dog;

    @Override
    Animal getAnimalClass() {
        return dog;
    }

    @Override
    void shout() {
        System.out.println("狗的叫声：汪汪");
    }
}

class Cat extends Animal {
    Cat cat;

    @Override
    Animal getAnimalClass() {
        return cat;
    }

    @Override
    void shout() {
        System.out.println("猫的叫声：喵喵");
    }
}

class Goat extends Animal {
    Goat goat;

    @Override
    Animal getAnimalClass() {
        return goat;
    }

    @Override
    void shout() {
        System.out.println("山羊的叫声：咩咩");
    }
}

　　

 

 SourceMonitor的生成报表内容：