关于pta三次作业的总结
oop三次pta总结
前言
在这学期的java课程学习当中，我已经体会到了java这门语言的重要性了，就从这三次pta题目的设计与思路来说吧（还真的有点小难），特别是每一期pta的最后一题......
《答题判题程序》，这道题目依次迭代，难度依次上升（如果没有设计好，基本是寄了），题目不多看几遍细节是真的不能把握，如果细节忽略了，那就要付出几倍的时间和
去修正了。(别问我怎么知道的)
这道题目涵盖正则表达式，类的设计，等知识点。从复杂到更复杂，时间耗费的越来越多，（一个测试点一天）
接下来一题一题来分析看看吧，也总结一下自己的代码设计错误
设计与分析
题目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.Scanner; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int number; number = sc.nextInt(); Answerpaper answerpaper[] = new Answerpaper[2 * number + 1]; int[] num = new int[number + 1]; String str; sc.nextLine(); String[][] Str = new String[number + 2][]; for (int i = 1; i <= number + 1; i++) { str = sc.nextLine(); Str[i] = str.split(":"); for (int j = 1; j < Str[i].length; j++) { while (Str[i][j].charAt(0) == ' ') { Str[i][j] = Str[i][j].substring(1); } if (i == number + 1) { while (Str[i][j].charAt(Str[i][j].length() - 1) == '#' || Str[i][j].charAt(Str[i][j].length() - 1) == 'A' || Str[i][j].charAt(Str[i][j].length() - 1) == ' ') { Str[i][j] = Str[i][j].substring(0, Str[i][j].length() - 1); } } if (j == 1 && i != number + 1) { while (Str[i][j].charAt(Str[i][j].length() - 1) == '#' || Str[i][j].charAt(Str[i][j].length() - 1) == 'Q' || Str[i][j].charAt(Str[i][j].length() - 1) == ' ') { Str[i][j] = Str[i][j].substring(0, Str[i][j].length() - 1); } num[i] = 0; for (int k = 0; k < Str[i][j].length(); k++) num[i] += ((int) Str[i][j].charAt(k) - 48) * Math.pow(10, Str[i][j].length() - k - 1); } if (j == 2 && i != number + 1) { Str[i][j] = Str[i][j].substring(0, Str[i][j].length() - 1); Str[i][j] = Str[i][j].substring(0, Str[i][j].length() - 1); while (Str[i][j].charAt(Str[i][j].length() - 1) == ' ') { Str[i][j] = Str[i][j].substring(0, Str[i][j].length() - 1); } } if (j == 3) { while (Str[i][j].charAt(Str[i][j].length() - 1) == ' ') { Str[i][j] = Str[i][j].substring(0, Str[i][j].length() - 1); } } } } for (int i = 1; i <= number; i++) { answerpaper[num[i]] = new Answerpaper(number, num[i], Str[1 + number][num[i]], Str[i][3], Str[i][2]); } for (int i = 1; i <= number; i++) { for (int j = 1; j <= number - 1; j++) { if (num[j] > num[j + 1]) { int a = num[j + 1]; num[j + 1] = num[j]; num[j] = a; } } } for (int i = 1; i <= number; i++) { answerpaper[num[i]].printlnof(); answerpaper[num[i]].printresult(); } for (int i = 1; i <= number; i++) { if (answerpaper[num[i]].paper.problem.answerright(answerpaper[num[i]])) { if (i != number) { System.out.printf("true "); } else { System.out.printf("true"); } } else { if (i != number) System.out.printf("false "); else System.out.printf("false"); } } } } class Problem { int num; String content; String standardAnswer; public Problem(int num, String content, String standardAnswer) { this.num = num; this.content = content; this.standardAnswer = standardAnswer; } public boolean answerright(Answerpaper answerpaper) { if (answerpaper.answer.equals(standardAnswer)) return true; return false; } } class Paper { Problem problem; int number; public Paper(int number, String standardAnswer, int num, String content) { problem = new Problem(num, content, standardAnswer); this.number = number; } public Problem getProblem() { return this.problem; } } class Answerpaper { Paper paper; static int num = 0; String answer; private boolean result; public Answerpaper(int number, int num, String standardAnswer, String answer, String content) { this.answer = answer; paper = new Paper(number, standardAnswer, num, content); } public boolean numjudgeAnswer(int num) { return true; } public void printlnof() { System.out.printf("%s", paper.getProblem().content); } public void printresult() { System.out.printf("~%s\n", paper.getProblem().standardAnswer); } }
我的基本思路是将输入的问题，试卷，答卷分割成各个部分，并储存进Answerpaper类。Answerpaper类中有paper类，paper类中有problem类储存题目，这样一来就可通过引用答卷类从而对答卷上的答题信息进行正误的判断，将三种信息很好的关联了起来，我为了分割字符串还在"main"函数中定义了一个二维字符串数组。。。而我分割输入就是通过"N","S","T"来判断输入是问题还是试卷还是答卷。再使用split()和substring函数从而做到将多余的字符去掉从而得到需要的
看上去我对类的设计非常不错，三个类分的很好，但是但是我类中的变量都不是private（私有的），从而很严重的破坏了类的封装性。主要是当时也为了图方便，想着直接引用就行了，还不用写getter方法 ，但是却忘了最重要的类的封装性。
还有就是我在主方法里面分割字符串（还分割的很复杂），主方法里面就只能做两件事就是输入输出，但是我却在主方法里面做了别的事，这是不可取得
然后就是我没有用正则表达式（最简便得方法），正则表达式我竟然学了没用，本来这道题就是考察正则表达式的。叹。。。（无力感）
额，这里Main函数是红色，因为字符串的分割全在Main函数中，要加一个splitinput类去解决这个问题。
啊，这个Main函数实在是太复杂了呀，二维的字符串数组真的是太复杂了，所以一定要有一个splitinput类去解决问题，而且要使用正则表达式啊，这真的是废物代码啊。连复杂度为6的代码都有，真的需要去好好改进。所以第一次代码简直跟写C语言一样（没有可读性）
题目2：
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-1基础上增补或者修改的内容。
要求输入题目信息、试卷信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三种，三种信息可能会打乱顺序混合输入：
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、判题信息的顺序与输入答题信息中的顺序相同
样例：5 8 0~13
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
4、提示错误的试卷号
如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”，参见样例9。
设计建议：
参考答题判题程序-1，建议增加答题类，类的内容以及类之间的关联自行设计。
代码：
保密
相较于第一题，这一题难度直接上来了，增加了太多东西了。（难）
增加了答卷，判定试卷是不是满分，还有不一样的判分输出，乱序输入.........
这道题真的就要好好地看题目，要去把每一个细节抓住才可以下笔，而我因为上一次写的很不好需要重新构造类（重写了一天）这次增加了一个splitinput类这个类就是将那些问题，试卷，答卷的输入的有效信息进行提取。
我的基本思路是将输入通过splitinput类进行分割，将所有的题目储存进入question类 ，所有的试卷存入试卷类，然后根据ScoreSumJudge类判断试卷是否是满分试卷。而答卷类通过输入去遍历，从而完成对答卷分数结果的输出
这道题的不足就在于对答卷结果的分析是在AnswerQuestion类中，没有做到类的单一职责性，应该设计一个agent类
这里可以看到Main函数的OCavg很高，因为有很多for循环存在于其中，需要改进
而AnswerQuestion类中的WMC的数值很高，主要是因为答卷的评分判断也在其中，这里十分需要改进。
第二次代码的复杂度还是比较不行的复杂度为5的代码还是有很多，在AnswerQuestion类中进行了对答卷的判分，没有实现单一职责的基础上还没有实现代码的简洁，还需要继续改进才能写出更好的代码。
题目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、题目引用错误提示信息
试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。例如：
输入：
#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。
本题暂不考虑出现多张答卷的信息的情况。
代码：
保密
第三次答题程序又在第二题基础上又增加了学生信息，删除题目，错误格式的判断，还有空白试卷等特殊情况；
相较于上一次在splitinput类中增加了对学生信息和删除信息的分离，由于第二次的代码可复用，思路也是沿用上一次的思路。这次增加了很多类，特别的增加了一个agent类，用来处理数据和输出。
从类图中来看还是类是非常多的
还有就是wrongformat格式的判断：
if (!(input[i].matches("^#N:\\s*(\\d+)\\s*#Q:\\s*(.*?)\\s*#A:\\s*(.*)"))) 这个用来判断问题
if (!(input[i].matches("^#T:( )*\\w+( )*(( )*\\w+( )*-( )*\\w+( )*)+"))) 这个用来判断试卷
虽然这里判断格式用到了正则表达式，但是我却没有在分割字符串时进行使用，这是个很大的问题
但是写着写着我发现了一个问题主方法里面的对象太多了，也可以从类中看到Main函数与很多类都有联系，其实我应该让Main函数部分联系的类去和对应的类去尝生关系，这是一种错误的行为(代码可读性和维护性会很差)。还有就是我应该多加一个view类来进行输出
还是强调一下Main函数的问题，Main就只用和agent类联系就可以了，其他的事交给agent联系的各个类来完成就可以了的
还有就是当前在对答卷中的答案进行分析时，发现真的很复杂，导致agent类中的东西太多了，判断的太多了，可能是设计的问题导致
不过这次的测试点是真的难过(感觉有一两个测试点涵盖的内容有很多都没说，要去猜)
这张图中可以看到我Main函数Ocavg很高，主要是在这其中用了太多的循环和if语句，最大的问题我直接在其中还使用了错误格式判断的if语句本来是应该在对应的类中实现的但是我却当时十分的烦（因为错误格式的问题总是过不去），所以当时脑子一热就在Main函数中写了，这些都不应该出现
还有就是我的Splitinput类中的WMC好高，由于所有的字符串的判断都在里面，所以导致的这种情况，其实应该将这些再一次细分一下类的，这样导致这个类的可扩展性就十分的低了。
这次的5复杂度的代码相对于上一次改进还是挺大的，主要是增加了agent类去进行答卷的判分，没有让一个类承受它不该有的代码，但是在splitinput类中它分离的字符串的种类还是太多了，所以还得进行改进。。
踩坑心得：
第一次pta测试时没有什么很纠结的测试点。
而第二次答题程序其实注意一下题目和答案里面的空格就可以了
测试样例
#N:3 #Q:idaf fdaf daf #A:5 fda dfa #N:2 #Q:2+2= #A:4 #T:1 3-7 2-6 #S:1 #A:5 #A:22 #N:1 #Q:1+1= #A:2 da dsa #T:2 2-5 1-3 3-2 #S:2 #A:5 #A:4 end
结果
alert: full score of test paper1 is not 100 points alert: full score of test paper2 is not 100 points idaf fdaf daf~5~false 2+2=~22~false 0 0~0 2+2=~5~false 1+1=~4~false answer is null 0 0 0~0
就比如说这个题目内有空格和答案有空格不能用空格分割。。。
最无语的其实就是第三次的测试点 上素材：
输入
#T:1 1-8 1-9 1-9 6-9 3-6 1-65 #X:20201103 Tom-20201104 Jack-20201105 Www #S:1 20201103 #A:3- | #A:6- #N:1 #Q:1+1= #A: end
结果
alert: full score of test paper1 is not 100 points answer is null answer is null 1+1=~|~false answer is null answer is null 1+1=~~true 20201103 Tom: 0 0 0 0 0 65~65
输入
#N:1 #Q:1+1= #A: 4
#T:1 1-5 7-8 8-9 9-2 2-8 10-6
#X:20201103 Tomgrrrrrrrrrrrrrrrrr-20201104 Jack-20201104 Www
#S:1 20201103 #A:2-9 #A:9- 9 #A:1- 4
#S:2 20201103
#D:N-2
#T:2 1-4
#N:2 #Q:2+2= #A:4
end
结果
alert: full score of test paper1 is not 100 points alert: full score of test paper2 is not 100 points 1+1=~4~true non-existent question~0 answer is null answer is null answer is null answer is null 20201103 Tomgrrrrrrrrrrrrrrrrr: 5 0 0 0 0 0~5 answer is null 20201103 Tomgrrrrrrrrrrrrrrrrr: 0~0
输入
#N:1 #Q:1+1= #A: #N:2 #Q:2+2= #A: caonima #N:3 #Q:6+6= #A: #T:1 3-88 2-8 1-4 6-9 5-7 9-9 10-99 #D:N-3 #X:11111111 Tom-20201104 Jack-20201105 Www #N:5 #Q:2+2= #A: 282 #S:1 11111111 #A:2- caonima #A:3- #A:1- #A:5-282 #A:4-99 #N:9 #Q:2+2= #A: 828 end
输出
alert: full score of test paper1 is not 100 points the question 3 invalid~0 2+2=~caonima~true 1+1=~~true non-existent question~0 2+2=~282~true answer is null answer is null 11111111 Tom: 0 8 4 0 7 0 0~19
这些测试点必须得都过才能全对，这种标准答案可以有空格，回答的答案的前后空格必须去掉，还有答案可以为空，无论是回答答案还是标准答案都是可以为空的，一开始写代码时是真的没有去注意，但是后面的测试点有要满足这种情况才可以过，所以当时写这一题真的花了好久的时间
还有就是：
输入：
dgn#Q:1+1= #A:2 #N:2 #Q:2+2= #A:4 #T:1 1-5 2-8 #X:20201103 Tom-20201104 Jack-20201105 Www #S:1 20201103 #A:1-5 #A:2-4 #D:N-2 end
输出：
wrong format:dgn#Q:1+1= #A:2 alert: full score of test paper1 is not 100 points non-existent question~0 the question 2 invalid~0 20201103 Tom: 0 0~0
之前只考虑了对错误格式的内部出错(就是前面的#Q这些保留，后面的格式错误）结果有几个测试点就是过不了，太难受了，所以一定要对多种情况进行考虑
在进行代码书写时某些细致问题没有注意导致出错，所以需要仔细认真
还有正则表达式，我的分割字符串的类中就没有使用，例如：
public void splitQuestion() { if (input.contains("laji1")) { this.QuestionNum = String.valueOf(input.charAt(3)); this.Question = "laji1"; this.StandardAnswer = "laji1"; return; } input = input.replaceAll(" #A", ""); String s[] = input.split(":"); while (s[1].charAt(s[1].length() - 1) == ' ' || s[1].charAt(s[1].length() - 1) == '#' || s[1].charAt(s[1].length() - 1) == 'Q') { s[1] = s[1].substring(0, s[1].length() - 1); } while (s[1].charAt(0) == ' ') { s[1] = s[1].substring(1, s[1].length()); } this.QuestionNum = s[1]; this.Question = s[2]; if (s.length == 4) { if (s[3].matches("\\s+")) { this.StandardAnswer = ""; return; } while (s[3].charAt(s[3].length() - 1) == ' ') { s[3] = s[3].substring(0, s[3].length() - 1); } while (s[3].charAt(0) == ' ') { s[3] = s[3].substring(1, s[3].length()); } this.StandardAnswer = s[3]; } else { this.StandardAnswer = ""; } }
我基本上就在一个一个的判断，没有可读性，别人根本看不懂，这是一个非常大的问题，以后的pta一定会去努力解决
改进建议：
对于main函数方法中的对象创建太多的问题必须要进行改进，提高代码的可读性。
类要保证单一职责的原则，书写类时要遵守这一点
某一个类不能写的太多，不然类的维护性会非常差
正则表达式要熟悉使用。
总结：
题目在不断变化，而我们的代码的类的设计需要有可扩展性，对于类的书写要满足类的特性。叹，写完这次博客，pta又一次的迭代题目又要来了，加油。
对这些题目的总结
1.对于正则表达式的学习与使用应该要增强，因为它不仅是个很好的工具也很好的提高了我们代码的可读性，像一些字符串的判断和一些字符的去除有很好的作用
2.对类的设计要时刻满足类的特点和要求，代码要有代码的样子。
3.要提前去了解一些类的相关信息，例如下一次的作用会涉及继承关系，一定要去提前复习且熟悉
4.最重要的就是我的Main函数是真的很有问题啊，很多事情的分配都有问题，一定要全部都改掉啊
