南昌航空大学-软件学院-23201117-方宗卫第一次blog作业
前言
本次blog总结前三次大作业以及对于写完作业之后的思考，主要是对于最后一题答卷系统的思路以及错误总结。
1.关于题量
对于作业来说，映入眼帘的肯定是题量。三次java的PTA大作业中，随着最后一题的难度的增加，前面题目的数量也会减少，因此题目量适中，单纯从题量来说，每个同学用心去写肯定是可以写完的。
2.关于知识点
在知识点上，每次PTA前面的小题上都是在帮助我们进行基础语法知识的补充和类与对象的小练手，例如第一次中对于数组的考察，第二次中对于链表的考察，第三次对于日期类的使用。每次题集的最后一题则是对于类设计的考察，让我们贯彻面向对象思想，学会类的设计。
3.关于难度
第一次大作业的题目较为简单，前面的四题小题主要是对于类的小设计以及对于数组的考查，最后一题题目理解起来较为简单，借助老师提示的类设计，设计三个类即可较好的解决问题。
第二次大作业的题目在第一次的基础上有所上升，前三题仍然是对于类的小设计以及对于链表的使用，最后一题答卷系统是在第一次最后一题的基础上加难，无论是类还是代码量都相比第一次更多，类的设计更加重要。
第三次大作业的题目是最难的，第二题中的日期类对于大家来说十分陌生，第三题的逻辑和正则表达式的要求更加严格。
设计与心得
第一次最后一题
public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int number = in.nextInt();
Problem[] problem = new Problem[number];
in.useDelimiter("\n");
for(int i = 0;i < number; i++){
String str1 = in.next();
String[] strs = str1.split(" *#A: *| *#Q: *| *#N: *");
Problem problem1 = new Problem();
problem1.setNumber(Integer.parseInt(strs[1]));
problem1.setName(strs[2]);
problem1.setAnswer(strs[3]);
problem[Integer.parseInt(strs[1]) - 1] = problem1;
}
Paper paper = new Paper(number,problem);
String str2 = in.next();
String str1 = str2.replaceAll("[#A:]","");
String[] strs1 = str1.split("\\s+");
String[] answer = new String[number];
for(int i = 0,j = 0;i < number;i++){
if(!strs1[i].equals("\\s+")){
answer[j]= strs1[i];
j++;
}
}
AnswerPaper answerPaper = new AnswerPaper(number,paper,answer);
answerPaper.checkAnswer();
answerPaper.showResult();
}
public static class AnswerPaper {
private int number;
private Paper paper;
private String[] answer = new String[number];
private boolean[] answerRight = new boolean[100];
public AnswerPaper(int number,Paper paper,String[] answer){
this.number = number;
this.answer = answer;
this.paper = paper;
//this.answerRight = answerRight;
}
public void setNumber(int number) {
this.number = number;
}
public int getNumber() {
return number;
}
public Paper getPaper() {
return paper;
}
public void setPaper(Paper paper) {
this.paper = paper;
}
public String[] getAnswer() {
return answer;
}
public void setAnswer(String[] answer) {
this.answer = answer;
}
public boolean[] getAnswerRight() {
return answerRight;
}
public void setAnswerRight(boolean[] answerRight) {
this.answerRight = answerRight;
}
public void checkAnswer(){
for(int i = 0;i < number;i++){
if(paper.getProblems()[i].isRight(answer[i])){
answerRight[i] = true;
}else{
answerRight[i] = false;
}
}
}
public void showResult(){
for(int i = 0;i < number;i++){
System.out.println(paper.getProblems()[i].getName() + "~" + answer[i]);
}
for(int i = 0;i < number;i++){
if(answerRight[i]){
System.out.print(true);
if(i != number - 1){
System.out.print(" ");
}
}else{
System.out.print(false);
if(i != number - 1){
System.out.print(" ");
}
}
}
}
}
public static class Paper {
private int number;
private Problem[] problems= new Problem[number];
public Paper(int number,Problem[] problems){
this.number = number;
this.problems = problems;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public void setProblems(Problem[] problems) {
this.problems = problems;
}
public Problem[] getProblems() {
return problems;
}
}
public static class Problem {
private int number;
private String name;
private String answer;
public Problem() {
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
public boolean isRight(String answer1) {
if (answer.equals(answer1)) {
return true;
} else {
return false;
}
}
}
}
设计：三个类，Problem类用于储存问题，Paper类用于储存试卷并且制造试卷，AnswerPaper类则是作为一个控制类对于试卷的判断对错。Main类进行输入。
分析：首先最大问题是用了内部类导致类的设计就出现了很大错误，对于这个错误来源于自己的对于java内部类的无知，在自己不明白的情况下使用idea的自动合并类功能，导致出现了内部类。其次，抛去内部类的问题回到自己的设计，学生答题系统，按照老师的提示设计了三个类（Problem，Paper,AnswerPaper),第一来源于Problem中的方法isRight，作为一个实体类，拥有了自己的判定方法，属实不合理，第二是实在AnswerPaper类中，也没有遵循单一职责原则，AnswerPaper出现了输出的方法，第三就是在Main类中的主函数中进行的输入操作。最后自己的对于变量名的使用，没有做到通俗易懂，导致了很多类中都属性混乱。
根据Sorcemontor的代码检测，
1.代码的深度（Avg Depth）过高，对于输入的处理用了过多的if语句输入保存，后期的输出以及题目的判定也用了过多的循环，以后有待解决。
2.代码注释较少，不利于阅读和修改
3.代码没有明显的逻辑错误。
第二次大作业最后一题
public class Main {
public static void main(String[] args) {
ProblemBank problemBank = new ProblemBank();
LinkedList<Paper> papers = new LinkedList<Paper>();
LinkedList<Answer> answers = new LinkedList<Answer>();
String[] strsT = new String[100];
String[] strs;
String[] strs1;
int count1 = 0;
Scanner in = new Scanner(System.in);
in.useDelimiter("\n");
String str = in.next();
int number = 0;
//输入阶段
while (!str.equals("end")) {
if (str.charAt(1) == 'N') {//题目输入
strs = str.split(" *#A: *| *#Q: *| *#N: *");
Problem problem = new Problem();
problem.setNumber(Integer.parseInt(strs[1]));
problem.setName(strs[2]);
problem.setAnswer(strs[3]);
problemBank.setProblems(problem);
str = in.next();
number++;
}
if (str.charAt(1) == 'T') {//分值、试卷输入
count1++;
strsT[count1] = str;
str = in.next();
}
if (str.charAt(1) == 'S') {//答案输入
Answer answer = new Answer();
strs = str.split(" *#S: *| *#A: *");
answer.setNumber(Integer.parseInt(strs[1]));
for(int i = 2;i < strs.length;i++){
answer.setAnswer(strs[i]);
}
answer.setCount(strs.length - 2);
answers.add(answer);
str = in.next();
}
}
//试卷组卷
for(int i = 1;i <= count1;i++){
strs = strsT[i].split( " *#T: *|[\\s+]");
Paper paper =new Paper();
paper.setNumber(Integer.parseInt(strs[1]));
for (int k = 2; k < strs.length; k++) {
strs1 = strs[k].split("-");
paper.setPoints(Integer.parseInt(strs1[0]), Integer.parseInt(strs1[1]));
paper.setTest(problemBank.getProblems()[Integer.parseInt(strs1[0])]);
}
paper.setCount(strs.length - 2);
papers.add(paper);
}
//输出
View view = new View();
for(int i = 0;i < papers.size();i++){
view.showPoints(papers.get(i));
}
view.showResults(papers,answers,number,problemBank);
}
}
class Paper {
private int number;//试卷号
private int[] points = new int[100];//各题的分数
private int count = 0;
Problem[] test = new Problem[100];//题目
public Paper() {
Arrays.fill(points, -1);
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public int[] getPoints() {
return points;
}
public void setPoints(int x, int point) {
points[count+1] = point;
}
public Problem[] getTest() {
return test;
}
public void setTest(Problem problem) {
count++;
test[count] = problem;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
class AnswerPaper {
private int number;//题目个数
private Paper paper = new Paper();//试卷
private ProblemBank problemBank;//题库
private Answer answer = new Answer();
private boolean[] answerRight = new boolean[100];
public AnswerPaper(int number, ProblemBank problemBank, Paper paper, Answer answer) {
this.number = number;
this.paper = paper;
this.problemBank = problemBank;
this.answer = answer;
}
public AnswerPaper() {
}
public void setNumber(int number) {
this.number = number;
}
public int getNumber() {
return number;
}
public Paper getPaper() {
return paper;
}
public void setPaper(Paper paper) {
this.paper = paper;
}
public void setAnswer(Answer answer) {
this.answer = answer;
}
public Answer getAnswer() {
return answer;
}
public int addPoints() {
int sum = 0;
for (int i = 1; i <= paper.getCount(); i++) {
if (answerRight[i]) {
sum += paper.getPoints()[i];
}
}
return sum;
}
public boolean[] checkAnswer() {
for (int i = 1; i <= paper.getCount(); i++) {
if (paper.getTest()[i].isRight(answer.getAnswer()[i])) {
answerRight[i] = true;
} else {
answerRight[i] = false;
}
}
return answerRight;
}
public void showResult() {
for (int i = 1; i <= paper.getCount(); i++) {
if(i <= answer.getCount()){
if (answerRight[i]) {
System.out.println(paper.getTest()[i].getName() + "~" + answer.getAnswer()[i] + "~" + true);
} else {
System.out.println(paper.getTest()[i].getName() + "~" + answer.getAnswer()[i] + "~" + false);
}
}else{
System.out.println("answer is null");
}
}
for (int i = 1; i <= paper.getCount(); i++) {
if (answerRight[i]) {
System.out.print(paper.getPoints()[i]);
} else {
System.out.print(0);
}
if (i != paper.getCount()) {
System.out.print(" ");
}
}
System.out.println("~" + addPoints());
}
}
class View {
public void showPoints(Paper paper){
int sum = 0;
for (int i = 1; i <= paper.getCount(); i++) {
if(paper.getPoints()[i] != -1){
sum += paper.getPoints()[i];
}
}
if (sum != 100) {
System.out.println("alert: full score of test paper" + paper.getNumber() + " is not 100 points");
}
}
public void showResults(LinkedList<Paper> papers,LinkedList<Answer> answers,int number,ProblemBank problemBank) {
for (int i = 0; i < answers.size(); i++) {
int count = 0;
for (int j = 0; j < papers.size(); j++) {
if (answers.get(i).getNumber() == papers.get(j).getNumber()) {
count++;
}
}
if (count == 0) {
System.out.println("The test paper number does not exist");
} else {
AnswerPaper answerPaper = new AnswerPaper(number, problemBank, papers.get(answers.get(i).getNumber() - 1), answers.get(i));
boolean[] answerRight = answerPaper.checkAnswer();
answerPaper.showResult();
}
}
}
}
class Answer {
private int number = 0;//答案号
private String[] answer = new String[100];//答案
private int count = 0;
public void Answer(){
}
public void setNumber(int number) {
this.number = number;
}
public int getNumber() {
return number;
}
public void setAnswer(String answer) {
count++;
this.answer[count] = answer;
}
public String[] getAnswer() {
return answer;
}
public void setCount(int count) {
this.count = count;
}
public int getCount() {
return count;
}
}
class Problem {
private int number;//题目号
private String name;//题目内容
private String answer;//标准答案
public Problem() {
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
public boolean isRight(String answer1) {
if (answer.equals(answer1)) {
return true;
} else {
return false;
}
}
}
class ProblemBank {
private int number;//题目数量
private Problem[] problems = new Problem[100];//题库
public ProblemBank() {
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public void setProblems(Problem problem) {
problems[problem.getNumber()] = problem;
}
public Problem[] getProblems() {
return problems;
}
}
设计：六个类。相较于第一次大作业中，增加三个类，首先是Answer类，用于储存考生的答案，其次是ProblemBank，担任题库，便于Paper的组卷，最后是Paper,用于组卷，形成一张试卷。
分析：从代码中可以看出，第二次pta相较于第一次没有内部类的大问题，同时单独写了一个view输出类，相较于第一次三个类也增加了几个类，但是从类图中可见，自己的设计的类十分混乱，基本上就是写到哪个类就直接就调用另一个类，基本没有设计的地方，第一次接触如此多类图，不免慌乱。其次是在Main类中，它不仅充当了一个输入类还担任着控制类的角色，最后是对于ProblemBank类的设计错误，写完细看，其实这个类是多余的，想制造题库，直接使用数组即可，不用额外增加其他类。
根据Sorcemontor的代码检测：
1.本次代码在提前之前对于期间逻辑进行了优化，所以复杂度以及深度都有所缓解，没有上次那么严重。
2.在增加了3个类，增加更多需求的情况下，注释比上次接近，不利于阅读以及修改
第三次大作业最后一题
import java.util.*;
public class Main {
public static void main(String[] args){
Input input = new Input();
RewindingSystem rewindingSystem = new RewindingSystem();
ArrayList<Test> tests = new ArrayList<>();
int[] isRights = new int[100];
RollSystem rollSystem = new RollSystem();
View view = new View();
input.begin();//开始输入
tests = rollSystem.begin(input.getTestMessages(),input.getProblems());//组卷
for(int i = 0;i < tests.size();i++){
view.showSum(tests.get(i));
}
for(int i = 0;i < input.getAnswers().size();i++){
int count = 0;
for(int j = 0;j <tests.size();j++){
if(input.getAnswers().get(i).getNumber() == tests.get(j).getNumber()){
isRights = rewindingSystem.begin(tests.get(j),input.getAnswers().get(i),input.getNumber());
view.showResult(tests.get(j),isRights,input.getAnswers().get(i),input.getStudents());
count++;
}
}
if(count == 0){
System.out.println("The test paper number does not exist");
}
}
}
}
class Answer {
private int number;
private String studentName;
private String[] answer = new String[100];
ArrayList<String> answers = new ArrayList<>();
ArrayList<Integer> answerNumbers = new ArrayList<>();
private String id = new String();
public Answer(){
}
public Answer(int number,String name,int n,String studentName){
this.number = number;
answers.add(name);
answerNumbers.add(n);
this.studentName = studentName;
}
public String[] getAnswer() {
return answer;
}
public void setAnswer(String answer,int x) {
this.answer[x] = answer;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public void setAnswers(String answer) {
answers.add(answer);
}
public ArrayList<String> getAnswers() {
return answers;
}
public void setAnswerNumbers(int answerNumber) {
answerNumbers.add(answerNumber);
}
public ArrayList<Integer> getAnswerNumbers() {
return answerNumbers;
}
public int getNumber() {
return number;
}
public void setNumber(int number){
this.number = number;
}
}
class Input {
Problem[] problems = new Problem[100];//题库
ArrayList<Student> students = new ArrayList<>();//考生们
ArrayList<Answer> answers = new ArrayList<>();//考生答案库
ArrayList<String> testMessages = new ArrayList<>();//组卷相关要求信息
ArrayList<String> answerMessages = new ArrayList<>();//答案相关要求信息
int number;//删除题目的题号
public void begin(){
//输入前准备
Scanner in = new Scanner(System.in);
in.useDelimiter("\n");
String message = in.next();
while(!message.equals("end")){
//题库组建
if(checkWrong(message)) {
if (message.charAt(1) == 'N') {
String[] messages1 = message.split(" *#A: *| #Q:|#N:");
Problem problem = new Problem();
problem.setName(Integer.parseInt(messages1[1]), messages1[2]);
if(messages1.length != 4){
problem.setStandardAnswer("");
}else{
messages1[3]=messages1[3].replaceAll("\\s+$","");
//System.out.println(messages1[3]);
problem.setStandardAnswer(messages1[3]);
}
problems[Integer.parseInt(messages1[1])] = problem;
message = in.next();
}
}else {
System.out.println("wrong format:" + message);
message = in.next();
}
//分数信息保存，为后续组卷做好准备
if(checkWrong(message)) {
if(message.charAt(1) == 'T'){
testMessages.add(message);
message = in.next();
}
}else {
System.out.println("wrong format:" + message);
message = in.next();
}
//考生组建
if(checkWrong(message)) {
if(message.charAt(1) == 'X'){
String[] messages = message.split(" |#X:|-");
for(int i = 1;i < messages.length;i += 2){
Student student = new Student(messages[i+1],messages[i]);
students.add(student);
}
message = in.next();
}
}else {
System.out.println("wrong format:" + message);
message = in.next();
}
//答案库组建
if(checkWrong(message)) {
if(message.charAt(1) == 'S'){
answerMessages.add(message);
message = in.next();
}
}else {
System.out.println("wrong format:" + message);
message = in.next();
}
//接收删除题目题号
if(checkWrong(message)) {
if(message.charAt(1) == 'D') {
String[] messages = message.split("#D:N-");
number = Integer.parseInt(messages[1]);
message = in.next();
}
}else {
System.out.println("wrong format:" + message);
message = in.next();
}
}
answers = rollSystemAnswers(answerMessages);
}
public boolean checkWrong(String message){
String regex1 = "#N:\\d+ #Q:(.+) #A:(.+)*";
String regex2 = "^#T:\\d+( \\d+-\\d+)*";
String regex3 = "#X:\\d+(\\w+ \\w+)+(-\\w+ \\w+)*";
String regex4 = "#S:\\d+ \\w+( #A:\\w+-(.*)*)*";
String regex5 = "#D:N-\\d+";
if(message.matches(regex1)){
return true;
}else if(message.matches(regex2)){
return true;
}else if(message.matches(regex3)){
return true;
}else if(message.matches(regex4)){
return true;
}else if(message.matches(regex5)){
return true;
}else if(message.equals("end")){
return true;
}else{
return false;
}
}
public ArrayList<Answer> rollSystemAnswers(ArrayList<String> answerMessages){
ArrayList<Answer> answers = new ArrayList<>();
for(int i = 0;i < answerMessages.size();i++){
String[] messages = answerMessages.get(i).split("#S:| *#A:|[-]");
Answer answer = new Answer();
String[] messages1 = messages[1].split(" ");
answer.setNumber(Integer.parseInt(messages1[0]));
answer.setId(messages1[1]);
for(int j = 2;j < messages.length;j = j+2){
answer.setAnswers(messages[j+1]);
answer.setAnswerNumbers(Integer.parseInt(messages[j]));
answer.setAnswer(messages[j+1],Integer.parseInt(messages[j]));
}
answers.add(answer);
}
return answers;
}
public int getNumber() {
return number;
}
public Problem[] getProblems() {
return problems;
}
public ArrayList<Answer> getAnswers() {
return answers;
}
public ArrayList<String> getTestMessages() {
return testMessages;
}
public ArrayList<Student> getStudents() {
return students;
}
}
class Problem {
//题目号和题目连接
HashMap<Integer,String> name = new HashMap<>();
//标准答案
private String standardAnswer;
public Problem() {
}
public HashMap<Integer, String> getName() {
return name;
}
public void setName(int number,String name) {
this.name.put(number,name);
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
}
class RewindingSystem {
public int[] begin(Test test,Answer answer,int number){
int[] isRight = new int[100];
Arrays.fill(isRight,0);
for(int i = 0;i < test.problemNumber.size();i++){
if(checkNull(i+1,answer)){
if(test.getProblems()[test.problemNumber.get(i)] != null){
if(test.problemNumber.get(i) != number){
if(test.getProblems()[test.getProblemNumber().get(i)].getStandardAnswer().equals(answer.getAnswer()[i+1])){
isRight[i+1] = 1;
}else{
isRight[i+1] = 0;
}
}else{
isRight[i+1] = 2;
}
}else{
isRight[i+1] = 3;
}
}else{
isRight[i+1] = 4;
}
}
return isRight;
}
public boolean checkNull(int number,Answer answer){
for(int i = 0;i < answer.getAnswers().size();i++){
if(number == answer.getAnswerNumbers().get(i)){
return true;
}
}
return false;
}
}
class RollSystem {
public ArrayList<Test> begin(ArrayList<String> testMessages,Problem[] problems){
ArrayList<Test> tests = new ArrayList<>();
for(int i = 0;i < testMessages.size();i++){
Test test = new Test();
String[] messages1 = testMessages.get(i).split("#T:|\\s");
test.setNumber(Integer.parseInt(messages1[1]));
int count = 0;
for(int j = 2;j < messages1.length;j++){
String[] messages2 = messages1[j].split("-");
test.setProblems(problems[Integer.parseInt(messages2[0])],Integer.parseInt(messages2[0]));
test.setPoints(Integer.parseInt(messages2[1]),Integer.parseInt(messages2[0]));
test.setPointsA(Integer.parseInt(messages2[1]));
test.setProblemNumber(Integer.parseInt(messages2[0]));
count++;
}
test.setCount(count);
tests.add(test);
}
return tests;
}
}
class Student {
private String name;
private String id;
public Student(){
}
public Student(String name,String id){
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
class Test {
int number = 0;
Problem[] problems = new Problem[100];
ArrayList<Integer> problemNumber = new ArrayList<>();
ArrayList<Integer> pointsA = new ArrayList<>();
int[] points = new int[100];
private int count = 0;//题目数量
public int getCount() {
return count;
}
public ArrayList<Integer> getPointsA() {
return pointsA;
}
public void setPointsA(int point) {
this.pointsA.add(point);
}
public ArrayList<Integer> getProblemNumber() {
return problemNumber;
}
public void setProblemNumber(int number) {
this.problemNumber.add(number);
}
public void setCount(int count) {
this.count = count;
}
public Test(){
Arrays.fill(points,0);
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public void setProblems(Problem problem,int x) {
problems[x] = problem;
}
public Problem[] getProblems() {
return problems;
}
public void setPoints(int point,int x) {
points[x] = point;
}
public int[] getPoints() {
return points;
}
public int getSum(){
int sum = 0;
for(int i = 0;i < points.length;i++){
sum += points[i];
}
return sum;
}
}
class View {
public void showSum(Test test){
if(test.getSum() != 100){
System.out.println("alert: full score of test paper" + test.getNumber() + " is not 100 points");
}
}
public void showResult(Test test,int[] isRight,Answer answer,ArrayList<Student> students){
for(int i = 0;i < test.getCount();i++) {
if(isRight[i+1] == 4){
System.out.println("answer is null");
}else{
if(isRight[i+1] == 3){
System.out.println("non-existent question~0");
}else{
if(isRight[i+1] == 2){
System.out.println("the question " + test.getProblemNumber().get(i) + " invalid~0");
}else{
if(isRight[i+1] == 1){
System.out.println(test.getProblems()[test.problemNumber.get(i)].getName().get(test.problemNumber.get(i)) + "~" + answer.getAnswer()[i+1]+ "~true");
}else{
System.out.println(test.getProblems()[test.problemNumber.get(i)].getName().get(test.problemNumber.get(i)) + "~" + answer.getAnswer()[i+1]+ "~false");
}
}
}
}
}
if(findStudent(students,answer) == null){
System.out.println(answer.getId() + " not found");
}else{
System.out.print(findStudent(students,answer).getId() + " " + findStudent(students,answer).getName() + ": ");
int sum = 0;
for(int i = 0;i < test.getCount();i++){
if(isRight[i+1] == 1){
System.out.print(test.getPointsA().get(i));
sum += test.getPointsA().get(i);
}else {
System.out.print("0");
}
if(i != test.getCount()-1){
System.out.print(" ");
}else{
System.out.print("~");
System.out.println(sum);
}
}
}
}
public Student findStudent(ArrayList<Student> students,Answer answer){
for(int i = 0;i < students.size();i++){
if(students.get(i).getId().equals(answer.getId())){
return students.get(i);
}
}
return null;
}
}
设计：本次较于前两次代码进行重构，一共九个类，首先Main类用于调用其他类的方法，Input类进行输入以及输入的处理，通过Input产生三个类（Student类，Answer类，Problem类），对于第二次大作业的思考，将ProblemBank类改成Problem的数组，通过RollSystem（组卷系统）将Test类建立，之后通过RewingdingSystem（改卷系统）进行答案的判定算分，最后交给View输出。
分析：本次较于前两次类设计比较合理，该有的实体类都有，Main中也没有了输入处理，也有专门的类用来输出。不过，后面通过思考，组卷系统和改卷系统两个控制类可以合成一个控制类，对于其他实体类进行控制。但是，本次代码虽然可以过测试点，但是后期自己使用时出现bug，有一些情况并没有考虑进去，这个有待改进。
根据Sorcemontor的代码检测：
1.题目输入情况和判定的增加，复杂度有所增加
2.类相比于前两次增加较多
3.逻辑较为清晰，代码行数也增加较多。
踩坑心得
1.在第一次大作业中第四题，由于本题来自第三题的迭代，因此还是按照第三题的思路去写，导致未看清题目中要求使用成绩类，最后快要写完了重构代码
2.在第一次大作业的最后一题中，因为正则表达式的陌生，导致自己使用split时无法切割出正确的部分，输出出现多空格或者少空格的情况，导致答案出现格式错误或者非零返回
3.在第一次大作业中，误用IDEA的合并类功能导致出现内部类问题，与原定类设计大相径庭。
4.在第二次大作业的最后一题中，一直认为正则表达式有无[]切割出来的部分是差不多的，乱用[]导致有些答案非零返回，数组越界
5.在第二次大作业的最后一题中，未考虑到题目可以在试卷#S后输入，导致题库没有这题，最后试卷中没有该题，导致数组越界，答案错误。
6.第三次大作业第三题中，未看清题目，未考虑两个日期相等的情况，原本输出合法的情况输出成不合法。
7.第三次大作业第三题中，未看清题目（实则自己逞强要手打输出），导致最后输出多了一个“的”字，调试代码时死活觉得是自己逻辑问题导致耗时巨大（苦笑）。
8.第三次大作业最后一题中，开始沿用第二次混乱的代码，（嘴硬）相信自己的在原来代码基础上解决问题，最终耗费一整天的时间遇到某个问题因为类的设计无法改变仅得了42分
9.第三次大作业最后一题中，本次最后一题要考虑输入WrongFormat的问题，开始投机取巧使用try-catch导致测试点过不去
10.第三次大作业最后一题中，未仔细看题，借助对于第二次大作业的记忆做题，弄混#S中顺序号和#T中的题号，答案错误
11.第三次大作业最后一题中，本题考察点我认为只有两个，当确定逻辑没有问题后，那肯定是正则表达式的错误，测无数个测试点后（我哭死呜呜呜），发现#N的正则表达式少切割了一些空格，#S的正则表达式多切了一些空格，导致了空字符答案以及最后的混合输入测试点答案错误
改进建议
1.三次大作业中前两次都是没有进行类的设计，都是边写变思考，导致类间关系混乱。以后对于问题的解决第一步应该是对于类的设计，而不是直接coding。
2.注释偏少，在代码出现问题是，多个类中都有类似的变量名，没有注释导致修改困难，同时对于其他人提出建议也将会有障碍。以后得好好写注释，利己利他。
3.正则表达式学的不够透彻，自己的写的正则表达式无法实际的处理问题，同时自己的正则表达式不能做到通用，只能在局部起作用。应该透彻学习正则表达式。
4.代码仍出现bug，应该及时解决，防止下次花大量时间修改。
5.很多方法有必要存在，但是放在不适合的类中，导致类无法实现单一职责原则。以后设计类时方法也要好好设计，不能胡乱放进类中
总结
1.首先自己的编码规范，自己的注释偏少，并且英语水平不太行，导致自己的变量名类名晦涩难懂并且极其草率，以后自己使用IDEA的插件，好好纠正自己的问题
2.MVC模式的使用让我们框架更加合理，Main仅用于其他类的调用让逻辑清晰，单一职责原则让类的耦合性降低便于调试。
3.Good design comes first！设计比写代码更重要，好的设计可以少走很多弯路。
4.正则表达式是一个很强大的工具，对于字符串是一大利器，无论是split还是replaceAll都让代码更加简短且效率。
5.有的时候ArrayList和LinkedList比单纯的数组好用，特别是对于没有固定长度的数组。