第三次总结性blog-526互联

1.前言

2.设计与分析

3.踩坑心得

4.改进建议

5.总结

1.前言

题目集8

　　　　课程成绩统计程序-1

题目集9

　　　　统计Java程序中关键词的出现次数

题目集10

　　　　容器-HashMap-检索

　　　　容器-HashMap-排序

　　　　课程成绩统计程序-2

　　　　动物发声模拟器（多态）

题目集11

　　　　容器-ArrayList-排序

　　　　课程成绩统计程序-3

　　　　jmu-Java-02基本语法-03-身份证排序

　　　　jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack

　　　　 jmu-Java-03面向对象基础-05-覆盖

题目集8是比较简单的，我也完成了，但是我的代码超限，尽管我改了变量名，且把重复的地方也用方法代替了，但最后我代码还是不能全过，这是比较可惜的。

题目集9我感觉我自己写的代码没有问题，但就是过不了全部的测试点，测试点没有例子，找了许久也没试出来

题目集10其他问题我觉得简单，但是那道迭代问题的数据处理问题，没有啥思路，室友给了点方法，但我还是没有做出来，放弃了

题目集11的出现我是真没有想到，为什么还会有pta，18周我们有3次考试，2个节课作业，这次pta我也看了那个迭代题目，发现必须需要大改，没啥思路，时间全部投入到英语6级考试去了，星期6考完，晚上看了pta交了总人数，发现很多人没交，但也有人满分了，但是总体是不太行的，估计大家这星期都挺忙的。

2.设计与分析

　　　　课程成绩统计程序-1

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

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

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

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

1、输入：

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

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

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

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

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

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

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

以上信息的相关约束：

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

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

3）学号由8位数字组成

4）姓名不超过10个字符

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

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

2、输出：

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

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

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

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

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

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

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

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

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

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

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

异常情况：

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

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

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

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

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

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

信息约束：

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

package 课程成绩统计系统3;
import java.text.Collator;
import java.util.*;
import java.util.regex.Pattern;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Select select = new Select();
        ArrayList<SelectedCourse> selectedCourses= new ArrayList();
        Pattern pattern = Pattern.compile("[0-9]*");
        String[] s = in.nextLine().split(" ");
        while (!s[0].equals("end") && !pattern.matcher(s[0]).matches()){
               if((s.length == 3 || s.length == 4) && s[0].length() <= 10){
                    if((s[1].equals("必修")||s[1].equals("选修"))&&(s[2].equals("考试")||s[2].equals("考察"))){
                        if(!select.getCourse().contains(new Course(s[0],"","")))
                            if(!select.addCourse(s[0],s[1],s[2]))
                                System.out.println(s[0]+" : course type & access mode mismatch");
                            }

                        }
                s = in.nextLine().split(" ");
        }
        while (!s[0].equals("end")){
                if(s.length == 5 || s.length == 4){
                    SelectedCourse record = new SelectedCourse(new Course(s[2],"",""),new Student( Integer.parseInt(s[0]),""));

                        if (!selectedCourses.contains(record)) {
                            if (Integer.parseInt(s[3]) >= 0 && Integer.parseInt(s[3]) <= 100) {
                                if (s.length == 4) {
                                    int judge = select.addCourseScore(s[2], -1, Integer.parseInt(s[3]));
                                    if (judge == -1) {
                                        System.out.println(s[2] + " does not exist");
                                    } else if (judge == -2)
                                        System.out.println(s[0] + " " + s[1] + " : access mode mismatch");
                                    else if (judge == 0)
                                        selectedCourses.add(record);
                                    select.addStudent(Integer.parseInt(s[0]), s[1], s[2], -1, Integer.parseInt(s[3]));
                                    select.addClass(s[0]);
                                    select.addClassStudent(s[0]);
                                } else if (s.length == 5 && Integer.parseInt(s[4]) >= 0 && Integer.parseInt(s[4]) <= 100) {
                                    int judge = select.addCourseScore(s[2], Integer.parseInt(s[3]), Integer.parseInt(s[4]));
                                    if (judge == -1)
                                        System.out.println(s[2] + " does not exist");
                                    else if (judge == -2)
                                        System.out.println(s[0] + " " + s[1] + " : access mode mismatch");
                                    else if (judge == 0)
                                        //System.out.println("666");
                                        selectedCourses.add(record);
                                    //}
                                        select.addStudent(Integer.parseInt(s[0]), s[1], s[2], Integer.parseInt(s[3]), Integer.parseInt(s[4]));
                                        //System.out.println("6");
                                        select.addClass(s[0]);
                                        //System.out.println("55");
                                        select.addClassStudent(s[0]);
                                    }

                            }

                        }


                }

                s = in.nextLine().split(" ");
        }
                select.students.sort(Comparator.naturalOrder());
                select.courses.sort(Comparator.naturalOrder());
                select.classes.sort(Comparator.naturalOrder());
                select.scorePrint();
    }
}



        class Select {
            public ArrayList<Course> courses = new ArrayList<>();
            public ArrayList<Student> students = new ArrayList<>();
            public ArrayList<Class> classes = new ArrayList<>();
            public ArrayList<Course> getCourse() {
                return courses;
            }
            private Score score = new ExaminationGrades();
            public boolean addCourse(String courseName, String courseNature, String assessmentMethod) {

                if (courseName.length() > 10) {
                    System.out.println("wrong format");
                    return true;
                }
                if (findCourse(courseName) >= 0)
                    return true;
                if (courseNature.equals("必修") && assessmentMethod.equals("考察"))
                    return false;
                if (findCourse(courseName) == -1)
                    this.courses.add(new Course(courseName, courseNature, assessmentMethod));
                return true;
            }
            //在courses中根据课程名寻找课程并返回下标
            public int findCourse(String course) {
                Course judge = new Course(course, "", "");
                return courses.indexOf(judge);
            }
            public int addCourseScore(String courseName, int uScore, int fScore){
                int index = findCourse(courseName);
                if(index == -1){
                    return -1;
                }
                else{
                    Course replace = courses.get(index);
                    if(replace.getA5().equals("考试")){
                        if(uScore >= 0){
                            score = new ExaminationGrades(fScore,uScore);
                            replace.addFinalScore(fScore);
                            replace.addUsualScore(uScore);
                        }
                        else
                            return -2;
                    }
                    else{
                        if(uScore < 0){
                            score = new ExmineGrade(fScore);
                            replace.addFinalScore(fScore);
                        }
                        else
                            return -2;
                    }
                    replace.addTotalScore(score.getTotalScore());
                    courses.set(index, replace);
                    return 0;
                }
            }
            public void addStudent(int xueHao, String name, String courseName, int uScore, int fScore){
                int index = findStudent(xueHao);
                if(index == -1)
                    this.students.add(new Student(xueHao, name));
                if(courses.contains(new Course(courseName,"",""))) {
                    if(!(courses.get(findCourse(courseName)).getA3().equals("考试") && uScore == -1)){
                        if(!(courses.get(findCourse(courseName)).getA3().equals("考察") && uScore >= 0)){
                            if (courses.get(findCourse(courseName)).getA3().equals("考试"))
                                score = new ExaminationGrades(fScore, uScore);
                            else
                                score = new ExmineGrade(fScore);
                            index = findStudent(xueHao);
                            Student replace = students.get(index);
                            replace.addTotalScore(score.getTotalScore());
                            students.set(index, replace);
                        }
                    }
                }
            }
            public int findStudent(int xueHao){
                Student judge = new Student(xueHao,"");
                return students.indexOf(judge);
            }
            public void addClass(String xueHao){
                if(xueHao.length() == 8 && findClass(xueHao.substring(0,6)) == -1)
                    classes.add(new Class(xueHao.substring(0,6), 0));
            }
            public void addClassStudent(String xueHao){
                int index = findClass(xueHao.substring(0,6));
                Class replace = classes.get(index);
                replace.addStudent(students.get(findStudent(Integer.parseInt(xueHao))));
                classes.set(index, replace);
            }
            public int findClass(String classNum){
                Class jugde = new Class(classNum, 0);
                return classes.indexOf(jugde);
            }
            public void scorePrint() {
                for (int i = 0; i < students.size(); i++)
                    students.get(i).scoreShow();
                for (int i = 0; i < courses.size(); i++)
                    courses.get(i).scoreShow();
                for (int i = 0; i < classes.size(); i++)
                    classes.get(i).scoreShow();
            }
        }

        class Class implements  Comparable<Class>{
            private String d1;
            private int d2;
            private ArrayList<Student> students = new ArrayList<>();

            public Class(String classNum, int averageScore) {
                this.d1 = classNum;
                this.d2 = averageScore;
            }
            public void addStudent(Student student){
                students.add(student);
                double score = 0.0;
                for(int i = 0; i < students.size(); i++) {
                    score += students.get(i).getAverageScore();
                }
                //System.out.println(score);
                this.d2 = (int)(score / students.size());
                //System.out.println(d2);
            }
            public int getAverageScore() {
                return d2;
            }
            public void scoreShow(){
                //System.out.println(d2);
                if(d2 == 0) {
                    //System.out.println("66");
                    System.out.println(d1 + " has no grades yet");
                }
                else {
                    //System.out.println("66");
                    System.out.println(d1 + " " + d2);
                }
            }
            public boolean equals(Object obj) {
                Class c = (Class) obj;
                return this.d1.equals(c.d1);
            }

            @Override
            public int compareTo(Class o) {
                if (this.d2 > o.d2)
                    return 1;
                else if (this.d2< o.d2) {
                    return -1;
                }
                return  0;
            }
        }

        class Course implements Comparable<Course>{
            private String a1, a3, a5;
            private ArrayList<Integer> finalScores = new ArrayList<>();
            private ArrayList<Integer> usualScores = new ArrayList<>();
            private ArrayList<Double> totalScores = new ArrayList<>();

            public Course(String courseName, String courseNature, String assessmentMethod) {
                this.a1 = courseName;
                this.a3 = courseNature;
                this.a5 = assessmentMethod;
            }

            public String getA1() {
                return a1;
            }

            public String getA3() {
                return a3;
            }

            public String getA5() {
                return a5;
            }

            public void addFinalScore(int score) {
                finalScores.add(score);
            }

            public void addUsualScore(int score) {
                usualScores.add(score);
            }

            public void addTotalScore(double score) {
                totalScores.add(score);
            }

            public int getAverageFinal() {
                double score = 0.0;
                for (int i = 0; i < finalScores.size(); i++)
                    score += finalScores.get(i);
                return (int) (score / finalScores.size());
            }

            public int getAverageUsual() {
                double score = 0.0;
                for (int i = 0; i < usualScores.size(); i++)
                    score += usualScores.get(i);
                return (int) (score / usualScores.size());
            }

            public int getAverageTotal() {
                double score = 0.0;
                for (int i = 0; i < totalScores.size(); i++)
                    score += totalScores.get(i);
                return (int) (score / totalScores.size());
            }
            public void scoreShow(){
                //System.out.println(a3);
                if(totalScores.isEmpty())
                    System.out.println(a1 +" has no grades yet");
                else{
                    if(a5.equals("考试")) {
                        //System.out.println("555");
                        System.out.println(a1 + " " + getAverageUsual() + " " + getAverageFinal() + " " + getAverageTotal());
                    }
                    else {
                        //System.out.println("666");
                        System.out.println(a1 + " " + getAverageFinal() + " " + getAverageTotal());
                    }
                }
            }
            @Override
            public boolean equals(Object obj) {
                Course c = (Course) obj;
                return this.a1.equals(c.a1);
            }

            @Override
            public int compareTo(Course o) {
                if(this.getAverageTotal() > o.getAverageTotal())
                    return -1;
                else if (this.getAverageTotal() < o.getAverageTotal()) {
                    return 1;
                }
                return 0;
            }
        }

        class ExaminationGrades extends Score {
            public ExaminationGrades() {
            }
            public ExaminationGrades(int finalCourse) {
                super(finalCourse);
            }

            public ExaminationGrades(int finalCourse, int usualCourse) {
                super(finalCourse, usualCourse);
            }

            @Override
            public double getTotalScore() {
                return b1 * 0.7 + b2 * 0.3;
            }
        }

        class ExmineGrade extends Score {
            public ExmineGrade() {
            }

            public ExmineGrade(int finalCourse) {
                super(finalCourse);
            }

            @Override
            public double getTotalScore() {
                return b1;
            }
        }

        abstract class Score {

            protected int b1 = 0, b2 = 0;


            public Score() {
            }

            public Score(int finalCourse) {
                this.b1 = finalCourse;
            }

            public Score(int finalCourse, int usualCourse) {
                this.b1 = finalCourse;
                this.b2 = usualCourse;
            }

            public abstract double getTotalScore();
        }
        class Student implements Comparable<Student>{
            private int c1;

            private String c2;

            private ArrayList<Double> totalScores = new ArrayList<>();
            public Student(int xueHao, String name) {
                this.c1 = xueHao;
                this.c2 = name;

            }
            public int getXueHao() {
                return c1;
            }
            public int getAverageScore() {
                double score = 0.0;
                for(int i = 0; i < totalScores.size(); i++)
                    score += totalScores.get(i);
                if(totalScores.size() == 0)
                    return 0;
                else
                    return (int)(score / totalScores.size());
            }
            public void addTotalScore(double score){
                totalScores.add(score);
            }
            public void scoreShow(){
                if(totalScores.isEmpty())
                    System.out.println(c1+" "+c2+" did not take any exams");
                else
                    System.out.println(c1+" "+c2+" "+getAverageScore());
            }
            @Override
            public boolean equals(Object obj) {
                Student s = (Student)obj;
                if(this.c1 == s.c1)
                    return true;
                else
                    return false;
            }

            @Override
            public int compareTo(Student o) {
                if(this.getXueHao() > o.getXueHao())
                    return 1;
                else if (this.getXueHao() < o.getXueHao()) {
                    return -1;
                }
                return 0;
            }
        }
class SelectedCourse {
    public Course course;
    public Student student;

    public Score score;
    public SelectedCourse(Course course, Student student) {
        this.course = course;
        this.student = student;
        this.score = new ExaminationGrades();
    }

    public Course getCourse() {
        return course;
    }
    public Student getStudent() {
        return student;
    }

    public boolean equals(Object obj) {
        SelectedCourse sc = (SelectedCourse) obj;
        if(this.course.getA1().equals(sc.getCourse().getA1())&&this.student.getXueHao() == sc.getStudent().getXueHao())
            return true;
        else
            return false;
    }

}

这次题目我觉得难度适中，可以。室友使用数组做的，我也尝试用，写到匹配分数时，我发现需要写方法来匹配，个人觉得很难。所以我最后使用了list集合，挺方便的。

　　　　统计Java程序中关键词的出现次数

编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：

Java中共有53个关键字（自行百度）
从键盘输入一段源码，统计这段源码中出现的关键字的数量
注释中出现的关键字不用统计
字符串中出现的关键字不用统计
统计出的关键字及数量按照关键字升序进行排序输出
未输入源码则认为输入非法

输入格式:

输入Java源码字符串，可以一行或多行，以exit行作为结束标志

输出格式:

当未输入源码时，程序输出Wrong Format
当没有统计数据时，输出为空
当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为数量\t关键字

import java.util.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.TreeMap;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] s ={"abstract","assert","boolean","break","byte","case","catch", "char","class","const","continue","default","do","double","else", "enum","extends","false","final","finally","float", "for","goto","if","implements","import","instanceof", "int","interface","long","native","new","null","package", "private","protected","public","return","short","static", "strictfp","super","switch","synchronized","this","throw", "throws","transient","true","try","void","volatile","while"};
        int i = 0;
        StringBuilder stringbuilder = new StringBuilder();
        Map map =new HashMap();
        String a = in.nextLine();
        int flag = 0,j;
        while (!a.equals("exit")){
            stringbuilder.append(a.replaceAll("//.*", " ").replaceAll("\".*\"", " ").replaceAll("\\[", " ").replaceAll("\\]", " ").replaceAll("\\,", " ").replaceAll("\\{"," ").replaceAll("\\}"," ").replaceAll("\\("," ").replaceAll("\\)"," ").replaceAll("\\;"," "));
            a = in.nextLine();
            flag=1;
        }
        if(flag == 0) {
            System.out.println("Wrong Format");
        }
        String b = stringbuilder.toString().replaceAll("/\\*\\s*.*\\s*\\*/", " ").replaceAll("\\[", "").replaceAll("\\,","").replaceAll("\\]", "");
        for(i=0;i< s.length;i++) {
            Pattern pattern = Pattern.compile("\\b"+s[i]+"\\b");
            Matcher matcher = pattern.matcher(b);
            j = 0;
            while(matcher.find()) {
                j ++ ;
            }
            if(j!=0){
                map.put(s[i], j);
            }
        }
        Set set = map.keySet();
        Object[] arr = set.toArray();
        Arrays.sort(arr);
        for (Object k : arr) {
            System.out.println(map.get(k) + "\t" + k);
        }
        
    }
}

我思路还是看了课才了解，stringbulider的用法，让后我在这道题实现了stringbuilder中的方法，例如append与tostring，replaceall，replace。我觉的没有问题，因为我是根据题目要求来写的，一开始我只有删除注释与字符串的想法，先处理一行，再拼接这行字符串。最后我再处理数据，然后就过了大部分测试点，一部分测试点没有过，看完测试结果，我发现要去除那些符号，我以为是这里的问题，然后我不断加上去，还尝试多种方式，但最后好像不是这里的问题。后遗憾没得全分。

　　　　容器-HashMap-检索

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

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

姓名可能会存在重复。

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

输入格式:

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

以“end”为输入结束标志

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

输出格式:

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

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

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class Main {
    public static void main(String[] args) {
        Map<String,Student> map = new HashMap<>();
        Scanner in = new Scanner(System.in);
        String a = in.nextLine();
        while (!a.equals("end")){
            String[] b = a.split(" ");
            Student student = new Student(b[1],Integer.parseInt(b[2]));
            map.put(b[0],student);
            a = in.nextLine();
        }
        String c = in.nextLine();
        Set<Map.Entry<String,Student>>set = map.entrySet();
        boolean flag = false;
        for (Map.Entry<String,Student> entry: set){
                Student student1 = map.get(entry);
                if (c.equals(entry.getKey())) {
                    flag =true;
                    System.out.println(c + " " + entry.getValue().getName() + " " + entry.getValue().getScore());
                }
        }
        if(flag == false){
            System.out.println("The student "+ c+" does not exist");
        }

    }
}
class Student{
    private String name;
    private int score;

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

    public String getName() {
        return name;
    }

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

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

这里我觉的很简单。不过多解释。

　　　　容器-HashMap-排序

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

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

姓名可能会存在重复。

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

输入格式:

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

以“end”为输入结束标志

输出格式:

按学号从大到小的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+成绩

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, Student> map = new HashMap<>();
        Scanner in = new Scanner(System.in);
        String a = in.nextLine();
        while (!a.equals("end")){
            String[] b = a.split(" ");
            Student student = new Student(b[1],Integer.parseInt(b[2]));
            map.put(Integer.valueOf(b[0]),student);
            a = in.nextLine();
        }
        
        ArrayList<Integer>list = new ArrayList<>(map.keySet());
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1>o2?-1:1;
            }
        });

        Iterator<Integer>iterator = list.iterator();
        while ((iterator.hasNext())){
            Integer key = iterator.next();
            Student student  = map.get(key);
            System.out.println(key +" "+ student.getName() + " "+ student.getScore());
        }
    }
}
class Student{
    private String name;
    private int score;

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

    public String getName() {
        return name;
    }

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

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

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

这道题我最后没写出来，我展示我写的代码，但是没有过测试点

package 课程成绩统计系统6;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        GradeData gradeData = new GradeData();
        ArrayList<SelectedCourse> selectedCourses= new ArrayList<>();
        Pattern pattern = Pattern.compile("[0-9]*");
        String[] command = in.nextLine().split(" ");
        while (!command[0].equals("end") && !pattern.matcher(command[0]).matches()){
            if((command.length == 3 || command.length == 4) && command[0].length() <= 10){
                if((command[1].equals("必修")||command[1].equals("选修"))&&(command[2].equals("考试")||command[2].equals("考察"))){
                    if(!gradeData.getCourse().contains(new Course(command[0],"","")))
                        if(!gradeData.addCourse(command[0],command[1],command[2]))
                            System.out.println(command[0]+" : course type & access mode mismatch");
                }
                else
                    System.out.println("wrong format");
            }
            else
                System.out.println("wrong format");
            command = in.nextLine().split(" ");
        }
        while (!command[0].equals("end")){
            if(command.length>=4) {
                SelectedCourse record = new SelectedCourse(command);
                if (record.judge()) {
                    if (!selectedCourses.contains(record)) {
                        if (command.length == 4) {
                            int judge = gradeData.addCourseScore(command[2], -1, Integer.parseInt(command[3]));
                            if (judge == -1)
                                System.out.println(command[2] + " does not exist");
                            else if (judge == -2)
                                System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
                            else if (judge == 0)
                                selectedCourses.add(record);
                            gradeData.addStudent(Integer.parseInt(command[0]), command[1], command[2], -1, Integer.parseInt(command[3]));
                            gradeData.addClass(command[0]);
                        }
                        if (command.length == 5) {
                            int judge = gradeData.addCourseScore(command[2], Integer.parseInt(command[3]), Integer.parseInt(command[4]));
                            if (judge == -1)
                                System.out.println(command[2] + " does not exist");
                            else if (judge == -2)
                                System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
                            else if (judge == 0)
                                selectedCourses.add(record);
                            gradeData.addStudent(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[3]), Integer.parseInt(command[4]));
                            gradeData.addClass(command[0]);
                        }
                        if(command.length == 8){
                            String[] b = new String[]{command[4],command[5],command[6],command[7]};
                            //b.length = 0;
                            //b.length = command.length-4;
                            int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]));
                            if (judge == -1)
                                System.out.println(command[2] + " does not exist");
                            else if (judge == -2)
                                System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
                            else if (judge == 0)
                                selectedCourses.add(record);
                            gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]));
                            gradeData.addClass(command[0]);
                        }
                        if(command.length == 9){
                            //String[] b = new String[]{command[4],command[5],command[6],command[7]};
                            //b.length = 0;
                            //b.length = command.length-4;
                            int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]));
                            if (judge == -1)
                                System.out.println(command[2] + " does not exist");
                            else if (judge == -2)
                                System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
                            else if (judge == 0)
                                selectedCourses.add(record);
                            gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]));
                            gradeData.addClass(command[0]);
                        }
                        if(command.length == 10){
                            String[] b = new String[]{command[4],command[5],command[6],command[7]};
                            //b.length = 0;
                            //b.length = command.length-4;
                            int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]));
                            if (judge == -1)
                                System.out.println(command[2] + " does not exist");
                            else if (judge == -2)
                                System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
                            else if (judge == 0)
                                selectedCourses.add(record);
                            gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]));
                            gradeData.addClass(command[0]);
                        }
                        if(command.length == 11){
                            String[] b = new String[]{command[4],command[5],command[6],command[7]};
                            //b.length = 0;
                            //b.length = command.length-4;
                            int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]));
                            if (judge == -1)
                                System.out.println(command[2] + " does not exist");
                            else if (judge == -2)
                                System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
                            else if (judge == 0)
                                selectedCourses.add(record);
                            gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]));
                            gradeData.addClass(command[0]);
                        }
                        if(command.length == 12){
                            String[] b = new String[]{command[4],command[5],command[6],command[7]};
                            //b.length = 0;
                            //b.length = command.length-4;
                            int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]),Integer.parseInt(command[11]));
                            if (judge == -1)
                                System.out.println(command[2] + " does not exist");
                            else if (judge == -2)
                                System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
                            else if (judge == 0)
                                selectedCourses.add(record);
                            gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]),Integer.parseInt(command[11]));
                            gradeData.addClass(command[0]);
                        }if(command.length == 13){
                            String[] b = new String[]{command[4],command[5],command[6],command[7]};
                            //b.length = 0;
                            //b.length = command.length-4;
                            int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]),Integer.parseInt(command[11]),Integer.parseInt(command[12]));
                            if (judge == -1)
                                System.out.println(command[2] + " does not exist");
                            else if (judge == -2)
                                System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
                            else if (judge == 0)
                                selectedCourses.add(record);
                            gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]),Integer.parseInt(command[11]),Integer.parseInt(command[12]));
                            gradeData.addClass(command[0]);
                        }
                    }
                } else
                    System.out.println("wrong format");
            }
            else
                System.out.println("wrong format");
            command = in.nextLine().split(" ");
        }
        gradeData.students.sort(Comparator.naturalOrder());
        gradeData.courses.sort(Comparator.naturalOrder());
        gradeData.classes.sort(Comparator.naturalOrder());
        gradeData.scorePrint();
    }
}
class GradeData {
     ArrayList<Course> courses = new ArrayList<>();
     ArrayList<Student> students = new ArrayList<>();
     ArrayList<Class> classes = new ArrayList<>();
     Score score = new ExamScore(0,0);

    public GradeData() {
    }
    public ArrayList<Course> getCourse() {
        return courses;
    }
    //添加课程信息
    public boolean addCourse(String course, String property, String form){
        if(course.length() > 10){
            System.out.println("wrong format");
            return true;
        }
        if(findCourse(course) >= 0)
            return true;
        if(property.equals("必修") && form.equals("考察")||(property.equals("实验")&&(!form.equals("实验"))))
            return false;
        if(findCourse(course) == -1)
            this.courses.add(new Course(course, property, form));
        return true;
    }
    public int addCourseScore(String course, int uScore, int fScore){
        int index = findCourse(course);
        if(index == -1){
            return -1;
        }
        else{
            Course replace = courses.get(index);
            if(replace.getForm().equals("考试")){
                if(uScore >= 0){
                    score = new ExamScore(fScore,uScore);
                    replace.addFinalScore(fScore);
                    replace.addUsualScore(uScore);
                }
                else
                    return -2;
            }
            else{
                if(uScore < 0){
                    score = new ResearchSourse(fScore);
                    replace.addFinalScore(fScore);
                }
                else
                    return -2;
            }
            replace.addTotalScore(score.getTotalScore());
            courses.set(index, replace);
            return 0;
        }
    }
    public int addCourseScore1(String course,int...scores){
        int index = findCourse(course);
        if(index == -1){
            return -1;
        }
        else{
            Course replace = courses.get(index);
            if(replace.getForm().equals("实验")){
                int i = 0;
                if(scores[i] >= 0){
                    score = new Experimentgrades(scores);
                    replace.addExperimentScore(scores);
                }
                else
                    return -2;
            }
            replace.addTotalScore(score.getTotalScore());
            courses.set(index, replace);
            return 0;
        }
    }
    public int findCourse(String course){
        Course judge = new Course(course,"","");
        return courses.indexOf(judge);
    }
    public void addStudent(int stuID, String name, String course, int uScore, int fScore){
        int index = findStudent(stuID);
        if(index == -1)
            this.students.add(new Student(name, stuID));
        if(courses.contains(new Course(course,"",""))) {
            if(!(courses.get(findCourse(course)).getForm().equals("考试") && uScore == -1)){
                if(!(courses.get(findCourse(course)).getForm().equals("考察") && uScore >= 0)){
                    if (courses.get(findCourse(course)).getForm().equals("考试"))
                        score = new ExamScore(fScore, uScore);
                    else
                        score = new ResearchSourse(fScore);
                    index = findStudent(stuID);
                    Student replace = students.get(index);
                    replace.addTotalScore(score.getTotalScore());
                    students.set(index, replace);
                }
            }
        }
    }
    public void addStudent1(int stuID, String name, String course,int...scores){
        int index = findStudent(stuID);
        if(index == -1)
            this.students.add(new Student(name, stuID));
        if(courses.contains(new Course(course,"",""))) {
            if((courses.get(findCourse(course)).getForm().equals("实验") )){
                    score = new Experimentgrades(scores);
                    index = findStudent(stuID);
                    Student replace = students.get(index);
                    replace.addTotalScore(score.getTotalScore());
                    students.set(index, replace);
                }
            }
        }

    public int findStudent(int stuID){
        Student judge = new Student("", stuID);
        return students.indexOf(judge);
    }
    public void addClass(String stuID){
        if(stuID.length() == 8 && findClass(stuID.substring(0,6)) == -1)
            classes.add(new Class(stuID.substring(0,6), -1));
        int index = findClass(stuID.substring(0,6));
        if(!students.get(findStudent(Integer.parseInt(stuID))).getTotalScores().isEmpty()){
            Class replace = classes.get(index);
            replace.addStudent(students.get(findStudent(Integer.parseInt(stuID))));
            classes.set(index, replace);
        }
    }
    public int findClass(String classNum){
        Class jugde = new Class(classNum, -1);
        return classes.indexOf(jugde);
    }


    public void scorePrint(){
        for (int i = 0; i < students.size(); i++)
            students.get(i).scoreShow();
        for (int i = 0; i < courses.size(); i++)
            courses.get(i).scoreShow();
        for (int i = 0; i < classes.size(); i++)
            classes.get(i).scoreShow();
    }
}
class SelectedCourse {
    public Course course;
    public Student student;
    public String[] command;
    public SelectedCourse(String[] command) {
        this.course = new Course(command[2],"","");
        this.student = new Student("",Integer.parseInt(command[0]));
        this.command = command;
    }
    public boolean judge(){
        Pattern pattern = Pattern.compile("0|[0-9]{1,2}|100");
        if(command[0].length() == 8 && command[1].length() <= 10){
            //if(command[2].equals(course.getCourse())&&(course.getForm().equals("实验"))&&(Integer.parseInt(command[3])>3||Integer.parseInt(command[3])<10)){
                //System.out.println();
            //}
            //else {
                if (pattern.matcher(command[3]).matches()) {
                    if (command.length == 4) {
                        return true;
                    } else if (pattern.matcher(command[4]).matches()) {
                        return true;
                    } else
                        return false;
                } else
                    return false;
            //}
        }
        else
            return false;

    }
    public Course getCourse() {
        return course;
    }
    public Student getStudent() {
        return student;
    }
    @Override
    public boolean equals(Object obj) {
        SelectedCourse sc = (SelectedCourse) obj;
        if(this.course.getCourse().equals(sc.getCourse().getCourse())&&this.student.getStuID() == sc.getStudent().getStuID())
            return true;
        else
            return false;
    }
}
class Class implements  Comparable<Class>{
    private String classNum;
    private int averageScore;
    private ArrayList<Student> students = new ArrayList<>();
    public Class(String classNum, int averageScore) {
        this.classNum = classNum;
        this.averageScore = averageScore;
    }
    public void addStudent(Student student){
        students.add(student);
        double score = 0.0;
        for(int i = 0; i < students.size(); i++)
            score += students.get(i).getAverageScore();
        this.averageScore = (int)(score / students.size());
    }
    public int getAverageScore() {
        return averageScore;
    }
    public void scoreShow(){
        if(students.isEmpty())
            System.out.println(classNum+" has no grades yet");
        else
            System.out.println(classNum+" "+averageScore);
    }
    @Override
    public boolean equals(Object obj) {
        Class c = (Class) obj;
        return this.classNum.equals(c.classNum);
    }

    @Override
    public int compareTo(Class o) {
        if (this.averageScore> o.averageScore)
            return 1;
        else if (this.averageScore< o.averageScore) {
            return -1;
        }
        return  0;
    }
}
class Student implements Comparable<Student>{
    private String name;
    private int stuID;
    private ArrayList<Double> totalScores = new ArrayList<>();
    public Student(String name, int stuID) {
        this.name = name;
        this.stuID = stuID;
    }
    public ArrayList<Double> getTotalScores() {
        return totalScores;
    }
    public int getStuID() {
        return stuID;
    }
    public void addTotalScore(double score){
        totalScores.add(score);
    }
    public int getAverageScore() {
        double score = 0.0;
        for(int i = 0; i < totalScores.size(); i++)
            score += totalScores.get(i);
        if(totalScores.size() == 0)
            return 0;
        else
            return (int)(score / totalScores.size());
    }

    public void scoreShow(){
        if(totalScores.isEmpty())
            System.out.println(stuID+" "+name+" did not take any exams");
        else
            System.out.println(stuID+" "+name+" "+getAverageScore());
    }
    @Override
    public boolean equals(Object obj) {
        Student s = (Student)obj;
        if(this.stuID == s.stuID)
            return true;
        else
            return false;
    }

    @Override

        public int compareTo(Student o) {
            if(this.getStuID() > o.getStuID())
                return 1;
            else if (this.getStuID() < o.getStuID()) {
                return -1;
            }
            return 0;
        }

}

class Course implements Comparable<Course>{
    private String course;
    private String property;
    private String form;
    private ArrayList<Integer> finalScores = new ArrayList<>();
    private ArrayList<Integer> usualScores = new ArrayList<>();
    private ArrayList<Double> totalScores = new ArrayList<>();

    public Course(String course, String property, String form) {
        this.course = course;
        this.form = form;
        this.property = property;
    }

    public String getCourse() {
        return course;
    }

    public String getForm() {
        return form;
    }
    public void addFinalScore(int score){
        finalScores.add(score);
    }
    public void addUsualScore(int score){
        usualScores.add(score);
    }
    public  void addExperimentScore( int...scores){

        int total = 0;
        int i = 0;
        for(int grade:scores)
        {
            total += grade;
            i++;
        }
        totalScores.add((double) total);


    }

    //public void addShiyan(int...score){

    //}

    public void addTotalScore(double score){
        totalScores.add(score);
    }
    public int getAverageFinal(){
        double score = 0.0;
        for(int i = 0; i < finalScores.size(); i++)
            score += finalScores.get(i);
        return (int)(score / finalScores.size());
    }
    public int getAverageUsual(){
        double score = 0.0;
        for(int i = 0; i < usualScores.size(); i++)
            score += usualScores.get(i);
        return (int)(score / usualScores.size());
    }
    public int getAverageTotal(){
        double score = 0.0;
        for(int i = 0; i < totalScores.size(); i++)
            score += totalScores.get(i);
        return (int)(score / totalScores.size());
    }
    public void scoreShow(){
        if(totalScores.isEmpty())
            System.out.println(course+" has no grades yet");
        else{
            if(form.equals("考试"))
                System.out.println(course+" "+getAverageUsual()+" "+getAverageFinal()+" "+getAverageTotal());
            else if(form.equals("考察"))
                System.out.println(course+" "+getAverageFinal()+" "+getAverageTotal());
            else if (form.equals("实验")) {
                System.out.println(course + " "+ getAverageTotal());

            }
        }
    }
    @Override
    public boolean equals(Object obj) {
        Course c = (Course) obj;
        return this.course.equals(c.course);
    }

    @Override
    public int compareTo(Course o) {
        if(this.getAverageTotal() > o.getAverageTotal())
            return -1;
        else if (this.getAverageTotal() < o.getAverageTotal()) {
            return 1;
        }
        return 0;
    }
}

abstract class Score {
    protected int finalScore = 0;
    protected int usualScore = 0;
    ArrayList<Integer>arrayList = new ArrayList<>();

    public Score() {
    }
    public Score(int finalCourse) {
        this.finalScore = finalCourse;
    }
    public Score(int finalCourse, int usualCourse) {
        this.finalScore = finalCourse;
        this.usualScore = usualCourse;
    }

    public Score(int finalScore, int usualScore, ArrayList<Integer> arrayList) {
        this.finalScore = finalScore;
        this.usualScore = usualScore;
        this.arrayList = arrayList;
    }

    public abstract double getTotalScore();
}


class ExamScore extends Score{
    public ExamScore(int finalCourse, int usualCourse) {
        super(finalCourse, usualCourse);
    }
    @Override
    public double getTotalScore(){
        return finalScore * 0.7 + usualScore * 0.3;
    }
}

class ResearchSourse extends Score{
    public ResearchSourse(int finalCourse){
        super(finalCourse);
    }
    @Override
    public double getTotalScore(){
        return finalScore;
    }
}

 class Experimentgrades extends Score{
    int total = 0;
    public Experimentgrades(int...scores){
        int i= 0;
        for(int grade:scores)
        {
            total += grade;
            i++;
        }

    }
    @Override
    public double getTotalScore() {
        return total;
    }
}

这道题难就难在动态数据处理，传参时碰到的问题。我采用了死方法，穷举法（有缺陷），但是却没过测试点。

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

分数 20

作者刘凤良

单位天津仁爱学院

设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩

其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。

请在下面的【】处添加代码。

//动物发生模拟器.  请在下面的【】处添加代码。
public class AnimalShoutTest2 {
    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()
    【】

}

//定义抽象类Animal
【】class Animal{
    【】
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat 【】{
    【】    
    【】
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog 【】{
    【】
    【】
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat 【】{
    【】
    【】
}

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()
    private static void speak(Animal aniaml){
            System.out.println(aniaml.getAnimalClass()+"的叫声"+"："+aniaml.shout());
    }

    }

//定义抽象类Animal
abstract class Animal{
    abstract public String shout();
    abstract public String getAnimalClass();
}
    //基于Animal类，定义猫类Cat，并重写两个抽象方法
    class Cat extends Animal{

        @Override
        public String shout() {
            return "喵喵";
        }

        @Override
        public String getAnimalClass() {
            return "猫";
        }
    }
    //基于Animal类，定义狗类Dog，并重写两个抽象方法
    class Dog extends Animal{

        @Override
        public String shout() {
            return "汪汪";
        }

        @Override
        public String getAnimalClass() {
            return "狗";
        }
    }
    //基于Animal类，定义山羊类Goat，并重写两个抽象方法
    class Goat extends Animal{

        @Override
        public String shout() {
            return "咩咩";
        }

        @Override
        public String getAnimalClass() {
            return "山羊";
        }
    }

这道题没啥难度，最简单的问题。

　　　　容器-ArrayList-排序

题目描述

编辑

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

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

姓名可能会存在重复。

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

import java.util.*;

public class Main {
    public static void main(String[] args) {

        ArrayList<Student> list = new ArrayList<Student>();
        Scanner in = new Scanner(System.in);
        String a = in.nextLine();
        while (!a.equals("end")){
            String[] b = a.split(" ");
            Student student = new Student(b[0],b[1],Integer.parseInt(b[2]),Integer.parseInt(b[3]));

            list.add(student);
            a = in.nextLine();
        }


        Collections.sort(list);
        for (Student student:list
             ) {
            System.out.println(student.getId()+ " "+student.getName() + " " +student.getTotal());
        }
        
    }
}
class Student implements Comparable<Student>{
    private String Id;
     private String name;
     private int chinese;
     private int math;

    public Student(String id, String name, int chinese, int math) {
        Id = id;
        this.name = name;
        this.chinese = chinese;
        this.math = math;
    }

    public String getId() {
        return Id;
    }

    public void setId(String id) {
        Id = id;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public String getName() {
        return name;
    }

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

    public  int  getTotal(){
        return getChinese() + getMath();
    }

    @Override
    public int compareTo(Student o) {
        return o.getTotal() - this.getTotal();
    }
}

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

　　　　 jmu-Java-02基本语法-03-身份证排序

输入n，然后连续输入n个身份证号。
然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出exit并退出。
输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
输入sort2，将所有身份证按照里面的年月日升序输出。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        in.nextLine();
        String[] b = new String[a];
        String[]d = new String[a];
        for (int i = 0; i < a; i++) {
            b[i] = in.nextLine();
        }
        String c= in.nextLine();
        for (;c.equals("sort1")||c.equals("sort2");){
            if (c.equals("sort1")) {
                for (int j = 0; j < a; j++) {
                    d[j] = b[j].substring(6, 10) + "-" + b[j].substring(10, 12) + "-" + b[j].substring(12, 14);
                }
                Arrays.sort(d);
                for (int j = 0; j < a; j++) {
                    System.out.println(d[j]);
                }
            } else if (c.equals("sort2")) {
                for (int j = 0; j < a; j++){
                    d[j] = b[j].substring(6,14);
                }
                Arrays.sort(d);
                for (int j =0 ;j< a;j++) {
                    for(int i = 0;i < a;i++)
                        if(b[i].contains(d[j]))
                            System.out.println(b[i].toString());
                }
            }
            System.out.println("exit");
            c= in.nextLine();


        }

    }
}

　　　　 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack

定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法:

public Integer push(Integer item);
//如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。

public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
public Integer peek();  //获得栈顶元素，如果为空，则返回null.
public boolean empty(); //如果为空返回true
public int size();      //返回栈中元素个数

定义IntegerStack的实现类ArrayIntegerStack，内部使用数组实现。创建时，可指定内部数组大小。

main方法说明

输入n，建立可包含n个元素的ArrayIntegerStack对象
输入m个值，均入栈。每次入栈均打印入栈返回结果。
输出栈顶元素，输出是否为空，输出size
使用Arrays.toString()输出内部数组中的值。
输入x，然后出栈x次，每次出栈均打印。
输出栈顶元素，输出是否为空，输出size
使用Arrays.toString()输出内部数组中的值

import java.util.Arrays;
import java.util.Scanner;
interface IntegerStack {
    public Integer push(Integer item);
        //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。

    public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
    public Integer peek();  //获得栈顶元素，如果为空，则返回null.
    public boolean empty(); //如果为空返回true
    public int size();      //返回栈中元素个数
}


public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        ArrayIntegerStack arrayIntegerStack = new ArrayIntegerStack(a);
        int m = in.nextInt();
        for(int i=0;i<m;i++) {
            int temp = in.nextInt();
            System.out.println(arrayIntegerStack.push(temp));
        }

        System.out.println(arrayIntegerStack.peek()+","+arrayIntegerStack.empty()+","+arrayIntegerStack.size());
        System.out.println(Arrays.toString(arrayIntegerStack.getA()));
        int x = in.nextInt();
        for(int j = 0;j<x;j++) {
            System.out.println(arrayIntegerStack.pop());
        }
        System.out.println(arrayIntegerStack.peek()+","+arrayIntegerStack.empty()+","+arrayIntegerStack.size());
        System.out.println(Arrays.toString(arrayIntegerStack.getA()));
    }
}




class ArrayIntegerStack implements IntegerStack{
    private Integer[] a;
    private int number = 0; // 用于标记数组长度

    public Integer[] getA() {
        return a;
    }

    public void setA(Integer[] a) {
        this.a = a;
    }
    public ArrayIntegerStack(int b){
        a = new Integer[b];
        number = 0;
    }

    @Override
    public Integer push(Integer item) {
        if(item==null) {
            return null;
        }
        if(number==this.a.length) {
            return null;
        }
        a[number++]=item;
        return item;

    }

    @Override
    public Integer pop() {
        if(number==0) {
            return null;
        }
        number--;
        return a[number];
    }

    @Override
    public Integer peek() {
        if(number==0) {
            return null;
        }
        return a[number-1];
    }

    @Override
    public boolean empty() {
        if(number==0) {
            return true;
        }
        else {
            return false;
        }
    }

    @Override
    public int size() {
        return number;
    }
}

　　　　 jmu-Java-03面向对象基础-05-覆盖

Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。

1. 新建PersonOverride类

a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。

b. 有参构造方法，参数为name, age, gender

c. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true

d.toString()方法返回格式为：name-age-gender

e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.

2. main方法

2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。

提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。

import java.util.Objects;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int n1 = in.nextInt();
        PersonOverride[] personOverride =new PersonOverride[n1];
        for(int i=0;i<n1;i++) {
            personOverride[i] = new PersonOverride();
        }
        int n2 = in.nextInt();
        PersonOverride[] personOverrides = new PersonOverride[n2];
        int length = 0;
        for(int i=0;i<n2;i++) {
            String name = in.next();
            int age = in.nextInt();
            boolean gender = in.nextBoolean();
            boolean flag = true;
            PersonOverride personOverride1 = new PersonOverride(name, age, gender);
            for (int j = 0; j < length; j++) {
                if (personOverrides[j].equals(personOverride1)) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                personOverrides[length] = personOverride1;
                length++;
            }
        }
            for(PersonOverride personOverride2:personOverride) {
                System.out.println(personOverride2);
            }
            for(int j=0;j<length;j++) {
                System.out.println(personOverrides[j]);
            }
            System.out.println(length);
            System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
        }
    }



 class PersonOverride {
    private String name;
    private  int age;
    private boolean gender;

    public PersonOverride() {
        this("default",1,true);
    }

    public PersonOverride(String name, int age, boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    @Override
    public String toString() {
        return name + "-" + age + "-" + gender;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o){
            return true;
        }
        if(o == null)
        {
            return false;
        }
        if (this.getClass() != o.getClass()){
            return false;
        }
        PersonOverride p = (PersonOverride) o;
        return Objects.equals((this.name), p.name) && this.gender == p.gender && this.age==p.age;
    }


}

按照它给的一步一步写，应该是不难的。

3.踩坑心得

题目集8，我觉的没啥问题，大部分的给的测试点都能过

这是我的类图，经过室友的指点我改善了代码，把比较方法，使用compartor接口来实现，非常好用。最后，是代码超限，拿不下较大分数。这是比较要注意改进的地方。

因为我删代码，删了那些错误输出，结果没过这些代码。

但是我测过那些代码，实际上是全部能过的。

题目集9

这里的正常测试我都试了几十遍了，但还是没有试出来为什么结果错了。还有那个方括号我也是测过了，不知道为什代码错了，现在我也还是不知道为什么。

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
    public static void main(String[] args) {
        HashMap<String,Integer> hashMap = new HashMap<>();
        String[] s = { "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const","continue", "default", "do", "double", "else", "enum", "extends", "false", "final", "finally", "float", "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native", "new", "null", "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "void", "volatile", "while" };//关键词数组
        int count = 0;
        Scanner input = new Scanner(System.in);
        String a = input.nextLine();
        String b = "";

        for(;!a.equals("exit");){//输入代码,拼接代码
            b = b + "\n" + a;
            a = input.nextLine();
        }
        if(b.isEmpty())//判断输入的代码是否为空int
            System.out.println("Wrong Format");
        else{
            b = delete(b);
            b = delete1(b);
            b = delete2(b);
            b = delte3(b);
            b = delte4(b);
            b = delte5(b);

        }
        for(int i = 0;i < s.length; i ++){//数量统计
            Pattern pattern = Pattern.compile("\\b" + s[i] + "\\b");// 创建关键词的正则表达式
            Matcher matcher = pattern.matcher(b);// 字符串与关键词匹配
            count = 0;
            while (matcher.find()) // 找到该关键词的话,记录该关键词的次数
                count++;
            if (count != 0)
                hashMap.put(s[i], count);
        }
        Set set = hashMap.keySet();
        Object[] arr = set.toArray();
        Arrays.sort(arr);
        for (Object k : arr) {
            System.out.println(hashMap.get(k) + "\t" + k);
        }
    }
    public static String delete(String b){//删除字符串的内容
            String c = "\".*?\"";
            String tmep = b.replaceAll(c," ");
            return tmep;
    }
    public static String delete1(String b){//删除单行注释
        String d = "//.*";
        String tmep = b.replaceAll(d," ");
        return tmep;
    }
    public static String delete2(String c){//删除多行注释
        String e = "/\\*[\\s\\S]*?\\*///";
        String tmep = c.replaceAll(e," ");
        return tmep;
    }
    private static String delte3(String d) {
        String f = "\\[" ;
        String temp = d.replaceAll(f," ");
        return temp;
    }
    private static String delte4(String b) {
        String f = "\\]" ;
        String temp = b.replaceAll(f," ");
        return temp;
    }
    private static String delte5(String b) {
        String f = "\\," ;
        String temp = b.replaceAll(f," ");
        return temp;
    }
}