BLOG-3

一、题目集分析

本次博客将对PTA的第6-8次题目集进行分析，情况如下：

（1）题量分析：

• 第一次练习共计1题（课程成绩统计程序-1）
• 第二次练习共计4题（3道HashMap类型题目的基础操作外加课程成绩统计程序-2）
• 第三次练习共计5题（课程成绩统计程序-3）

　　从题量而言，数量适中。

（2）知识点分析：

第一次题目集作为课程成绩统计系统的母题给出了该系统的基本框架要求，即相关的类，以及类与类之间的作用关系，像学生类，班级类，成绩类。然后给出相关输入输出的异常情况要求。总体上而言，该题的多种异常情况的处理是一大难点，需要同学们合理运用正则表达式以及先通过解析类进行处理输入的数据，否则的话会导致当输入的异常情况过于复杂时，对应异常情况的输出会出现混论的特点。
第二次题目集考察了HashMap的检索与排序外加一道动物发生器的多态问题，然后就是课程成绩统计系统的加强版，加入了实验课，对实验课的权重要进行分析。
第三次题目集延续题目集二出现了课程成绩统计程序3的题目，此题综合性较强，涉及知识点的灵活运用程度较高，题目涉及面较广，内容上综合性不断提升。
二、相关题目源码分析

• 课程成绩统计程序-1

　　1.题目

　　2.题目类图

　　3.题目分析

首先，需要根据所给的类图进行架构，由于题目要求是循环输入，当遇到“end”截至。其中输入的有效数据主要有两种，分别是：（1）课程类信息（2）学生个人的对应课程的成绩信息。我们首先再读入的过程中就需要对这两种不同的信息进行区分，于是直接以字符串的形式读取，再调用slip函数进行分隔，最后通过正则表达式进行处理的方式为最优方式。对于课程信息类，其输入是为了创建一个课表，对应于后续的一系列选择了该课的学生的成绩进行分析。其实此时便可以看出我们需要一个类，其可以架通学生和课程，于是程序之初我们选择先行写入一个选课类，再在其中放入一个课程类的list和一个学生类的list。在此提醒，解析类的作用是及逆行判别的，为了使解析类 看起来更加的清晰明了，我们最好是再写一个方法，其中调用解析类，再根据解析类的返回值走出相应的异常处理。做好这些后，当课程信息符合要求即将其存入列表中，当学生信息符合要求也将其存入列表中。由于选课类很好的组合了课程类和学生类，于是我们选择在选课类中建立相关的方法用于计算学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。再在主方法中调用这些方法进行输出，使得整体的代码看上去更加的简洁明了。

　　4.源代码

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

public class Main {

    public static void main(String[] args) {
        
        int flag1=1;//成绩超出范围的wrongformat检测
        
        
        //输入的前半段必须建立一张课表作为标准
        CourseTable k = new CourseTable();
        //后半段输入时必须建立一张多班级的列表
        BanjiTable b = new BanjiTable();
        //再开始进行输入处理
        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        while (!s.equals("end")) {
            String[] str = s.split(" ");
            if (str.length == 3) {
                if(k.FindCourse(str[0])==null) {
                    //建立课表信息
                    Course a = new Course(str[0],str[1],str[2]);//创建好单门课程信息后加入大课表
                    if(str[1].equals("必修")&&str[2].equals("考察")) {
                        a.setFlag(0);
                        System.out.println(str[0]+" : course type & access mode mismatch");
                    }
                    k.getCourselist().add(a);
                }
            } else if (str.length == 4||str.length==5) {//则表示一定是学生信息，于是先对学生信息建立对象
                Student stu = new Student(str[0],str[1]);
                
                //再为学生的个人课程列表建立信息
                if(k.FindCourse(str[2])!=null) {
                    //在班级存在的前提下比对该学生是否已经存在，若存在则无需建立新的学生信息
                    String coursename = k.FindCourse(str[2]).getCoursename();
                    String xiu = k.FindCourse(str[2]).getXiu();
                    String form = k.FindCourse(str[2]).getForm();
                    Course personbiao = new Course(coursename,xiu,form);
                    stu.getPersoncourse().add(personbiao);
                    if(str.length==4&&xiu.equals("选修")) {
                        int m = Integer.parseInt(str[3]);
                        if(m>100) {
                            flag1=0;
                        }
                        stu.getPersoncourse().get(stu.getPersoncourse().size()-1).setNormalscore(m);
                        stu.getPersoncourse().get(stu.getPersoncourse().size()-1).setFinalscore(m);
                    }else if(str.length==5&&form.equals("考试")) {
                        int m1 = Integer.parseInt(str[3]);
                        int m2 = Integer.parseInt(str[4]);
                        if(m1>100||m2>100) {
                            flag1=0;
                        }
                        stu.getPersoncourse().get(stu.getPersoncourse().size()-1).setNormalscore(m1);
                        stu.getPersoncourse().get(stu.getPersoncourse().size()-1).setFinalscore(m2);
                    }else {
                        if(str.length==4&&form.equals("考察")&&xiu.equals("必修")) {        
                            System.out.println(str[2]+" does not exist");
                        }
                        if((form.equals("考察")&&str.length!=4)||(form.equals("考试")&&str.length!=5)) {
                            System.out.println(str[0]+" "+str[1]+" : access mode mismatch");
                        }
                        if(str.length==4&&xiu.equals("必修")) {
                            stu.setFlag(0);
                        }        
                    }
                    //比对成功说明课程存在
                    String banhao = str[0].substring(0,6);
                    if(b.FindBanji(banhao)!=null) {//如果比对成功说明班级已经存在，则将学生信息录入已存在的班级
                        //再在班级中比对该学生是否存在
                        if(b.FindBanji(banhao).FindStudent(str[0])!=null) {
                            //如果学生也存在还需判断这个学生这门课的成绩是否也存在
                            //比对个人课表
                            Student yicunzai = b.FindBanji(banhao).FindStudent(str[0]);
                            //首先判断这个学生的课表里有没有这门课
                            //有则判断该课成绩是否为0，为0可修改
                            //有成绩不为0，则执行空方法
                            //没有，则给该学生的个人列表中加入课程信息
                            if(yicunzai.FindPersonCourse(str[2])==null) {
                                yicunzai.getPersoncourse().add(personbiao);
                                int weizhi = yicunzai.getPersoncourse().size()-1;
                                if(str.length==4) {
                                    int m = Integer.parseInt(str[3]);
                                    if(m>100) {
                                        flag1=0;
                                    }
                                    yicunzai.getPersoncourse().get(weizhi).setNormalscore(m);
                                    yicunzai.getPersoncourse().get(weizhi).setFinalscore(m);
                                }else if(str.length==5) {
                                    int m1 = Integer.parseInt(str[3]);
                                    int m2 = Integer.parseInt(str[4]);
                                    if(m1>100||m2>100) {
                                        flag1=0;
                                    }
                                    yicunzai.getPersoncourse().get(weizhi).setNormalscore(m1);
                                    yicunzai.getPersoncourse().get(weizhi).setFinalscore(m2);    
                                }
                            }else {//不为null,说明学生已有这门课
                                if(!yicunzai.FindCourseFen(str[2])) {
                                    //可以添加成绩的前提条件是课程
                                    if(str.length==4) {
                                        int m = Integer.parseInt(str[3]);
                                        if(m>100) {
                                            flag1=0;
                                        }
                                        yicunzai.FindPersonCourse(str[2]).setNormalscore(m);
                                        yicunzai.FindPersonCourse(str[2]).setFinalscore(m);
                                    }else if(str.length==5) {
                                        int m1 = Integer.parseInt(str[3]);
                                        int m2 = Integer.parseInt(str[4]);
                                        if(m1>100||m2>100) {
                                            flag1=0;
                                        }
                                        yicunzai.FindPersonCourse(str[2]).setNormalscore(m1);
                                        yicunzai.FindPersonCourse(str[2]).setFinalscore(m2);
                                    }
                                }
                            }    
                        }else {
                            //班级已存在，但是该学生不存在
                            Banji q = b.FindBanji(banhao);
                            q.getStudentlist().add(stu);
                        }
                    }else {//否则的话新建一个班级，把该行学生信息加入班级中，再加入列表中
                        Banji a = new Banji(banhao);
                        a.getStudentlist().add(stu);
                        b.getBanjilist().add(a);
                    }
                }else {
                    System.out.println(str[0]+" "+str[1]+" "+str[2]+" does not exist");
                }
            }
            s = input.nextLine();
        }
        /***********************************************************************************/
        //对应处理问题的输出
        if(flag1==0) {
            System.out.println("wrong format");
        }
        if(flag1==1) {
            //(1)第一部分的输出对应为以学生为中心的输出
            b.getBanjilist().sort(Comparator.naturalOrder());
            for (int i=0;i<b.getBanjilist().size(); i++) {
                b.getBanjilist().get(i).getStudentlist().sort(Comparator.naturalOrder());
                //将班级列表中的每一个班级提出对单个班级中的学生按照学号进行排序
                //再依照学号顺序输出每位学生的总成绩平均分
                for (int j=0;j<b.getBanjilist().get(i).getStudentlist().size();j++) {
                    if(b.getBanjilist().get(i).getStudentlist().get(j).getFlag()==0||b.getBanjilist().get(i).getStudentlist().get(j).PersonAverageScore()==0) {
                        System.out.println(b.getBanjilist().get(i).getStudentlist().get(j).getNum()+" "+b.getBanjilist().get(i).getStudentlist().get(j).getName()+" did not take any exams");
                    }
                    //20201103 张三 34
                    String studentnum = b.getBanjilist().get(i).getStudentlist().get(j).getNum();
                    String studentname = b.getBanjilist().get(i).getStudentlist().get(j).getName() ;
                    int personAver = b.getBanjilist().get(i).getStudentlist().get(j).PersonAverageScore();
                    if(personAver!=0) {
                        System.out.println(studentnum+" "+studentname+" "+personAver);
                    }
                }
            }
        }
        
        //（3）第三部分的输出对应为以课程为中心的输出——输出单门课程的各大平均成绩
        k.giveNumToCourse();
        k.getCourselist().sort(Comparator.naturalOrder());
        if(b.getBanjilist().size()!=0) {
            b.NormalAverage(k);
        }
        for(int i=0;i<k.getCourselist().size();i++) {
            String kename = k.getCourselist().get(i).getCoursename();
            int kenormalfen = k.getCourselist().get(i).getAvernormalscore();
            int kefinalfen = k.getCourselist().get(i).getAverfinalscore();
            int ketotalfen = k.getCourselist().get(i).getAvertotalscore();
            if(kenormalfen==0&&kefinalfen==0&&ketotalfen==0||flag1==0) {
                if(k.getCourselist().get(i).getFlag()==1||flag1==0) {
                    System.out.println(kename+" has no grades yet");
                }
            }else {
                if(k.getCourselist().get(i).getForm().equals("考察")) {//这种情况下只需要输出平时成绩的平均分和总平均分即可
                    System.out.println(kename+" "+kenormalfen+" "+ketotalfen);
                }else {
                    System.out.println(kename+" "+kenormalfen+" "+kefinalfen+" "+ketotalfen);
                }
            }
        }
        
        if(flag1==1) {
            //（4）第四部分的输出对应为以班级成绩为中心的输出
            for (int i=0;i<b.getBanjilist().size(); i++) {
                b.getBanjilist().get(i).setTotalCourse(k);
                b.getBanjilist().get(i).setTotalFen();
                b.getBanjilist().get(i).setTotalAverFen();
                String banname = b.getBanjilist().get(i).getClassnum();
                int banfen = b.getBanjilist().get(i).getTotalAverFen();
                if(banfen==0) {
                    System.out.println(banname+" has no grades yet");
                }else {
                    System.out.println(banname+" "+banfen);
                }    
            }
        }
        input.close();
    }
}

/**********************************************************************/
class Course implements Comparable<Course>{
    private int sortNumber;
    public int getSortNumber() {
        return sortNumber;
    }
    public void setSortNumber(int sortNumber) {
        this.sortNumber = sortNumber;
    }
    private int flag=1;//判断该种课程性质是否存在
    public int getFlag() {
        return flag;
    }
    public void setFlag(int flag) {
        this.flag = flag;
    }
    private String coursename;
    private String xiu;//选修必修
    private String form;//考试or考察
    private int normalscore=0;//平时成绩
    private int finalscore=0;//期末成绩，对于考察课程可以令其期末成绩为0
    private int totalscore=0;//这门课的总成绩
    /*************************************/
    //另一部分变量只有在统计课程均分的时候才用的到
    private int avernormalscore=0;
    private int averfinalscore=0;
    private int avertotalscore=0;
    
    
    
    public int getAvernormalscore() {
        return avernormalscore;
    }
    public void setAvernormalscore(int avernormalscore) {
        this.avernormalscore = avernormalscore;
    }
    public int getAverfinalscore() {
        return averfinalscore;
    }
    public void setAverfinalscore(int averfinalscore) {
        this.averfinalscore = averfinalscore;
    }
    public int getAvertotalscore() {
        return avertotalscore;
    }
    public void setAvertotalscore(int avertotalscore) {
        this.avertotalscore = avertotalscore;
    }
    public void setNormalscore(int normalscore) {
        this.normalscore = normalscore;
    }
    public void setFinalscore(int finalscore) {
        this.finalscore = finalscore;
    }
    /***********************************/
    public String getCoursename() {
        return coursename;
    }
    public int getNormalscore() {
        return normalscore;
    }
    public int getFinalscore() {
        return finalscore;
    }
    public int getTotalscore() {
        return (int)(this.normalscore*0.3+this.finalscore*0.7);
    }
    public String getXiu() {
        return xiu;
    }
    public String getForm() {
        return form;
    }
    //单门课程构造器
    Course(String coursename,String xiu,String form){
        this.coursename=coursename;
        this.xiu=xiu;
        this.form=form;
    }
    //一个方法用于course排序
        public int compareTo(Course a) {
            int n1 = this.sortNumber;
            int n2 = a.getSortNumber();
            if (n1>n2)
                return 1;
            else if (n1<n2)
                return -1;
            return 0;
        }
}
/**********************************************************************/
class CourseTable {
    private ArrayList<Course> courselist = new ArrayList<>();
    
    public ArrayList<Course> getCourselist() {
        return courselist;
    }
    
    
    //给一个方法将公共大课表里面的课程信息进行赋值
    public void giveNumToCourse() {
        for(int i=0;i<courselist.size();i++) {
            if(courselist.get(i).getCoursename().equals("java")) {
                courselist.get(i).setSortNumber(1);
            }else if(courselist.get(i).getCoursename().equals("数据结构")) {
                courselist.get(i).setSortNumber(2);
            }else if(courselist.get(i).getCoursename().equals("数据库")) {
                courselist.get(i).setSortNumber(3);
            }else if(courselist.get(i).getCoursename().equals("形式与政治")) {
                courselist.get(i).setSortNumber(4);
            }
        }
    }
    
    //一个方法返回公共大课表中该课程的信息
    public Course FindCourse(String name) {
        for(int i=0;i<courselist.size();i++) {
            if(courselist.get(i).getCoursename().equals(name)) {
                return courselist.get(i);
            }
        }
        return null;
    }
}
/*********************************************************************/
class Student implements Comparable<Student>{
    private int flag =1;//判断学生是否没参加考试
    public int getFlag() {
        return flag;
    }
    public void setFlag(int flag) {
        this.flag = flag;
    }
    private String num;//学号
    private String name;//姓名
    private double persontotalfen=0;//该学生所有课程的总分
    private ArrayList<Course> personcourse = new ArrayList<>();//每位学生自己的课程列表
    
    public String getNum() {
        return num;
    }
    public String getName() {
        return name;
    }
    public double getPersontotalfen() {
        return persontotalfen;
    }
    public ArrayList<Course> getPersoncourse() {
        return personcourse;
    }
    //直接根据学号姓名可建立学生信息
    Student(String num,String name){
        this.num=num;
        this.name=name;
    }
    //一个方法判断个人的该门课程是否有分
    public boolean FindCourseFen(String s) {
        for(int i=0;i<this.personcourse.size();i++) {
            if(personcourse.get(i).getCoursename().equals(s)&&personcourse.get(i).getFinalscore()!=0) {
                return true;
            }
        }
        return false;
    }
    //一个方法检查个人课程列表中的已有课程
    public Course FindPersonCourse(String s) {
        for(int i=0;i<this.personcourse.size();i++) {
            if(personcourse.get(i).getCoursename().equals(s)) {
                return personcourse.get(i);
            }
        }
        return null;
    }
    //一个方法计算一个学生所有课程总分下的平均分
    public int PersonAverageScore() {
        int aver=0;
        double sum=0;
        for(int i=0;i<personcourse.size();i++) {
            sum+=personcourse.get(i).getNormalscore()*0.3+personcourse.get(i).getFinalscore()*0.7;
        }
        this.persontotalfen=sum;
        aver+=(int)(sum/personcourse.size());
        return aver;
    }
    //写好两个学生学号的比较
    public int compareTo(Student a) {
        int n1 = Integer.parseInt(this.num);
        int n2 = Integer.parseInt(a.getNum());
        if (n1>n2)
            return 1;
        else if (n1<n2)
            return -1;
        return 0;
    }
}
/*********************************************************************/
class Banji implements Comparable<Banji>{
    private String classnum;
    private double totalfen;
    private int cent=0;//记录这个班级总共参与了几门课程
    private int TotalAverFen;//班级所有成绩的总均分
    private ArrayList<Student> studentlist = new ArrayList<>();
    public String getClassnum() {
        return classnum;
    }
    public int getTotalAverFen() {
        return TotalAverFen;
    }
    public ArrayList<Student> getStudentlist() {
        return studentlist;
    }
    // 班级的构造器
    Banji(String classnum) {
        this.classnum = classnum;
    }
    //传入学生学号，在班级里面找人，如果找到则返回学生对象
    public Student FindStudent(String num) {
        for(int i=0;i<studentlist.size();i++) {
            if(studentlist.get(i).getNum().equals(num)) {
                return studentlist.get(i);
            }
        }
        return null;
    }
    //传入大课程列表进行比对，从而计数该班级已经参与的课程
    public void setTotalCourse(CourseTable a) {
        for(int i=0;i<a.getCourselist().size();i++) {
            for(int j=0;j<studentlist.size();j++) {
                //再找每个学生的课表进行比对
                for(int k=0;k<studentlist.get(j).getPersoncourse().size();k++) {
                    if(studentlist.get(j).getPersoncourse().get(k).getCoursename().equals(a.getCourselist().get(i).getCoursename())) {
                        this.cent++;
                        break;
                    }
                }
            }
        }
    }
    //计算班级所有人所有课程的总成绩分
    public void setTotalFen() {
        double sum=0;
        for(int i=0;i<studentlist.size();i++) {
            sum+=studentlist.get(i).getPersontotalfen();
        }
        this.totalfen=sum;
    }
    //计算该班级所有课程的总成绩的平均分
    public void setTotalAverFen() {
        this.TotalAverFen=(int)(this.totalfen/this.cent);
    }
    //写好两个班级号的比较
    public int compareTo(Banji a) {
        int n1 = Integer.parseInt(this.classnum);
        int n2 = Integer.parseInt(a.getClassnum());
        if (n1>n2)
            return 1;
        else if (n1<n2)
            return -1;
        return 0;
    }
}
/*********************************************************************/
class BanjiTable{
    private ArrayList<Banji> banjilist = new ArrayList<>();
    public ArrayList<Banji> getBanjilist() {
        return banjilist;
    }
    //通过比对班号返回班级对象
    public Banji FindBanji(String num) {
        for(int i=0;i<banjilist.size();i++) {
            if(banjilist.get(i).getClassnum().equals(num)) {
                return banjilist.get(i);
            }
        }
        return null;
    }
    //一个方法传入课程列表，依照大课表来计算单门课程的（1）平时成绩平均分（2）期末平均分（3）总平均分
    public void NormalAverage(CourseTable a) {//直接在方法中将课程列表中的课程的各类平均分全根据数据设置好
        //比对课名，提取数据计算
        for(int i=0;i<a.getCourselist().size();i++) {
            int cent=0;//对应每一门课的人数进行计数
            int sum1=0;//对应一门课的平时成绩总分
            int sum2=0;//对应一门课的期末成绩总分
            int sum3=0;//对应一门课的所有人的总分
            //先遍历班级列表
            for(int j=0;j<banjilist.size();j++) {
                //再遍历每个班级的学生列表
                for(int k=0;k<banjilist.get(j).getStudentlist().size();k++) {
                    //再比对每个学生个人列表中的课程，调出正在统计的课程的平时分
                    for(int m=0;m<banjilist.get(j).getStudentlist().get(k).getPersoncourse().size();m++) {
                        int n1=banjilist.get(j).getStudentlist().get(k).getPersoncourse().get(m).getNormalscore();
                        int n2=banjilist.get(j).getStudentlist().get(k).getPersoncourse().get(m).getFinalscore();
                        int n3=banjilist.get(j).getStudentlist().get(k).getPersoncourse().get(m).getTotalscore();
                        if(banjilist.get(j).getStudentlist().get(k).getPersoncourse().get(m).getCoursename().equals(a.getCourselist().get(i).getCoursename())&&(n1+n2+n3!=0)) {
                            cent++;
                            sum1+=n1;
                            sum2+=n2;
                            sum3+=n3;
                        }
                    }
                }
            }
            //对课程列表中的课程下的平均分进行设定
            if(cent!=0) {
                a.getCourselist().get(i).setAvernormalscore((int)(sum1/cent));
                a.getCourselist().get(i).setAverfinalscore((int)(sum2/cent));
                a.getCourselist().get(i).setAvertotalscore((int)(sum3/cent));
            }
        }
    }
}

• 容器-HashMap-排序

　　1.题目

 

　　2.源代码

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

public class Main {

    public static void main(String[] args) {
        List<Student> banji = new ArrayList<Student>();
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        while(!str.equals("end")) {
            String[] student = new String[3];
            student=str.split(" ");
            int score = Integer.parseInt(student[2]);
            Student a = new Student(student[0],student[1],score);
            banji.add(a);
            str = input.nextLine();
        }
        //检索学生信息
        Students StudentTable = new Students(banji);
        StudentTable.ShowSortStudent();
        input.close();
    }

}

class Student implements Comparable<Student>{
    private String num;//每个学生的标识符，唯一且不相同（key)
    private String name;
    private int score;
    
    public String getNum() {
        return num;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }

    Student(String num,String name,int score){
        this.num=num;
        this.name=name;
        this.score=score;
    }
    
    //实现了从大到小的正向排序
    public int compareTo(Student student2) {
        int s1, s2;
        s1 = Integer.parseInt(getNum());
        s2 = Integer.parseInt(student2.getNum());
        if (s1 > s2)
            return -1;
        else if (s1 < s2)
            return 1;
        return 0;
    }
    
}

class Students{
    private List<Student> list;
    private Map<String,Student> studentMap;
    
    Students(List<Student> list){
        this.list=list;
        studentMap=new HashMap();
        for(Student a : this.list) {
            studentMap.put(a.getNum(),a);
        }
    }

    public Student FindStudentByNum(String studentnum) {
        Student a = studentMap.get(studentnum);
        return a;
    }
    
    public void ShowSortStudent() {
        this.list.sort(Comparator.naturalOrder());
        for(int i=0;i<list.size();i++) {
            System.out.println(list.get(i).getNum()+" "+list.get(i).getName()+" "+list.get(i).getScore());
        }
    }
}

 

• 容器-HashMap-检索　　

　　1.题目

　　2.源代码

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        List<Student> banji = new ArrayList<Student>();
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        while(!str.equals("end")) {
            String[] student = new String[3];
            student=str.split(" ");
            int score = Integer.parseInt(student[2]);
            Student a = new Student(student[0],student[1],score);
            banji.add(a);
            str = input.nextLine();
        }
        //检索学生信息
        Students StudentTable = new Students(banji);
        String q = input.next();
        Student person = StudentTable.FindStudentByNum(q);
        if(person!=null) {
            System.out.println(person.getNum()+" "+person.getName()+" "+person.getScore());
        }else {
            System.out.println("The student "+q+" does not exist");
        }
        
        input.close();
    }

}

class Student{
    private String num;//每个学生的标识符，唯一且不相同（key)
    private String name;
    private int score;
    
    public String getNum() {
        return num;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }

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

class Students{
    private List<Student> list;
    private Map<String,Student> studentMap;
    
    Students(List<Student> list){
        this.list=list;
        studentMap=new HashMap();
        for(Student a : this.list) {
            studentMap.put(a.getNum(),a);
        }
    }

    public Student FindStudentByNum(String studentnum) {
        Student a = studentMap.get(studentnum);
        return a;
    }
}

 

• 动物发声模拟器（多态）

　　1.题目

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

 

　　2.源代码

//动物发生模拟器.  请在下面的【】处添加代码。
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 a) {
        String s1 = a.getAnimalClass();
        String s2 = a.shout();
        System.out.println(s1+"的叫声："+s2);
    }

}

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

    @Override
    public String getAnimalClass() {
        String a = "猫";
        return a;
    }

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

    @Override
    public String getAnimalClass() {
        String a = "狗";
        return a;
    }

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

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

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

 

• 课程成绩统计程序-2

1.题目

 

2.题目类图

 

3.题目分析

 该题在课程成绩统计系统1上增添了实验课，并对实验课的次数进行了限制要求，同时还增添了一项新的操作即可以在建立课程列表的时候对考试课程的平时成绩和期末成绩的权重可以自主设置。这些新要求的出现可以直接通过在成绩类和课程类中进行修改。与此同时，我们还需要修改解析类中的判别，对实验课的数量以及成绩单输入进行限制。

4.源代码

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

public class Main {
    public static void main(String[] args) {
          Scanner s = new Scanner(System.in);
            String record = s.nextLine();
            ParseInput handle=new ParseInput();
            while (!record.equals("end")) {
                handle.parseInput(record);//解析用户输入的每一行数据
                record = s.nextLine();
            }
            handle.showStudents();
            handle.showCourses();
            handle.showClasses();
    }
}
/*********************************************************************************************************/
class Inputmatching {
    static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
    static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String scoreMatching = "([1-9]?[0-9]|100)";
    static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String courseTypeMatching = "(选修|必修|实验)";
    static String checkcourseTypeMatching = "(考试|考察|实验)";
    //cousrInput用于定义课程信息模式（正则表达式）
    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
    //scoreInput用于定义成绩信息模式（正则表达式）
    public static int matchingInput(String s) {
        if (matchingCourse(s)) {
            return 1;
        }
        if (matchingScore(s)) {
            return 2;
        }
        return 0;//如果返回0则一定是格式错了或者成绩不对
    }
    //对应课程类信息正则表达式匹配
    private static boolean matchingCourse(String s) {
        return s.matches(courseInput);
    }
    
    private static boolean matchingScore(String s) {
        //只要格式没错，成绩没超出范围
        String[] a = s.split(" ");
        boolean t1 = a[0].matches(stuNumMatching);
        boolean t2 = a[1].matches(stuNameMatching);
        boolean t3 = a[2].matches(courseNameMatching);
        boolean t4 = true;
        for(int i=3;i<a.length;i++) {
            t4 = a[i].matches(scoreMatching);
        }
        return (t1&&t2&&t3&&t4);
    }
}
/************************************************************************************************************/
//解析处理类，在此调用方法
class ParseInput {
    
    Xuanke Table = new Xuanke();
    
    //在此方法中调用正则表达式进行匹配
    public void parseInput(String record) {
        Inputmatching a = new Inputmatching();
        int n = a.matchingInput(record);
        if(n==1) {
            //建立课程列表
            String str1[] = new String[3];
            str1 = record.split(" ");
            Course b = new Course(str1[0],str1[1],str1[2]);
            //先检查课程信息是否匹配错误
            if(b.IfCourseFit()==-1) {
                System.out.println(b.coursename+" : course type & access mode mismatch");
            }
            //再查重，若原先没有该课则加入
            //若原先有但是信息匹配出错则修改
            if(Table.FindCourse(str1[0])!=null) {
                Course q = Table.FindCourse(str1[0]);
                if(q.IfCourseFit()==-1) {
                    q.xingzhi=str1[1];
                    q.fangshi=str1[2];
                }
            }else {
                Table.a.add(b);
            }
            
        }else if(n==2) {
            //建立学生信息
            String str2[] = new String[3];
            str2 = record.split(" ");
            String banjihao = str2[0].substring(0,6);
            
            if(Table.FindCourse(str2[2])==null) {
                System.out.println(str2[0]+" "+str2[1]+" :"+str2[2]+" does not exist");
            }else if(IfScorseNumberRight(record)!=1){
                if(IfScorseNumberRight(record)==-1) {
                    System.out.println("wrong format");
                }else {
                    Student m = new Student(str2[0],str2[1]);
                    Course q = Table.FindCourse(str2[2]);
                    Course p = new Course(q.coursename,q.xingzhi,q.fangshi);
                    m.a.add(p);
                    Table.b.add(m);
                    if(Table.FindBanji(banjihao)!=null) {
                        Banji s = Table.FindBanji(banjihao);
                        if(s.FindStudent(m.num)==null) {
                            s.a.add(m);
                        }
                    }else {
                        Banji s = new Banji(banjihao);
                        s.a.add(m);
                        Table.c.add(s);
                    }
                    System.out.println(str2[0]+" "+str2[1]+" : access mode mismatch");
                }
            }else{
                    Student m = new Student(str2[0],str2[1]);
                    Course q = Table.FindCourse(str2[2]);
                    Course p = new Course(q.coursename,q.xingzhi,q.fangshi);
                    p.AddScore(str2);
                    m.a.add(p);
                    Table.b.add(m);
                    if(Table.FindBanji(banjihao)!=null) {
                        Banji s = Table.FindBanji(banjihao);
                        if(s.FindStudent(m.num)==null) {
                            s.a.add(m);
                        }
                    }else {
                        Banji s = new Banji(banjihao);
                        s.a.add(m);
                        Table.c.add(s);
                    }
            }
        }else if(n==0){
            System.out.println("wrong format");
        }    
    }
    
    //成绩解析的第二种异常
    public int IfScorseNumberRight(String s) {
        String[] a = s.split(" ");
        if(Table.FindCourse(a[2]).fangshi.equals("考察")&&a.length==4) {
            return 1;
        }else if(Table.FindCourse(a[2]).fangshi.equals("考试")&&a.length==5) {
            return 1;
        }else if(Table.FindCourse(a[2]).fangshi.equals("实验")) {
            int n = Integer.parseInt(a[3]);
            if(n<=3) {
                return -1;
            }else if(a.length==4+n){
                return 1;
            }
        }
        return 0;
    }
    
    public void showStudents() {
        Table.PrintStudentTotalAver();
    }

    public void showCourses() {
        Table.PrintCourseKindAver();
    }

    public void showClasses() {
        Table.PrintBanjiAverScore();
        
    }
         
}
/*****************************************************************************************************/

class Student implements Comparable<Student> {
    String num;//学号
    String name;//姓名
    ArrayList<Course> a = new ArrayList<Course>();//个人课表
    
    Student(String num,String name){
        this.num=num;
        this.name=name;
    }
    
    //根据课程名在课表中找课
    public Course FindCourse(String s) {
        for(int i=0;i<a.size();i++) {
            if(a.get(i).coursename.equals(s)) {
                return a.get(i);
            }
        }
        return null;
    }
    
    public int PersonTotalAver() {
        int sum=0;
        int cent=0;
        for(int i=0;i<a.size();i++) {
            sum+=a.get(i).sumscore;
            cent++;
        }
        return (int)(sum/cent);
    }
    
    public int compareTo(Student a) {
        int n1,n2;
        n1 = Integer.parseInt(this.num);
        n2 = Integer.parseInt(a.num);
        if(n1>n2)
            return 1;
        else if(n1<n2)
            return -1;
        return 0;
    }
    
}
/*******************************************************************************************************/
class Course implements Comparable<Course>{
    int Flag=0;//记录课程的输出顺序
    String coursename;//课程名
    String xingzhi;//课程形式：必修、选修、实验
    String fangshi;//课程考察方式：考试、考察、实验
    int pingshi=0;//平时成绩分数
    int qimo=0;//期末成绩的分数
    int[] shiyan = new int[9];//若该门课程为实验对应的分数
    int sumscore=0;//总成绩
    
    Course(String coursename,String xingzhi,String fangshi){
        this.coursename=coursename;
        this.xingzhi=xingzhi;
        this.fangshi=fangshi;
        if(coursename.equals("C语言")) {
            this.Flag=1;
        }else if(coursename.equals("java")) {
            this.Flag=2;
        }else if(coursename.equals("java实验")) {
            this.Flag=3;
        }else if(coursename.equals("编译原理")) {
            this.Flag=4;
        }
    }
    
    //判断课程的性质与考察方式的匹配
    public int IfCourseFit() {
        if(this.xingzhi.equals("实验")&&this.fangshi.equals("实验")) {
            return 1;
        }else if(this.xingzhi.equals("必修")&&this.fangshi.equals("考试")) {
            return 2;
        }else if(this.xingzhi.equals("选修")&&this.fangshi.equals("考试")) {
            return 3;
        }else if(this.xingzhi.equals("选修")&&this.fangshi.equals("考察")) {
            return 4;
        }else {
            return -1;
        }
    }
    
    //根据课程的匹配方式为其添加分数
    public void AddScore(String[] a) {
        if(this.IfCourseFit()==1) {//实验课成绩
            int n = Integer.parseInt(a[3]);//记录实验次数
            int sum=0;//记录实验总分
            for(int i=0;i<n;i++) {
                int score = Integer.parseInt(a[i+4]);
                this.shiyan[i] = score;
                sum+=score;
            }
            this.sumscore=(int)(sum/n);
        }else if(this.IfCourseFit()==2) {//必修考试
            int n1 = Integer.parseInt(a[3]);
            int n2 = Integer.parseInt(a[4]);
            this.pingshi = n1;
            this.qimo = n2;
            this.sumscore=(int)(n1*0.3+n2*0.7);
        }else if(this.IfCourseFit()==3) {//选修考试
            int n1 = Integer.parseInt(a[3]);
            int n2 = Integer.parseInt(a[4]);
            this.pingshi = n1;
            this.qimo = n2;
            this.sumscore=(int)Math.round(n1*0.3+n2*0.7);
        }else if(this.IfCourseFit()==4) {//选修考察
            int n1 = Integer.parseInt(a[3]);
            this.qimo = n1;
            this.sumscore=n1;
        }
    }
    
    public int compareTo(Course a) {
        int n1,n2;
        n1 = this.Flag;
        n2 = a.Flag;
        if(n1>n2)
            return 1;
        else if(n1<n2)
            return -1;
        return 0;
    }
    
    //计算单门课程所有学生的平时成绩均分
    public int[] TotalAverScore(ArrayList<Student> b) {
        int[] sumscore = new int[3];
        int cent = 0;
        for(int i=0;i<b.size();i++) {
            Course a = b.get(i).FindCourse(this.coursename);
            if(a!=null) {
                cent++;
                if(!a.fangshi.equals("实验")) {
                    sumscore[0]+=a.pingshi;
                    sumscore[1]+=a.qimo;
                    sumscore[2]+=a.sumscore;
                }else {
                    sumscore[2]+=a.sumscore;
                }
            }
        }
        int[] aversumscore = new int[3];
        if(cent!=0) {
            aversumscore[0]=(int)(sumscore[0]/cent);
            aversumscore[1]=(int)(sumscore[1]/cent);
            aversumscore[2]=(int)(sumscore[2]/cent);
        }
        return aversumscore;
    }
}
/****************************************************************************************************/
class Xuanke {
    ArrayList<Course> a = new ArrayList<Course>();
    ArrayList<Student> b = new ArrayList<Student>();
    ArrayList<Banji> c = new ArrayList<Banji>();
    
    //根据课程名在课表中找课
    public Course FindCourse(String s) {
        for(int i=0;i<a.size();i++) {
            if(a.get(i).coursename.equals(s)) {
                return a.get(i);
            }
        }
        return null;
    }
    
    //输出学生所有课程的总均分
    public void PrintStudentTotalAver() {
        b.sort(Comparator.naturalOrder());
        for(int i=0;i<b.size();i++) {
            if(b.get(i).PersonTotalAver()!=0) {
                System.out.println(b.get(i).num+" "+b.get(i).name+" "+b.get(i).PersonTotalAver());
            }else {
                System.out.println(b.get(i).num+" "+b.get(i).name+" did not take any exams");
            }    
        }
    }
    
    //输出所有课程的各类平均分
    public void PrintCourseKindAver() {
        a.sort(Comparator.naturalOrder());
        for(int i=0;i<a.size();i++) {
            int[] q = a.get(i).TotalAverScore(b);
            if(q[2]==0) {
                if(a.get(i).IfCourseFit()!=-1) {
                    System.out.println(a.get(i).coursename+" has no grades yet");
                }
            }else {
                if(!a.get(i).fangshi.equals("实验")) {
                    if(a.get(i).fangshi.equals("考察")) {
                        System.out.println(a.get(i).coursename+" "+q[1]+" "+q[2]);
                    }else {
                        System.out.println(a.get(i).coursename+" "+q[0]+" "+q[1]+" "+q[2]);
                    }
                }else {
                    //课程名称+英文空格+总成绩平均分
                    System.out.println(a.get(i).coursename+" "+q[2]);
                }
            }
        }
    }
    
    //在班级中找班
    public Banji FindBanji(String s) {
        for(int i=0;i<c.size();i++) {
            if(c.get(i).banjihao.equals(s)) {
                return c.get(i);
            }
        }
        return null;
    }
    
    public void PrintBanjiAverScore() {
        c.sort(Comparator.naturalOrder());
        for(int i=0;i<c.size();i++) {
            if(c.get(i).BanjiTotalScoreAver()!=0) {
                System.out.println(c.get(i).banjihao+" "+c.get(i).BanjiTotalScoreAver());
            }else {
                System.out.println(c.get(i).banjihao+" has no grades yet");
            }    
        }
    }
}
class Banji implements Comparable<Banji>{
    String banjihao;
    
    Banji(String s){
        this.banjihao=s;
    }
    
    ArrayList<Student> a = new ArrayList<Student>();
    
    //在班级中找学生
    public Student FindStudent(String s) {
        for(int i=0;i<a.size();i++) {
            if(a.get(i).num.equals(s)) {
                return a.get(i);
            }
        }
        return null;
    }
    
    //计算班级的总均分
    public int BanjiTotalScoreAver() {
        int sum=0;
        for(int i=0;i<a.size();i++) {
            sum+=a.get(i).PersonTotalAver();
        }
        return (int)(sum/a.size());
    }
    
    public int compareTo(Banji a) {
        int n1,n2;
        n1 = this.BanjiTotalScoreAver();
        n2 = a.BanjiTotalScoreAver();
        if(n1>n2)
            return 1;
        else if(n1<n2)
            return -1;
        return 0;
    }
    
}

• 容器-ArrayList-排序

　　1.题目

 

　　2.源代码

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

public class Main {

    public static void main(String[] args) {
        ArrayList<Student> q = new ArrayList<Student>();
        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        while(!s.equals("end")){
            String[] str = s.split(" ");
            int n1 = Integer.parseInt(str[2]);
            int n2 = Integer.parseInt(str[3]);
            Student a = new Student(str[0],str[1],n1,n2);
            q.add(a);
            s = input.nextLine();
        }
        q.sort(Comparator.naturalOrder());
        for(int i=0;i<q.size();i++) {
            System.out.println(q.get(i).id+" "+q.get(i).name+" "+q.get(i).SumScore());
        }
    }

}

class Student implements Comparable<Student> {
    String id;
    String name;
    int math;
    int pysical;
    
    Student(String s1,String s2,int n1,int n2){
        this.id=s1;
        this.name=s2;
        this.math=n1;
        this.pysical=n2;
    }
    
    public int SumScore() {
        int sum = this.math+this.pysical;
        return sum;
    }
    
    //从高到低排序
    public int compareTo(Student a) {
        int n1=this.SumScore();
        int n2=a.SumScore();
        if(n1>n2) {
            return -1;
        }else if(n1<n2) {
            return 1;
        }
        return 0;
    }
}

 

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

　　1.题目

 

　　2.源代码

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

public class Main {

    public static void SortID(String[] s) {
        for(int i=0;i<s.length;i++) {
            int flag = i;
            for(int j=i+1;j<s.length;j++) {
                int year1 = Integer.parseInt(s[flag].substring(6,10));
                int month1 = Integer.parseInt(s[flag].substring(10,12));
                int day1 = Integer.parseInt(s[flag].substring(12,14));
                int year2 = Integer.parseInt(s[j].substring(6,10));
                int month2 = Integer.parseInt(s[j].substring(10,12));
                int day2 = Integer.parseInt(s[j].substring(12,14));
                if(year1>year2) {
                    flag=j;
                }else if(year1==year2&&month1>month2) {
                    flag=j;
                }else if(year1==year2&&month1==month2&&day1>day2) {
                    flag=j;
                }
            }
            //找到最小的日期交换两个字符串的位置
            String temp = s[i];
            s[i] = s[flag];
            s[flag] = temp;
        }
    }
    
    
    
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String num = input.nextLine();
        int n = Integer.parseInt(num);
        String[] a = new String[n];
        for(int i=0;i<n;i++) {
            a[i] = input.nextLine();
        }
        String choice = input.nextLine();
        while(choice.equals("sort1")||choice.equals("sort2")) {
            if(choice.equals("sort1")) {
                SortID(a);
                for(int i=0;i<a.length;i++) {
                    int year = Integer.parseInt(a[i].substring(6,10));
                    int month = Integer.parseInt(a[i].substring(10,12));
                    int day = Integer.parseInt(a[i].substring(12,14));
                    if(month<10&&day>=10) {
                        System.out.println(year+"-0"+month+"-"+day);
                    }else if(month>=10&&day<10) {
                        System.out.println(year+"-"+month+"-0"+day);
                    }else if(month<10&&day<10) {
                        System.out.println(year+"-0"+month+"-0"+day);
                    }else {
                        System.out.println(year+"-"+month+"-"+day);
                    }
                }
            }else if(choice.equals("sort2")){
                SortID(a);
                for(int i=0;i<a.length;i++) {
                    System.out.println(a[i]);
                }
            }
            choice = input.nextLine();
        }
        System.out.println("exit");
    }
}

 

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

　　1.题目

 

　　2.源代码

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

public class Main {
    public static void main(String[] args) {
          Scanner s = new Scanner(System.in);
            String record = s.nextLine();
            ParseInput handle=new ParseInput();
            while (!record.equals("end")) {
                handle.parseInput(record);//解析用户输入的每一行数据
                record = s.nextLine();
            }
            handle.showStudents();
            handle.showCourses();
            handle.showClasses();
    }
}
/*********************************************************************************************************/
class Inputmatching {
    static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
    static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String scoreMatching = "([1-9]?[0-9]|100)";
    static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String courseTypeMatching = "(选修|必修|实验)";
    static String checkcourseTypeMatching = "(考试|考察|实验)";
    //cousrInput用于定义课程信息模式（正则表达式）
    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
    //scoreInput用于定义成绩信息模式（正则表达式）
    public static int matchingInput(String s) {
        if (matchingCourse(s)) {
            return 1;
        }
        if (matchingScore(s)) {
            return 2;
        }
        return 0;//如果返回0则一定是格式错了或者成绩不对
    }
    //对应课程类信息正则表达式匹配
    private static boolean matchingCourse(String s) {
        return s.matches(courseInput);
    }
    
    private static boolean matchingScore(String s) {
        //只要格式没错，成绩没超出范围
        String[] a = s.split(" ");
        boolean t1 = a[0].matches(stuNumMatching);
        boolean t2 = a[1].matches(stuNameMatching);
        boolean t3 = a[2].matches(courseNameMatching);
        boolean t4 = true;
        for(int i=3;i<a.length;i++) {
            t4 = a[i].matches(scoreMatching);
        }
        return (t1&&t2&&t3&&t4);
    }
}
/************************************************************************************************************/
//解析处理类，在此调用方法
class ParseInput {
    
    Xuanke Table = new Xuanke();
    
    //在此方法中调用正则表达式进行匹配
    public void parseInput(String record) {
        Inputmatching a = new Inputmatching();
        int n = a.matchingInput(record);
        if(n==1) {
            //建立课程列表
            String str1[] = new String[3];
            str1 = record.split(" ");
            Course b = new Course(str1[0],str1[1],str1[2]);
            //先检查课程信息是否匹配错误
            if(b.IfCourseFit()==-1) {
                System.out.println(b.coursename+" : course type & access mode mismatch");
            }
            //再查重，若原先没有该课则加入
            //若原先有但是信息匹配出错则修改
            if(Table.FindCourse(str1[0])!=null) {
                Course q = Table.FindCourse(str1[0]);
                if(q.IfCourseFit()==-1) {
                    q.xingzhi=str1[1];
                    q.fangshi=str1[2];
                }
            }else {
                Table.a.add(b);
            }
            
        }else if(n==2) {
            //建立学生信息
            String str2[] = new String[3];
            str2 = record.split(" ");
            String banjihao = str2[0].substring(0,6);
            
            if(Table.FindCourse(str2[2])==null) {
                System.out.println(str2[0]+" "+str2[1]+" :"+str2[2]+" does not exist");
            }else if(IfScorseNumberRight(record)!=1){
                if(IfScorseNumberRight(record)==-1) {
                    System.out.println("wrong format");
                }else {
                    Student m = new Student(str2[0],str2[1]);
                    Course q = Table.FindCourse(str2[2]);
                    Course p = new Course(q.coursename,q.xingzhi,q.fangshi);
                    m.a.add(p);
                    Table.b.add(m);
                    if(Table.FindBanji(banjihao)!=null) {
                        Banji s = Table.FindBanji(banjihao);
                        if(s.FindStudent(m.num)==null) {
                            s.a.add(m);
                        }
                    }else {
                        Banji s = new Banji(banjihao);
                        s.a.add(m);
                        Table.c.add(s);
                    }
                    System.out.println(str2[0]+" "+str2[1]+" : access mode mismatch");
                }
            }else{
                    Student m = new Student(str2[0],str2[1]);
                    Course q = Table.FindCourse(str2[2]);
                    Course p = new Course(q.coursename,q.xingzhi,q.fangshi);
                    p.AddScore(str2);
                    m.a.add(p);
                    Table.b.add(m);
                    if(Table.FindBanji(banjihao)!=null) {
                        Banji s = Table.FindBanji(banjihao);
                        if(s.FindStudent(m.num)==null) {
                            s.a.add(m);
                        }
                    }else {
                        Banji s = new Banji(banjihao);
                        s.a.add(m);
                        Table.c.add(s);
                    }
            }
        }else if(n==0){
            System.out.println("wrong format");
        }    
    }
    
    //成绩解析的第二种异常
    public int IfScorseNumberRight(String s) {
        String[] a = s.split(" ");
        if(Table.FindCourse(a[2]).fangshi.equals("考察")&&a.length==4) {
            return 1;
        }else if(Table.FindCourse(a[2]).fangshi.equals("考试")&&a.length==5) {
            return 1;
        }else if(Table.FindCourse(a[2]).fangshi.equals("实验")) {
            int n = Integer.parseInt(a[3]);
            if(n<=3) {
                return -1;
            }else if(a.length==4+n){
                return 1;
            }
        }
        return 0;
    }
    
    public void showStudents() {
        Table.PrintStudentTotalAver();
    }

    public void showCourses() {
        Table.PrintCourseKindAver();
    }

    public void showClasses() {
        Table.PrintBanjiAverScore();
        
    }
         
}
/*****************************************************************************************************/

class Student implements Comparable<Student> {
    String num;//学号
    String name;//姓名
    ArrayList<Course> a = new ArrayList<Course>();//个人课表
    
    Student(String num,String name){
        this.num=num;
        this.name=name;
    }
    
    //根据课程名在课表中找课
    public Course FindCourse(String s) {
        for(int i=0;i<a.size();i++) {
            if(a.get(i).coursename.equals(s)) {
                return a.get(i);
            }
        }
        return null;
    }
    
    public int PersonTotalAver() {
        int sum=0;
        int cent=0;
        for(int i=0;i<a.size();i++) {
            sum+=a.get(i).sumscore;
            cent++;
        }
        return (int)(sum/cent);
    }
    
    public int compareTo(Student a) {
        int n1,n2;
        n1 = Integer.parseInt(this.num);
        n2 = Integer.parseInt(a.num);
        if(n1>n2)
            return 1;
        else if(n1<n2)
            return -1;
        return 0;
    }
    
}
/*******************************************************************************************************/
class Course implements Comparable<Course>{
    int Flag=0;//记录课程的输出顺序
    String coursename;//课程名
    String xingzhi;//课程形式：必修、选修、实验
    String fangshi;//课程考察方式：考试、考察、实验
    int pingshi=0;//平时成绩分数
    int qimo=0;//期末成绩的分数
    int[] shiyan = new int[9];//若该门课程为实验对应的分数
    int sumscore=0;//总成绩
    
    Course(String coursename,String xingzhi,String fangshi){
        this.coursename=coursename;
        this.xingzhi=xingzhi;
        this.fangshi=fangshi;
        if(coursename.equals("C语言")) {
            this.Flag=1;
        }else if(coursename.equals("java")) {
            this.Flag=2;
        }else if(coursename.equals("java实验")) {
            this.Flag=3;
        }else if(coursename.equals("编译原理")) {
            this.Flag=4;
        }
    }
    
    //判断课程的性质与考察方式的匹配
    public int IfCourseFit() {
        if(this.xingzhi.equals("实验")&&this.fangshi.equals("实验")) {
            return 1;
        }else if(this.xingzhi.equals("必修")&&this.fangshi.equals("考试")) {
            return 2;
        }else if(this.xingzhi.equals("选修")&&this.fangshi.equals("考试")) {
            return 3;
        }else if(this.xingzhi.equals("选修")&&this.fangshi.equals("考察")) {
            return 4;
        }else {
            return -1;
        }
    }
    
    //根据课程的匹配方式为其添加分数
    public void AddScore(String[] a) {
        if(this.IfCourseFit()==1) {//实验课成绩
            int n = Integer.parseInt(a[3]);//记录实验次数
            int sum=0;//记录实验总分
            for(int i=0;i<n;i++) {
                int score = Integer.parseInt(a[i+4]);
                this.shiyan[i] = score;
                sum+=score;
            }
            this.sumscore=(int)(sum/n);
        }else if(this.IfCourseFit()==2) {//必修考试
            int n1 = Integer.parseInt(a[3]);
            int n2 = Integer.parseInt(a[4]);
            this.pingshi = n1;
            this.qimo = n2;
            this.sumscore=(int)(n1*0.3+n2*0.7);
        }else if(this.IfCourseFit()==3) {//选修考试
            int n1 = Integer.parseInt(a[3]);
            int n2 = Integer.parseInt(a[4]);
            this.pingshi = n1;
            this.qimo = n2;
            this.sumscore=(int)Math.round(n1*0.3+n2*0.7);
        }else if(this.IfCourseFit()==4) {//选修考察
            int n1 = Integer.parseInt(a[3]);
            this.qimo = n1;
            this.sumscore=n1;
        }
    }
    
    public int compareTo(Course a) {
        int n1,n2;
        n1 = this.Flag;
        n2 = a.Flag;
        if(n1>n2)
            return 1;
        else if(n1<n2)
            return -1;
        return 0;
    }
    
    //计算单门课程所有学生的平时成绩均分
    public int[] TotalAverScore(ArrayList<Student> b) {
        int[] sumscore = new int[3];
        int cent = 0;
        for(int i=0;i<b.size();i++) {
            Course a = b.get(i).FindCourse(this.coursename);
            if(a!=null) {
                cent++;
                if(!a.fangshi.equals("实验")) {
                    sumscore[0]+=a.pingshi;
                    sumscore[1]+=a.qimo;
                    sumscore[2]+=a.sumscore;
                }else {
                    sumscore[2]+=a.sumscore;
                }
            }
        }
        int[] aversumscore = new int[3];
        if(cent!=0) {
            aversumscore[0]=(int)(sumscore[0]/cent);
            aversumscore[1]=(int)(sumscore[1]/cent);
            aversumscore[2]=(int)(sumscore[2]/cent);
        }
        return aversumscore;
    }
}
/****************************************************************************************************/
class Xuanke {
    ArrayList<Course> a = new ArrayList<Course>();
    ArrayList<Student> b = new ArrayList<Student>();
    ArrayList<Banji> c = new ArrayList<Banji>();
    
    //根据课程名在课表中找课
    public Course FindCourse(String s) {
        for(int i=0;i<a.size();i++) {
            if(a.get(i).coursename.equals(s)) {
                return a.get(i);
            }
        }
        return null;
    }
    
    //输出学生所有课程的总均分
    public void PrintStudentTotalAver() {
        b.sort(Comparator.naturalOrder());
        for(int i=0;i<b.size();i++) {
            if(b.get(i).PersonTotalAver()!=0) {
                System.out.println(b.get(i).num+" "+b.get(i).name+" "+b.get(i).PersonTotalAver());
            }else {
                System.out.println(b.get(i).num+" "+b.get(i).name+" did not take any exams");
            }    
        }
    }
    
    //输出所有课程的各类平均分
    public void PrintCourseKindAver() {
        a.sort(Comparator.naturalOrder());
        for(int i=0;i<a.size();i++) {
            int[] q = a.get(i).TotalAverScore(b);
            if(q[2]==0) {
                if(a.get(i).IfCourseFit()!=-1) {
                    System.out.println(a.get(i).coursename+" has no grades yet");
                }
            }else {
                if(!a.get(i).fangshi.equals("实验")) {
                    if(a.get(i).fangshi.equals("考察")) {
                        System.out.println(a.get(i).coursename+" "+q[1]+" "+q[2]);
                    }else {
                        System.out.println(a.get(i).coursename+" "+q[0]+" "+q[1]+" "+q[2]);
                    }
                }else {
                    //课程名称+英文空格+总成绩平均分
                    System.out.println(a.get(i).coursename+" "+q[2]);
                }
            }
        }
    }
    
    //在班级中找班
    public Banji FindBanji(String s) {
        for(int i=0;i<c.size();i++) {
            if(c.get(i).banjihao.equals(s)) {
                return c.get(i);
            }
        }
        return null;
    }
    
    public void PrintBanjiAverScore() {
        c.sort(Comparator.naturalOrder());
        for(int i=0;i<c.size();i++) {
            if(c.get(i).BanjiTotalScoreAver()!=0) {
                System.out.println(c.get(i).banjihao+" "+c.get(i).BanjiTotalScoreAver());
            }else {
                System.out.println(c.get(i).banjihao+" has no grades yet");
            }    
        }
    }
}
class Banji implements Comparable<Banji>{
    String banjihao;
    
    Banji(String s){
        this.banjihao=s;
    }
    
    ArrayList<Student> a = new ArrayList<Student>();
    
    //在班级中找学生
    public Student FindStudent(String s) {
        for(int i=0;i<a.size();i++) {
            if(a.get(i).num.equals(s)) {
                return a.get(i);
            }
        }
        return null;
    }
    
    //计算班级的总均分
    public int BanjiTotalScoreAver() {
        int sum=0;
        for(int i=0;i<a.size();i++) {
            sum+=a.get(i).PersonTotalAver();
        }
        return (int)(sum/a.size());
    }
    
    public int compareTo(Banji a) {
        int n1,n2;
        n1 = this.BanjiTotalScoreAver();
        n2 = a.BanjiTotalScoreAver();
        if(n1>n2)
            return 1;
        else if(n1<n2)
            return -1;
        return 0;
    }
    
}

 

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

　　1.题目

 

　　2.源代码

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

public class Main {

    public static void main(String[] args) {
        ArrayList<PersonOverride> person1 = new ArrayList<PersonOverride>();
        ArrayList<PersonOverride> person2 = new ArrayList<PersonOverride>();
        Scanner input = new Scanner(System.in);
        int n1 = input.nextInt();
        for(int i=0;i<n1;i++) {
            PersonOverride a = new PersonOverride();
            person1.add(a);
        }
        int n2 = input.nextInt();
        String k = input.nextLine();//吞并空格
        for(int j=0;j<n2;j++) {
            String s = input.nextLine();
            String[] str = s.split(" ");
            String name = str[0];
            int age = Integer.parseInt(str[1]);
            boolean gender;
            if(str[2].equals("true")) {
                gender = true;
            }else {
                gender = false;
            }
            PersonOverride b = new PersonOverride(name,age,gender);
            boolean ifHave = false;
            for(int i=0;i<person2.size();i++) {
                if(person2.get(i).equals(b)) {
                    ifHave = true;
                    break;
                }
            }
            if(!ifHave) {
                person2.add(b);
            }
        }
        for(int i=0;i<person1.size();i++) {
            System.out.println(person1.get(i).toString());
        }
        for(int j=0;j<person2.size();j++) {
            System.out.println(person2.get(j).toString());
        }
        System.out.println(person2.size());
        System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
}

class PersonOverride{
    private String name;
    private int age;
    private boolean gender;
    
    public PersonOverride() {
        this.name = "default";
        this.age = 1;
        this.gender = true;
    }
    
    public PersonOverride(String name, int age, boolean gender) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    
    @Override
    public String toString() {
        return this.name+"-"+this.age+"-"+this.gender;
    }


    public boolean equals(PersonOverride a) {
        if(this.name.equals(a.name)&&this.age==a.age&&this.gender==a.gender) {
            return true;
        }else {
            return false;
        }
    }
}

• 课程成绩统计程序-3

　　1.题目

 

　　2.题目类图

 

　　3.题目分析

 在课程成绩系统1和2的基础上对实验成绩的每一次进行了权重的限制，于是和课设2一样我们需要对解析类和成绩类进行相应的修改。并且在算分时的计算方法对应修改。

　　4.源代码

import java.text.Collator;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
          Scanner s = new Scanner(System.in);
            String record = s.nextLine();
            ParseInput handle=new ParseInput();
            while (!record.equals("end")) {
                handle.parseInput(record);
                record = s.nextLine();
            }
            handle.showStudents();
            handle.showCourses();
            handle.showClasses();
    }
}
/*********************************************************************************************************/
class Inputmatching {
    static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
    static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String scoreMatching = "([1-9]?[0-9]|100)";
    static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
    static String courseTypeMatching = "(选修|必修|实验)";
    static String checkcourseTypeMatching = "(考试|考察|实验)";
    public static int matchingInput(String s) {
        if (matchingCourse(s)) {
            return 1;
        }
        if (matchingScore(s)) {
            return 2;
        }
        System.out.println("wrong format");
        return 0;
    }
    
    private static boolean matchingCourse(String s) {
        String[] a = s.split(" ");
        boolean t1 = a[0].matches(courseNameMatching);
        boolean t2 = a[1].matches(courseTypeMatching);
        boolean t3 = a[2].matches(checkcourseTypeMatching);
        boolean t4 = true;
        if(a[1].equals("实验")) {
            int n=Integer.parseInt(a[3]);
            if(n<4||n>9) {
                t4=false;
            }
        }
        return (t1&&t2&&t3&&t4);
    }
    
    private static boolean matchingScore(String s) {
        String[] a = s.split(" ");
        boolean t1 = a[0].matches(stuNumMatching);
        boolean t2 = a[1].matches(stuNameMatching);
        boolean t3 = a[2].matches(courseNameMatching);
        boolean t4 = true;
        for(int i=3;i<a.length&&t4==true;i++) {
            t4 = a[i].matches(scoreMatching);
        }
        return (t1&&t2&&t3&&t4);
    }
}
/************************************************************************************************************/
class ParseInput {
    
    Xuanke Table = new Xuanke();
    
    public void parseInput(String record) {
        Inputmatching a = new Inputmatching();
        int n = a.matchingInput(record);
        if(n==1) {
            int type = IfCourseFit(record);
            
            String[] s = record.split(" ");
            
            if(type==-1) {
                System.out.println(s[0]+" : course type & access mode mismatch");
            }else if(type==1) {
        
                if(!ifScorenumAndQuannumEqual(record)) {
                    System.out.println(s[0]+" : number of scores does not match");
                }
                if(ifScorenumAndQuannumEqual(record)&&!ifShiyanEqualOne(record)) {
                    System.out.println(s[0]+" : weight value error");
                }
                if(ifScorenumAndQuannumEqual(record)&&ifShiyanEqualOne(record)) {
                    if(Table.FindCourse(s[0])==null) {
                        ShiYan course = new ShiYan(record);
                        Table.a.add(course);
                    }
                }
            }else if(type==2||type==3) {
                if(!ifKaoshiEqualOne(record)) {
                    System.out.println(s[0]+" : weight value error");
                }
                if(ifKaoshiEqualOne(record)) {
                    if(Table.FindCourse(s[0])==null) {
                        KaoShi course = new KaoShi(record);
                        Table.a.add(course);
                    }
                }
            }else if(type==4) {
                if(Table.FindCourse(s[0])==null) {
                    KaoCha course = new KaoCha(record);
                    Table.a.add(course);
                }
            }
        }else if(n==2){
            int type = IfScoreGood(Table,record);
            String[] s = record.split(" ");
            
            if(type==1) {
                Student d = new Student(s[0],s[1]);
                Table.b.add(d);
                RecordBanNum(record,Table);
                System.out.println(s[2]+" does not exist");    
            }else if(type==2) {
                Student d = new Student(s[0],s[1]);
                Table.b.add(d);
                RecordBanNum(record,Table);
                System.out.println(s[0]+" "+s[1]+" : access mode mismatch");
            }else if(type==0) {
                RecordBanNum(record,Table);
                //建立成绩信息
                String coursename = s[2];
                Course studentcourse = Table.FindCourse(coursename);
                Score b = null ;
                if(studentcourse.coursetest.equals("考试")) {
                     b = new KaoShiScore(record,Table);
                }else if(studentcourse.coursetest.equals("考察")) {
                     b = new KaoChaScore(record);
                }else if(studentcourse.coursetest.equals("实验")) {
                     b = new ShiYanScore(record,Table);
                }
                //学生课程总成绩平均分
                //单门课程成绩
                //班级所有课程总成绩平均分        
                //人不存在
                //人在课不在
                //人在课也在
                if(Table.FindStudent(s[0])!=null&&Table.FindStudent(s[0]).FindCourseScore(s[2])) {
                    //System.out.println("不做任何事");
                }else if(Table.FindStudent(s[0])!=null&&!(Table.FindStudent(s[0]).FindCourseScore(s[2]))) {
                    Student one = Table.FindStudent(s[0]);
                    one.a.add(b);
                }else if(Table.FindStudent(s[0])==null) {
                    Student one = new Student(s[0],s[1]);
                    one.a.add(b);
                    Table.b.add(one);
                }
                
                Course tow = Table.FindCourse(s[2]);
                tow.a.add(b);                    
            }
        }
    }
    
    public int IfCourseFit(String s) {
        String[] a = s.split(" ");
        if(a[1].equals("实验")&&a[2].equals("实验")) {
            return 1;
        }else if(a[1].equals("必修")&&a[2].equals("考试")) {
            return 2;
        }else if(a[1].equals("选修")&&a[2].equals("考试")) {
            return 3;
        }else if(a[1].equals("选修")&&a[2].equals("考察")) {
            return 4;
        }else {
            return -1;
        }
    }

    public boolean ifScorenumAndQuannumEqual(String s) {
        String[] str = s.split(" ");
        int n = Integer.parseInt(str[3]);
        int m = str.length-4;
        if(m==n) {
            return true;
        }else {
            return false;
        }
    } 
    
    public boolean ifShiyanEqualOne(String s) {
        String[] str = s.split(" ");
        double quan = 0;
        for(int i=4;i<str.length;i++) {
            double n = Double.parseDouble(str[i]);
            quan+=n;
        }
        if(quan!=1) {
            return false;
        }
        return true;
    }
    
    public boolean ifKaoshiEqualOne(String s) {
        String[] str = s.split(" ");
        double n1 = Double.parseDouble(str[3]);
        double n2 = Double.parseDouble(str[4]);
        double quan = n1 + n2;
        if(quan-1>0.00000000000001) {
            return false;
        }
        return true;
    }
    
    public int IfScoreGood(Xuanke kebiao,String s) {
        String[] str = s.split(" ");
        Course a = kebiao.FindCourse(str[2]);
        int scorenum = str.length-3;
        //先检查课表里有没有这门课
        if(a==null) {
            return 1;
        }else if(!ifScoreFitCourse(a,scorenum)){
            return 2;
        }else {
            return 0;
        }
    }
    
    //成绩数量与课程性质是否匹配
    public boolean ifScoreFitCourse(Course a,int n) {
        if(a.coursetest.equals("考察")) {
            if(n==1) {
                return true;
            }
        }else if(a.coursetest.equals("考试")) {
            if(n==2) {
                return true;
            }
        }else if(a.coursetest.equals("实验")) {
            if(a instanceof ShiYan) {
                ShiYan m = (ShiYan)a;
                if(m.n==n) {
                    return true;
                }
            }
        }
        return false;
    }  
    
    public void RecordBanNum(String record,Xuanke q) {
        String num = record.substring(0,6);
        for(int i=0;i<q.c.size();i++) {
            if(q.c.get(i).equals(num)) {
                return;
            }
        }
        q.c.add(num);
    }
    
    
    public void showStudents() {
        Table.PrintStudent();
    }

    public void showCourses() {
        Table.PrintCourse();
    }

    public void showClasses() {
        Table.PrintBanji();
    }
         
}
/*****************************************************************************************************/

class Student implements Comparable<Student>{
   String id;
   String name;
   int sumscore;
   ArrayList<Score> a = new ArrayList<Score>();
   
   Student(String id,String name){
       this.id=id;
       this.name=name;
   }
   
   public int AverTotalScore() {
       float sum = 0;
       int n = a.size();
       for(int i=0;i<a.size();i++) {
           sum+=a.get(i).totalscore;
       }
       this.sumscore=(int)sum;
       return (int)(sum/n);
   }
   
   //查学生有没有这门课的成绩,找到了课程就不能在加入信息，如果没找到就可以加入信息
   public boolean FindCourseScore(String coursename) {
       for(int i=0;i<a.size();i++) {
           if(a.get(i).coursename.equals(coursename)) {
               return true;
           }
       }
       return false;
   }
   
   public int compareTo(Student a) {
       int n1,n2;
       n1 = Integer.parseInt(this.id);
       n2 = Integer.parseInt(a.id);
       if(n1>n2)
           return 1;
       else if(n1<n2)
           return -1;
       return 0;
   }
}
/*******************************************************************************************************/
class Course implements Comparable<Course>{
   String coursename;
   String coursekind;
   String coursetest;
   ArrayList<Score> a = new ArrayList<Score>();
   
   public int compareTo(Course o) {
       Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
       return compare.compare(coursename,o.getCoursename());
   }

    public String getCoursename() {
        return coursename;
    }
    
    //计算课程总均分
    public int TotalAverCourseScore() {
        float sum=0;
        int n=a.size();
        for(int i=0;i<a.size();i++) {
            sum+=a.get(i).totalscore;
        }
        return (int)(sum/n);
    }
}

//考察课
class KaoCha extends Course{
    
    KaoCha(String coursename, String coursekind, String coursetest) {
        this.coursename=coursename;
        this.coursekind=coursekind;
        this.coursetest=coursetest;
    }
    
    KaoCha(String record){
        String[] s = record.split(" ");
        this.coursename=s[0];
        this.coursekind=s[1];
        this.coursetest=s[2];
    }
}

//考试课
class KaoShi extends Course{
    float normalquan;
    float finalquan;
    
    KaoShi(String coursename, String coursekind, String coursetest,float n1,float n2) {
        this.coursename=coursename;
        this.coursekind=coursekind;
        this.coursetest=coursetest;
        this.normalquan=n1;
        this.finalquan=n2;
    }
    
    KaoShi(String record){
        String[] s = record.split(" ");
        this.coursename=s[0];
        this.coursekind=s[1];
        this.coursetest=s[2];
        float n1 = Float.parseFloat(s[3]);
        float n2 = Float.parseFloat(s[4]);
        this.normalquan=n1;
        this.finalquan=n2;
    }
}

//实验课
class ShiYan extends Course{
    int n;//分项成绩数量
    float[] fenxiangquan;
    
    ShiYan(String coursename, String coursekind, String coursetest,int n) {
        this.coursename=coursename;
        this.coursekind=coursekind;
        this.coursetest=coursetest;
        this.n=n;
        this.fenxiangquan = new float[n];
    }

    ShiYan(String record){
        String[] s = record.split(" ");
        this.coursename=s[0];
        this.coursekind=s[1];
        this.coursetest=s[2];
        int num = Integer.parseInt(s[3]);
        this.n=num;
        this.fenxiangquan = new float[n];
        for(int i=0;i<n;i++) {
            fenxiangquan[i] = Float.parseFloat(s[i+4]);    
        }
    }
    
    
    public void setfenxiangquan(int i,float quan) {
        this.fenxiangquan[i] = quan;
    }
}


/**************************************************************************************************/
class Score{
    String coursename=null;
    float totalscore=0;
}

//考察课成绩
class KaoChaScore extends Score{
    KaoChaScore(String s){
        String[] str = s.split(" ");
        this.coursename=str[2];
        this.totalscore=Integer.parseInt(str[3]);
    }
}

//考试课成绩
class KaoShiScore extends Score{
    KaoShiScore(String s,Xuanke a){
        String[] str = s.split(" ");
        this.coursename=str[2];
        Course m = a.FindCourse(str[2]);
        int score1 = Integer.parseInt(str[3]);
        int score2 = Integer.parseInt(str[4]);
        if(m instanceof KaoShi) {
            KaoShi course = (KaoShi)m;
            float quan1 = course.normalquan;
            float quan2 = course.finalquan;
            this.totalscore=score1*quan1+score2*quan2;
        }
    }
}

//实验课成绩
class ShiYanScore extends Score{
    ShiYanScore(String s,Xuanke a){
        String[] str = s.split(" ");
        this.coursename=str[2];
        Course m = a.FindCourse(str[2]);
        if(m instanceof ShiYan) {
            ShiYan course = (ShiYan)m;
            for(int i=0;i<course.n;i++) {
                int score = Integer.parseInt(str[i+3]);
                float quan = course.fenxiangquan[i];
                this.totalscore+=score*quan;
            }
        }
    }
}

/****************************************************************************************************/
class Xuanke {
    ArrayList<Course> a = new ArrayList<Course>();
    ArrayList<Student> b = new ArrayList<Student>();
    ArrayList<String> c = new ArrayList<String>();//班号！
    ArrayList<Banji> e = new ArrayList<Banji>();
    
    //找列表课程（传课程名）
    public Course FindCourse(String s) {
        for(int i=0;i<a.size();i++) {
            if(a.get(i).coursename.equals(s)) {
                return a.get(i);
            }
        }
        return null;
    }
    
    //找列表学生(传学号）
    public Student FindStudent(String s) {
        for(int i=0;i<b.size();i++) {
            if(b.get(i).id.equals(s)) {
                return b.get(i);
            }
        }
        return null;
    }
    
    
    //输出学生信息
    public void PrintStudent() {
        b.sort(Comparator.naturalOrder());
        for(int i=0;i<b.size();i++) {
            int sumfen = b.get(i).AverTotalScore();
            if(sumfen==0) {
                System.out.println(b.get(i).id+" "+b.get(i).name+" did not take any exams");
            }else {
                System.out.println(b.get(i).id+" "+b.get(i).name+" "+sumfen);
            }
        }
    }
    
    //输出课程信息
    public void PrintCourse() {
        a.sort(Comparator.naturalOrder());
        for(int i=0;i<a.size();i++) {
            int coursesumfen = a.get(i).TotalAverCourseScore();
            if(coursesumfen==0) {
                System.out.println(a.get(i).coursename+" has no grades yet");
            }else {
                System.out.println(a.get(i).coursename+" "+coursesumfen);
            }
        }
    }
    
    //输出班级信息
    public void PrintBanji() {
        SetBanji();
        e.sort(Comparator.naturalOrder());    
        for(int i=0;i<e.size();i++) {
            int fen = e.get(i).fen;
            if(fen==0) {
                System.out.println(e.get(i).num+" has no grades yet");
            }else {
                System.out.println(e.get(i).num+" "+fen);
            }
        }
    }
    
    //所有课程的总均分
    public void SetBanji() {
        for(int i=0;i<c.size();i++) {
            float sum=0;
            int cent=0;
            for(int j=0;j<b.size();j++) {
                String banhao = b.get(j).id.substring(0,6);
                if(banhao.equals(c.get(i))) {
                    int m = b.get(i).AverTotalScore();
                    cent++;
                    sum+=b.get(j).sumscore;
                }
            }
            int banjizongfen = (int)(sum/cent);
            Banji r = new Banji(c.get(i),banjizongfen);
            e.add(r);
        }
    }
}

class Banji implements Comparable<Banji>{
    String num;
    int fen;
    int banhao;
    
    Banji(String num,int fen){
        this.num=num;
        this.fen=fen;
        this.banhao = Integer.parseInt(num);
    }
    
/*     public int compareTo(Banji a) {
           int n1,n2;
           n1 = this.fen;
           n2 = a.fen;
           if(n1>n2)
               return 1;
           else if(n1<n2)
               return -1;
           return 0;
       }*/
     
     public int compareTo(Banji a) {
           int n1,n2;
           n1 = this.banhao;
           n2 = a.banhao;
           if(n1>n2)
               return 1;
           else if(n1<n2)
               return -1;
           return 0;
       }
}

三、踩坑心得

（1）在第一次写成绩系统时对题目整体的架构并不是太好，并没有写号正则表达式以及解析类，于是在后续增强一些条件的时候需要重新架构一系列的类的组合关系十分麻烦。

（2）HashMap的使用过程中对key调用value的使用有写不熟练。

四、主要困难和改进意见

当面对较为复杂的实际问题时，分析问题的能力较弱。当要构建出多个类并实现类之间的相互联系的时候，思维能力较弱。对对象数组的使用不够熟练。改进意见：应多敲代码。

五、总结

通过前三次的作业，我逐渐做到：

1、 掌握类与对象的基本概念；

2、 掌握类的声明、创建与使用方法；

3、 掌握类的构造方法的定义与使用方法

4、 掌握类的成员变量、成员方法的定义与使用方法；

5、 理解类变量、类方法与实例变量、实例方法的区别；

6、 理解Java语言中包的概念以及package、import语句的使用；

7、 理解引用变量与对象实例之间的关系与区别；

8、 理解方法调用时引用类型参数的传递过程；