(1)前言：
前三次的大作业的包含了很多知识点，有类与对象的基本定义与使用，方法的定义，数据的封装。String类的使用和各种String的处理方法，包括字符串按照正则表达式查找和切割。
后面因为数组的使用具有很多的局限性，所以引用了集合的概念，例如ArrayList和HashMap（但是因为对于HashMap不够充分了解，怕报错，就没用用到，只用了ArrayList）。
这三次作业的题量没有很多也没有很少，只能算是中等。
难度也没有很难，因为对于我来说只要不是题目看不懂，或是要求不清晰，花花时间都能给他搞出来，但是第三次的作业就出现了这种情况，下面会提到。
，可能是各种各样的理念和知识点掌握的不够熟练，也可能是c语言残留的思想在影响我，第一次大作业比起说是面向过程的设计，更像是面向过程的设计，原因是主函数实在是太长了
这一段代码的主函数足足有近一百行代码，而其他类中的代码却只有一点点内容甚至还有多余的内容，并且他们类与类之间的分工并不明确，方法定义的时候根本就是乱的。
之后在后期维护修改的时候就更加的头痛了，大部分的时间都花在找那个方法上了
(2)设计与分析：
第一次的java大作业要求是设计一个简单的答题程序
点击查看代码
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner in=new Scanner(System.in);
int t=in.nextInt();
int i,a1,a2;
String N=new String();
String Q=new String();
String A=new String();
String[] arr=new String[t];
Examination examination=new Examination();
for(i=0;i<t;i++)
{
arr[i]=in.next();
arr[i]+=in.nextLine();
for(a1=3;a1<arr[i].length();a1++)
{
if(arr[i].charAt(a1)=='#')
break;
}
for(a2=a1+3;a2<arr[i].length();a2++)
{
if(arr[i].charAt(a2)=='#')
break;
}
N=arr[i].substring(3,a1);
while(N.charAt(0)==' '||N.charAt(N.length()-1)==' ')
{
if(N.charAt(0)==' ')
{
N=N.substring(1);
}
else
{
N=N.substring(0,N.length()-1);
}
}
Q=arr[i].substring(a1+3,a2);
while(Q.charAt(0)==' '||Q.charAt(Q.length()-1)==' ')
{
if(Q.charAt(0)==' ')
{
Q=Q.substring(1);
}
else
{
Q=Q.substring(0,Q.length()-1);
}
}
A=arr[i].substring(a2+3);
while(A.charAt(0)==' '||A.charAt(A.length()-1)==' ')
{
if(A.charAt(0)==' ')
{
A=A.substring(1);
}
else
{
A=A.substring(0,A.length()-1);
}
}
Question question=new Question(N,Q,A);
examination.saveQuestion(question);
}
examination.sortExamination();
Answer answer=new Answer(examination);
String ans1=new String();
String ans=new String();
ans1=in.next();
ans1+=in.nextLine();
//String end=in.next();
int j=3;
for(i=4;i<ans1.length();i++)
{
if(ans1.charAt(i)=='#')
{
ans=ans1.substring(j,i-1);
answer.getAnswer(ans);
j=i+3;
}
}
ans=ans1.substring(j);
answer.getAnswer(ans);
answer.getJiegou();
for(i=0;i<t;i++)
{
examination.getQuestion(i);
answer.putAnswer(i);
}
answer.putJiegou();
}
}
class Question
{
private String card;
private String info;
private String standardAnswer;
public Question()
{
;
}
public Question(Question qt)
{
this.card=qt.getCard();
this.info=qt.getInfo();
this.standardAnswer=qt.getStandardAnswer();
}
public Question(String card,String info,String standardAnswer)
{
this.card=card;
this.info=info;
this.standardAnswer=standardAnswer;
}
public String getCard() {
return card;
}
public void setCard(String card) {
this.card = card;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
public boolean getAnswer(String answer)
{
return (this.standardAnswer).equalsIgnoreCase(answer);
}
}
class Examination
{
private Question[] arr;
private int sum;
public Examination()
{
sum=0;
arr=new Question[sum+2];
}
public void getQuestion(int i)
{
String question=arr[i].getInfo();
System.out.print(question+"~");
}
public int getSum()
{
return sum;
}
public void saveQuestion(Question x)
{
arr[sum]=new Question(x);
sum++;
Question[] toarr=new Question[sum+2];
for(int i=0;i<sum;i++)
{
toarr[i]=arr[i];
}
arr=toarr;
}
public boolean getAnswer(int i,String answer)
{
if(arr[i].getAnswer(answer))
{
return true;
}
else
return false;
}
public void sortExamination()
{
Question t=new Question();
for(int i=0;i<sum-1;i++)
{
for(int j=0;j<sum-1-i;j++)
{
if(arr[j].getCard().length()>arr[j+1].getCard().length())
{
t=arr[j];
arr[j]=arr[j+1];
arr[j+1]=t;
}
else if(arr[j].getCard().length()==arr[j+1].getCard().length())
{
if((arr[j].getCard()).compareTo(arr[j+1].getCard())>0)
{
t=arr[j];
arr[j]=arr[j+1];
arr[j+1]=t;
}
}
}
}
}
}
class Answer
{
private Examination arr;
private String[] answer;
private int sum1;
private boolean[] jieguo;
private int sum2;
public Answer(Examination ex)
{
arr=ex;
answer=new String[arr.getSum()];
sum1=0;
jieguo=new boolean[arr.getSum()];
sum2=0;
}
public void putAnswer(int i)
{
System.out.println(answer[i]);
}
public void getAnswer(String ans)
{
answer[sum1]=new String(ans);
sum1++;
}
public void getJiegou()
{
for(int i=0;i<sum1;i++)
{
if(arr.getAnswer(i,answer[i]))
{
jieguo[i]=true;
}
else
{
jieguo[i]=false;
}
}
sum2=sum1;
}
public void putJiegou()
{
for(int i=0;i<sum2;i++)
{
System.out.print(jieguo[i]);
if(i<sum2-1)
{
System.out.print(" ");
}
}
}
}
我的想法是将题目信息封装成一个类，包括题号，题目和标准答案，以及各种判题的方法也在里面。
将试卷封装成一个类，里面含有题目和题目的数量，还有打印试卷信息的方法。
将答卷封装成一个类，里面有试卷，答案，和答案的正误。
首先对输入的字符串进行处理将他们的信息整合到题目里，再将题目整合到试卷里，再将试卷整合到答卷里，最对答卷进行判断和输出。
总的来说第一次的作业并没有什么难度，就算不用类封装也完全能做，也并不会麻烦多少，代码量也不会相差很多唯一有点挑战性的地方在于如何将代码更加简洁明了的表示出来，让代码的整体性结构更加的完整。
第二次的java大作业在第一次的大作业基础上增补或者修改的内容
点击查看代码
import java.util.*;
public class Main
{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
ArrayList<Question> sumquestion=new ArrayList<>();//题库
ArrayList<Examination> sumexamination=new ArrayList<>();//试卷库
String[] sum;
ArrayList<Answer> sumanswer=new ArrayList<>();
for(;;)
{
String str=in.nextLine();
if(str.equals("end"))
break;
if(str.charAt(1)=='N'){
sum=Instrument.Info1(str);
Question question=new Question(Integer.parseInt(sum[1]),sum[2],sum[3]);
sumquestion.add(question);
}
else if(str.charAt(1)=='T'){
sum=Instrument.Info2(str);
Examination ex=new Examination();
ex.setCard(Integer.parseInt(sum[0]));
for(int i=1;i<sum.length;i++){
String[] x=sum[i].split("-");
int card=Integer.parseInt(x[0]);
int score=Integer.parseInt(x[1]);
for(int j=0;j<sumquestion.size();j++){
if(sumquestion.get(j).getCard()==card){
ex.setQuestion(sumquestion.get(j),score);
break;
}
}
}
if(ex.getSumscore()!=100)
System.out.println("alert: full score of test paper"+ex.getCard()+" is not 100 points");
sumexamination.add(ex);
}
else{
sum=Instrument.Info3(str);
int i;
Answer answer=null;
for(i=0;i<sumexamination.size();i++){
if(sumexamination.get(i).getCard()==Integer.parseInt(sum[1])){
break;
}
}
if(i<sumexamination.size()){
answer=new Answer(sumexamination.get(i));
}
else{
answer=null;
sumanswer.add(answer);
continue;
}
for(i=2;i<sum.length;i++){
answer.setAnswer(sum[i],i-2);
}
sumanswer.add(answer);
}
}
for(int j=0;j<sumanswer.size();j++){
int i;
if(sumanswer.get(j)==null){
System.out.println("The test paper number does not exist");
continue;
}
for(i=0;i<sumanswer.get(j).getExamination().getNumquestions();i++){
if(i<sumanswer.get(j).getNumanwers()){
System.out.println(sumanswer.get(j).getExamination().getQuestion(i).getInfo()+"~"+sumanswer.get(j).getAnswer(i)+"~"+sumanswer.get(j).getarr(i));
}
else{
System.out.println("answer is null");
}
}
for(i=0;i<sumanswer.get(j).getExamination().getNumquestions();i++){
if(i<sumanswer.get(j).getNumanwers()){
System.out.print(sumanswer.get(j).getScore(i));
}
else{
System.out.print(0);
}
if(i<sumanswer.get(j).getExamination().getNumquestions()-1)
System.out.print(" ");
}
System.out.println("~"+sumanswer.get(j).getSumscore());
}
}
}
class Answer{
private Examination ex;
private ArrayList<Boolean> arr;
private ArrayList<String> an;
private ArrayList<Integer> score;
private int sumscore;
public Answer(Examination ex){
this.ex=ex;
arr=new ArrayList<>();
an=new ArrayList<>();
score=new ArrayList<>();
sumscore=0;
}
public int getSumscore(){
return sumscore;
}
public int getScore(int i){
return score.get(i);
}
public boolean getarr(int i){
return arr.get(i);
}
public String getAnswer(int i){
return an.get(i);
}
public int getNumanwers(){
return an.size();
}
public Examination getExamination(){
return ex;
}
public void setAnswer(String ans,int i){
an.add(ans);
if(ex.getAnswer(ans,i)){
arr.add(1>0);
score.add(ex.getScore(i));
sumscore+=ex.getScore(i);
}
else{
arr.add(1<0);
score.add(0);
}
}
}
class Examination{
private int card;
private ArrayList<Question> arrquestions;
private ArrayList<Integer> score;
private int sumscore;
public Examination()
{
arrquestions=new ArrayList<>();
score=new ArrayList<>();
}
public int getNumquestions(){
return arrquestions.size();
}
public int getSumscore() {
return sumscore;
}
public int getCard() {
return card;
}
public void setCard(int card) {
this.card = card;
}
public Question getQuestion(int i){
return arrquestions.get(i);
}
public void setQuestion(Question x,int y){
arrquestions.add(x);
score.add(y);
sumscore+=y;
}
public int getScore(int i){
return score.get(i);
}
public boolean getAnswer(String ans,int i){
return arrquestions.get(i).getAnswer(ans);
}
}
class Question{
private int card;
private String info;
private String standardAnswer;
public Question(){}
public Question(int card,String info,String standardAnswer){
this.card=card;
this.info=info;
this.standardAnswer=standardAnswer;
}
public int getCard() {
return card;
}
public void setCard(int card) {
this.card = card;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
public boolean getAnswer(String answer){
return this.standardAnswer.equalsIgnoreCase(answer);
}
}
class Instrument{
private Instrument(){}
public static String[] Info1(String str){
String[] arr=str.split("#");
for(int i=1;i<4;i++){
arr[i]=arr[i].substring(2);
arr[i]=arr[i].trim();
}
return arr;
}
public static String[] Info2(String str){
String[] arr=str.split("\\s+");
arr[0]=arr[0].substring(3);
return arr;
}
public static String[] Info3(String str){
String[] arr=str.split("#");
for(int i=1;i<arr.length;i++){
arr[i]=arr[i].substring(2);
arr[i]=arr[i].trim();
}
return arr;
}
}
第三次的java大作业在前两次的大作业基础上增补新加了学生的信息和题目的删除以及各种不符合要求的信息输出。
点击查看代码
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
ArrayList<Question> sumquestion = new ArrayList<>();//题库
ArrayList<Examination> sumexamination = new ArrayList<>();//试卷库
ArrayList<Student> sumstudent = new ArrayList<>();//学生库
ArrayList<Test> sumtest = new ArrayList<>();//总库
ArrayList<String> examinations=new ArrayList<>();//临时的试卷
ArrayList<String> ans=new ArrayList<>();//临时的答案
for (; ; ) {
String str = in.nextLine();
if (str.equals("end"))
break;
if(!str.matches("(#N:\\d+ #Q:.+ #A:.*)|(#T:\\d+( \\d+-\\d+)*)|(#S:\\d+ \\d{8}(\\s* #A:\\d+-.*)*)|(#X:\\d{8} .+(-\\d{8} .+)*)|(#D:N-\\d+)")){
System.out.println("wrong format:"+str);
continue;
}
if (str.charAt(1) == 'N') {//题目
Question question = new Question(str);
sumquestion.add(question);
} else if (str.charAt(1) == 'T') {//试卷
examinations.add(str);
} else if (str.charAt(1) == 'X') {//学生
str = str.substring(3);
String[] xx;
if(str.matches(".+-.+"))
xx = str.split("-");
else{
xx=new String[1];
xx[0]=str;
}
for (int i = 0; i < xx.length; i++) {
String[] xxx = xx[i].split("\\s+");
Student student = new Student(xxx[0], xxx[1]);
sumstudent.add(student);
}
} else if (str.charAt(1) == 'S') {//答卷
ans.add(str);
} else {//删除题目信息
int x=Integer.parseInt(str.substring(5));
for (int i = 0; i < sumquestion.size(); i++) {
if(sumquestion.get(i).getCard()==x){
sumquestion.get(i).deleteQuestion();
break;
}
}
}
}
for (int i = 0; i < examinations.size(); i++) {//试卷
Examination ex = new Examination(examinations.get(i), sumquestion);
sumexamination.add(ex);
}
for (int i = 0; i < ans.size(); i++) {//答卷
Test test;
String str = ans.get(i);
String[] xx = Instrument.Info2(str);
int x=Integer.parseInt(xx[0]);
Answer answer=new Answer(str);
Examination examination;
Student student;
int k=0;
for(k=0;k<sumexamination.size();k++){//找到试卷
if(x==sumexamination.get(k).getCard()){
break;
}
}
if(k<sumexamination.size()){
examination=sumexamination.get(k);
}
else{
examination=null;
}
int j=0;
for (j = 0; j < sumstudent.size(); j++) {//找到学生
if(xx[1].equals(sumstudent.get(j).getCard())){
break;
}
}
if(j < sumstudent.size()){
student=sumstudent.get(j);
}
else{
student=new Student(xx[1],null);
}
test=new Test(student,examination,answer);
sumtest.add(test);
}
for (int i = 0; i < sumtest.size(); i++) {
sumtest.get(i).printIofo();
}
}
}
class Test {
private Student student;
private Examination examination;
private Answer answer;
public Test(Student student, Examination examination, Answer answer) {
this.student = student;
this.examination = examination;
this.answer = answer;
}
public void printIofo() {
int sum = 0;
ArrayList<Integer> it=new ArrayList<>();
if (examination == null) {
System.out.println("The test paper number does not exist");
return;
}
int sumquestion = examination.getNumquestions();
int sumanswer = answer.getSumanswer();
for (int i = 0; i < sumquestion; i++) {//遍历每一个题目
int j;
for (j = 0; j < sumanswer; j++) {//找答案
if (i + 1 == answer.getCard(j)) {
break;
}
}
if (j < sumanswer) {
if (!(examination.getQuestion(i) == null)) {//错误题目
if (!examination.getQuestion(i).isDelete()) {//判断题目是否被删除
boolean x = examination.getQuestion(i).getAnswer(answer.getAnswer(j));
if (x) {
it.add(examination.getScore(i));
sum += examination.getScore(i);
} else {
it.add(0);
}
System.out.println(examination.getQuestion(i).getInfo() + "~" + answer.getAnswer(j) + "~" + x);
} else {
it.add(0);
System.out.println("the question " + examination.getQuestion(i).getCard() + " invalid~0");
}
} else {
it.add(0);
System.out.println("non-existent question~0");
}
} else {
System.out.println("answer is null");
it.add(0);
}
}
if (student.getName() == null) {
System.out.println(student.getCard() + " not found");
return;
}
System.out.print(student.getCard()+" "+student.getName()+":");
for (int i = 0; i < it.size(); i++) {
System.out.print(" "+it.get(i));
}
if(!it.isEmpty())
System.out.println("~"+sum);
else
System.out.println(" ~0");
}
}
class Question{
private int card;
private String info;
private String standardAnswer;
private Boolean delete;
public Question(String str){
String[] arr = Instrument.Info1(str);
card = Integer.parseInt(arr[1]);
info = arr[2];
standardAnswer = arr[3];
delete = false;
}
public int getCard() {
return card;
}
public Boolean isDelete() {
return delete;
}
public void deleteQuestion() {
delete = true;
}
public String getInfo() {
return info;
}
public boolean getAnswer(String answer){
return this.standardAnswer.equals(answer);
}
}
class Examination{
private int card;
private ArrayList<Question> arrquestions;
private ArrayList<Integer> score;
private int sumscore=0;
public Examination(String str,ArrayList<Question> sumquestion)
{
arrquestions=new ArrayList<>();
score=new ArrayList<>();
String[] sum = Instrument.Info2(str);
card=Integer.parseInt(sum[0]);
for (int i = 1; i < sum.length; i++) {
String[] x = sum[i].split("-");
int card1 = Integer.parseInt(x[0]);
int score1 = Integer.parseInt(x[1]);
int j;
for (j = 0; j < sumquestion.size(); j++) {
if (sumquestion.get(j).getCard() == card1) {
break;
}
}
if( j < sumquestion.size()){
setQuestion(sumquestion.get(j), score1);
}
else{
setQuestion(null,0);
}
}
if (sumscore != 100)
System.out.println("alert: full score of test paper" + this.card + " is not 100 points");
}
public int getNumquestions(){
return arrquestions.size();
}
public int getSumscore() {
return sumscore;
}
public int getCard() {
return card;
}
public void setCard(int card) {
this.card = card;
}
public Question getQuestion(int i){
return arrquestions.get(i);
}
public void setQuestion(Question x,int y){
arrquestions.add(x);
score.add(y);
sumscore+=y;
}
public int getScore(int i){
return score.get(i);
}
public boolean getAnswer(String ans,int i){
return arrquestions.get(i).getAnswer(ans);
}
}
class Answer {
private ArrayList<Integer> card;
private ArrayList<String> an;
public Answer(String str) {
an = new ArrayList<>();
card = new ArrayList<>();
String[] ans = str.split("#");
for (int i = 2; i < ans.length; i++) {
ans[i] = ans[i].trim();
String[] xx=ans[i].split("-");
xx[0]=xx[0].substring(2);
if(xx.length==1){
card.add(Integer.parseInt(xx[0]));
an.add("");
}
else{
card.add(Integer.parseInt(xx[0]));
an.add(xx[1]);
}
}
}
public int getSumanswer(){
return an.size();
}
public int getCard(int i) {
return card.get(i);
}
public String getAnswer(int i) {
return an.get(i);
}
}
class Student {
private String name;
private String card;
public Student() {}
public Student(String card, String name) {
this.name = name;
this.card = card;
}
public String getName() {
return name;
}
public String getCard(){
return card;
}
}
class Instrument {
public static String[] Info1(String str) {
String[] arr = str.split("#");
for (int i = 1; i < 4; i++) {
if(i==2){
arr[i] = arr[i].substring(2,arr[i].length()-1);
continue;
}
arr[i] = arr[i].substring(2);
arr[i] = arr[i].trim();
}
return arr;
}
public static String[] Info2(String str) {
if(str.matches(".+\\s+.+")){
String[] arr = str.split("\\s+");
arr[0] = arr[0].substring(3);
return arr;
}
else{
String[] arr=new String[1];
arr[0]=str.substring(3);
return arr;
}
}
}
由于我觉得前两次大作业的代码写得差强人意，所以第三次的代码我进行了一次大改。
首先是对类的信息封装做的更加完善，对于题目类新加了一个delete属性用来判断题目是否被删除。
试卷类属性基本没变，不过方法里面新加了试卷的构造方法，让试卷的属性都在类内进行处理。
答卷类里的属性全部删掉，就留下题号和答案。
还新加了一个学生类，里面存放学生的学号和姓名。
在此基础上我新加了一个Test类，里面用来存放学生，试卷和答卷，一个Test只有一个学生试卷和答卷。
还新加了学生库，Test库，临时的试卷库，临时的答案库。
基本思路是：先将输入的字符串进行分析和判断，看输入的是什么信息，然后进入到相应的处理渠道去处理，由于题目是乱序输入的，所以对于试卷和答卷的信息不能拿到后直接进行处理，要等其他信息输入完后在进行处理，所以得先把他们的信息储存到临时的信息库里面，最后在对他们进行处理。
另外不符合格式的信息要输出信息错误，这里我用到了正则表达式来对字符串先进行判断，如果符合条件就进行下一步，不符合就直接输出错误信息。
第三的大作业对于前两次的大作业难度增加了很多，对于题目所给的信息的理解很重要，必须要先读懂题目的意思才好开始写代码，写之前最好自己先花一个结构图，要进行什么的判断在进行什么的判断，因为需要判断的东西有很多，比如题目是否存在，题目是否被删除，答案是否存在等等，而题目上并没有给一个明确的判段顺序，需要自己进行分析，所以如果没有一个很清晰的结构，写着写着可能就不知道自己在写什么了。
(3)踩坑心得：
写代码之前最好最好要在脑子里先构建一个大概的框架，能写在纸上最好是写在纸上，之前是看到题目抬手就写，写完之后在慢慢修改，结果有些关键性问题很难改，或者说改起来很复杂，结果就是，越改代码越大便，可读性越差，到最后调试的时候是最痛苦的，调出来根本不知道错误在哪里。
还有就是对于包里自带类的方法一定要有一个清楚的认识，用多了ArrrayList，获取元素的时候用的都是get方法，结果获取String里面的字符时我想当然的写了一个get结果就像下面一样
这个问题卡了我还挺久的，我一直以为是没导包找不到String，后来终于找到了问题，都快要被自己给蠢哭了。
其实之前并没有建立Test这个类，原先的想法是将最后的输出定义成一个方法的，但有一个很致命的问题。
这个方法到底该放在哪一个类里面？
原先打算放在学生类里，但这样，学生类里就要有试卷类和答卷类，还会有各种判题方法，这会让学生类逐渐变的越来越复杂难懂，放在试卷和答卷里感觉也是一样的问题，一旦放在他们的类里，类内的属性就要增加很多，第二次大作业的时候我已经感受到了类里存类的复杂难调试了，所以这一次的大改我就想尽量去避免这种问题，最好让各个类单独存在且不互相影响，这样不论是对于代码的可读性还是后期代码的调试都会更加的方便。
综上，我想到了新建一个类，里面的属性有学生，试卷，答卷，而判题的方法就定义在这个类里面，然后Test类就此出现，这样就可以充分避免代码可读性太差以及不好调试的问题了。
(4)改进建议
代码的改进的话，我觉得应该多去了解包自带的类和方法。
以字符串String为例,在第一次大作业里我想去除字符串前后存在的空格，结果就是我自己手搓了一个去空格的方法，但其实完全没有必要，可以用字符串自带的去空格的方法
改进前：
改进后：
可以看到前后差别还是有的
除此之外的还有正则表达式的应用
原先的判断方法十分复杂且不准确
但由于我并没有保留原先的代码，所以只有改进后的代码了。
以上是已经改进了的，还有一些没有改进的，但想要改进的，比如说将判题的功能单一化，以第三次大作业为例
我想要将各种信息存不存在单独包装成一个方法，比如将试卷是否存在包装成一个方法，将判断题目是否存在包装成一个方法，将题目是否被删除包装成一个方法，再将输出题目信息包装成一个方法等等。
然后在这个方法里调用以上所提到的各种被包装的方法。
(5)总结
经过了这几次的作业，让我学到了如何更好的包装一个类，以及类内方法定义的合理性和复用性，还学到了很多String类自带的方法，包括trim，split，matches等等，以及正则表达式的应用（自我感觉最重要的东西），还有课外方面的，比如API文档的使用。
但是还有很多不足的地方，类与类之间的关系应该设计的更加的合理，数据结构感觉还有可以改进的地方，对于错误以及报错分析的不够完美。
我觉得老师发表大作业的时候应该更加的合理且明确，不应该让学生在理解题目意思的方面下难度，在做第三次大作业的时候我一直不能理解答案为什么可以为空，为空的时候我到底应该输出答案为空还是把空字符当作是答案来输出，且标准答案也可以为空，标准答案和答案都为空时答案正确？我不能理解。
如果后面没有再增加一个测试点，我就会一直认为答案信息的前面的数字是题号，结果才发现，居然是序列号。。。。
总的来说，样例给的不够多且不够合理。
