第三次博客作业

前言

这是本学期最后一次博客作业。这次作业主要分析课程统计系统的三次变式，即同一种题目的三种不同类型。课程统计系统比较简单，并没有太复杂的东西。正确输出也比较好做，其中较难的部分是错误输出，错误输出分为好几种方式，需要根据不同情况输出不同的错误提示。

通过这个题目，我可以发现我自身的某些问题。写代码需要我们根据不同情况了，有着不同的输出。我们不仅需要输出正确答案，同时也需要输出某些错误提示，而这也是一个好代码所必需的作用。但是我往往只能做到正确的输出，在面对某些错误提示时会出现的漏洞，无法正确写出来。

作业分析

这次作业并没有很复杂的部分，但是我们需要请一一对应，仔细比对，否则就会出现输出与输入不符的问题。此次作业涉及的知识点还是比较广的，但是难度合适，题目内容也不多。往往需要我们理解就能够做出来了，也不会耗费我们太多的时间。

总的来说，比起上次那个菜单系列作业，课程成绩统计系统要简单的多，而且老师上课也带着我们设计了那些类一遍，所以说这次写的顺畅了很多。而且这次作业开始大量应用hashmap,hashset等集合，不再是简单的使用对象数组。尽管这些集合我们不太熟悉，但是通过这三次大作业，提升很大。

 

1. 课程成绩统计程序-1：相比菜单系列，这次作业主要的难点在于对最终信息的排序的输出，因为之前没有学习过相关的内容，所有一开始写的有点艰难，之后在网上学习了List的sort方法，以及对sort方法的重写才完成。除了写排序的过程其他的倒没啥难点。

以下为代码：

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

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        kecheng kc=new kecheng();
        chengji cj=new chengji();
        xuanke xk=new xuanke();
        String a;
        int i=0;
        int sum=0;
        int total=0;
        while(true) {
            a=in.nextLine();
            String[] b=a.split(" ");
            if(b.length==3) {
                kc.考试科目(b[0]);
                if(b[1].equals("必修")) kc.bixiuke(b[0]);
                if(b[1].equals("选修")) kc.xuanxiuke(b[0]);
                if(b[2].equals("考试"))  kc.bixiu(b[0]);
                if(b[2].equals("考察"))  kc.xuanxiu(b[0]);
            }
            if(b.length==4) {
                if(kc.list1.contains(b[2])&&kc.list4.contains(b[2]))
                {//System.out.println("b[2]");
                    kc.科目(b[0].substring(0, 6));
                    System.out.println( b[2]+" : course type & access mode mismatch");
                    System.out.println(b[2]+" does not exist");
                }
            else if(kc.list1.contains(b[2]))
                {//System.out.println("b[2]");
                    kc.科目(b[0].substring(0, 6));
                    System.out.println(b[0]+" "+ b[1]+" : access mode mismatch");
                    System.out.println(b[0]+" "+ b[1]+" did not take any exams");
                }
                else {

                    if(b[2].equals("java")) kc.java(b[3]);
                    if(b[2].equals("形式与政治")) kc.形式与政治(b[3]);
                    if(b[2].equals("数据库")) kc.数据库(b[3]);
                    if(b[2].equals("数据结构")) kc.数据结构(b[3]);
                    banji bj = new banji(b[0].substring(0, 6), b[3]);
                    xuesheng xs = new xuesheng(b[0], b[1], Integer.parseInt(b[3]));
                    xk.xuanke(bj, xs);
                }
                //}//System.out.println(b[0]+" "+b[1]+" "+cj.xuanxiu(b[3]));
            }
            if(b.length==5) {
                if(kc.list2.contains(b[2])&&kc.list3.contains(b[2]))
                {//System.out.println("b[2]");
                    kc.科目(b[0].substring(0, 6));
                    System.out.println( b[2]+" : course type & access mode mismatch");
                    System.out.println(b[2]+" does not exist");
                }
               else if(kc.list2.contains(b[2])) {System.out.println(b[0]+" "+ b[1]+" : access mode mismatch");
                    kc.科目(b[0].substring(0, 6));}
                else {
                    if(b[2].equals("java")) {kc.java(b[3]); kc.java(b[4]);}
                    if(b[2].equals("形式与政治")) {kc.形式与政治(b[3]); kc.形式与政治(b[4]);}
                    if(b[2].equals("数据库")) {kc.数据库(b[3]); kc.数据库(b[4]);}
                    if(b[2].equals("数据结构")) {kc.数据结构(b[3]); kc.数据结构(b[4]);}
                    banji bj=new banji(b[0].substring(0, 6), Integer.toString(cj.bixiu(b[3], b[4])));
                    xuesheng xs=new xuesheng(b[0],b[1],cj.bixiu(b[3],b[4]));
                    xk.xuanke(bj,xs);
                }// System.out.println(b[0]+" "+b[1]+" "+cj.bixiu(b[3],b[4]));
            }
            if(a.equals("end")) break;
        }
        xk.xs();
        if(kc.考试科目.contains("java")) {
         if(kc.java.isEmpty()) System.out.println("java"+" has no grades yet");
        else if(kc.list2.contains("java")) {
             for (int j = 0; j < kc.java.size(); j++) {
                 sum = sum + Integer.parseInt(kc.java.get(j));
                    }
              sum=sum/kc.java.size();
             System.out.println("java"+" "+sum+" "+sum);
         }
        else if(kc.list1.contains("java")) {
             for (int j = 0; j < kc.java.size(); j++) {
             sum = sum + Integer.parseInt(kc.java.get(j));
             total=total+ Integer.parseInt(kc.java.get(j+1));
             j++;
             }
            sum=sum/ kc.java.size()*2;
             total=total/ kc.java.size()*2;
             System.out.println("java"+" "+sum+" "+total+" "+(int)(sum*0.3+total*0.7));
            }
        else;
          }
        if(kc.考试科目.contains("数据结构")) {
            if(kc.数据结构.isEmpty()) System.out.println("数据结构"+" has no grades yet");
            else if(kc.list2.contains("数据结构")) {
                for (int j = 0; j < kc.数据结构.size(); j++) {
                    sum = sum + Integer.parseInt(kc.数据结构.get(j));
                }
                if(kc.数据结构.size()!=0)  sum=sum/kc.数据结构.size();
                System.out.println("数据结构"+" "+sum+" "+sum);
            }
            else if(kc.list1.contains("数据结构")) {
                for (int j = 0; j < kc.数据结构.size(); j++) {
                    sum = sum + Integer.parseInt(kc.数据结构.get(j))+ Integer.parseInt(kc.数据结构.get(j+1));
                    j++;
                }
                if(kc.数据结构.size()!=0) sum=sum/ kc.数据结构.size()*2;
                System.out.println("数据结构"+" "+sum);
            }
            else;
        }
        if(kc.考试科目.contains("数据库")) {
            if(kc.数据库.isEmpty()) System.out.println("数据库"+" has no grades yet");
            else if(kc.list2.contains("数据库")) {
                for (int j = 0; j < kc.数据库.size(); j++) {
                    sum = sum + Integer.parseInt(kc.数据库.get(j));
                }
                if(kc.数据库.size()!=0)  sum=sum/kc.数据库.size();
                System.out.println("数据库"+" "+sum+" "+sum);
            }
            else if(kc.list1.contains("数据库")) {
                for (int j = 0; j < kc.数据库.size(); j++) {
                    sum = sum + Integer.parseInt(kc.数据库.get(j))+ Integer.parseInt(kc.数据库.get(j+1));
                    j++;
                }
                if(kc.数据库.size()!=0) sum=sum/ kc.数据库.size()*2;
                System.out.println("数据库"+" "+sum);
            }
            else;
        }
        if(kc.考试科目.contains("形式与政治")) {
            if(kc.形式与政治.isEmpty()) System.out.println("形式与政治"+" has no grades yet");
            else if(kc.list2.contains("形式与政治")) {
                for (int j = 0; j < kc.形式与政治.size(); j++) {
                    sum = sum + Integer.parseInt(kc.形式与政治.get(j));
                }
                if(kc.形式与政治.size()!=0)  sum=sum/kc.形式与政治.size();
                System.out.println("形式与政治"+" "+sum+" "+sum);
            }
            else if(kc.list1.contains("形式与政治")) {
                for (int j = 0; j < kc.形式与政治.size(); j++) {
                    sum = sum + Integer.parseInt(kc.形式与政治.get(j))+ Integer.parseInt(kc.形式与政治.get(j+1));
                    j++;
                }
                if(kc.形式与政治.size()!=0) sum=sum/ kc.形式与政治.size()*2;
                System.out.println("形式与政治"+" "+sum);
            }
            else;
        }
        if(!kc.科目.isEmpty()) {
            if (kc.科目.size() >= 2) System.out.println(kc.科目.get(0)+" has no grades yet");
            else System.out.print(kc.科目.get(0)+" has no grades yet");
            if (kc.科目.size() >= 2) {
                for (i = 1; i < kc.科目.size(); i++) {
                    int flag = 0;
                    for (int j = kc.科目.size()-1; j>=0; j--) {
                        if (kc.科目.get(i).equals(kc.科目.get(j - 1))) flag = 1;
                    }
                    if (flag == 0) System.out.println(kc.科目.get(i)+" has no grades yet");
                }
            }
        }
           else xk.bj();
        //    System.out.println(xk.b[0].num+" "+xk.b[0].name+" "+xk.b[0].fen);
    }
}
class kecheng{
    ArrayList<String> list1= new ArrayList<String>();
    ArrayList<String> list2= new ArrayList<String>();
    ArrayList<String> list3= new ArrayList<String>();
    ArrayList<String> list4= new ArrayList<String>();
    public void bixiuke(String a ) {
        list1.add(a);
    }
    public void xuanxiuke(String a ) {
        list2.add(a);
    }
    public void bixiu(String a ) {
        list3.add(a);
    }
    public void xuanxiu(String a ) {
        list4.add(a);
    }
    ArrayList<String> 科目= new ArrayList<String>();
    public void 科目(String a ) {
        科目.add(a);
    }
    ArrayList<String> 考试科目= new ArrayList<String>();
    public void 考试科目(String a ) {
        考试科目.add(a);
    }
    ArrayList<String> java= new ArrayList<String>();
    public void java(String a ) {
        java.add(a);
    }
    ArrayList<String> 形式与政治= new ArrayList<String>();
    public void 形式与政治(String a ) {
        形式与政治.add(a);
    }
    ArrayList<String> 数据库= new ArrayList<String>();
    public void 数据库(String a ) {
        数据库.add(a);
    }
    ArrayList<String> 数据结构= new ArrayList<String>();
    public void 数据结构(String a ) {
        数据结构.add(a);
    }
}
class xuesheng{
    String num;
    String name;
    int fen;
    public xuesheng(String num,String name,int fen) {
        this.num=num;
        this.name=name;
        this.fen=fen;

    }
    xuesheng(){

    }

}
class banji{
    String classes;

    String fen;
    public banji(String num,String fen) {
        this.classes=num;
        this.fen=fen;

    }
    banji(){

    }


}
class chengji{
    int num=0;
    public int bixiu(String a,String b) {
        int num=(int)(Integer.parseInt(a)*0.3+Integer.parseInt(b)*0.7);
        return num;
    }
    public int xuanxiu(String a) {
        int num=(int)(Integer.parseInt(a));
        return num;
    }

}
class xuanke{
    banji[] a=new banji[10];
    xuesheng[] b=new xuesheng[10];
    xuesheng[] v=new xuesheng[10];
    int i=0;
        int s=0;
    int z=0;
    public void xuanke( banji sid1,xuesheng sid2){
        this.a[i]=sid1;
        this.b[i]=sid2;
        i++;
    }
    xuanke(){

    }
    public void bj(){
        int j=0;
        for(j=0;j<i;j++) {
            if(a[j].classes.equals("202011"))  s=Integer.parseInt(a[j].fen)+s;
            if(a[j].classes.equals("202012")) z=Integer.parseInt(a[j].fen)+z;
        }
       if(j!=0) s=s/j;
        if(j!=0) z=z/j;
        if(s!=0&&z!=0) System.out.println("202011"+" "+s);
        if(s!=0&&z==0)    System.out.print("202011"+" "+s);
        if(z!=0) System.out.println("202012"+" "+z);
    }
    public void xs(){
        for(int j=0;j<i;j++){
            for(int x=0;x<i;x++){
                if(b[j].num.compareTo(b[x].num)<0) {
                    v[1] =b[x];
                    b[x]=b[j];
                    b[j]=v[1];
                }
            }
        }
        for(int j=0;j<i;j++) {
            System.out.println(b[j].num+" "+b[j].name+" "+b[j].fen);
        }
    }
}

2. 课程成绩统计程序-2：比起上次作业，这次作业增加了一个实验课的成绩统计，整体的代码没有核心的算法改变，只是增加了对于实验课的处理，写完这次作业可以很清晰的感受到类的设计合理带来的便捷。

代码的整体核心没有发生变化，以下为对类的分析

 

class xuesheng{
    ArrayList<String> 学生= new ArrayList<String>();
    public void getxs(String a) {
        学生.add(a);
    }
    String[] a = new String[100];
    String[] b = new String[100];
    String[] e = new String[100];
    int[] c = new int[100];
    int[] d = new int[100];
    int i = 0;
    int count = 0;

    public void date1(String w, String x, String s,int y, int z) {
        this.a[i] = w;
        this.b[i] = x;
        this.e[i] = s;
        this.c[i] = y;
        this.d[i] = z;
        i++;
        count++;
    }
    public void setxs() {
        Collections.sort(学生);
        for (int i = 0; i < 学生.size(); i++) {
            for (int j = 0; j < count; j++) {
                if (a[j].equals(学生.get(i))&& d[j] == 0) {
                    System.out.println(学生.get(i) + " " +e[j]+ " " +c[j]);
                }
                if (a[j].equals(学生.get(i))&& d[j] != 0) {
                    System.out.println(学生.get(i) + " " +e[j]+ " " +(int)(c[j]*0.3+0.7*d[j]));
                }

            }
        }
    }
}

class kecheng{
    ArrayList<String> list1= new ArrayList<String>();
    ArrayList<String> list2= new ArrayList<String>();
    ArrayList<String> list3= new ArrayList<String>();
    ArrayList<String> 考试科目= new ArrayList<String>();
    public void 必修课(String a){list1.add(a);}
    public void 选修课(String a){list2.add(a);}
    public void 实验(String a){list3.add(a);}
    public void 考试科目(String a){考试科目.add(a);}
    String[] a = new String[100];
    String[] b = new String[100];
    int[] c = new int[100];
    int[] d = new int[100];
    int i = 0;
    int count = 0;

    public void date1(String w, String x, int y, int z) {
        this.a[i] = w;
        this.b[i] = x;
        this.c[i] = y;
        this.d[i] = z;
        i++;
        count++;
    }
    public void setxk() {
        Collections.sort(考试科目);
        for (int i = 0; i < 考试科目.size(); i++) {
            int flag = 0;
            int sum = 0;
            int num = 0;
            for (int j = 0; j < count; j++) {
                if (b[j].equals(考试科目.get(i))&&list1.contains(b[j])) {
                    sum = sum + c[j];
                    num = num + d[j];
                    flag++;
                }
                if (b[j].equals(考试科目.get(i))&&list2.contains(b[j])) {
                    sum = sum + c[j];
                    flag++;
                }
                if (b[j].equals(考试科目.get(i))&&list3.contains(b[j])) {
                    sum = sum + c[j];
                    flag++;
                }
            }
            if (sum != 0 && flag != 0 && num != 0 ) {
                sum = sum / flag;
                num = num / flag;
                System.out.println(考试科目.get(i) + " " + sum + " " + num + " " + (num + sum) / 2);
            }
            else if (sum != 0 && flag != 0 && num == 0&&list2.contains(考试科目.get(i))) {
                sum = sum / flag;
                System.out.println(考试科目.get(i) + " " + sum + " " + sum);
            }
            else if (sum != 0 && flag != 0 && num == 0&&list3.contains(考试科目.get(i))) {
                sum = sum / flag;
                System.out.println(考试科目.get(i) + " " + sum);
            }
            else;
        }
    }

}

在学生类中使用数组对数据进行收集与归纳，然后再使用列表对数据进行排列。在学生内容我收集了学号，姓名，班级，课程成绩等数据，这些数据帮助我在输出学生成绩时有很大的作用。记录这些数据对于我后面也颇有用处，不存在遗忘数据的情况。

在课程类中使用了多个列表来记录不同课程的不同考核方式和不同类型。这有助于我后面输出错误提示，与之关联的错误提示大概有三个。我需要根据这个输出课程类型错误等错误提示。课程数据的归纳是错误提示中的重中之重，如果不能对课程数据进行一个正确的归纳，有可能导致后面错误提示出现巨大错误。

3 课程成绩统计程序-3：这次作业的改变的相较于前两次有较大的改变，改变了课程信息输入和课程成绩信息格式，同时改变了最终成绩的计算方式，以及类之间的关系，代码改动较大，需要判断的错误也变多，但总体难度并不高。

import java.text.Collator;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Scanner;
import java.util.Collections;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int juddgeexist=0;
        int uu;
        int ss=0;
        grade gra_gra=new grade(null);
        String five="^(\\d{8})\\s+([\\u4e00-\\u9fa5a-zA-Z0-9_]{1,10})\\s+([\\u4e00-\\u9fa5a-zA-Z0-9_]{1,10})\\s+([0-9]|[1-9][0-9]|100)\\s+([0-9]|[1-9][0-9]|100)$";
        String four="^(\\d{8})\\s+([\\u4e00-\\u9fa5a-zA-Z0-9_]{1,10})\\s+([\\u4e00-\\u9fa5a-zA-Z0-9_]{1,10})\\s+([0-9]|[1-9][0-9]|100)$";
        Chosecoure date = new Chosecoure();
        int cont = 0;
        int sin=0;
        int run;
        while (in.hasNextLine()) {
            run=0;
            String a = in.nextLine().trim();
            String[] b = a.split(" ");
            int length = b.length;
            ss=0;
            int iq = 0;
            if (a.equals("end"))
                break;
            else {
                if (length == 3) {
                    float []fll = new float[2];
                    fll[0]=1;
                    Course c = new Course(b[0],b[1],b[2],1,fll);
                    if (c.课程性质和课程的考核方式匹配()) {
                        if(c.权重之和是否为1()){
                            for (Course e : date.course) {
                                if (e.name.equals(b[0])) {
                                    iq = 1;
                                    break;
                                } else
                                    iq = 0;
                            }
                            if (iq == 0)
                                date.course.add(c);
                        }
                        else{
                            System.out.println(b[0] + " : weight value error");
                        }
                    }
                }
                else if (length == 6) {
                    float []fll = new float[2];
                    fll[0]=Float.parseFloat(b[4]);;
                    fll[1]=Float.parseFloat(b[5]);
                    Course c = new Course(b[0], b[1], b[2],2,fll);
                    if (c.课程性质和课程的考核方式匹配()) {
                        if(c.权重之和是否为1()){
                            for (Course e : date.course) {
                                if (e.name.equals(b[0])) {
                                    iq = 1;
                                    break;
                                } else
                                    iq = 0;
                            }
                            if (iq == 0)
                                date.course.add(c);
                        }
                        else{
                            System.out.println(b[0] + " : weight value error");
                        }
                    }
                }
                else if(length>6&&(b[2].equals("实验")||b[2].equals("考察")||b[2].equals("考试"))) {
                    float[] fll = new float[length - 4];
                    for (int i = 0; i < length - 4; i++) {
                        fll[i] = Float.parseFloat(b[i+4]);
                    }
                    Course c = new Course(b[0], b[1], b[2], Integer.parseInt(b[3]), fll);
                    if (c.合法()) {
                        if(length - 4 == Integer.parseInt(b[3]))
                            if (c.课程性质和课程的考核方式匹配()) {
                                if (c.权重之和是否为1()) {
                                    for (Course e : date.course) {
                                        if (e.name.equals(b[0])) {
                                            iq = 1;
                                            break;
                                        } else
                                            iq = 0;
                                    }
                                    if (iq == 0)
                                        date.course.add(c);
                                }
                                else{
                                    System.out.println(b[0] + " : weight value error");
                                }
                            }
                            else {
                                System.out.println(b[0]+" : number of scores does not match");
                            }
                    }
                    else{
                        System.out.println("wrong format");
                    }
                }
                date.course.forEach((e)->{
                    e.decidemark();
                });
                for(Course e: date.course){
                    if(e.name.equals(b[2]))
                        run=e.mark;
                }
                if ((length == 4 || length == 5)&&run!=3) {
                    if (length == 4) {
                        if (!a.matches(four)) {
                            System.out.println("wrong format");
                        }else{
                            int []fll = new int[9];
                            fll[0]=-1;
                            fll[1]=Integer.parseInt(b[3]);
                            Score sco = new Score(b[0], b[1],b[2],fll);
                            Student stu = new Student(b[0], b[1]);
                            date.student.add(stu);
                            date.grades.add(new grade(gra_gra.getgradenumber(b[0])));
                            for(Course e: date.course)
                            {
                                if (e.name.equals(b[2]) && e.mark == 1)
                                    sin = 1;
                                if(e.name.equals(b[2]))
                                {
                                    sco.getweight(e.weight);
                                    sco.getsize(e.size);
                                }
                            }
                            if (sco.存在这个课程(b[2], date.course) && sco.成绩数量匹配考核方式(b[2], date.course))
                            {
                                if (cont == 0&&sin==1) {
                                    sco.dailyScore = 0;
                                    sco.decidecourse(date.course);
                                    date.score.add(sco);
                                    sco.dailyScore = -1;
                                    cont++;
                                }
                                for (Score e : date.score) {
                                    if (e.number.equals(b[0]) && e.name.equals(b[1]) && e.course.name.equals(b[2]) && e.dailyScore == -1 && e.examScore == Integer.parseInt(b[3])&&sin==1)
                                        break;
                                    else {
                                        sco.dailyScore = 0;
                                        sco.decidecourse(date.course);
                                        date.score.add(sco);
                                        for (grade m : date.grades) {
                                            if (m.gradenumber.equals(gra_gra.getgradenumber(b[0]))) {
                                                juddgeexist = 1;
                                                break;
                                            } else
                                                juddgeexist = 0;
                                        }
                                        if (juddgeexist == 0)
                                            date.grades.add(new grade(gra_gra.getgradenumber(b[0])));
                                        break;
                                    }
                                }
                            } else if (!sco.存在这个课程(b[2], date.course) && !sco.成绩数量匹配考核方式(b[2], date.course))
                                System.out.println(b[2] + " does not exist");
                            else if (!sco.存在这个课程(b[2], date.course))
                                System.out.println(b[2] + " does not exist");
                            else if (!sco.成绩数量匹配考核方式(b[2], date.course))
                                System.out.println(b[0] + " " + b[1] + " : access mode mismatch");
                        }
                    }
                    if (length == 5) {
                        if (!a.matches(five)) {
                            System.out.println("wrong format");
                        }
                        else{
                            uu=0;
                            int []fll=new int [9];
                            fll[0]= Integer.parseInt(b[3]);
                            fll[1]= Integer.parseInt(b[4]);
                            Score sco = new Score(b[0],b[1],b[2],fll);
                            Student stu = new Student(b[0], b[1]);
                            date.student.add(stu);
                            date.grades.add(new grade(gra_gra.getgradenumber(b[0])));
                            for(Course e: date.course){
                                if(e.name.equals(b[2])&&e.mark==2)
                                    sin=2;
                                if(e.name.equals(b[2]))
                                {
                                    sco.getweight(e.weight);
                                    sco.getsize(e.size);
                                }
                            }
                            if (sco.存在这个课程(b[2], date.course) && sco.成绩数量匹配考核方式(b[2], date.course) && a.matches(five)&&sin==2)//判断数据是否合法
                            {
                                if (cont == 0&&sin==2) {
                                    sco.decidecourse(date.course);
                                    date.score.add(sco);
                                    cont++;
                                }
                                for (Score e : date.score) {
                                    if (e.number.equals(b[0]) && e.name.equals(b[1]) && e.course.name.equals(b[2]) && e.dailyScore == Integer.parseInt(b[3]) && e.examScore == Integer.parseInt(b[4])&&sin==2) {
                                        uu=1;
                                    }
                                } if(uu==0&& sco.存在这个课程(b[2], date.course) && sco.成绩数量匹配考核方式(b[2], date.course) && a.matches(five)&&sin==2) {
                                date.score.add(sco);
                                for (grade m : date.grades) {
                                    if (m.gradenumber.equals(gra_gra.getgradenumber(b[0]))) {
                                        juddgeexist = 1;
                                        break;
                                    } else {
                                        juddgeexist = 0;
                                    }
                                }
                                if (juddgeexist == 0)
                                    date.grades.add(new grade(gra_gra.getgradenumber(b[0])));
                            }
                            } else if (!sco.存在这个课程(b[2], date.course) && !sco.成绩数量匹配考核方式(b[2], date.course)) {
                                System.out.println(b[2] + " does not exist");
                            } else if (!sco.存在这个课程(b[2], date.course)) {
                                System.out.println(b[2] + " does not exist");
                            } else if (!sco.成绩数量匹配考核方式(b[2], date.course)) {
                                System.out.println(b[0] + " " + b[1] + " : access mode mismatch");
                            }
                        }
                    }
                }
                if ((length > 5||run==3)&&!b[2].equals("实验")&&!b[2].equals("考察")&&!b[2].equals("考试")) {
                    int []fll = new int[9];
                    for(int i=0;i<9;i++)
                        fll[i]=-1;
                    for(int i=0;i<length-3;i++)
                    {
                        fll[i]=Integer. parseInt(b[i+3]);
                    }
                    Student stu = new Student(b[0], b[1]);
                    Score sco = new Score(b[0], b[1], b[2],fll);
                    date.student.add(stu);
                    date.grades.add(new grade(gra_gra.getgradenumber(b[0])));
                    sco.getlength(length);
                    for(Course e: date.course){
                        if(e.name.equals(b[2])&&e.mark==3)
                            sin=3;
                        if(e.name.equals(b[2]))
                        {
                            sco.getweight(e.weight);
                            sco.getsize(e.size);
                        }
                    }
                    if (sco.存在这个课程(b[2], date.course) && sco.成绩数量匹配考核方式(b[2], date.course) && sco.是否合法()&&sin==3) {
                        sco.decidecourse(date.course);
                        date.score.add(sco);
                        for (grade m : date.grades) {
                            if (m.gradenumber.equals(gra_gra.getgradenumber(b[0]))) {
                                juddgeexist = 1;
                                break;
                            } else {
                                juddgeexist = 0;
                            }
                        }
                        if (juddgeexist == 0)
                            date.grades.add(new grade(gra_gra.getgradenumber(b[0])));
                        cont++;
                    }
                    else if (!sco.存在这个课程(b[2], date.course) && !sco.成绩数量匹配考核方式(b[2], date.course)&& sco.是否合法()) {
                        System.out.println(b[2] + " does not exist");
                    } else if (!sco.存在这个课程(b[2], date.course)&& sco.是否合法()) {
                        System.out.println(b[2] + " does not exist");
                    } else if (!sco.成绩数量匹配考核方式(b[2], date.course)&&sco.是否合法()) {
                        System.out.println(b[0] + " " + b[1] + " : access mode mismatch");
                    }
                    else if(!sco.是否合法()&&sco.存在这个课程(b[2], date.course))
                    {
                        System.out.println("wrong format");
                    }
                }
            }
        }
        for (Student e : date.student) {
            e.getStudenttotol(date.score);
        }
        int flag = 0;
        int flag1=0;
        String num = "000";
        Collections.sort(date.student);
        for (Student q : date.student) {
            flag = 0;
            if(!num.equals(q.number))
                flag = 1;
            num = q.number;
            if(flag == 1)
            {
                if (q.JudgeEmpty())
                    System.out.println(q.number + " " + q.name + " " + q.student_score);
                else
                    System.out.println(q.number+" "+q.name+" "+"did not take any exams");
            }
        }


        date.Course_and_Score();
        Collections.sort(date.grades);
        Collections.sort(date.course);
        date.output();
        date.grade_score(date.score);
        String num1="000";
        for(grade e : date.grades){
            flag1=0;
            if(!num1.equals(e.gradenumber))
            {
                flag1=1;
                num1=e.gradenumber;
            }
            if(flag1==1)
            {
                if(e.size!=0)
                    System.out.println(e.gradenumber+" "+e.grade_score);
            }
        }
    }
}
class Course implements Comparable<Course>{
    String name;
    String nature;
    String assessment;
    int size=0;
    int course_score=0;
    int course_dailyscore=0;
    int course_finalscore=0;
    float []weight=new float[9];
    int found=0;
    int mark=0;
    float sum=0;
    Course(String name,String nature,String assessment,int size,float fll[])
    {
        this.assessment=assessment;
        this.nature=nature;
        this.name=name;
        this.size=size;
        this.weight=fll;
    }
    boolean 课程性质和课程的考核方式匹配()
    {
        if((nature.equals("必修")&&assessment.equals("考察"))||(nature.equals("实验")&&assessment.equals("考试"))||(nature.equals("实验")&&assessment.equals("考察"))||(nature.equals("必修")&&assessment.equals("实验"))||(nature.equals("选修")&&assessment.equals("实验")))
        {
            System.out.println(name+" : course type & access mode mismatch");
            return false;
        }
        else
            return true;
    }
    public int compareTo(Course o) {

        try {
            Comparator compator = Collator.getInstance(Locale.CHINA);
            if (compator.compare(this.name, o.name) < 0) {
                return -1;
            } else if (compator.compare(this.name, o.name) > 0) {
                return 1;
            }
        } catch (Exception e) {
        }
        return 0;
    }
    @Override
    public String toString() {
        return name;
    }
    void decidemark(){
        if(nature.equals("必修")||assessment.equals("考试"))
            this.mark=2;
        if(assessment.equals("考察"))
            this.mark=1;
        if(assessment.equals("实验")&&nature.equals("实验"))
            this.mark=3;
    }
    boolean 权重之和是否为1(){
        for(int i=0;i<size;i++)
        {
            sum+=weight[i];
        }
        if(sum==1.0)
        {
            return true;
        }
        else {
            return false;
        }
    }
    boolean 合法(){
        if(size<4||size>9)
            return false;
        else
            return true;
    }
}
class Score{
    String number;
    String name;
    Course course = new Course(null,null,null,0,null);
    int dailyScore;
    int examScore;
    int flag=-1;
    int[] chengji=new int[9];
    float [] weight=new float[9];
    int size=0;
    int mark=0;
    int length;
    void getsize(int size){
        this.size=size;
    }
    void getweight(float weight[]){
        this.weight=weight;
    }
    void  getlength(int length){
        this.length=length;
    }
    Score(String number, String name ,String coursename,int chengji[])
    {
        this.number=number;
        this.course.name=coursename;
        this.name=name;
        this.chengji=chengji;
        for(int i=0;i<9;i++)
        {
            if(chengji[i]==-1)
                this.chengji[i]=0;
        }
    }
    void decidecourse(List<Course> course){
        course.forEach((e)->{
            if(e.name.equals(this.course.name))
            {
                this.course=e;
            }
        });
    }
    boolean 是否合法(){
        if(size<4||size>9)
            return false;
        for(int i=0;i<9;i++)
        {
            if(chengji[i]<0||chengji[i]>100)
                return false;
        }
        return true;
    }
    int getFinalScore()
    {
        float sum=0;
        if(course.assessment.equals("考察")&&course.nature.equals("选修"))
            return examScore;
        else if(course.nature.equals("必修")&&!course.assessment.equals("实验"))
        {
            return (int)(examScore*weight[0]+dailyScore*weight[1]);
        }
        else if(course.assessment.equals("考试")&&course.nature.equals("选修"))
        {
            return (int)(examScore*weight[0]+dailyScore*weight[1]);
        }
        else if(course.assessment.equals("实验") && course.nature.equals("实验")){
            for(int q=0;q<size;q++)
            {
                sum+=chengji[q]*weight[q];
            }
            return (int)(sum);
        }
        else
            return 0;
    }
    boolean 存在这个课程(String name,List<Course> course){
        boolean a=false;
        for (Course e : course) {
            if (name.equals(e.name)) {
                a = true;
                return a;
            }
        }
        return a;
    }
    boolean 成绩数量匹配考核方式(String name,List<Course> course){
        boolean b = true;
        for (Course e : course) {
            if(e.name.equals(name)) {
                b = (!e.assessment.equals("考察") || flag != 1 || mark == 2) && (!e.assessment.equals("考试") || flag != 0 || mark == 1) && (!e.nature.equals("必修") || flag != 0 || mark == 1) && (!e.nature.equals("实验") || length - 3 == size);
                break;
            }
        }
        return b;
    }
}
class Chosecoure {
    List<Score> score = new ArrayList<>();
    List<Course> course = new ArrayList<>();
    List<Student> student = new ArrayList<>();
    List<grade> grades=new ArrayList<>();
    grade lmlm=new grade(null);
    int m = 0;
    void Course_and_Score() {
        for (Course f : course) {
            m = 0;
            for (Score e : score) {
                if (e.course.name.equals(f.name)) {
                    f.course_score += e.getFinalScore();
                    f.course_dailyscore += e.dailyScore;
                    f.course_finalscore += e.examScore;
                    m++;
                }
            }
            if (m != 0) {
                f.course_score = f.course_score / m;
                f.course_finalscore = f.course_finalscore / m;
                f.course_dailyscore = f.course_dailyscore / m;
            } else {
                System.out.println(f.name + " has no grades yet");
                f.found=1;
            }
        }
    }
    void grade_score(List<Score> e)
    {
        grades.forEach((q)->{
            e.forEach((p)->{
                if(q.gradenumber.equals(lmlm.getgradenumber(p.number)))
                {
                    q.grade_score+=p.getFinalScore();
                    q.size++;
                }
            });
            if(q.size != 0)
                q.grade_score/=q.size;
            if(q.size==0)
                System.out.println(q.gradenumber+" has no grades yet");
        });
    }

    void output() {
        course.forEach((e) -> {
            {
                if ((e.assessment.equals("考试") || e.nature.equals("必修"))&&e.found==0)
                    System.out.println(e.name + " " + e.course_dailyscore + " " + e.course_finalscore + " " + e.course_score);
                if (e.assessment.equals("考察")&&e.found==0) {
                    System.out.println(e.name + " " + e.course_finalscore + " " + e.course_finalscore);
                }
                if(e.assessment.equals("实验")&&e.nature.equals("实验")&&e.found==0)
                {
                    System.out.println(e.name+ " " + e.course_score);
                }
            }
        });
    }
}
class Student implements Comparable<Student>{
    String number;
    String name;
    int student_score = 0;
    int student_score_size=0;
    Student(String number,String name)
    {
        this.number=number;
        this.name=name;
    }
    boolean JudgeEmpty(){
        return student_score_size != 0;
    }
    int getStudenttotol(List<Score> e){
        e.forEach((f)->{
            if(f.name.equals(name)&&f.number.equals(number))
            {
                student_score+=f.getFinalScore();
                student_score_size++;
            }
        });
        if(student_score_size != 0)
            student_score=student_score/student_score_size;
        return student_score;
    }
    public int compareTo(Student o) {
        return this.number.compareTo(o.number);
    }
    public String toString() {
        return number;
    }
}
class grade implements Comparable<grade>{
    String gradenumber;
    grade(String gradenumber){
        this.gradenumber=gradenumber;
    }
    int grade_score = 0;
    int size=0;
    String getgradenumber(String number){
        this.gradenumber=number.substring(0,6);
        return gradenumber;
    }
    public int compareTo(grade o) {
        return this.gradenumber.compareTo(o.gradenumber);
    }
    public String toString() {
        return gradenumber;
    }
}

这次作业与前两次作业有着巨大的不同，不仅改变了课程类型和成绩的输入方式，也改变了成绩的计算方式。这就导致我需要重新规划好不同成绩之间的不同计算，需要添加某些类来辅助计算成绩，比如成绩的加权类，不同成绩对于不同的权。

其次就是错误提示变得更多更复杂，我需要使用更多的列表来对应不同的错误提示，导致代码长度较长。我感觉可以避免代码长度较长这个问题，但是能力有限。

个人心得：

熟悉语法：通过完成各种Java大作业，我对Java的语法有了更深入的理解，并能够熟练地运用各种语法特性来解决问题。

强大的功能：Java作为一门强大的编程语言，拥有丰富的库和框架，能够处理各种复杂的问题。通过作业的实践，我掌握了一些常用的库和框架，并且了解了如何利用它们来简化编程任务。

掌握面向对象编程：Java是一门面向对象的编程语言，通过完成Java大作业，我更深刻地理解了面向对象的思想，并学会了如何将复杂的问题分解成对象，并通过相互的交互来解决问题。

提高问题解决能力：在完成Java大作业的过程中，我经常会遇到各种问题和错误，需要通过调试和查找资料来解决。这个过程不仅提高了我的问题解决能力，还培养了我的耐心和坚持不懈的精神。

实践与理论相结合：在学习Java大作业的过程中，不仅需要掌握Java的理论知识，还需要将所学知识应用到实际问题中去。通过实践，我更加深入地理解了课堂上的理论知识，并且加深了对Java编程的兴趣。

总的来说，通过学习Java大作业一学期，我不仅加深了对Java编程语言的理解和掌握，还提高了自己的问题解决能力和实际应用能力，这对我日后的学习和工作都将有很大的帮助