第一次博客作业-答题判题程序1-3 blog-1

lingx555 / 2024-04-20 / 原文

一、前言：

　　在学习面向对象程序设计的过程中，我完成了三次PTA题目集的作业，在此过程中我感受颇多。

　　上半学期学习C语言过程中有些错误的习惯对我学习面向对象造成了很大的影响，比如喜欢将代码全写入主函数当中，而不放入函数中分块。各种问题的积累导致我在初见nchu-software-oop-2024-上-1中的最后一题答题判题程序-1时有些棘手，平时关于类间关系的思考和训练也比较少，因此我花了大量的时间在编写类和设计类上，尽管设计的还是不理想，但还是收获了不少。答题判题程序-1除去类设计的模块，剩下的就是对字符串的解析、各种字符串的储存等，因此它在答题判题程序这个系列中是最基础的一道题。

　　在第二次题目集nchu-software-oop-2024-上-2中，答题判题程序-2相较于第一次难度略有提升，同时也增加了一些要求，这些要求都使我们对类的设计，类之间的关系的理解进一步提升。如第二次题目集新增加的“#T”所对应的试卷字符串，“#S”所对应的答卷字符串，都需要我们对其进行解析并储存入对应的类中，并将这些类建立依赖或关联关系，调用从而解决问题。

　　第三次题目集nchu-software-oop-2024-上-3中的答题判题程序-3相较于前两次变动不大，但是加入了很多出错判断，加强了对代码的质量的要求，因此程序复杂度提高较大。并且在题目集3中，新增了学生类Student与删除信息对应的类Delete，如果对类间关系不熟，并且不能熟练应用面向对象的基本原则（尤其是单一职责原则），很容易将代码越写越乱，最后自己写的代码自己都看不懂。

二、设计与分析及踩坑心得：

　　以下对三次题目集的答题判题程序进行代码分析：

　　一：答题判题程序-1：

　　要求：设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。

　　输入格式：

　　1、题目数量

　　　　格式：整数数值，若超过1位最高位不能为0，

　　　　样例：34

　　2、题目内容

　　　　一行为一道题，可以输入多行数据。

　　　　格式："#N:"+题号+" "+"#Q:"+题目内容+" "#A:"+标准答案

　　　　　格式约束：题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。

　　　　样例：#N:1 #Q:1+1= #A:2

#N:2 #Q:2+2= #A:4

　　3、答题信息

　　　　答题信息按行输入，每一行为一组答案，每组答案包含第2部分所有题目的解题答案，答案的顺序号与题目题号相对应。

　　　　格式："#A:"+答案内容

　　　　格式约束：答案数量与第2部分题目的数量相同，答案之间以英文空格分隔。

　　　　样例：#A:2 #A:78

      　　2是题号为1的题目的答案
      　　78是题号为2的题目的答案

　　　　答题信息以一行"end"标记结束，"end"之后的信息忽略。

　　输出格式:

　　1、题目数量

　　　　格式：整数数值，若超过1位最高位不能为0，

　　　　样例：34

　　2、答题信息

　　　　一行为一道题的答题信息，根据题目的数量输出多行数据。

　　　　格式：题目内容+" ~"+答案

　　　　样例：1+1=~2

　　　　　2+2= ~4

　　3、判题信息

　　　　判题信息为一行数据，一条答题记录每个答案的判断结果，答案的先后顺序与题目题号相对应。

　　　　格式：判题结果+" "+判题结果

　　　　格式约束：

     　　　　1、判题结果输出只能是true或者false，
     　　　　2、判题信息的顺序与输入答题信息中的顺序相同

　　　　样例：true false true

　　源代码：

import java.util.*;
import java.text.DecimalFormat;
public class Main{
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        String w;
        int num=input.nextInt();
        String s[] = new String[num];
        Question []question=new Question[num];
        Paper paper=new Paper();
        Answer answer=new Answer(paper);
        for(int i=0;i<num;i++){
            if(i==0){
            w=input.nextLine();
            }
            s[i]=input.nextLine();
        }
        String answ=input.nextLine();
        answ=answ.replaceAll("#A","");
        answ=answ.replaceAll(" ","");
        String []answerin=answ.split(":");
        for(int i=0;i<num;i++){
            answer.saveOneAnswer(i,answerin[i+1],num);
        }
        for(int i=0;i<num;i++){
            if(s[i].equals("end")){
                System.exit(0);
            }
            else{
                s[i]=s[i].replaceAll("#N","");
                s[i]=s[i].replaceAll("#Q","");
                s[i]=s[i].replaceAll("#A","");
                String []ti=s[i].split(":");
                ti[1]=ti[1].replaceAll(" ","");
                ti[2]=ti[2].replaceAll("^\\s+","");
                ti[2]=ti[2].replaceAll("\\s+$","");
                ti[3]=ti[3].replaceAll(" ","");
                int num2=Integer.parseInt(ti[1]);
                question[num2-1]=new Question(i,ti[2],ti[3]);
                paper.saveQuestion(num2-1,ti[2]);
            }
        }
        for(int i=0;i<num;i++){
            answer.toStringanswer(i);
        }
        for(int j=0;j<num;j++){
            if(question[j].getstardardThing().equals(answerin[j+1])){
                System.out.print("true");
                if(j!=num-1){
                System.out.print(" ");
                }
            }
            else{
                System.out.print("false");
                if(j!=num-1){
                System.out.print(" ");
                }
            }
        }
        System.exit(0);
    }
}
class Question {
    private int questionNum=0;
    private String questionThing;
    private String stardardThing;
    public Question(){
        
    }

public Question(int questionNum,String questionThing,String stardardThing){
        this.questionNum=questionNum;
        this.questionThing=questionThing;
        this.stardardThing=stardardThing;
    }
    public int getquestionNum(){
        return questionNum;
    }
    public String getquestionThing(){
        return questionThing;
    }
    public String getstardardThing(){
        return stardardThing;
    }
    public void setquestionNum(int questionNum){
        this.questionNum=questionNum;
    }
    public void setquestionThing(String questionThing){
        this.questionThing=questionThing;
    }
    public void setstardardThing(String stardardThing){
        this.stardardThing=stardardThing;
    }
    public boolean isStardard(){
        if(this.questionThing.equals(stardardThing)){
            return true;
        }
        else{
            return false;
        }
    }
}

class Paper {
    Question question1;
    Question []question2=new Question[1000];
    private int questionSum=0;
    public Paper(){
        
    }
    public boolean isCorrect(int num,String answer){
        if(question2[num].getstardardThing().equals(answer)){
            return true;
        }
        else{
            return false;
        }
    }
    public void saveQuestion(int num,String question){
        question2[num]=new Question();
        question2[num].setquestionThing(question);
    }
}
class Answer {
    Paper paper;
    private String []answerList=new String [1000];
    public Answer(Paper paper){
        this.paper=paper;
    }
    public boolean isRight(int num){
        if(answerList[num].equals(paper.question2[num].getstardardThing())){
            return true;
        }
        else{
            return false;
        }
    }
    public void toStringanswer(int num){
        System.out.println(paper.question2[num].getquestionThing()+"~"+answerList[num]);
    }
    public void saveOneAnswer(int num,String answer,int sum){
        answerList[num]=answer;
    }
}

　　设计分析以及踩坑心得：

　　在题目集1中的答题判断程序-1中，我用到了三个类。以下是对这三个类的设计分析：

　　1、Question类：

　　储存题目的题号、题目内容、标准答案等信息，并可以对这些信息进行储存和返回。

　　Question类中还有方法isStardard()，它可以判断答卷中的答案是否符合标准答案standardAnswer。

public boolean isStardard(){
        if(this.questionThing.equals(stardardThing)){
            return true;
        }
        else{
            return false;
        }
 }

　　2、Paper类：

　　用于封装试卷信息，Paper类中有题目类的对象集合——题目列表，与之相对应，Paper类中有方法saveQuestion()，它可以保存题目，并将其置于题目列表中。

　　Paper中还有判题方法isCorrect()，它可以判断答案answer是否符合对应题号的题目标准答案standardAnswer。

　　3、Answer类：

　　Answer类中所具有的属性：paper（试卷类的对象），[]answerList（保存每一题的答案）

　　Answer类中所具有的方法：判题方法isRight()，它能够判断答案列表中的结果是否符合试卷中其对应题号的题目标准答案；输出方法toStringanswer()，它能够根据题目所要求的输出格式进行答案的输出，具体的方法代码见下：

public void toStringanswer(int num){
        System.out.println(paper.question2[num].getquestionThing()+"~"+answerList[num]);
 }

　　记得当时第一次接触类的设计，对于类的方法的构造还是有点困难，比如本题中的Paper类和Question类中究竟是依赖关系还是关联关系，就把我难住了有一会……在网上查找了一些资料，比如下面这个网址：关联和依赖的区别-CSDN博客，最后我才发现用关联比较合适。搞懂了这个之后，我也差不多摸清了这三个类间的关系，以下是题目集1的类图：

　　二：答题判题程序-2：

　　要求：输入题目信息、试卷信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。

　　输入格式：

　　程序输入信息分三种，三种信息可能会打乱顺序混合输入：

　　1、题目信息：

　　　　一行为一道题，可输入多行数据（多道题）。

　　　　格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案

　　　　格式约束：

    　　1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
    　　2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。

　　　　样例：#N:1 #Q:1+1= #A:2

　　　　　　　　#N:2 #Q:2+2= #A:4

　　2、试卷信息：

　　　　一行为一张试卷，可输入多行数据（多张卷）。

　　　　格式："#T:"+试卷号+" "+题目编号+"-"+题目分值

     　　题目编号应与题目信息中的编号对应。
     　　一行信息中可有多项题目编号与分值。

　　　　样例：#T:1 3-5 4-8 5-2

　　3、答卷信息：

　　　　答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序与试卷信息中的题目顺序相对应。

　　　格式："#S:"+试卷号+" "+"#A:"+答案内容

　　　格式约束：答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。

　　　样例：#S:1 #A:5 #A:22

       1是试卷号 
       5是1号试卷的顺序第1题的题目答案
       22是1号试卷的顺序第2题的题目答案

　　　答题信息以一行"end"标记结束，"end"之后的信息忽略。

　　　　输出格式:

　　　　1、试卷总分警示：

　　　　　　该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100分，该部分忽略，不输出。

　　　　　格式："alert: full score of test paper"+试卷号+" is not 100 points"

　　　　　　样例：alert: full score of test paper2 is not 100 points

　　　　2、答卷信息

　　　　　一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。

　　　　　格式：题目内容+"~"+答案++"~"+判题结果（true/false）

　　　　　约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"

　　　　　样例：3+2=~5~true

　　　　　　4+6=~22~false.

      　　answer is null

　　　　3、判分信息：

　　　　　　判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。

　　　　　　格式：题目得分+" "+....+题目得分+"~"+总分

　　　　　　格式约束：

 　　　　1、没有输入答案的题目计0分
 　　　　2、判题信息的顺序与输入答题信息中的顺序相同

　　　　　　根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。

　　　　4、提示错误的试卷号：

　　　　　　如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”，参见样例9。

　　　　源代码：

package java8;
import java.util.*;
import java.text.DecimalFormat;
public class Main{
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int sum=0;
        int papernum=0;
        int p=0;
        int answernum=0;
        int len=0;
        String w;
        String s[] = new String[100];
        Question []question=new Question[100];
        Paper []paper=new Paper[100];
        Answer []answer=new Answer[100];
        Grades []gradess=new Grades[100];
        for(int i=0;i<100;i++){
            s[i]=input.nextLine();
            if(s[i].equals("end")){
                break;
            }
            else{
                String []ti=s[i].split(":");
                if(ti[0].equals("#N")){
                    ti[1]=ti[1].replaceAll(" ","");
                    ti[1]=ti[1].replaceAll("#Q","");
                    int num2=Integer.parseInt(ti[1]);
                    ti[2]=ti[2].replaceAll("^\\s+","");
                    
                    ti[2]=ti[2].replaceAll("#A","");
                    ti[2]=ti[2].replaceAll("\\s+$","");
                    ti[3]=ti[3].replaceAll(" ","");
                    question[num2]=new Question(num2,ti[2],ti[3]);
                }
                else if(ti[0].equals("#T")){
                    papernum++;
                    String []pap=ti[1].split(" ");
                    len=pap.length;
                    //pap[0]=pap[0].replaceAll("#T:","");
                    int num2=Integer.parseInt(pap[0]);
                    gradess[papernum]=new Grades();
                    paper[num2]=new Paper(len-1);
                    for(int j=0;j<len-1;j++){
                        String []grade=pap[j+1].split("-");
                        int num3=Integer.parseInt(grade[0]);
                        int num4=Integer.parseInt(grade[1]);
                        //paper[num2]=new Paper(num3,question[num3],num4);
                        paper[papernum].setQuestion(j+1,question[num3]);
                        //paper[papernum].question2[j+1].setQuestionGrades(num4);
                        paper[papernum].question2[j+1].setGradess(papernum,gradess[papernum]);
                        paper[papernum].question2[j+1].grades[papernum].setGrades(num4,j+1);
                        sum=sum+num4;
                       //System.out.println(paper[1].question2[1].getQuestionGrades());
                    }
                    
                    //System.out.println(paper[1].question2[2].getQuestionGrades());
                    paper[num2].setSumGrades(sum);
                    if(paper[num2].getSumGrades()!=100){
                        System.out.println("alert: full score of test paper"+papernum+" is not 100 points");
                    }
                    sum=0;
                }
                else if(ti[0].equals("#S")){
                    answernum++;
                    int len1=ti.length-1;
                    ti[1]=ti[1].replaceAll(" ","");
                    ti[1]=ti[1].replaceAll("#A","");
                    int num2=Integer.parseInt(ti[1]);
                    
                    answer[answernum]=new Answer(num2,paper[num2],len1-1);
                    if(num2>papernum){
                        answer[answernum].setisMatch(1);
                        continue;
                    }
                    for(int j=2;j<=len1;j++){
                        ti[j]=ti[j].replaceAll(" ","");
                        ti[j]=ti[j].replaceAll("#A","");
                        answer[answernum].saveOneAnswer(num2,j-1,ti[j]);
                    }
                    
                }
            }
        }
        int num5=1;
       for(int i=1;i<=answernum;i++){
           if(answer[i].getisMatch()!=1){
            for(int j=1;j<=answer[i].getanswerlen();j++){
                        System.out.print(paper[num5].question2[j].getquestionThing());
                        answer[i].toStringanswer(j,paper[num5]);
                        answer[i].isCorect(paper[num5].question2[j].getstardardThing(),j);
                }
           if(answer[i].getanswerlen()<paper[num5].getquestionlen()){
               for(int j=0;j<paper[num5].getquestionlen()-answer[i].getanswerlen();j++){
               System.out.println("answer is null");
               }
           }
            answer[i].getGradesThing(num5);
            System.out.println(answer[i].getanswerGradesSum());
           if(num5<papernum){
               num5++;
           }
        }
       
        else{
            System.out.println("The test paper number does not exist");
        }
    }
}
}
class Question {
    private int questionNum=0;
    private String questionThing;
    private String stardardThing;
    private int questionGrades;
    Grades []grades=new Grades[100];
    public Question(){
        
    }
    public void setGradess(int papernum,Grades grades1){
        grades[papernum]=new Grades();
        grades[papernum]=grades1;
    }
    public void setQuestionGrades(int grade){
        this.questionGrades=grade;
    }
    public int getQuestionGrades(){
        return questionGrades;
    }
    public Question(int questionNum,String questionThing,String stardardThing){
        this.questionNum=questionNum;
        this.questionThing=questionThing;
        this.stardardThing=stardardThing;
    }
    public int getquestionNum(){
        return questionNum;
    }
    public String getquestionThing(){
        return questionThing;
    }
    public String getstardardThing(){
        return stardardThing;
    }
    public void setquestionNum(int questionNum){
        this.questionNum=questionNum;
    }
    public void setquestionThing(String questionThing){
        this.questionThing=questionThing;
    }
    public void setstardardThing(String stardardThing){
        this.stardardThing=stardardThing;
    }
    public boolean isStardard(){
        if(this.questionThing.equals(stardardThing)){
            return true;
        }
        else{
            return false;
        }
    }
}
class Paper {
    Question question1;
    Question []question2=new Question[1000];
    private int sumGrades;
    private int questionSum=0;
    private int questionlen=0;
    public int getquestionlen(){
        return questionlen;
    }
    public Paper(){
        
    }
    public Paper(int len){
        questionlen=len;
    }
    /*public Paper(int num,Question question,int grade){
        
    }*/
    public void setQuestion(int num,Question question){
        question2[num]=new Question();
        question2[num]=question;
    }
    public void setSumGrades(int sum){
        this.sumGrades=sum;
    }
    public int getSumGrades(){
        return sumGrades;
    }
    public void saveQuestion(int num,String question){
        question2[num]=new Question();
        question2[num].setquestionThing(question);
    }
    
}
class Answer {
    Paper u;
    private int y=0;
    Paper []paper1=new Paper[1000];
    private String []answerList=new String [1000];
    private String []isCorect=new String [1000];
    private int listnum=0;
    private int answerGradesSum=0;
    private int answerlen=0;
    private int isMatch=0;
    public Answer(int num,Paper paper,int len){
        paper1[num]=new Paper();
        paper1[num]=paper;
        this.answerlen=len;
    }
    public int getisMatch(){
        return isMatch;
    }
    public void setisMatch(int a){
        isMatch=a;
    }
    public int getanswerlen(){
        return answerlen;
    }
    public void toStringanswer(int num,Paper paper){
        u=paper;
        System.out.print("~"+answerList[num]+"~");
    }//paper1[1].question2[num].getquestionThing()+"~"+
    public void saveOneAnswer(int answernum,int num,String answer){
        answerList[num]=answer;
        listnum=paper1[answernum].getquestionlen();
    }
    public void isCorect(String s,int a){
        if(s.equals(answerList[a])){
            isCorect[a]="true";
            System.out.println("true");
        }
        else{
            isCorect[a]="false";
            System.out.println("false");
        }
    }
    public int getanswerGradesSum(){
        return answerGradesSum;
    }
    public void getGradesThing(int num7){
        for(int i=1;i<=listnum;i++){
            y++;
            if(isCorect[i]=="true"){
                if(i!=listnum){
                    System.out.print(paper1[num7].question2[i].grades[num7].getGrades(i)+" ");
                    answerGradesSum+=paper1[num7].question2[i].grades[num7].getGrades(i);
                }
                else{
                    System.out.print(paper1[num7].question2[i].grades[num7].getGrades(i));
                    answerGradesSum+=paper1[num7].question2[i].grades[num7].getGrades(i);
                }
            }
            else{
                if(i!=listnum){
                    System.out.print("0 ");
                }
                else{
                    System.out.print("0");
                }
            }
        }
        if(y==0){
            for(int i=1;i<=paper1[num7].getquestionlen();i++){
                if(i!=1){
                System.out.print(" 0");
                }
                else{
                System.out.print("0");
                }
            }
        }
        System.out.print("~");
    }
}
class Grades {
    private int []grades=new int [100];
    public Grades(){
        
    }
    public void setGrades(int grades,int num){
        this.grades[num]=grades;
    }
    public int getGrades(int num){
        return grades[num];
    }
}

　　设计分析以及踩坑心得：

　　题目集2中的答题判断程序-2相较于答题判断程序-1，增加了下面几种需求：

　　　　1.程序信息输入由一种变为三种，并且三种信息可能会打乱混合输入。

　　　　2.新增输入的试卷信息（以“#T”开头的字符串）：一行为一张试卷，可输入多行数据（多张卷）。格式为："#T:"+试卷号+" "+题目编号+"-"+题目分值。

　　　　3.新增输入的答案信息（以“#S”开头的字符串）：每组答案包含某个试卷信息中的题目的解题答案，答案的顺序与试卷信息中的题目顺序相对应。格式约束：答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略。

　　　　4.新增试卷总分警示：当试卷的总分不足100分时，输出提示语句：格式为"alert: full score of test paper"+试卷号+" is not 100 points"。

　　　　5.新增提示：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null" 。

　　对于以上5种新增的需求，我对上次的代码进行了以下几点修改：

　　　　1.新增Grades类，由于在上次的代码中，我在Question类中标准答案的存储方式为数组，对于这道题某些测试点所存在的答案覆盖问题不能解决，因此我将标准答案建立一个新类Grades，并将其置于Grades类中进行储存和返回。

　　　　2.在Question类中我添加了新的属性questionGrades，即每道题的分数。

　　　　3.在解析并切割新增的字符串时，我在代码中添加了多种正则表达式和切割方式，之后再将信息存入对应的类中，从而实现题目，试卷，答卷等各数据的存储。

　　以下是题目集二的类图：

　　三：答题判题程序-3：

　　要求：输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。

　　输入格式：　

　　　　程序输入信息分五种，信息可能会打乱顺序混合输入。

　　　　1、题目信息
　　　　　　题目信息为独行输入，一行为一道题，多道题可分多行输入。

　　　　　　格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案

格式约束：
    1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
    2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：#N:1 #Q:1+1= #A:2
     #N:2 #Q:2+2= #A:4

　　　　2、试卷信息

　　　　　试卷信息为独行输入，一行为一张试卷，多张卷可分多行输入数据。
　　　　　　格式："#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...

格式约束：
   题目编号应与题目信息中的编号对应。
   一行信息中可有多项题目编号与分值。 
样例：#T:1 3-5 4-8 5-2

　　　　3、学生信息

　　　　　　学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名，格式如下。

　　　　　　格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名

格式约束：
    答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
 样例：
       #S:1 #A:5 #A:22
       1是试卷号 
       5是1号试卷的顺序第1题的题目答案

　　　　4、答卷信息

　　　　　　答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序号与试卷信息中的题目顺序相对应。答卷中：

　　　　　　格式："#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...

格式约束：
       答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
       答案内容可以为空，即””。
       答案内容中如果首尾有多余的空格，应去除后再进行判断。
样例：
       #T:1 1-5 3-2 2-5 6-9 4-10 7-3
       #S:1 20201103 #A:2-5 #A:6-4
       1是试卷号
       20201103是学号
       2-5中的2是试卷中顺序号，5是试卷第2题的答案，即T中3-2的答案 
       6-4中的6是试卷中顺序号，4是试卷第6题的答案，即T中7-3的答案 
注意：不要混淆顺序号与题号

　　　　5、删除题目信息

　　　　　　删除题目信息为独行输入，每一行为一条删除信息，多条删除信息可分多行输入。该信息用于删除一道题目信息，题目被删除之后，引用该题目的试卷依然有效，但被删除的题目将以0分计，同时在输出答案时，题目内容与答案改为一条失效提示，例如：”the question 2 invalid~0”

　　　　　　格式："#D:N-"+题目号

　　　　　　格式约束：

       题目号与第一项”题目信息”中的题号相对应，不是试卷中的题目顺序号。

       本题暂不考虑删除的题号不存在的情况。

样例：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end

输出
alert: full score of test paper1 is not 100 points
1+1=~5~false
the question 2 invalid~0
20201103 Tom: 0 0~0

　　　　答题信息以一行"end"标记结束，"end"之后的信息忽略。

　　输出格式:

　　1、试卷总分警示：

　　　　该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100 分，该部分忽略，不输出。　

　　　　格式："alert: full score of test paper"+试卷号+" is not 100 points"

　　　　样例：alert: full score of test paper2 is not 100 points

　　2、答卷信息：　　　　　

　　　　一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。

　　　　格式：题目内容+"~"+答案++"~"+判题结果（true/false）

约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"   
样例：
     3+2=~5~true
     4+6=~22~false.
     answer is null

　　3、判分信息

　　　　判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。

　　　格式：**学号+" "+姓名+": "**+题目得分+" "+....+题目得分+"~"+总分

　　　格式约束：

     1、没有输入答案的题目、被删除的题目、答案错误的题目计0分
     2、判题信息的顺序与输入答题信息中的顺序相同

　　　样例：20201103 Tom: 0 0~0

       根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。

　　4、被删除的题目提示信息

　　　　当某题目被试卷引用，同时被删除时，答案中输出提示信息。样例见第5种输入信息“删除题目信息”。

　　 5、题目引用错误提示信息　　

输入：

#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-4
end

输出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0

如果答案输出时，一道题目同时出现答案不存在、引用错误题号、题目被删除，只提示一种信息，答案不存在的优先级最高，例如：
输入：
#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103
end

输出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0

　　6、格式错误提示信息

　　　　输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。

      例如：wrong format:2 #Q:2+2= #4

　　7、试卷号引用错误提示输出　　

　　　　如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出，参见样例8。

　　8、学号引用错误提示信息

　　　　如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。参见样例9。

　　　　本题暂不考虑出现多张答卷的信息的情况。

　　源代码：

import java.util.*;
import java.text.DecimalFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main{
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int sum=0;
        int papernum=0;
        int p=0;
        int judgeWrongNum=0;
        int answernum=0;
        int len=0;
        int studentnum=0;
        int speak=0;
        String w;
        String s[] = new String[100];
        int []judgeQuestion=new int[1000];
        Question []question=new Question[1000];
        Paper []paper=new Paper[1000];
        Answer []answer=new Answer[1000];
        Grades []gradess=new Grades[1000];
        Student []students=new Student[1000];
        Delete []delete=new Delete[1000];
        Check check=new Check();
        for(int i=0;i<100;i++){
            delete[i]=new Delete();
        }
        for(int i=0;i<100;i++){
            question[i]=new Question();
        }
        for(int i=0;i<100;i++){
            paper[i]=new Paper();
        }
        /*for(int i=0;i<10;i++){
            answer[i]=new Answer();
        }*/
        int da=1000;
        int te=0;
        for(int i=0;i<100;i++){
            s[i]=input.nextLine();
            if(s[i].contains("end")){
                break;
            }
            if(s[i].startsWith("#S")){
                    da=i;
            }
            if(s[i].startsWith("#T")){
                te=i;
                if(da<te){
                String u=s[da];
                s[da]=s[te];
                s[te]=u;
                te=0;
                }
            }
            
            speak++;
        }
        for(int i=0;i<=speak;i++){
            //s[i]=input.nextLine();
            if(s[i].contains("end")){
                break;
            }
            else{
                if(check.checkCorrectQuestion(s[i])){
                if(s[i].startsWith("#N")){
                    String []ti=s[i].split(":");
                    ti[1]=ti[1].replaceAll(" ","");
                    ti[1]=ti[1].replaceAll("#Q","");
                    int num2=Integer.parseInt(ti[1]);
                    ti[2]=ti[2].replaceAll("^\\s+","");
                    ti[2]=ti[2].replaceAll("#A","");
                    ti[2]=ti[2].replaceAll("\\s$","");
                    if(delete[num2].getdeleteNum()==num2){
                        delete[num2].setdeleteNum(0);
                        question[num2].setquestionThing(ti[2]);
                        question[num2].setstardardThing(ti[3]);
                    }
                    else{
                        if(ti.length==3){
                            question[num2]=new Question(num2,ti[2],"");
                        }
                        else{
                            ti[3]=ti[3].replaceAll("^\\s+","");
                            ti[3]=ti[3].replaceAll("\\s+$","");
                            question[num2]=new Question(num2,ti[2],ti[3]);
                        }
                    }
                    judgeQuestion[num2]=1;
                }
                else if(s[i].startsWith("#T")){
                    String []ti=s[i].split(":");
                    papernum++;
                    ti[1]=ti[1].replaceAll("^\\s+","");
                    ti[1]=ti[1].replaceAll("\\s+$","");
                    String []pap=ti[1].split(" ");
                    len=pap.length;
                    int num2=Integer.parseInt(pap[0]);
                    gradess[papernum]=new Grades();
                    paper[num2]=new Paper(len-1);
                    for(int j=0;j<len-1;j++){
                        String []grade=pap[j+1].split("-");
                        int num3=Integer.parseInt(grade[0]);
                        int num4=Integer.parseInt(grade[1]);
                        if(judgeQuestion[num3]==0){
                            question[num3]=new Question(num3,"-100","-100");
                            paper[num2].setQuestion(j+1,question[num3]);
                            continue;
                        }
                        else{
                            paper[num2].setQuestion(j+1,question[num3]);
                            paper[num2].question2[j+1].setGradess(papernum,gradess[papernum]);
                            paper[num2].question2[j+1].grades[papernum].setGrades(num4,j+1);
                            sum=sum+num4;
                        }
                    }
                    paper[num2].setSumGrades(sum);
                    if(paper[num2].getSumGrades()!=100){
                        check.settell(papernum);
                            check.puttell(papernum);
                        
                    }
                    sum=0;
                }
                else if(s[i].startsWith("#S")){
                    String []ti=s[i].split(":");
                    answernum++;
                    int len1=ti.length-1;
                    ti[1]=ti[1].replaceAll("#A","");
                    ti[1]=ti[1].replaceAll("^\\s+","");
                    String []ta=ti[1].split(" ");
                    ta[1]=ta[1].replaceAll("\\s*$","");
                    ta[1]=ta[1].replaceAll("^\\s*","");
                    int num2=Integer.parseInt(ta[0]);
                    answer[answernum]=new Answer(num2,paper[num2],len1-1);
                    if(num2>papernum){
                        answer[answernum].setisMatch(1);
                        continue;
                    }
                    for(int j=2;j<=len1;j++){
                        ti[j]=ti[j].replaceAll("#A","");
                        ti[j]=ti[j].replaceAll("^\\s+","");
                        String []daan=ti[j].split("-");
                        daan[0]=daan[0].replaceAll(" ","");
                        int num3=Integer.parseInt(daan[0]);
                        answer[answernum].setisAnswer(num3);
                        if(daan.length==1){
                            answer[answernum].saveOneAnswer(num2,paper[num2].question2[num3].getquestionNum(),num3,"");
                        }
                        else{
                            daan[1]=daan[1].replaceAll("^\\s+","");
                            daan[1]=daan[1].replaceAll("\\s+$","");
                            answer[answernum].saveOneAnswer(num2,paper[num2].question2[num3].getquestionNum(),num3,daan[1]);
                        }
                    }
                    for(int j=0;j<studentnum;j++){
                        if(ta[1].equals(students[j].getstudentNumber())){
                            answer[answernum].setstudentAnswer(students[j]);
                            judgeWrongNum=1;
                        }
                    }
                    delete[0]=new Delete();
                    if(judgeWrongNum==0){
                        delete[0].setwrongNum(ta[1]);
                    }
                }
                else if(s[i].startsWith("#X")){
                    String []ti=s[i].split(":");
                    ti[1]=ti[1].replaceAll("^\\s+","");
                    ti[1]=ti[1].replaceAll("\\s+$","");
                    String []stu=ti[1].split("-");
                    stu[0]=stu[0].replaceAll("^\\s+","");
                    stu[0]=stu[0].replaceAll("\\s+$","");
                    studentnum=stu.length;
                    for(int j=0;j<studentnum;j++){
                        String []stud=stu[j].split(" ");
                        students[j]=new Student(stud[0],stud[1]);
                    }
                }
                else if(s[i].startsWith("#D")){
                    String []ti=s[i].split(":");
                    ti[1]=ti[1].replaceAll(" ","");
                    String []del=ti[1].split("-");
                    int num3=Integer.parseInt(del[1]);
                    delete[num3].setdeleteNum(num3);
                }
            }
                else{
                    check.TowrongThings(s[i]);
                }
            }
        }
        int num5=1;
        for(int i=1;i<=answernum;i++){
           if(answer[i].getisMatch()!=1){
            for(int j=1;j<=paper[num5].getquestionlen();j++){
                    if(answer[i].isanswer[j]==null){
                        System.out.println("answer is null");
                    }
                    
                    else if(paper[num5].question2[j].getquestionThing()=="-100"){
                        System.out.println("non-existent question~0");
                    }
                    else if(paper[num5].question2[j].getquestionNum()!=delete[paper[num5].question2[j].getquestionNum()].getdeleteNum()&&paper[num5].question2[j].getquestionThing()!="-100"){
                        System.out.print(paper[num5].question2[j].getquestionThing());
                        answer[i].toStringanswer(paper[num5].question2[j].getquestionNum(),j,paper[num5]);
                        answer[i].isCorect(paper[num5].question2[j].getstardardThing(),paper[num5].question2[j].getquestionNum(),j);
                    }
                    else if(paper[num5].question2[j].getquestionThing()!="-100"){
                        System.out.println("the question "+paper[num5].question2[j].getquestionNum()+" invalid~0");
                        paper[num5].question2[j].grades[num5].setGrades(j,0);
                    }
                }
               if(judgeWrongNum==0){
                   delete[0].TowrongNum();
               }
               if(judgeWrongNum==1){
                    answer[i].student.TostudentThings();
                    answer[i].getGradesThing(num5);
                    System.out.println(answer[i].getanswerGradesSum());
               }
           if(num5<papernum){
               num5++;
           }
        }
        else{
            System.out.println("The test paper number does not exist");
        }
    }
}
}
class Question {
    private int questionNum=0;
    private String questionThing;
    private String stardardThing;
    private int questionGrades;
    Grades []grades=new Grades[1000];
    public Question(){
        
    }
    public void setGradess(int papernum,Grades grades1){
        grades[papernum]=new Grades();
        grades[papernum]=grades1;
    }
    public void setQuestionGrades(int grade){
        this.questionGrades=grade;
    }
    public int getQuestionGrades(){
        return questionGrades;
    }
    public Question(int questionNum,String questionThing,String stardardThing){
        this.questionNum=questionNum;
        this.questionThing=questionThing;
        this.stardardThing=stardardThing;
    }
    public int getquestionNum(){
        return questionNum;
    }
    public String getquestionThing(){
        return questionThing;
    }
    public String getstardardThing(){
        return stardardThing;
    }
    public void setquestionNum(int questionNum){
        this.questionNum=questionNum;
    }
    public void setquestionThing(String questionThing){
        this.questionThing=questionThing;
    }
    public void setstardardThing(String stardardThing){
        this.stardardThing=stardardThing;
    }
    public boolean isStardard(){
        if(this.questionThing.equals(stardardThing)){
            return true;
        }
        else{
            return false;
        }
    }
}
class Paper {
    Question question1;
    Question []question2=new Question[1000];
    private int sumGrades;
    private int questionSum=0;
    private int questionlen=0;
    public int getquestionlen(){
        return questionlen;
    }
    public void setquestionlen(int len){
        this.questionlen=questionlen;
    }
    public Paper(){
        
    }
    public Paper(int len){
        questionlen=len;
        for(int i=0;i<100;i++){
            question2[i]=new Question();
        }
    }
    public void setQuestion(int num,Question question){
        question2[num]=new Question();
        question2[num]=question;
    }
    public void setSumGrades(int sum){
        this.sumGrades=sum;
    }
    public int getSumGrades(){
        return sumGrades;
    }
    public void saveQuestion(int num,String question){
        question2[num]=new Question();
        question2[num].setquestionThing(question);
    }
    
}
class Answer {
    Paper u;
    private int y=0;
    Student student;
    Paper []paper1=new Paper[1000];
    String [][]answerList=new String [1000][1000];
    String []isanswer=new String [1000];
    private String [][]isCorect=new String [1000][1000];
    private int listnum=0;
    private int answerGradesSum=0;
    private int answerlen=0;
    private int isMatch=0;
    public Answer(){
        
    }
    public Answer(int num,Paper paper,int len){
        paper1[num]=new Paper();
        paper1[num]=paper;
        this.answerlen=len;
    }
    public void setstudentAnswer(Student student){
        this.student=student;
    }
    public Student getStudent(){
        return student;
    }
    public void setisAnswer(int num){
        isanswer[num]="1";
    }
    public int getisMatch(){
        return isMatch;
    }
    public void setisMatch(int a){
        isMatch=a;
    }
    public int getanswerlen(){
        return answerlen;
    }
    public void toStringanswer(int num,int num1,Paper paper){
        u=paper;
        System.out.print("~"+answerList[num][num1]+"~");
    }
    public void saveOneAnswer(int answernum,int num2,int num3,String answer){
        answerList[num2][num3]=answer;
        listnum=paper1[answernum].getquestionlen();
        
    }
    public void isCorect(String s,int a,int b){
        if(s.equals(answerList[a][b])){
            isCorect[a][b]="true";
            System.out.println("true");
        }
        else{
            isCorect[a][b]="false";
            System.out.println("false");
        }
    }
    public int getanswerGradesSum(){
        return answerGradesSum;
    }
    public void getGradesThing(int num7){
        for(int i=1;i<=listnum;i++){
            y++;
            if(isCorect[paper1[num7].question2[i].getquestionNum()][i]=="true"){
                if(i!=listnum){
                    System.out.print(paper1[num7].question2[i].grades[num7].getGrades(i)+" ");
                    answerGradesSum+=paper1[num7].question2[i].grades[num7].getGrades(i);
                }
                else{
                    System.out.print(paper1[num7].question2[i].grades[num7].getGrades(i));
                    answerGradesSum+=paper1[num7].question2[i].grades[num7].getGrades(i);
                }
            }
            else{
                if(i!=listnum){
                    System.out.print("0 ");
                }
                else{
                    System.out.print("0");
                }
            }
        }
        if(y==0){
            for(int i=1;i<=paper1[num7].getquestionlen();i++){
                if(i!=1){
                System.out.print(" 0");
                }
                else{
                System.out.print("0");
                }
            }
        }
        System.out.print("~");
    }
}
class Grades {
    private int []grades=new int [100];
    public Grades(){
        
    }
    public void setGrades(int grades,int num){
        this.grades[num]=grades;
    }
    public int getGrades(int num){
        return grades[num];
    }
}
class Student {
    Answer answer;
    private String studentName;
    private String studentNumber;
    public Student(){
        
    }
    public void setstudentAnswer(Answer answer){
        this.answer=answer;
    }
    public Student(String studentNumber,String studentName){
        this.studentName=studentName;
        this.studentNumber=studentNumber;
    }
    public void setstudentName(){
        this.studentName=studentName;
    }
    public void setstudentNumber(){
        this.studentNumber=studentNumber;
    }
    public String getstudentName(){
        return studentName;
    }
    public String getstudentNumber(){
        return studentNumber;
    }
    public void TostudentThings(){
        System.out.print(studentNumber+" "+studentName+": ");
    }
}
class Delete {
    private String wrongNum;
    Question []question=new Question[100];
    private int deleteNum;
    public Delete(){
        
    }
    public void TowrongNum(){
        System.out.println(wrongNum+" not found");
    }
    public void setwrongNum(String wrongNum){
        this.wrongNum=wrongNum;
    }
    public Delete(int num){
        this.deleteNum=num;
    }
    public int getdeleteNum(){
        return deleteNum;
    }
    public void setdeleteNum(int deleteNum){
        this.deleteNum=deleteNum;
    }
}
class Check {
    private int checksum=0;
    int []papertell=new int[100];
    public Check(){
        
    }
    public boolean checkCorrectQuestion(String s){
        String check1=new String();
        String check2=new String();
        String check3=new String();
        String check4=new String();
        String check5=new String();
        check1="#N:\\s*(\\d+)\\s*#Q:\\s*(.*?)\\s*#A:\\s*(.*?)\\s*";
        check2="^#T:( )*\\d+( )*((\\d+(( )*)-(( )*)\\d+( )*)+)$";
        check3="^#X:\\s*\\w+\\s(\\w+)+(?:-\\d+\\s\\w+)*$";
        check4="^#S:( )*\\d+( )*\\w+\\s*(.*?)$";
        check5="^#D:\\s*N\\s*-\\s*\\d+( )*$";
        if(s.matches(check1)){
            return true;
        }
        if(s.matches(check2)){
            return true;
        }
        if(s.matches(check3)){
            return true;
        }
        if(s.matches(check4)){
            return true;
        }
        if(s.matches(check5)){
            return true;
        }
            return false;
    }
    public void TowrongThings(String s){
        System.out.println("wrong format:"+s);
    }
    public void puttell(int i){
        System.out.println("alert: full score of test paper"+i+" is not 100 points");
    }
    public void settell(int i){
        papertell[i]=i;
    }
}

　　设计分析以及踩坑心得：

　　本次题目集在错误格式的判断上以及程序的复杂度上难度有明显的提高，以下是题目集3增加的几种需求：

　　　　1.程序输入信息由三种变为五种，信息可能会打乱顺序混合输入。

　　　　2.新增输入的学生信息（以“#X”开头的字符串）：学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名，格式：格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名

　　　　3.答卷信息的格式有所改变，格式更改为：格式："#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...（新增学号）

　　　　4.新增删除题目信息，删除题目信息为独行输入，每一行为一条删除信息，多条删除信息可分多行输入。该信息用于删除一道题目信息，题目被删除之后，引用该题目的试卷依然有效，但被删除的题目将以0分计，同时在输出答案时，题目内容与答案改为一条失效提示，例如：”the question 2 invalid~0”，删除信息字符串的格式为："#D:N-"+题目号。

　　　　5.判分信息的格式有所改变，需要在姓名前面加上学生的学号。

　　　　6.新增题目引用错误提示信息：当试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。

　　　　7.新增格式错误提示信息：输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。（格式要求有前两次题目集以及这次题目集新加的格式所确定）

　　　　8.新增试卷号引用错误提示输出：如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出.

　　　　9.新增学号引用错误提示输出：如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。

　　本次题目集3中最后一题的需求增加较多，所以本次代码上有较大程度的修改，以下是修改内容和实际分析：

　　　　1.由于输入的字符串类型由三种变成了五种，故本次由添加了两个字符串的正则解析方式。

　　　　2.新增Student类，用于储存和管理学生信息，代码如下：

class Student {
    Answer answer;
    private String studentName;
    private String studentNumber;
    public Student(){
        
    }
    public void setstudentAnswer(Answer answer){
        this.answer=answer;
    }
    public Student(String studentNumber,String studentName){
        this.studentName=studentName;
        this.studentNumber=studentNumber;
    }
    public void setstudentName(){
        this.studentName=studentName;
    }
    public void setstudentNumber(){
        this.studentNumber=studentNumber;
    }
    public String getstudentName(){
        return studentName;
    }
    public String getstudentNumber(){
        return studentNumber;
    }
    public void TostudentThings(){
        System.out.print(studentNumber+" "+studentName+": ");
    }
}

　　　　在Student类中，添加属性学生的姓名与学生的学号（基本需求），并在属性中添加answer类进行关联，目的是便于将学生和学生的答卷进行绑定。

　　　　Student类中具有基本的get/set方法，其中方法TostudentThings()的作用是输出学生信息。

　　　　3.由于增加了删除信息的需求，故新增Delete类，用于进行删除操作等方面的管理。记得刚写到这里的时候，看错了题目信息，纠结了很久类的删除问题，再仔细读题才发现只需将被删除的题目分数以0分计即可。

　　　　4.本道题比较棘手的还是错误格式的判断问题，刚看题时一头雾水，仔细思考了一下，这不还是考正则表达式的匹配吗，只是这次的正则表达式相对复杂。因此我又添加了一个类Check下面是类中的具体内容：

class Check {
    private int checksum=0;
    int []papertell=new int[100];
    public Check(){
        
    }
    public boolean checkCorrectQuestion(String s){
        String check1=new String();
        String check2=new String();
        String check3=new String();
        String check4=new String();
        String check5=new String();
        check1="#N:\\s*(\\d+)\\s*#Q:\\s*(.*?)\\s*#A:\\s*(.*?)\\s*";
        check2="^#T:( )*\\d+( )*((\\d+(( )*)-(( )*)\\d+( )*)+)$";
        check3="^#X:\\s*\\w+\\s(\\w+)+(?:-\\d+\\s\\w+)*$";
        check4="^#S:( )*\\d+( )*\\w+\\s*(.*?)$";
        check5="^#D:\\s*N\\s*-\\s*\\d+( )*$";
        if(s.matches(check1)){
            return true;
        }
        if(s.matches(check2)){
            return true;
        }
        if(s.matches(check3)){
            return true;
        }
        if(s.matches(check4)){
            return true;
        }
        if(s.matches(check5)){
            return true;
        }
            return false;
    }
    public void TowrongThings(String s){
        System.out.println("wrong format:"+s);
    }
    public void puttell(int i){
        System.out.println("alert: full score of test paper"+i+" is not 100 points");
    }
    public void settell(int i){
        papertell[i]=i;
    }
}

　　　　其中，Check类是对错误信息的管理，包括对错误信息的判断，错误信息的存储和输出。check1-check5是对五种不同字符串的判断格式的正则表达式。

　　　 5.对试卷号引用错误，学号引用错误，以及答案不存在的顺序问题，我在输出时对他们进行了排序：先判断答案是否存在，如果存在则判断其他两者。

　　　　6.由于本次题目集新增的类比较多，并且时间紧张，导致我在设计类时忽略了很多点，如未将输入的字符串的解析放在一个类中，在某个类中存在太多方法并未将其简化等。

　　　　7.目前我对类之间的关系（尤其是聚集）掌握的还不是特别熟练，在前三次题目集的训练中，我的类间关系大多还是依赖或关联，以下是第三次的类图：

　　　　度量：

　　　　从代码中类的复杂度可得，代码中的Main类复杂度非常大，原因是我在main类中加入了对字符串的切割和解析，从而使我代码的平均复杂度也大大增加。因此，这也是我在之后类设计与代码改进的一个重要方向。

三、改进建议：

　　　　在完成了这三次题目集之后，我花了大概一个小时的时间回顾了从题目集1到题目集3学习的收获历程，也正是因为这次反思，我才发现我提交的三次代码还有巨大的改进空间……

　　　　1.代码规范性方面：虽然段老师在发布这三次题目集之前专门花了半节课带我们了解了阿里的编码规范，这在我的代码上也有所体现，但是有些变量的命名还是用“英文单词+数字”完成，如check1（有些是当时不清楚单词怎么拼写，偷懒没有查百度，为了图快就直接写在代码里了），这个编码规范的问题我也会在接下来的题目集里尽量落实。

　　　　2.类的设计方面：这一块可能就是目前我的代码（尤其是第三次）所存在的最大的问题。就比如下面这段代码：

if(s[i].startsWith("#N")){
     String []ti=s[i].split(":");
     ti[1]=ti[1].replaceAll(" ","");
     ti[1]=ti[1].replaceAll("#Q","");
     int num2=Integer.parseInt(ti[1]);
     ti[2]=ti[2].replaceAll("^\\s+","");
     ti[2]=ti[2].replaceAll("#A","");
     ti[2]=ti[2].replaceAll("\\s$","");
     if(delete[num2].getdeleteNum()==num2){
         delete[num2].setdeleteNum(0);
         question[num2].setquestionThing(ti[2]);
         question[num2].setstardardThing(ti[3]);
     }else{
         if(ti.length==3){
               question[num2]=new Question(num2,ti[2],"");
         }
         else{
               ti[3]=ti[3].replaceAll("^\\s+","");
               ti[3]=ti[3].replaceAll("\\s+$","");
               question[num2]=new Question(num2,ti[2],ti[3]);
          }
     }
     judgeQuestion[num2]=1;
}

　　　　这段代码乍一看也没什么，不就是一段切割以“#N”开头的字符串的过程吗。但是，这段字符串是出现在我的main主类中的，它不应该在这。它应该在单独的一个类中，不能在Question类，Paper类等其他实体类中，如果在，就严重违背了面向对象程序设计的单一职责原则，这些点都是应该在我写代码前应该考虑到的，这也体现了我的代码存在巨大的缺陷和改进空间。

　　　　3.数据储存的选择方面：在存入题目字符串蕴含的数据时，我从第一次题目集开始就毫不犹豫的选择了在c语言学习过程中经常打交道的数组。当然，在前几次题目集中，数组的运用还算比较轻松，但随着题目的迭代，如果要在数据中插入新数据，在数据中“挪动”或删除数据，数组的使用吃力程度指数级增长……而在完成题目集的过程中，我观察到许多同学都用了链表储存数据，这也是我的代码的重要改进方向。

四、总结：

　　　　这三次题目集是我第一次面向对象的阶段性训练，这三次题目集的总结其实前面已经讲了一些，总的来说收获最大的有几个方面，对正则表达式的应用，类间关系的判断，依赖、关联关系的具体使用等，收获这些知识的同时我也查阅了很多资料，在写程序时经常浏览下面几个网址：Java LinkedList | 菜鸟教程 (runoob.com)、Java常用正则表达式整理_java 正则表达式空格-CSDN博客等。在得分，训练的同时，我有很多时刻都惊叹于Java类设计的妙处，听老师讲面向对象七大基本原则，只是把原则里的文字记在了脑袋里，而当我经过不断地训练（如实验的大象进冰箱，上课讲的雨刷系统等经典案例），我才慢慢领悟了这些原则的实用性和正确性。

　　　　而对于线上线下课堂的改进方面，我认为上课过程中和学生的互动是很有必要的，对于一些抽象难懂的知识，如果通过简单代码例子的方式实现，我们可能理解得更快。