对java面向对象设计的pta前三次作业总结
1. 前言
对于java程序语言与c相差不大，对于c语言的学习者来说学习java并不会很难，要写好java程序语言的语法的熟练使用是必要的
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
这道题的结构相对简单，没有太复杂的引用，考察了大家对关联类的使用以及对字符串的分割操作
题量在一百多行就能解决
我自己在写这个作业的时候都要不停地学习许多新的对字符串的操作方法（正确的方法真的能极大地加快我们对写代码的速度，这就比c语言要自己写函数要方便的多）
就比如：正则表达式
可用split方法分割以某个字符为界的字符串 String[] code=code1.split("\\s+");
它就是把字符串中以一个或多个空格将字符串code1分割开储存在字符串数组code里面（注：code是以0开始索引的字符串数组）
例如：
code1={asd fgh hjk lkk,k};
String[] code=code1.split("\\s+");
for(int a=0;a<code.length;a++){
System.out.println(code[a]);
}
结果是
asd fgh hjk lkk,k
以及用replaceAll方法替换掉影响split使用的字符 String code=code1.replaceAll("#N","");//将字符串中的“#N”字符替换为空
code1={#N:asd fgh hjk lkk,k}; String code=code1.replaceAll("#N",""); System.out.println(code);
结果是
:asd fgh hjk lkk,k
在这作者劝告大家自学正则表达式的用法，对字符串的处理有极大的帮助，就不用像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=5true
4+6=22false.
answer is null
3、判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：5 8 0~13
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
4、提示错误的试卷号
如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”，参见样例9。
设计建议：
参考答题判题程序-1，建议增加答题类，类的内容以及类之间的关联自行设计。
这题相对第一题进行了增加：增加了每一题的分数，分数是否不满一百，多卷作答
题量相对于第一题几乎增加了一倍（这一题我写了200多行） 难度增加不大，主要还是要看第一次的代码写得怎么样，我在代码结构进行了调整，在类里增加了多加的功能（没用继承）
知识点与第一题基本相同，更多的是对原代吗的迭代
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=5false
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=5true
4+6=22false.
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。
本题暂不考虑出现多张答卷的信息的情况。
输入样例1:
简单输入，不含删除题目信息。例如：N:1 #Q:1+1= #A:2
T:1 1-5
X:20201103 Tom
S:1 20201103 #A:1-5
end
第三次作业的难度陡然提升，对应对能力差的同学来说是致命的，这题对学生考验的不仅仅是代码能力，考验了学生对题目的理解类间设计的合理性
题量加大了许多，最少都要写到400行以上，算是一次中等难度题
总体来说该三次作业的难度在在逐渐爬升，学生需要注意的点越来越多，考虑的方面越来越多，一时间写不出来不要紧，不是还有时间吗
2.设计与分析
1）对输入数据进行分析：
需要一个类QuestionMessage储存#N表示的题目类，还要分开其中的题号、题目以及正确答案
需要一个答题类AnswerPaper作为题目输入的跳板，将题目导入到这里并保存#S中的输入答案，并将题目导入TextPaper，与之相关联
TextPaper专门处理从AnswerPaper传入的题目并处理字符串把题号、题目、答案保存在QuestionMessage中
第二次作业几乎没有变化
第三次作业新增了Students类用来储存学生的信息，Process类用来将输入的每一行字符串进行正则表达式判断，符合要求就储存起来，储存用的是链表LinkedList
整体来说只有第三次作业的类要好好设计一下，在写最后一题时一定要好好看题目要求，不然就会跟我一样找两三天的错误
注意：
一定要注意正则表达式的正确性
一定要保证代码的逻辑正确（我就是因为学生读取只能读第一个，最后5个测试点试了一天）
一定要考虑字符串的格式问题（测试点的字符串会有多余的空格，因为这个卡了半天）
分析第一题
i.根据正则表达式进行分割处理
ii.用类储存分割的数据
iii.再Main函数中实现数据输入，参数导入类中储存，输出处理后的数据
注：分割时要注意分割目标，建议对：进行分割，而不是空格，原因是题目字符串中会有空格影响分割
分析第二题
i.第一题的分析不变
ii.分数加在原有类QuestionMessage中作为每一题的属性
iii.在TextPaper类中增加addSum方法进行总分统计判断题目总分是否达到100分
iiii.对不存在的试卷进行判断
iiii.题目不存在输出 The test paper number does not exist
注：输出总分是否达到100分的语句中paper应该按照从小到大进行顺次输出
分析第三题
i.原有分析不变
ii.不符合要求的字符串先要以wrong format输出
iii.在输入过程中要注意可能存在的空格，比如题目字符串中标准答案会存在空格，要将字符串前后空格去掉，推荐trim()方法以及答卷的答案字符串前后的空格
iiii.对不存在的答卷进行判断：什么都不输出，但有输出wrong format和总分是否达到100分
iiiii.注意#D所删掉的题目：题目分数为0且输出为the question 2 invalid~0
iiiii.新增Students类储存学生的信息：学号 姓名，且对不存在的学生判断
注：该题目要求过多，理性判断题目要求，找到题目的突破点
样例：
输出：
样例：
输出：
3.我的代码
第一题代码：
import java.util.Scanner;
class QuestionMessage{
private int num;
private String message;
private String standardAnswer;
public void setNum(int num){
this.num=num;
}
public void setMessage(String message){
this.message=message;
}
public void setStandardAnswer(String standardAnswer){
this.standardAnswer=standardAnswer;
}
public int getNum(){
return num;
}
public String getMessage(){
return message;
}
public String getStandardAnswer(){
return standardAnswer;
}
public boolean judge(String answer){
if(this.standardAnswer==answer)
return true;
else
return false;
}
public QuestionMessage(int num,String message,String standardAnswer){
this.num=num;
this.message=message;
this.standardAnswer=standardAnswer;
}
}
class TextPaper{
public QuestionMessage[] quest=new QuestionMessage[100];
private int number;
public TextPaper(String questions,int number){
this.number=number;
String[] question=questions.split(":");
String trim1=null;
String trim2=null;
String trim3=null;
for(int a=1;a<=number;a++){
trim1=question[a*3-2].trim();
trim2=question[a*3-1].trim();
trim3=question[a*3].trim();
quest[Integer.valueOf(trim1)]=new QuestionMessage(Integer.valueOf(trim1),trim2,trim3);
}
}
public boolean judgeAnswer(String answer1,int number1){
if(answer1.equals(quest[number1].getStandardAnswer())){
return true;
}
return false;
}
}
class AnswerPaper{
public TextPaper text;
private String[] answers=new String[1000];
public int[] judgements=new int[1000];
public AnswerPaper(String ask,int nums,String ans){
String[] _ans1=ans.split("\\s+");
for(int a=0;a<nums;a++){
this.answers[a+1]=_ans1[a];
}
this.text=new TextPaper(ask,nums);
}
public void ifRight(int num1){
if(text.judgeAnswer(answers[num1],num1)){
this.judgements[num1]=1;
}
else
this.judgements[num1]=0;
}
public void printReult(int num2){
if(judgements[num2]==1)
System.out.printf("true");
else
System.out.printf("false");
}
public void keepAnswer(int num3,String answ){
String[] _answ=answ.split("\\s+");
this.answers[num3]=_answ[num3-1];
}
public String getAnswers(int num4){
return answers[num4];
}
}
public class Main{
public static void main(String[]args){
Scanner s=new Scanner(System.in);
int number=s.nextInt();
s.nextLine();
String question=s.nextLine();
String question1=null;
for(int a=1;a<number;a++){
question1=s.nextLine();
question+=question1;
}
String answer=s.nextLine();
String Question=question.replaceAll("#Q|#A|#N","");
String Answer=answer.replaceAll("#A:","");
AnswerPaper ans=new AnswerPaper(Question,number,Answer);
//System.out.printf("%s",Question);
for(int a=1;a<=number;a++){
ans.ifRight(a);
System.out.println(ans.text.quest[a].getMessage()+"~"+ans.getAnswers(a));
}
for(int a=1;a<=number;a++){
if(ans.judgements[a]==1&&a!=number){
System.out.printf("true ");
continue;
}
if(ans.judgements[a]==0&&a!=number){
System.out.printf("false ");
continue;
}
if(ans.judgements[a]==1&&a==number){
System.out.printf("true");
}
if(ans.judgements[a]==0&&a==number){
System.out.printf("false");
}
}
}
}
第二次作业代码
import java.util.Scanner;
class QuestionMessage{
private int num;
private String message;
private String standardAnswer;
private int score;
public void setNum(int num){
this.num=num;
}
public void setMessage(String message){
this.message=message;
}
public void setScore(int score){
this.score=score;
}
public int getScore(){
return score;
}
public void setStandardAnswer(String standardAnswer){
this.standardAnswer=standardAnswer;
}
public int getNum(){
return num;
}
public String getMessage(){
return message;
}
public String getStandardAnswer(){
return standardAnswer;
}
public boolean judge(String answer){
if(this.standardAnswer==answer)
return true;
else
return false;
}
public QuestionMessage(int num,String message,String standardAnswer){
this.num=num;
this.message=message;
this.standardAnswer=standardAnswer;
}
}//一道题目的内容
class TextPaper{
public QuestionMessage[] quest=new QuestionMessage[100];
private int number;
private int sum=0;
public TextPaper(String questions,int number){
this.number=number;
String[] question=questions.split(":");
String trim1=null;
String trim2=null;
String trim3=null;
for(int a=1;a<=number;a++){
trim1=question[a*3-2].trim();
trim2=question[a*3-1].trim();
trim3=question[a*3].trim();
quest[Integer.valueOf(trim1)]=new QuestionMessage(Integer.valueOf(trim1),trim2,trim3);
}
}
public void addSum(int sum){
this.sum+=sum;
}
public void setSum(int score){
this.sum=score;
}
public int getSum(){
return sum;
}
public boolean judgeAnswer(String answer1,int number1){
if(answer1.equals(quest[number1].getStandardAnswer())){
return true;
}
return false;
}
public int getAllScore(){
return sum;
}
}
class AnswerPaper{
public TextPaper text;
private String[] answers=new String[100];
public int[] judgements=new int[100];
public AnswerPaper(String ask,int nums){
this.text=new TextPaper(ask,nums);
}
public void setAnswers(String answers,int num){
this.answers[num]=answers;
}
public void ifRight(int num1,int num2){
if(text.judgeAnswer(answers[num2],num1)){
this.judgements[num1]=1;
}
else
this.judgements[num1]=0;
}
public void printReult(int num2){
if(judgements[num2]==1)
System.out.printf("true");
else
System.out.printf("false");
}
public void keepAnswer(int num3,String answ){
String[] _answ=answ.split("\\s+");
this.answers[num3]=_answ[num3-1];
}
public String getAnswers(int num4){
return answers[num4];
}
}
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int t1 = 0;
int s1 = 0;
String question = " ";
int[] number=new int[100];
number[0]=0;
int num4=0;
int num = 0;
String[] T = new String[100];
String[] S = new String[100];
String all = " ";
for (int a = 1; ; a++) {
String message = s.nextLine();
if (message.equals("end"))
break;
if (message.charAt(1) == 'N') {
question += message;
num++;
}
if (message.charAt(1) == 'T') {
T[t1] = message;
t1++;
num4++;
number[num4]=number[num4-1];
}
if (message.charAt(1) == 'S') {
S[s1] = message;
s1++;
number[num4]++;
}
}
AnswerPaper[] ans = new AnswerPaper[100];
question=question.replaceAll("#A|#N|#Q","");
int num1 = 0;
String[] T1 = new String[100];
String[] S1 = new String[100];
for (int a = 0; a < t1; a++) {
T[a] = T[a].replaceAll("#T:", "");
T1 = T[a].split("\\s+");
ans[Integer.valueOf(T1[0])] = new AnswerPaper(question, num);
for (int b = 1; b < T1.length; b++) {
String[] T2 = T1[b].split("-");
ans[Integer.valueOf(T1[0])].text.quest[Integer.valueOf(T2[0])].setScore(Integer.valueOf(T2[1]));
ans[Integer.valueOf(T1[0])].text.addSum(Integer.valueOf(T2[1]));
}
}
for (int a = 0; a < s1; a++) {
S[a] = S[a].replaceAll("#S:|#A:", "");
S1 = S[a].split("\\s+");
}
int[] check = new int[100];
int[] number2=new int[100];
for (int b = 0; b < t1; b++){
T1 = T[b].split("\\s+");
if (ans[Integer.valueOf(T1[0])].text.getAllScore() != 100) {
number2[Integer.valueOf(T1[0])]=1;
}
}
for (int b = 1; b <= t1; b++){
if(number2[b]==1){
System.out.println("alert: full score of test paper" + b + " is not 100 points");
}
}
for (int a = 0; a < s1; a++) {
S1 = S[a].split("\\s+");
String[] T4=new String[100];
check[a] = Integer.valueOf(S1[0]);
if (a == 0 || check[a] != check[a - 1]) {
int check1 = 0;
for (int b = 0; b < t1; b++) {
String[] T2=T[b].split("\\s+");
if (Integer.valueOf(S1[0]) == Integer.valueOf(T2[0])) {
check1=1;
}
}
if(check1==0){
System.out.println("The test paper number does not exist");
continue;
}
if (a > 1) {
check[a] = check[a - 1];
}
}
for(int d=0;d<t1;d++) {
T1 = T[d].split("\\s+");
if (Integer.valueOf(T1[0]) == Integer.valueOf(S1[0])) {
break;
}
}
for (int b = 1; b < S1.length; b++) {
ans[Integer.valueOf(S1[0])].setAnswers(S1[b], b);
}
for(int b=0;b<T1.length-1;b++){
String[] T2=T1[b+1].split("-");
T4[b]=T2[0];
}
for (int b = 1; b < T1.length; b++) {
String[] T3 = T1[b].split("-");
String[] quest=question.split(":");
for (int c = 0; c < (S1.length-1); c++) {
ans[Integer.valueOf(S1[0])].ifRight(Integer.valueOf(T4[c]), c + 1);
}
if (ans[Integer.valueOf(S1[0])].judgements[Integer.valueOf(T4[b-1])] == 1) {
System.out.println(ans[Integer.valueOf(S1[0])].text.quest[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S1[0])].getAnswers(b) + "~" + "true");
}
else if(ans[Integer.valueOf(S1[0])].getAnswers(b)==null){
System.out.println("answer is null");
}
else {
System.out.println(ans[Integer.valueOf(S1[0])].text.quest[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S1[0])].getAnswers(b) + "~" + "false");
}
}
int sum = 0;
for (int b = 1; b < T1.length; b++) {
String[] T3 = T1[b].split("-");
String[] quest=question.split(":");
if (ans[Integer.valueOf(T1[0])].judgements[Integer.valueOf(T4[b-1])] == 1 && b + 1 != T1.length) {
System.out.printf("%d ", ans[Integer.valueOf(T1[0])].text.quest[Integer.valueOf(T4[b-1])].getScore());
sum += ans[Integer.valueOf(T1[0])].text.quest[Integer.valueOf(T4[b-1])].getScore();
}
if (ans[Integer.valueOf(T1[0])].judgements[Integer.valueOf(T4[b-1])] == 0 && b + 1 != T1.length) {
System.out.printf("0 ");
}
if (ans[Integer.valueOf(T1[0])].judgements[Integer.valueOf(T4[b-1])] == 1 && b + 1 == T1.length) {
sum += ans[Integer.valueOf(T1[0])].text.quest[Integer.valueOf(T4[b-1])].getScore();
System.out.printf("%d~%d\n", ans[Integer.valueOf(T1[0])].text.quest[Integer.valueOf(T4[b-1])].getScore(), sum);
}
if (ans[Integer.valueOf(T1[0])].judgements[Integer.valueOf(T4[b-1])] == 0 && b + 1 == T1.length) {
System.out.printf("0~%d\n", sum);
}
}
}
}
}
第三次作业代码
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.LinkedList;
class QuestionMessage{
private int num;
private String message;
private String standardAnswer;
public void setNum(int num){
this.num=num;
}
public void setMessage(String message){
this.message=message;
}
public void setStandardAnswer(String standardAnswer){
this.standardAnswer=standardAnswer;
}
public int getNum(){
return num;
}
public String getMessage(){
return message;
}
public String getStandardAnswer(){
return standardAnswer;
}
public boolean judge(String answer){
if(this.standardAnswer==answer)
return true;
else
return false;
}
public QuestionMessage(int num,String message,String standardAnswer){
this.num=num;
this.message=message;
this.standardAnswer=standardAnswer;
}
}//一道题目的内容
class TextPaper{
public QuestionMessage[] quest=new QuestionMessage[100];
private int[] score=new int[100];
private int number;
private int sum=0;
public TextPaper(String questions,int number){
this.number=number;
String[] question=questions.split(":");
String trim1=null;
String trim2=null;
String trim3=null;
for(int a=1;a<=number;a++){
int stand=0;
trim1=question[a*3-2].trim();
trim2=question[a*3-1].trim();
if(question.length<4){
trim3="";
}
else{
trim3=question[a*3].trim();
}
quest[Integer.valueOf(trim1)]=new QuestionMessage(Integer.valueOf(trim1),trim2,trim3);
}
}
public void setScore(int num,int sorce){
this.score[num]=sorce;
}
public int getScore(int num){
return score[num];
}
public boolean checkQuestion(String questions,int q){
String trim1;
String[] question=questions.split(":");
for(int a=1;a<=number;a++){
trim1=question[a*3-2].trim();
if(Integer.valueOf(trim1)==q){
return true;
}
}
return false;
}
public void addSum(int sum){
this.sum+=sum;
}
public void setSum(int score){
this.sum=score;
}
public int getSum(){
return sum;
}
public boolean judgeAnswer(String answer1,int number1){
if(answer1.equals(quest[number1].getStandardAnswer())){
return true;
}
return false;
}
public int getAllScore(){
return sum;
}
}
class AnswerPaper{
public TextPaper text;
private String ID;
private String[] answers=new String[100];
public int[] judgements=new int[100];
public AnswerPaper(String ask,int nums){
this.text=new TextPaper(ask,nums);
}
public AnswerPaper(){
}
public void setID(String ID){
this.ID=ID;
}
public String getID() {
return ID;
}
public void setAnswers(String answers, int num){
this.answers[num]=answers;
}
public void ifRight(int num1,int num2){
if(text.judgeAnswer(answers[num2],num1)){
this.judgements[num2]=1;
}
else
this.judgements[num2]=0;
}
public void printReult(int num2){
if(judgements[num2]==1)
System.out.printf("true");
else
System.out.printf("false");
}
public void keepAnswer(int num3,String answ){
String[] _answ=answ.split("\\s+");
this.answers[num3]=_answ[num3-1];
}
public String getAnswers(int num4){
return answers[num4];
}
}
class Students{
private String ID;
private String name;
public Students(String ID,String name){
this.ID=ID;
this.name=name;
}
public String getID() {
return ID;
}
public String getName(){
return name;
}
public void setID(String ID){
this.ID=ID;
}
public void setName(String name){
this.name=name;
}
}
class Process{
public int num=0;
private String question=" ";
private LinkedList<String> T=new LinkedList<String>();
private LinkedList<String> S=new LinkedList<String>();
private LinkedList<String> student=new LinkedList<String>();
private LinkedList<String> D=new LinkedList<String>();
public Process(){
}
public String getQuestion(){ return question; }
public LinkedList<String> getT(){
for(int a=0;a<T.size();a++){
T.set(a,T.get(a).replaceAll("#T:(\\s*)",""));
}
return T;
}
public LinkedList<String> getS(){
return S;
}
public LinkedList<String> getStudent(){
for(int a=0;a<student.size();a++){
student.set(a,student.get(a).replaceAll("#X:(\\s*)",""));
}
return student;
}
public LinkedList<String> getD(){
for(int a=0;a<D.size();a++){
D.set(a,D.get(a).replaceAll("#D:(\\s*)N(\\s*)-",""));
}
return D;
}
public void formatJudge(String message){
int check=0;
Pattern pattern=Pattern.compile("(^#N:\\s*(\\d+)\\s*#Q:\\s*(.*?)\\s*#A:\\s*(.*?)\\s*($|\\n))");
Pattern pattern1=Pattern.compile("^#T:\\s*(\\d+)(\\s*\\d+\\s*\\-\\s*\\d+\\s*)*$");
Pattern pattern2=Pattern.compile("^#X:(\\s*(\\d+)\\s*((\\w+)|[\u4e00-\u9fa5]+)\\s*(\\-)*\\s*)*");
Pattern pattern3=Pattern.compile("^#S:(\\d+)\\s*(\\d+)\\s*(#A:\\s*(\\d+)\\s*\\-\\s*(.*?)\\s*(?=#A:|\\n|$))*");
Pattern pattern4=Pattern.compile("^#D:\\s*N\\s*\\-\\s*(\\d+)$");
Matcher matcher=pattern.matcher(message);
while(matcher.find()){
question+=message;
num++;
check=1;
}
Matcher matcher1=pattern1.matcher(message);
while(matcher1.find()){
T.add(message);
check=1;
}
Matcher matcher2=pattern3.matcher(message);
while(matcher2.find()){
S.add(message);
check=1;
}
Matcher matcher3=pattern2.matcher(message);
while(matcher3.find()){
student.add(message);
check=1;
}
Matcher matcher4=pattern4.matcher(message);
while(matcher4.find()){
D.add(message);
check=1;
}
if(check==0){
System.out.println("wrong format:"+message);
}
}
}
public class Main {
public static void main(String[]args){
Scanner s=new Scanner(System.in);
String question;
Process process=new Process();
for(int a=0;;a++){
String message=s.nextLine();
if(message.equals("end")){
break;
}
process.formatJudge(message);
}
String[] S1=new String[100];
String[] T1=new String[100];
question=process.getQuestion().replaceAll("#N|#Q|#A"," ");
AnswerPaper[] ans=new AnswerPaper[100];
for(int a=0;a<30;a++){
ans[a]=new AnswerPaper();
}
int number=1;
for(int a=0;a<process.getT().size();a++){
T1=process.getT().get(a).split("\\s+");
ans[Integer.valueOf(T1[0])]=new AnswerPaper(question,process.num);
for(int b=1;b<T1.length;b++){
String[] T2=T1[b].split("-");
int check=0;
for(int c=0;c<process.getD().size();c++){
if(Integer.valueOf(process.getD().get(c).trim())==Integer.valueOf(T2[0])){
check=1;
}
}
if (check == 1&&ans[Integer.valueOf(T1[0])].text.checkQuestion(question,Integer.valueOf(T2[0]))) {
ans[Integer.valueOf(T1[0])].text.setScore(b,0);
ans[Integer.valueOf(T1[0])].text.addSum(0);
}
else if(check == 0&&ans[Integer.valueOf(T1[0])].text.checkQuestion(question,Integer.valueOf(T2[0]))){
ans[Integer.valueOf(T1[0])].text.setScore(b,Integer.valueOf(T2[1]));
ans[Integer.valueOf(T1[0])].text.addSum(Integer.valueOf(T2[1]));
}
}
}
String[] S3=new String[100];
String[] S4=new String[100];
int[] answerNum=new int[100];
for(int a=0;a<process.getS().size();a++) {
S1 = process.getS().get(a).split("#");
for (int b = 0; b < S1.length; b++) {
if(S1[b].startsWith("S:")){
S1[b] = S1[b].replaceAll("S:(\\s*)", "");
S3=S1[b].split(" ");
}
if(S1[b].startsWith("A:")){
S1[b] = S1[b].replaceAll("A:(\\s*)", "");
if(S1[b].length()>0){
S4=S1[b].split("-");
answerNum[Integer.valueOf(S4[0])]=Integer.valueOf(S4[0]);
if(S4.length<2){
ans[Integer.valueOf(S3[0])].setAnswers("",Integer.valueOf(S4[0]));
}
else{
ans[Integer.valueOf(S3[0])].setAnswers(S4[1].trim(),Integer.valueOf(S4[0]));
}
}
}
}
}
int studentNum=0;
Students[] students=new Students[100];
for(int a=0;a<process.getStudent().size();a++){
process.getStudent().set(a,process.getStudent().get(a).replaceAll("#X:",""));
String[] student1=process.getStudent().get(a).split("-");
for(int b=0;b<student1.length;b++){
String[] student2=student1[b].split("\\s+");
students[b]=new Students(student2[0],student2[1]);
studentNum++;
}
}
int[] check = new int[100];
int[] number2=new int[100];
if(process.getT().size()!=0){
int Max=Integer.valueOf(T1[0]);
for (int b = 0; b < process.getT().size(); b++){
T1=process.getT().get(b).split("\\s+");
if (ans[Integer.valueOf(T1[0])].text.getAllScore() != 100) {
number2[Integer.valueOf(T1[0])]=1;
if(Max<Integer.valueOf(T1[0])){
Max=Integer.valueOf(T1[0]);
}
}
}
for (int b = 1; b <= Max; b++){
if(number2[b]==1){
System.out.println("alert: full score of test paper" + b + " is not 100 points");
}
}
}
for (int a = 0; a < process.getS().size(); a++) {
S1 = process.getS().get(a).split("(\\s*)#");
for(int d=0;d<S1.length;d++) {
if (S1[d].startsWith("S:")) {
S1[d] = S1[d].replaceAll("S:(\\s*)", "");
S3 = S1[d].split(" ");
}
if (S1[d].startsWith("A:")) {
S1[d] = S1[d].replaceAll("A:(\\s*)", "");
S4 = S1[d].split("-");
}
}
for(int b=0;b<process.getT().size();b++){
T1=process.getT().get(b).split("\\s+");
if(Integer.valueOf(S3[0])==Integer.valueOf(T1[0])){
break;
}
}
String[] T4=new String[100];
check[a] = Integer.valueOf(S3[0]);
if (a == 0 || check[a] != check[a - 1]) {
int check1 = 0;
if(process.getT().size()!=0){
if (Integer.valueOf(S3[0]) == Integer.valueOf(T1[0])) {
check1 = 1;
}
}
if (check1 == 0) {
System.out.println("The test paper number does not exist");
continue;
}
if (a > 1) {
check[a] = check[a - 1];
}
}
for(int d=0;d<process.getT().size();d++) {
if (Integer.valueOf(T1[0]) == Integer.valueOf(S3[0])) {
break;
}
}
for(int b=0;b<T1.length-1;b++){
String[] T2=T1[b+1].split("-");
T4[b]=T2[0];
}
int num=1;
for (int b=1;b<T1.length;b++) {
S1 = process.getS().get(a).split("(\\s*)#");
String[] T3 = T1[b].split("-");
String[] quest=question.split(":");
for(int c=0;c<S1.length;c++){
if(S1[c].startsWith("S:")){
S1[c] = S1[c].replaceAll("S:(\\s*)", "");
S3=S1[c].split(" ");
}
if(S1[c].startsWith("A:")) {
S1[c] = S1[c].replaceAll("A:(\\s*)", "");
if(S1[c].length()>0){
S4 = S1[c].split("-");
if(b==Integer.valueOf(S4[0])){
if (ans[Integer.valueOf(S3[0])].text.checkQuestion(question, Integer.valueOf(T3[0]))) {
ans[Integer.valueOf(S3[0])].ifRight(Integer.valueOf(T4[b-1]), Integer.valueOf(S4[0]));
}
}
}
}
}
if(ans[Integer.valueOf(S3[0])].getAnswers(b)==null){
System.out.println("answer is null");
}
else{
if(ans[Integer.valueOf(S3[0])].text.checkQuestion(question,Integer.valueOf(T3[0]))){
if(ans[Integer.valueOf(S3[0])].text.getScore(Integer.valueOf(b))==0){
System.out.println("the question "+T3[0]+" invalid~0");
}
else if (ans[Integer.valueOf(S3[0])].judgements[b] == 1) {
System.out.println(ans[Integer.valueOf(S3[0])].text.quest[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S3[0])].getAnswers(b) + "~" + "true");
}
else {
System.out.println(ans[Integer.valueOf(S3[0])].text.quest[Integer.valueOf(T3[0])].getMessage() + "~" + ans[Integer.valueOf(S3[0])].getAnswers(b) + "~" + "false");
}
}
else{
System.out.println("non-existent question~0");
}
}
}
int sum = 0;
int check2=0;
for (int b = 0; b < studentNum; b++){
if(students[b].getID().equals(S3[1])){
check2=1;
break;
}
}
if(check2==1){
int number1=0;
for(int c=0;c<students.length;c++){
if(students[c].getID().equals(S3[1])){
number1=c;
break;
}
}
System.out.printf("%s %s: ",students[number1].getID(),students[number1].getName());
for (int b = 1; b < T1.length; b++) {
String[] T3 = T1[b].split("-");
String[] quest=question.split(":");
if (ans[Integer.valueOf(T1[0])].judgements[b] == 1 && b + 1 != T1.length) {
System.out.printf("%d ", ans[Integer.valueOf(T1[0])].text.getScore(b));
sum += ans[Integer.valueOf(T1[0])].text.getScore(b);
}
if (ans[Integer.valueOf(T1[0])].judgements[b] == 0 && b + 1 != T1.length) {
System.out.printf("0 ");
}
if (ans[Integer.valueOf(T1[0])].judgements[b] == 1 && b + 1 == T1.length) {
sum += ans[Integer.valueOf(T1[0])].text.getScore(b);
System.out.printf("%d~%d\n", ans[Integer.valueOf(T1[0])].text.getScore(b), sum);
}
if (ans[Integer.valueOf(T1[0])].judgements[b] == 0 && b + 1 == T1.length) {
System.out.printf("0~%d\n", sum);
}
}
}
else{
System.out.println(S3[1]+" not found");
}
}
}
}
4.改进建议
对我的代码虽然能够解决pta问题但不能够进行多次迭代操作，代码灵活性较低，main类中的代码过多，关联性过强，在后续的迭代中的难度较大
建议：
坚决执行单一职责原则将main类继续分解成其他单独的功能类，便于后续的改进和修改
对自己的代码一定要写一点必要的注释，不然连自己都看不懂
要注意代码的结构，什么部分和什么部分的顺序一定要了解明白（自己在测试的时候就会在先后输出出现问题）
5.总结
在这一次实验中我学到了类的单一职责原则、类与类间的关联关系、依赖关系，代码的迭代过程、代码的优先改进以及方法的复用
但我人需要进一步学习类间设计，让类间关系变得更加合理，降低类的耦合性
再写代码之前要优先画类图以理解题目要求，不在盲目乱撞，提高代码设计效率
如有不足请指教！
浙公网安备 33010602011771号