题目集1~3的总结性Blog
一 、前言：
总结三次题目集的知识点、题量、难度等情况
知识点
第一次题目集主要考察了输入输出处理，字符串处理，正则表达式，类型转换，类与数组的基本使用，类与对象，关联类等知识点。
第二次题目集主要考察了数据的查找、排序，字符串处理，正则表达式，类型转换，类与对象、方法的使用，方法的调用与返回，多个类的关系与使用、链表LinkedList等知识点。
第三次题目集主要考察了面向对象的封装性，java中日期类的使用，正则表达式等知识点。
三次题目集都体现了面向对象的设计思想。
题目及题量、难度
nchu-software-oop-2024-上-1：
7-1设计一个风扇Fan类
7-2类和对象的使用
7-3成绩计算-1-类、数组的基本运用
7-4成绩计算-2-关联类
7-5答题判题程序-1
共五道题，难度不高，感觉是之前课前题目集系列的过渡，为了我们熟悉类的使用，并且考察我们c语言的基础。其中前四题花费一天，最后一题即这次大作业的核心作业花费一天。第一次的答题判题程序较为简单，但也是第一次接触利用java语言进行多类设计。
nchu-software-oop-2024-上-2：
7-1手机按价格排序、查找
7-2sdut-oop-4-求圆的面积（类与对象）
7-3Java类与对象-汽车类
7-4答题判题程序-2
共四道题，难度较上次有提高。与上一次相比，答题程序的功能增加给这道题增加了不少难度，多种信息的输入以及输出都很复杂。其中前三题花费一天，最后一题即这次上次的答题判题程序的功能增加花费两天。
nchu-software-oop-2024-上-3：
7-1面向对象编程（封装性）
7-2jmu-java-日期类的基本使用
7-3答题判题程序-3
共三道题，难度较上次大大提高。第二题中日期类的使用利用java库中自带的日期类。在写第二题时对日期类学习到很多java自带的日期类函数的使用。一开始没有想到java有自带的日期类，犯了蠢自己写了个日期类。最后一题的难度更是飙升了好多：格式的更严格判断、空试卷的输出、空字符
二、第一次的答题判题程序分析
设计与分析
部分代码如下->
点击查看代码
（类）
class Topic{
int no;
String cotent;
String standaraAnswer;
public Topic()
{}
public Topic(int no,String cotent,String standaraAnswer)
{
this.no=no;
this.cotent=cotent;
this.standaraAnswer=standaraAnswer;
}
public String get()
{
String str="#N:"+no+" #Q:"+cotent+" #A:"+standaraAnswer;
return str;
}
public boolean answer(String s)
{
if(s.equals(this.standaraAnswer))
return true;
else
return false;
}
}
class Test{
int num;//题目数量
static Topic[] tt=new Topic[100];
public Test(){}
public Test(int n){
num=n;
}
public boolean answer(int n,String a)
{
return tt[n].answer(a);
}
public void get(int n,String q,String a)
{
tt[n]=new Topic(n,q,a);
}
}
class Answer{
static Test t;//试卷
int n;
String[] answer=new String[100];//答案列表
boolean[] a=new boolean[100];//判题列表
public Answer(){}
public Answer(int num)
{
n=num;
}
public void q(int n)//判题
{
a[n]=Test.tt[n].answer(answer[n]);
}
public void p(int n)//输出
{
String str=Test.tt[n].cotent+"~"+answer[n];
System.out.println(str);
}
public void a(int n,String s)//保存答案
{
answer[n]=s;
}
}
第一次的答题判题程序类图以及SourceMontor的生成报表内容：
在这次题目中我设计了Topic,Answer,Test,Main四个类。就是按照老师给的建议类设计而设计的。第一次的程序根据老师给的建议设计很快就写出代码了，还是很简单的。
- Topic类：用于表示题目，包括题号（no）、题目内容（content）和标准答案（standardAnswer）。包含了一个无参构造方法和一个有参构造方法，用于初始化题目对象。
提供了get方法，返回题目的字符串表示形式。
提供了answer方法，用于判断给定答案是否与标准答案一致。 - Answer类：用于表示答题情况，包括答题数量（n）、答案列表（answer[]）和判题列表（a[]）。
包含了一个无参构造方法和一个有参构造方法，用于初始化答题对象。
提供了q方法，用于判断指定题目的答案是否正确。
提供了p方法，用于输出指定题目的内容和答案。
提供了a方法，用于保存答案到答案列表中。 - Test类：用于表示一张试卷，包含题目数量（num）和题目类数组（Topic[]）。
包含了一个无参构造方法和一个有参构造方法，用于初始化试卷对象。
提供了answer方法，用于判断指定题目的答案是否正确。
提供了get方法，用于添加题目到试卷中。 - Main类：包含了主程序，用于输入试题信息、学生答题信息和判题结果输出。
输入题目数量，创建Answer对象和Test对象，循环输入题目信息并添加到试卷中，循环输入学生答题信息并判题并输出结果。
踩坑心得
- 设计题目类时误以为题目只为数字，没有考虑到题目内容中可能包含特殊字符或格式不规范的情况导致输入字符串时存不进去。
- 题号的输入顺序与题号无关，刚开始时忽略了这一点导致乱序输入时代码非零返回。
- 答卷中答案数量、顺序应与试卷的题目数量、顺序都一致，没注意这一点也导致了出现答案顺序对不上、答案数据不够时出现非零返回。
- 对格式处理不够严格，输入题目时忘记对无效空格的删除，导致输出的题目格式错误。
这次的代码总共写了133行，运用了四个类，学会了类与数组的使用，可以建立类数组，学会了关联类，对类间关系有了更好的认识。
改进建议
- 输入时数据时对字符串进行更加严格的格式判断。确保输入的内容符合预期格式，避免因输入内容格式错误导致的异常或错误情况的发生。
- 对题目内容的分析、获取进行优化，考虑更多的特殊情况和格式，确保能够正确解析各种格式的题目内容。
三、第二次答题判题程序分析
设计与分析
部分代码如下->
点击查看代码
（类）
class Topic{//题目
private int no;
private String cotent;
private String standaraAnswer;
public Topic()
{}
public Topic(int no,String cotent,String standaraAnswer)
{
this.no=no;
this.cotent=cotent;
this.standaraAnswer=standaraAnswer;
}
public String get()//获得题目信息
{
String str=cotent+"~"+standaraAnswer;
return str;
}
public boolean answer(String s)//判题
{
if(s.equals(this.standaraAnswer))
return true;
else
return false;
}
public String getC()
{
return cotent;
}
public String getS()
{
return standaraAnswer;
}
public int getN()
{
return no;
}
}
class Test{//试卷
int num=-1;//试卷编号
int tN;//试卷题目数量
int fen;
Topic[] tt=new Topic[100];//题目
Sort[] ss=new Sort[100];//题目对应分数
public Test(){}
public Test(int n){
num=n;
}
public void tNo(int n)
{
tN=n;
}
public void F(int f)
{
fen=f;
}
public boolean answer(int n,String a)//判题
{
return tt[n].answer(a);
}
public void get(int n,String q,String a)//创建题目
{
tt[n]=new Topic(n,q,a);
tN=n;
}
public void getS(int n,int f)//创建分
{
ss[n]=new Sort(n,f);
}
public int getN()
{
return num;
}
}
class Answer{//答卷
int n;//答卷的试卷编号
int num;
String[] answer=new String[100];//答案列表
boolean[] a=new boolean[100];//判题列表
int[] fen1=new int[100];//每一题的得分
int fen;//总分
public Answer(){}
public Answer(int n)
{
this.n=n;
}
public void q(int n,boolean b)//判题
{
a[n]=b;
}
public void nu(int n)
{
num=n;
}
public String p(int n)//输出
{
return answer[n];
}
public void a(int n,String s)//保存答案
{
answer[n]=s;
}
public void f(int n,int f)
{
fen1[n]=f;
}
public void P()
{
int sum=0;
for(int i=0;i<num;i++)
{
System.out.printf("%d",fen1[i]);
sum+=fen1[i];
if(i!=num-1)
System.out.printf(" ");
else
System.out.printf("~");
}
System.out.println(sum);
}
public int F()
{
for(int i=0;i<num;i++)
fen+=fen1[n];
return fen;
}
public int getN()
{
return n;
}
}
class Sort{//分值
private int num;
private int fen;
public Sort(){}
public Sort(int n,int f)
{
num=n;
fen=f;
}
public int getF()//获得分信息
{
return fen;
}
public int getN()//获得编号信息
{
return num;
}
}
第二次的答题判题程序类图以及SourceMontor的生成报表内容：
第二次的迭代程序我增加了一个分数类来存放各题的分数。总共设计了五个类。根据功能的增加改变了上次的四个类。
- Topic类：用于表示题目，包括题号（no）、题目内容（content）和标准答案（standardAnswer）。包含了一个无参构造方法和一个有参构造方法，用于初始化题目对象。
提供了get方法，返回题目的字符串表示形式。
提供了answer方法，用于判断给定答案是否与标准答案一致。
较上次增加了getC(),getS(),getN()三个方法来获取题号、题目内容和标准答案。 - Test类：用于表示一张试卷，包含试卷编号（num）、题目数量（tN）、总分（fen）、题目类数组（Topic[]）、和分数类数组（Sort[]）。
包含了一个无参构造方法和一个有参构造方法，用于初始化试卷对象。
提供了answer方法，用于判断指定题目的答案是否正确。
提供了get方法，用于添加题目到试卷中。
较上次增加了:
tNo方法：用于输入试卷编号。
F方法：用于输入试卷总分。
get方法：用于获取题目信息。getS方法 ：用于获取分信息。
getN方法：用于获取试卷编号。 - Answer类：用于表示答题情况，包括答卷的试卷编号（n）、答题数量（num）、答案列表（answer[]）、判题列表（a[]）、分数列表（fen1[]）和总得分（fen）。
包含了一个无参构造方法和一个有参构造方法，用于初始化答题对象。
提供了q方法，用于保存判断指定题目的答案是否正确的结果。
提供了p方法，用于返回答案字符串。
提供了a方法，用于保存答案到答案列表中。
较上次增加了：
nu方法：用于保存答题数量
f方法：用于保存每一题的得分。
P方法：用于输出得分情况。
F方法：用于计算总得分。
getN()方法：用于获取试卷编号。 - Sort类：用于表示一张试卷的题目各分数，包含题目编号（num）和题目满分（fen）。
包含了一个无参构造方法和一个有参构造方法，用于初始化分值对象。
提供了getF方法，用于获取分信息。
提供了getN方法，用于获取题目编号信息。 - Main类：包含了主程序，用于输入试题信息、学生答题信息和判题结果输出。
输入题目数量，创建Answer对象、Test对象和Topic对象，循环输入题目信息并添加到试卷中，循环输入学生答题信息并判题并输出结果。
踩坑心得
- 两试卷单答卷，乱序，有缺失的题号：忽略了试卷信息可能出现题号题目缺失的情况。
- 2试卷2答卷 满分不是100 答案有缺失 答卷试卷号不匹配 ：没有计算试卷总分以及判断试卷是否满分为100分。
没有考虑答卷中可能出现未输入答案的情况、输入试卷编号不存在的情况。
由于没有对试卷编号进行查找后再判断和对答案数量进行判断，导致出现非零返回。
这次的代码总共写了344行，运用了五个类，在上一次的基础上增加了分数类，增加试卷分值统计及答卷得分统计功能，修改了题目类、答卷类等，对上一次的答题判题程序进行了内容与功能的完善。
改进建议
- 输入试卷信息时先对所含题目编号进行查找判断，没有时输出题目不存在信息。然后对总分进行判断并输出相应信息
- 输入答卷信息时先对所输入的试卷编号进行查找判断，如果存在该试卷再进行后续操作。
- 判题时判断答案总数量是否符合试卷题目数量要求，未达到要求输入答案不存在信息。
四、第三次答题判题程序分析
设计与分析
部分代码如下->
点击查看代码
（类）
class Topic{//题目
private int no;
private String cotent;
private String standaraAnswer;
int y=0;//1题目不存在 2答案不存在
public Topic()
{}
public Topic(int no,String cotent,String standaraAnswer)
{
this.no=no;
this.cotent=cotent;
this.standaraAnswer=standaraAnswer;
}
public boolean answer(String s)//判题
{
if(standaraAnswer==null)
return false;
if(s.equals(this.standaraAnswer))
return true;
else
return false;
}
public String getC()
{return cotent;}
public String getS()
{return standaraAnswer;}
public int getN()
{return no;}
public void setC()
{cotent="shanchu";standaraAnswer="shanchu";}
public void setY(int n)
{y=n;}
}
class Test{//试卷
int num=-1;//试卷编号
int tN;//试卷题目数量
int fen;
Topic[] tt=new Topic[100];//题目
Sort[] ss=new Sort[100];//题目对应分数
public Test(){}
public Test(int n)
{num=n;}
public void tNo(int n)
{tN=n;}
public void F(int f)
{fen=f;}
public boolean answer(int n,String a)//判题
{return tt[n].answer(a);}
public void get(int n,String q,String a)//创建题目
{tt[n]=new Topic(n,q,a);tN=n;}
public void getS(int n,int f)//创建分
{ss[n]=new Sort(n,f);}
public int getN()
{return num;}
}
class Student{
private String num;
private String name;
Student(){}
Student(String num,String name)
{
this.num=num;
this.name=name;
}
public void print()
{System.out.println(num+"-"+name);}
public String getNum()
{return num;}
public String getName()
{return name;}
public String getS()
{return num+" "+name;}
}
class Answer{//答卷
int n;//答卷的试卷编号
String id;//学生学号
int num;
String name;
String[] answer=new String[100];//答案列表
boolean[] a=new boolean[100];//判题列表
boolean[] b=new boolean[100];
int[] fen1=new int[100];//每一题的得分
int fen;//总分
public Answer(){}
public Answer(int n)
{this.n=n;}
public void q(int n,boolean b)//保存判题结果
{a[n]=b;}
public void nu(int n)
{num=n;}
public void id(String n)
{id=n;}
public void name(String n)
{name=n;}
public String p(int n)//输出
{return answer[n];}
public void a(int n,String s)//保存答案
{answer[n]=s;b[n]=true;}
public void f(int n,int f)
{fen1[n]=f;}
public void P()
{
System.out.printf(id+" "+name+": ");
int sum=0;
for(int i=0;i<num;i++)
{
System.out.printf("%d",fen1[i]);
sum+=fen1[i];
if(i!=num-1)
System.out.printf(" ");
else
System.out.printf("~");
}
System.out.println(sum);
}
public int getN()
{return n;}
public String getid()
{return id;}
}
class Sort{//分值
private int num;
private int fen;
public Sort(){}
public Sort(int n,int f)
{
num=n;
fen=f;
}
public int getF()//获得分信息
{return fen;}
public int getN()//获得编号信息
{return num;}
}
public class Main{
public static Answer[] a1=new Answer[100];
public static Test[] t1=new Test[100];
public static Topic[] tt=new Topic[100];
public static Student[] ss=new Student[100];
public static int numSJ=0,numStu=0,an=0,sj=0,tihao=1;
public static void main(String[] args)
{
略；
}
public static void answer(int x)
{
if(x==1)
System.out.println("non-existent question~0");
if(x==2)
System.out.println("answer is null");
}
public static void Tihao1(int[] x,int n)
{
for(int i=0;i<n;i++)
System.out.println("the question "+x[i]+" invalid~0");
}
public static void setTimu(String s)
{
//存入题目
String[] s1=s.split(" #");
String[] s3=new String[3];
for(int j=0;j<2;j++)
{
String[] s2=s1[j].split(":");
s3[j]=s2[1].trim();
//System.out.println(s3[j]);
}
String[] s2=s1[2].split(":");
if(s2.length>1)
{
s3[2]=s2[1].trim();
}
else
s3[2]=null;
tt[Integer.parseInt(s3[0])]=new Topic(Integer.parseInt(s3[0]),s3[1],s3[2]);
//System.out.println(tt[n].get());
}
public static void setShijuan(String s)
{
Pattern p1=Pattern.compile("[0-9]+");
Matcher p11=p1.matcher(s);
int flag=0,j=0,f2=0;int ti=0,t0=0,n0=0;
while (p11.find())
{
t0=Integer.parseInt(p11.group());
if(flag==0)
{
n0=t0;
flag++;
t1[n0]=new Test(t0);
numSJ++;
continue;
}
if(flag%2==1)
{
for(int i=0;i<100;i++)
{
if(tt[i]==null)
continue;
if(t0==tt[i].getN())
{
t1[n0].tt[j]=new Topic(tt[i].getN(),tt[i].getC(),tt[i].getS());
ti=1;break;
}
else
ti=0;
}
if(ti==0)
{
t1[n0].tt[j]=new Topic(j,"cuo","cuo");
tihao=ti;
t1[n0].tt[j].setY(1);
}
flag++;
continue;
}
if(flag%2==0&&flag!=0)
{
f2+=t0;
t1[n0].getS(j,t0);
j++;
flag++;
}
}
t1[n0].tNo(j);
t1[n0].F(f2);
if(f2!=100)
System.out.println("alert: full score of test paper"+n0+" is not 100 points");
}
public static void setXuesheng(String s)
{
Pattern p1=Pattern.compile("\\w+");
Matcher p11=p1.matcher(s);
int flag=0;int i=0;
String[] stu=new String[2];
while(p11.find())
{
//System.out.println(p11.group());
if(flag==0){flag++;continue;}
else if(flag%2==1)
{
stu[flag%2]=p11.group();
flag++;
continue;
}
else if(flag%2==0)
{
stu[flag%2]=p11.group();
ss[i]=new Student(stu[1],stu[0]);
numStu++;
i++;
flag++;
}
}
}
public static void setDajuan(String s)
{
int t0=0,n0=0;
Pattern p1=Pattern.compile("[0-9]+");
Matcher p11=p1.matcher(s);
Pattern p2=Pattern.compile("#A:(.+)");
Matcher p22=p2.matcher(s);
int j=0,i=0;
while(p11.find()&&i<2)
{
t0=Integer.parseInt(p11.group());
if(i==0)
{
a1[an]=new Answer(t0);
sj=t0;
i++;
}
else if(i==1)
{
a1[an].id(p11.group());
i++;
}
}
while(p22.find())
{
String s0=p22.group();
String[] s1=s.split(" #A:");
for(int k=1;k<s1.length;k++)
{
String[] s2=s1[k].split("-");
if(s2.length==1)
{
int l=Integer.parseInt(s2[0]);
a1[an].a(l-1,null);
}
else if(s2.length==2)
{
int l=Integer.parseInt(s2[0]);
a1[an].a(l-1,s2[1]);
}
}
}
an++;
}
public static void Shanchu(String s)
{
Pattern p1=Pattern.compile("[0-9]+");
Matcher p11=p1.matcher(s);
while(p11.find()){
int t0=Integer.parseInt(p11.group());
//System.out.println(t0);
for(int i=1;i<=numSJ;i++)
{
for(int j=0;j<t1[i].tN;j++)
{
//System.out.println(j);
if(t1[i].tt[j].getN()==t0)
{
t1[i].tt[j].setC();
}
}
}
}
}
public static void p()
{
int fg=1;
for(int k=0;k<an;k++)
{
int[] tihao1=new int[100];
int tihao2=0;
int ans=2;
int fg2=0;
//System.out.println(a1[k].n);
for(int l=1;l<=numSJ;l++)
{
if(a1[k].n==t1[l].num)
{
fg=0;
break;
}
else
{fg=1;continue;}
}
if(fg==1)
{
System.out.println("The test paper number does not exist");
continue;
}
int sj0=a1[k].n;
a1[k].nu(t1[sj0].tN);
for(int i=0;i<t1[sj0].tN;i++)
{
if(a1[k].p(i)==null)
{
if(a1[k].b[i])
{
a1[k].q(i,false);
a1[k].f(i,0);
System.out.println(t1[sj0].tt[i].getC()+"~~"+"false");
}
else
t1[sj0].tt[i].setY(2);
}
else
{
if(t1[sj0].tt[i].getS()==null)
{
System.out.println(t1[sj0].tt[i].getC()+"~"+a1[k].p(i)+"~"+t1[sj0].answer(i,a1[k].p(i)));
a1[k].q(i,false);
a1[k].f(i,0);
}
if(t1[sj0].tt[i].getS().equals("cuo"))
{
a1[k].q(i,false);
a1[k].f(i,0);
}
else if(t1[sj0].tt[i].getS().equals("cuoti"))
{
tihao=0;
}
else if(t1[sj0].tt[i].getC().equals("shanchu"))
{
tihao1[tihao2]=t1[sj0].tt[i].getN();
tihao2++;
}
else
{
System.out.println(t1[sj0].tt[i].getC()+"~"+a1[k].p(i)+"~"+t1[sj0].answer(i,a1[k].p(i)));
a1[k].q(i,t1[sj0].answer(i,a1[k].p(i)));
if(t1[sj0].answer(i,a1[k].p(i)))
{
a1[k].f(i,t1[sj0].ss[i].getF());
}
else
a1[k].f(i,0);
}
}
answer(t1[sj0].tt[i].y);
}
for(int i=0;i<numStu;i++)
{
if(a1[k].getid().equals(ss[i].getNum()))
{
a1[k].name(ss[i].getName());
fg2=1;
break;
}
else
fg2=0;
}
if(fg2==0)
{
System.out.println(a1[k].getid()+" not found");
continue;
}
Tihao1(tihao1,tihao2);
a1[k].P();
}
}
}
第三次的答题判题程序类图以及SourceMontor的生成报表内容：
第三次的迭代程序中多了学生和删除。我增加了一个Student类，共有六个类，其他类只是根据功能的增加而增加了各个类中的方法，并且将每种信息的解析单独建立方法，优化代码。
- Topic类：用于表示题目，包括题号（no）、题目内容（content）、标准答案（standardAnswer）和存在信息（y）。包含了一个无参构造方法和一个有参构造方法，用于初始化题目对象。
提供了answer方法，getC()，getS()，getN()。
较上次增加了：
setC方法：用于标记删除的题目。
setY方法：用于标记题目不存在或答案不存在的情况。 - Test类：用于表示一张试卷，包含试卷编号（num）、题目数量（tN）、总分（fen）、题目类数组（Topic[]）、和分数类数组（Sort[]）。
包含了一个无参构造方法和一个有参构造方法，用于初始化试卷对象。
提供了answer方法，get方法、tNo方法、F方法、get方法、getS方法 、getN方法。
与上次程序中的试卷类一样，没有做改变。 - Student类：用于表示学生信息，包括学生的学号（num）和姓名（name）。
包含了一个无参构造方法和一个有参构造方法，用于初始化学生对象。
提供了print方法，用于输出学号、姓名。
提供了getNum方法，用于返回学号字符串。
提供了getName方法，用于返回姓名字符串。
提供了getS方法，用于返回学号和姓名共同组成的字符串。 - Answer：用于表示答题情况，包括答卷的试卷编号（n）、答题数量（num）、答题者学号（id）、答题者姓名（name）、答案列表（answer[]）、判题列表（a[]）、分数列表（fen1[]）和总得分（fen）。
包含了一个无参构造方法和一个有参构造方法，用于初始化答题对象。
提供了q方法，p方法，a方法，
nu方法，f方法，P方法，F方法，getN()方法。
较上次增加了：
id方法：用于保存答题者的学号。
name方法：用于保存答题者的姓名。
getid方法：用于获取答题者的学号。 - Sort类：用于表示一张试卷的题目各分数，包含题目编号（num）和题目满分（fen）。
包含了一个无参构造方法和一个有参构造方法，用于初始化分值对象。
提供了getF方法，getN方法。
与上次程序中的分数类一样，没有做改变。 - Main类：包含了主程序，用于输入试题信息、学生信息、学生答题信息和判题结果输出。
创建Answer对象、Test对象、Topic对象和Student对象，循环输入信息根据输入格式分别存入不同的对象。
增加了解析方法等：
main方法：主程序
answer方法：用于输出不合法的答案信息。
Tihao1方法：用于输出不合法的题目信息。
setTimu方法：用于解析题目信息。
setShijuan方法：用于解析试卷信息。
setXuesheng方法：用于解析学生信息。
setDajuan方法：用于解析答卷信息。
Shanchu方法：用于删除题目。
p方法：用于输出答题信息。
踩坑心得
这次的第三次的大作业让我卡了很久，卡了很多的测试点。
- 这次的大作业对输入信息的格式要求十分严格
改了很久的正则表达式才改出来。
学习了很久正则表达式。这次的每一条信息都要严格按照题目中提到的格式，不符合时要输出“wrong format+输入信息”。 - 这次的作业增加了一个重要的删除功能，一开始想简单的令原题目为空，但是删除题目应是让所有试卷中也有的题目同时都删除，令题目为空需要大量的循环嵌套，而且在查找题目时易出现忽略有题目为空的情况而导致非零返回。所以我在题目类增加了一个y标记题目和答案的存在信息。
- 巨大的坑~空字符！
首先是空白卷和答案为空的区别：空白卷是答题时只输入了试卷信息和答题人的信息，没有输题号也没有输答案，这时会输入“answer is null”，而答案为空则是当答题时输入题号却没有输入答案会认为时正常的答卷，此时输出“题目+++false”。这两者非常不一样，卡在这里卡了很久。 - 乱序输入的问题：这次的答卷中答题的顺序可以打乱，但判题仍是按照试卷中的题目顺序，这个在最后判题并输出时需要注意顺序问题。
这次的代码总共写了454行，运用了六个类，在上一次的基础上增加了学生类，主要增加了删除功能，修改了答卷类、主类和各种信息的解析等。
改进建议
- 努力学习正则表达式，严格按照大作业题目中的各信息格式要求更改上次代码中的正则表达式。
- 便于删除功能的实现，我在题目类增加了一个y作为标记，删除时便是题目不存在，答题时为作答也可以标记为答案不存在，还解决了优先级的功能，一举三得。
- 解析答卷信息时，加入标记每一道题目的答案情况，分为答案不存在、答案为空的情况，即上一条里的y，并根据大作业题目给出的输入信息优先级输出对应信息。
五、总结：
在这三次大作业中第二次体验一个程序的多次迭代，上一次还是C语言的课设。在每一次的迭代中学到了更多java语言的知识和面向对象的设计思想。
从第一次的简单的处理输入信息的分析和解析，到后面越来越复杂的信息处理，越来越复杂的格式要求，在这个过程中学到了正则表达式的多种用法、字符串的多种处理方法、字符串与其他类型比如整型的相互转换。
处理信息时还要考虑错误信息的处理，避免出现越界访问、非零返回等错误。
每一次的信息种类增加和功能增加都需要我再次对自己设计的类进行分析，在这个过程我慢慢发现java语言与c语言的区别，慢慢领悟面向对象设计的思想有何作用，也慢慢理解为什么要学习这门课程。
在这三周中，老师也经常在上课时点拨我们在类上的设计，指导我们完成这几次的大作业。在这些点拨过程中我也发现自己还有很多知识并不了解，甚至有些知识是自以为是的了解，使用中依然一头雾水。
我觉得在我完成的这三次大作业中我的答题判题程序还有很多可以改进的地方：没有很好的实现函数单一职责，有些函数的功能比较复杂；函数模块化不够；封装性不够，有一些的类没有做到所有数据的私有化，导致代码的安全性、灵活性都不高；没有尝试用HashMap，查找速度、插入删除操作、内存空间都还有很大可改进空间。
最后希望下一次的大作业能做到更好，尝试用一些灵活性更好的数据结构。
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 25岁的心里话
· 按钮权限的设计及实现