OO前三次大作业总结
一、前言
在这三次大作业中，我们学习了设计类，使用类和对象，类与类之间的关联，类的封装，正则表达式的使用，并且通过题目的练习，慢慢了解到了面向对象的思想。
第一次大作业中一共有五道题目，都是最为基础的内容，包含类的设计，类和对象的使用，以及类的关联。难度：简单，使我们更好的适应了Java中面向对现象的思想。
第二次大作业中一共有四道题目，难度在第一次大作业的基础上更上一层，其中包含封装类的设计思想，以及如何获取或修改封装类中内容的方法设计。难度：中等。
第三次大作业中一共有三道题目，难度为三道题目中最大的题目，其中对于封装类的需求更高，并且使用的正则表达式的要求更高。难度：高
二、设计与分析
1.第一次大作业最后一题
第一次大作业最后一题源代码
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int size = input.nextInt();
input.nextLine();
String str = new String();
int i,j,index=0,k;
AnswerPaper[] answerPaper = new AnswerPaper[size];
Subject[] subjects = new Subject[size];
for(i=0;i<size;i++){
str = input.nextLine();
String[] info = str.split("#[N|Q|A]:");
for(j=0;j<info.length;j++) info[j] = info[j].trim();
subjects[i] = new Subject();
subjects[i].setSubject(Integer.parseInt(info[1]),info[2],info[3]);
answerPaper[i] = new AnswerPaper(Integer.parseInt(info[1]), info[2]);
}
str = input.nextLine();
for(i=0;i<size;i++){
String[] answer = str.split("#A:");
for(j=0;j<size;j++) {
for(k=0;k<size;k++){
if(answerPaper[k].getNum() == j+1)
answerPaper[k].setAnswer(answer[j+1].trim());
}
}
}
for(i=0;i<size;i++){
for(j=0;j<size;j++){
if(answerPaper[i].getNum() == subjects[j].getNumber()){
answerPaper[i].setCheck(subjects[j].getAnswer());
}
}
}
String none = input.next();
for(i=0;i<size;i++){
for(j=0;j<size;j++) if(i+1 == answerPaper[j].getNum()) index = j;
System.out.println(answerPaper[index].questionAnswerToString());
}
for(i=0;i<size;i++) {
for(j=0;j<size;j++) if(i+1 == answerPaper[j].getNum()) index = j;
System.out.print(answerPaper[index].getcheck() );
if(i!=size-1) System.out.print(" ");
}
}
}
class Subject{
private int number;
private String question,answer;
public Subject(){
}
public Subject(int num,String questions,String answers){
this.answer = answers;
this.number = num;
this.question = questions;
}
void setSubject(int num,String questions,String answers){
this.answer = answers;
this.number = num;
this.question = questions;
}
String getQuestion(){
return question;
}
String getAnswer(){
return answer;
}
int getNumber(){
return number;
}
}
class AnswerPaper{
private int num;
private String question,answer;
private boolean check;
public AnswerPaper(){
}
public AnswerPaper(int num,String question){
this.num = num;
this.question = question;
}
void setAnswer(String answer){
this.answer = answer;
}
void setCheck(String answer1){
this.check = answer1.equals(answer);
}
String questionAnswerToString(){
return question +"~" + answer;
}
boolean getcheck(){
return check;
}
int getNum(){
return num;
}
}类图：
本次练习题较为简单，因此类并未过多，我设计了两个类，主类就不必多说了。
一个是题目类，包含题目的题号，题目的编号，题目的问题和题目的标准答案，然后方法就是常见的修改对象的属性或者获取对象的属性。
第二个类是答卷类，包含答卷的中的题目编号，问题，答题者的答案，答案的正确与否，然后方法也是常见的修改属性或者获取属性。
在这次练习中，我逐渐理解了面向对象的思想，面向对象思想强调将问题或事情分离成各个对象，并且将各个对象的属性和方法抽象出来，就像是现实中各个职位的划分一样，将每个人的职位划分清晰，使一个庞大的工程中各个人物分给各个职位的人，使任务变得更加清晰，变得更加易于管理，这也是面向对象的好处，不过当然在这次练习题中，我对于类的划分并没有划分的很好。
2.第二次大作业最后一题
第二次大作业最后一题源代码
第二次大作业最后一题源代码
import java.util.LinkedList;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
LinkedList<TestPaper> testPaper = new LinkedList<>();
LinkedList<AnswerPaper> answerPapers = new LinkedList<>();
getTestPaperAndAnswerPaper(testPaper,answerPapers);
for(TestPaper temp: testPaper){
if(temp.getSumpark()!=100)
System.out.println("alert: full score of test paper" + temp.getName() + " is not 100 points");
}
for (int i = 0; i < answerPapers.size(); i++) {
boolean flag = false;
for(TestPaper temp:testPaper){
if(answerPapers.get(i).getName().equals(temp.getName())){
flag = true;
for(int j = 0;j <temp.getList().size(); j++){
if(answerPapers.get(i).getAnswer(j) != null) {
System.out.println(temp.getList().get(j).getQuestion() + "~" + answerPapers.get(i).getAnswer(j) + "~" + answerPapers.get(i).compareAnswer(temp.getList().get(j),j));
}
else System.out.println("answer is null");
}
for(int j = 0;j <temp.getList().size(); j++){
if(answerPapers.get(i).getAnswer(j) != null) {
if (answerPapers.get(i).compareAnswer(temp.getList().get(j), j))
System.out.print(temp.getList().get(j).getpark());
else System.out.print("0");
}
else System.out.print("0");
if(j == temp.getList().size()-1 ) System.out.print("~");
else System.out.print(" ");
}
System.out.println(answerPapers.get(i).getSumpark(temp.getList()));
}
}
if(!flag) System.out.println("The test paper number does not exist");
}
}
public static void getTestPaperAndAnswerPaper(LinkedList<TestPaper> testPaper,LinkedList<AnswerPaper> answerPapers){
Scanner input = new Scanner(System.in);
LinkedList<String> line =new LinkedList<>();
//获取所有键盘输入信息
while(!input.hasNext("end")){
line.add(input.nextLine());
}
//对输入信息进行排序，题目信息排在试卷前面，答题卡信息排在最后
for (int i = 0; i < line.size() - 1; i++) {
for (int j = 0; j < line.size() - 1; j++) {
if((line.get(j).contains("#N:")&&line.get(j+1).contains("#T:"))||
(line.get(j).contains("#S:")&&line.get(j+1).contains("#T:"))||
(line.get(j).contains("#S:")&&line.get(j+1).contains("#N:"))){
String temp = line.get(j);
line.set(j,line.get(j+1));
line.set(j + 1, temp);
}
}
}
for (int i = 0; i < line.size(); i++) {
if(line.get(i).contains("#T:")) testPaper.add(addTestPaper(line.get(i)));
if(line.get(i).contains("#N:")) addSubject(testPaper,line.get(i));
if(line.get(i).contains("#S:")) getAnswer(answerPapers,line.get(i));
}
}
public static TestPaper addTestPaper(String line){
TestPaper testPaper = new TestPaper();
String[] numAndPark = line.split(" ");
for(int i = 0; i < numAndPark.length; i++) {
if(numAndPark[i].contains("#T:")) {
String name = numAndPark[i].substring(numAndPark[i].indexOf("#T:")+3).trim();
testPaper.setName(name);
}
if(numAndPark[i].contains("-")) {
String[] strings = numAndPark[i].split("-");
testPaper.addSubject(Integer.parseInt(strings[0]));
testPaper.getSubjectsViaNum(Integer.parseInt(strings[0])).setStandardPark(Integer.parseInt(strings[1]));
}
}
testPaper.setSumpark();
return testPaper;
}
public static void addSubject(LinkedList<TestPaper> testPapers,String line){
String[] imformationOfQuestion= line.split("#[N|Q|A]:");
for(TestPaper temp: testPapers) {
if(temp.getSubjectsViaNum(Integer.parseInt(imformationOfQuestion[1].trim())) != null) {
temp.getSubjectsViaNum(Integer.parseInt(imformationOfQuestion[1].trim())).setSubject(imformationOfQuestion[2].trim(),imformationOfQuestion[3].trim());
}
}
}
public static void getAnswer(LinkedList<AnswerPaper> answerPapers ,String line){
String name = line.substring(line.indexOf("#S:")+3,line.indexOf("#A:")).trim();
String[] answers = line.substring(line.indexOf("#A:")+3).replace("#A:","").split(" ");
AnswerPaper answerPaper = new AnswerPaper(name);
for (int i = 0; i < answers.length; i++) {
answerPaper.addAnswer(answers[i]);
}
answerPapers.add(answerPaper);
}
}
class TestPaper{
private String name;
//用于记录试卷名称
private LinkedList<Subject> List = new LinkedList<>();
private int sumpark;
TestPaper() {
this.sumpark = 0;
}
TestPaper(String name) {
this.name = name;
this.sumpark = 0;
}
public TestPaper(String name,LinkedList<Subject> List ,int sumpark){
this.name = name;
this.List = List;
this.sumpark = sumpark;
}
LinkedList<Subject> getList() {
return List;
}
//通过题目编号获取题目
Subject getSubjectsViaNum(int sum){
for (Subject index: List) {
if(index.getNumber() == sum) return index;
}
return null;
}
void setSumpark(){
for(Subject temp: List){
this.sumpark += temp.getpark();
}
}
void setName(String name){
this.name = name;
}
void addSubject(Subject subject){
List.add(subject);
}
void addSubject(int num){
Subject subject = new Subject(num);
List.add(subject);
}
int getSumpark(){
return sumpark;
}
String getName() {
return name;
}
}
class Subject{
private int number;
//用于记录题目编号
private String question,standardAnswer;
//用于记录题目内容以及答案
private int Park;
//用于记录答题卡中该题目得分
public Subject(){
}
public Subject(int num){
this.number = num;
this.question = "NONE";
this.standardAnswer = "NONE";
}
void setSubject(int num,String questions,String answers){
this.standardAnswer = answers;
this.number = num;
this.question = questions;
}
Subject(int num,String questions,String standardAnswer,int standardPark,boolean check){
this.standardAnswer = standardAnswer;
this.number = num;
this.question = questions;
this.Park = standardPark;
}
void setSubject(String questions,String answers){
this.standardAnswer = answers;
this.question = questions;
}
String getQuestion(){
return question;
}
String getAnswer(){
return standardAnswer;
}
int getNumber(){
return number;
}
void setStandardPark(int standardPark) {
this.Park = standardPark;
}
private void compareAnswer(String testerAnswer) {
if(testerAnswer.equals(this.standardAnswer)) ;
}
int getpark() {
return Park;
}
}
//答题卡类
class AnswerPaper {
private String name;
private LinkedList<String> answer = new LinkedList<>();
public AnswerPaper(String name){
this.name= name;
}
LinkedList<String> getAnswerList() {
return this.answer;
}
String getAnswer(int index){
if(index >= answer.size()) return null;
else return answer.get(index);
}
void addAnswer(String answer){
this.answer.add(answer);
}
int getSumpark(LinkedList<Subject> subjects){
int sumpark =0;
for (int i = 0; i < subjects.size() && i < answer.size(); i++) {
if(compareAnswer(subjects.get(i),i)) sumpark +=subjects.get(i).getpark();
}
return sumpark;
}
String getName(){
return name;
}
boolean compareAnswer(Subject subject,int index){
return answer.get(index).equals(subject.getAnswer()) ;
}
}
类图：
本次的练习题目是在前一次的大作业最后一题的基础上增加了更多的内容，使题目的复杂度变得更高。
本次题目中除了主类之外，我设计了三个类。
一个是题目类，属性为题目编号，问题，标准答案，每题的分数，方法为常见的获取和修改属性，其中的compareAnswer方法是根据传参的答案信息对每个题目是否正确做判断。
一个是试卷类，属性为试卷编号，试卷总分，以及题目对象链表（用于储存题目信息），方法为常规的获取修改属性信息。
一个为答卷类，属性为答卷的编号，答案链表（用于储存输入的答案），方法为常规的获取修改属性信息。
主类中一个主方法，第二个是添加试卷对象和答卷对象的方法，第三个是将输入的字符串分割成正确的试卷信息并且返回试卷对象，第四个是将输入的字符串分割成正确的题目信息，并返回一个题目对象，第五个是在答卷对象链表中添加答卷信息。
这次练习后，我感到内容渐渐变难了，同时对于不同类之间的关联运用也不是很熟练，导致写的时候脑子里面经常感到有些混乱。
3.第三次大作业最后一题
第三次大作业最后一题源代码
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Exam exam = new Exam();
readImfomation(exam);
Print.printSumMark(exam);
Print.printAnswer(exam);
}
public static void readImfomation(Exam exam) {
Scanner input = new Scanner(System.in);
LinkedList<String> line =new LinkedList<>();
//获取所有键盘输入信息
while(!input.hasNext("end")) line.add(input.nextLine());
//录入信息
for (String s : line) {
if(!Compare.matchIsLegal(s)) continue;
if (s.contains("#T:")) exam.testPapers.add(Add.addTestPaper(s));
if (s.contains("#N:")) exam.subsjects.add(Add.addSubject(s));
if (s.contains("#S:")) exam.AnswerPapers.add(Add.addAnswerPaper(s));
if (s.contains("#X:")) Add.addStudent(s, exam.students);
if (s.contains("#D:")) Add.addDeletList(exam.delist, s);
}
Deli.deleteSubject(exam.delist,exam.subsjects);
Compare.subjectToTestPaper(exam.subsjects,exam.testPapers);
Compare.answerToStandardAnswer(exam.AnswerPapers,exam.testPapers);
Add.addStudentToAnswerPaper(exam.AnswerPapers,exam.students);
}
}
class Print {
static void printSumMark(Exam exam) {
for (TestPaper testPaper : exam.testPapers) {
if (testPaper.getMark() < 100)
System.out.println("alert: full score of test paper" + testPaper.getName() + " is not 100 points");
}
}
static void printAnswer(Exam exam){
LinkedList<AnswerPaper> answerPapers = exam.AnswerPapers;
LinkedList<TestPaper> testPapers = exam.testPapers;
for (int i = 0; i < answerPapers.size(); i++) {
int index = Compare.testPaperExist(answerPapers.get(i).getNameOfPaper(),testPapers);
if(index==-1) {
System.out.println("The test paper number does not exist");
continue;
}
if (answerPapers.get(i).getNameOfPaper().equals(testPapers.get(index).getName())) {
LinkedList<Subject> subjects = testPapers.get(index).getSubjects();
for(int k = 0;k<subjects.size() ;k++){
if(k>=answerPapers.get(i).getAnswers().size()/*||answerPapers.get(i).getAnswers().get(k).equals("NONE")*/){System.out.println("answer is null");continue;}
if(subjects.get(k).getQuestion().toString().equals("DELETED")) {
System.out.println("the question " + subjects.get(k).getNumber() + " invalid~0");
continue;
}
if(testPapers.get(index).getSubjects().get(k).getQuestion().toString().equals("NONE")) {
System.out.println("non-existent question~0");
continue;
}
boolean flag = true;
int j ;
for (j = 0; j < answerPapers.get(i).getNumbers().size(); j++) {
if(k+1==answerPapers.get(i).getNumbers().get(j)) {
System.out.println(subjects.get(k).getQuestion() + "~" + answerPapers.get(i).getAnswer(j) + "~" + answerPapers.get(i).getJudgement(j));
flag = false;
}
}
if(flag) System.out.println("non-existent question~" + answerPapers.get(i).getAnswer(j));
}
}
if(!Print.printStudent(exam,i)) continue;
Print.printMark(exam,index,i);
}
}
static void printMark(Exam exam,int index, int i) {
AnswerPaper answerPaper = exam.AnswerPapers.get(i);
TestPaper testPaper = exam.testPapers.get(index);
for(int j = 0;j <testPaper.getSubjects().size(); j++){
int key = answerPaper.indexOfNumber(j+1);
if(key==-1 ) System.out.print("0");
else if(answerPaper.getJudgement(key)) System.out.print(testPaper.getSubjects().get(j).getMark());
else System.out.print("0");
if (!(j == testPaper.getSubjects().size() - 1)) System.out.print(" ");
}
System.out.print("~");
System.out.println(answerPaper.getMark());
}
static boolean printStudent(Exam exam, int i) {
LinkedList<AnswerPaper> answerPapers = exam.AnswerPapers;
if(answerPapers.get(i).getStudent()!=null)
System.out.print(answerPapers.get(i).getStudent().getName() + " " + answerPapers.get(i).getStudent().getID() + ": ");
else {
System.out.println(answerPapers.get(i).getID() + " not found");
return false;
}
return true;
}
}
class Add{
static TestPaper addTestPaper(String line){
TestPaper testPaper = new TestPaper();
String[] numAndPark = line.split(" ");
for (String s : numAndPark) {
if (s.contains("#T:")) {
String name = s.substring(s.indexOf("#T:") + 3).trim();
testPaper.setName(name);
}
if (s.contains("-")) {
String[] strings = s.split("-");
Subject subject = new Subject(Integer.parseInt(strings[0]));
testPaper.addSubjects(subject);
testPaper.getSubjectsViaNum(Integer.parseInt(strings[0])).setMark(Integer.parseInt(strings[1]));
}
}
testPaper.setMark();
return testPaper;
}
//添加答卷，返回答卷类
static AnswerPaper addAnswerPaper(String line){
String[] nameAndID;
AnswerPaper answerPaper;
if(line.indexOf("#A:") != -1) {
nameAndID = line.substring(line.indexOf("#S:")+3,line.indexOf("#A:")).trim().split(" ");
String name = nameAndID[0].trim();
String ID = nameAndID[1].trim();
String[] answers = line.substring(line.indexOf("#A:")+3).replace("#A:","").split(" ");
answerPaper = new AnswerPaper(name,ID);
for (String answer : answers) {
String[] str = answer.split("-");
answerPaper.add(Integer.parseInt(str[0].trim()),str.length>1? str[1].trim():"");
}
}
else {
nameAndID = line.substring(line.indexOf("#S:")+3).trim().split(" ");
String name = nameAndID[0].trim();
String ID = nameAndID[1].trim();
answerPaper = new AnswerPaper(name,ID);
}
return answerPaper;
}
static void addStudentToAnswerPaper(LinkedList<AnswerPaper> answerPapers, HashMap<String, Student> Students) {
for(AnswerPaper answerPaper:answerPapers){
answerPaper.setStudent(Students.get(answerPaper.getID()));
}
}
static void addStudent(String line, HashMap<String, Student> students){
String[] nameAndID = line.substring(line.indexOf("#X:")+3).split("-");
for (String s : nameAndID) {
String[] name = s.split(" ");
students.put(name[0].trim(), new Student(name[0], name[1]));
}
}
static Subject addSubject(String line){
String[] imformationOfQuestion= line.split("#[N|Q|A]:");
return new Subject(Integer.parseInt(imformationOfQuestion[1].trim()),new StringBuilder(imformationOfQuestion[2].trim()),imformationOfQuestion.length>3?imformationOfQuestion[3].trim():"");
}
static void addDeletList(LinkedList<Integer> delist,String line){
String string = line.substring(line.indexOf("#D:") + 3);
String[] num = string.split(" ");
for (String s : num) {
delist.add(Integer.parseInt(s.substring(s.indexOf("-") + 1).trim()));
}
}
}
class Compare{
static void answerToStandardAnswer(LinkedList<AnswerPaper> answerPapers, LinkedList<TestPaper> testPapers){
for (AnswerPaper answerPaper : answerPapers) {
for (TestPaper testPaper : testPapers) {
if (answerPaper.getNameOfPaper().equals(testPaper.getName())) {
LinkedList<Subject> subjects = testPaper.getSubjects();
for(int k=0;k<answerPaper.getNumbers().size();k++){
for(int i=0;i<testPaper.getSubjects().size();i++){
if(answerPaper.getNumbers().get(k)== i+1){
if(subjects.get(i)!=null && !subjects.get(i).getQuestion().toString().equals("NONE") &&
!subjects.get(i).getQuestion().toString().equals("DELETED") &&
subjects.get(i).getAnswer().equals(answerPaper.getAnswer(k))) {
answerPaper.addJudgement(true, subjects.get(i));
}
else answerPaper.addJudgement(false, null);
}
}
}
}
}
}
}
static boolean matchIsLegal(String s){
if (!(s.matches("#N:\\d+ #Q:.* #A:.*") ||s.matches("#T:\\d+ ?(\\d+-\\d+ ?)*")
|| s.matches("#X:(\\d+ \\w+[-| ]?)*") || s.matches("#S:(\\w+ \\d* ?)?(#A:\\w*-[^-| ]* *)*")
|| s.matches("#D:(N-\\d* ?)*"))){
System.out.println("wrong format:" + s);
return false;
}
return true;
}
static int testPaperExist(String nameOfPaper, LinkedList<TestPaper> testPapers){
for(int i = 0; i < testPapers.size(); i++){
if(testPapers.get(i).getName().equals(nameOfPaper)){
return i;
}
}
return -1;
}
static void subjectToTestPaper(LinkedList<Subject> subjects, LinkedList<TestPaper> testPaper){
for(TestPaper temp:testPaper){
for(int j = 0;j<temp.getSubjects().size();j++) {
Subject subject = temp.getSubjects().get(j);
for (int i = 0; i < subjects.size() && i < temp.getSubjects().size(); i++) {
if (subjects.get(i).getNumber() == subject.getNumber()) {
subjects.get(i).setMark(temp.getSubjects().get(j).getMark());
temp.getSubjects().set(j, subjects.get(i));
}
}
}
}
}
}
class Exam {
LinkedList<Subject> subsjects;
HashMap<String,Student> students;
LinkedList<AnswerPaper> AnswerPapers;
LinkedList<Integer> delist;
LinkedList<TestPaper> testPapers;
Exam(){
subsjects = new LinkedList<>();
students = new HashMap<>();
AnswerPapers = new LinkedList<>();
delist = new LinkedList<>();
testPapers = new LinkedList<>();
}
}
class Student{
private String name;
private String ID;
public Student(String name, String ID){
this.name = name;
this.ID = ID;
}
String getName(){
return this.name;
}
String getID(){
return this.ID;
}
void setName(String name){
this.name = name;
}
void setID(String ID){
this.ID = ID;
}
}
class TestPaper{
private String name;
private int mark;
private final LinkedList<Subject> subjects = new LinkedList<>();
public TestPaper(String name){
this.name = name;
mark = 0;
}
public TestPaper() {
}
String getName(){
return this.name;
}
void setName(String name){
this.name = name;
}
void addSubjects(Subject subject){
subjects.add(subject);
}
int getMark(){
return this.mark;
}
void setMark() {
for (Subject subject : subjects) {
mark += subject.getMark();
}
}
String getAnswer(int index){
return subjects.get(index).getAnswer();
}
Subject getSubjectsViaNum(int number) {
for (Subject subject : subjects) if (subject.getNumber() == number) return subject;
return null;
}
LinkedList<Subject> getSubjects() {
return subjects;
}
}
class Subject{
private int number;
private StringBuilder question;
String answer;
private int mark;
Subject(int number, StringBuilder question, String answer){
this.number = number;
this.question = question;
this.answer = answer;
mark = 0;
}
Subject(int number){
this.number = number;
this.question = new StringBuilder("NONE");
this.answer = "NONE";
mark = 0;
}
StringBuilder getQuestion(){
return question;
}
String getAnswer(){
return answer;
}
int getNumber(){
return number;
}
int getMark(){
return mark;
}
void setQuestion(StringBuilder question){
this.question = question;
}
void setAnswer(String answer) {
this.answer = answer ;
}
void setNumber(int number){
this.number = number;
}
void setMark(int mark){
this.mark = mark;
}
}
class AnswerPaper {
private Student student;
private final String nameOfPaper;
private String ID;
private LinkedList<Integer> numbers;
private LinkedList<String> answers;
private LinkedList<Boolean> judgements;
private int Mark;
public AnswerPaper(String nameOfPaper, Student student){
this.nameOfPaper = nameOfPaper;
this.student = student;
answers = new LinkedList<>();
judgements = new LinkedList<>();
numbers = new LinkedList<>();
Mark = 0;
}
public AnswerPaper(String nameOfPaper,String ID){
this.nameOfPaper = nameOfPaper;
answers = new LinkedList<>();
judgements = new LinkedList<>();
numbers = new LinkedList<>();
this.ID = ID;
}
void setStudent(Student student){
this.student = student;
}
void addMark(int mark){
this.Mark += mark;
}
void add(int number,String answer){
numbers.add(number);
addAnswer(answer);
}
void addAnswer(String answer){
answers.add(answer);
}
void addJudgement(Boolean judgement,Subject subject){
judgements.add(judgement);
if(subject == null) addMark(0);
else addMark(subject.getMark());
}
String getNameOfPaper(){
return nameOfPaper;
}
LinkedList<String> getAnswers(){
return answers;
}
LinkedList<Boolean> getJudgements(){
return judgements;
}
boolean getJudgement(int index){
if(index>=judgements.size()) return false;
return judgements.get(index);
}
String getAnswer(int index){
return answers.get(index);
}
int getMark(){
return this.Mark;
}
int indexOfNumber(int number){
for (int i = 0; i < numbers.size(); i++) {
if(numbers.get(i) == number) return i;
}
return -1;
}
LinkedList<Integer> getNumbers(){
return numbers;
}
String getID(){
return ID;
}
Student getStudent(){
return student;
}
}
class Deli{
static void deleteSubject(LinkedList<Integer> delist, LinkedList<Subject> subjects) {
for (int j = 0; j < delist.size(); j++) {
for (int i = 0; i < subjects.size(); i++) {
if (subjects.get(i).getNumber() == delist.get(j)) {
subjects.get(i).getQuestion().replace(0, subjects.get(i).getQuestion().length(), "DELETED");
}
}
}
}
}类图：
本次的练习题难度最大，不论是题目的复杂度还是题目的要求都比之前的高，而这次的题目中我进行了大量的修改，除了主类外，我设计了九个类。
一个是题目类，一个是试卷类，一个是答卷类，这几个类和前面几题中的类的内容都大致相同，不过我把题目类中的问题这一个属性的类型从String类修改为了StringBuilder类，因为题目中添加了删除题目信息这一个功能，而在输出部分又要识别到题目是否属于删除的题目，所以我修改了问题的类型，在对题目做出删除之后将问题的内容改为DELETED用于区分已删除和未被删除题目。
另外的六个类分别为：一个比较类，用于匹配和比较。一个是输出类，用于输出信息。一个是学生类，用于存储学生信息。一个是添加类，用于添加试卷，题目，答卷，学生，需要删除的题目信息。一个是考试类，用于储存几个存储信息的类。一个是删除类，用于删除题目。
主类中除了主方法外，另一个方法是读取控制台输入的信息。
这次题目难度上升很大，花费了不少时间才做完，同时为了使类的区分更加精细，我把之前写的大部分功能未区分开的内容划分出来，并且规划到了不同的类中。
三、踩坑心得
第一次大作业
这次大作业还算挺轻松的，几道题目都是一次提交过的。但是我当时写的时候应该多多考虑到类的设计，应该再添加上试卷类，用于保存题目，这样也利于后面大作业的修改与添加。
第二次大作业
这次大作业就没有那么幸运了，提交了8，9次才成功满分，在几次的提交之后，仍然有最后一个测试点过不去，经过多次的测试和思考后才发现是输出的顺序和题目的要求不一样，题目原本的输出要求是要按照答卷的输入顺序输出每张答卷的情况，而我写出来的代码是在遇到无效的试卷号的情况下的时候，把无效的试卷号的信息输出在所有的答卷信息之后的，所以一直和题目要求的结果不相同，在多次尝试提交后我发现了这一点，然后进行修改之后才成功全对。
这一次大作业要求相比第一次大作业要求就提高了不少，我应该读清楚题目的要求并写出符合题目要求的代码。
第三次大作业
这次的大作业就更是惨不忍睹了，多次提交之后都只能拿到91分，首先是输入信息的格式问题，有两个测试点多次没有过去，但在对正则表达式做出了较大改变之后才成功过了这两个测试点。
最初的时候我写的正则表达式是这样的
s.matches("#N:.*#Q:.*#A:.*") || s.matches("#T:.*[\\-.*]*")|| s.matches("#X:.*[\\-.*]*") || s.matches("#S:.*[#A:.*]*")|| s.matches("#D:.*[N\\-.*]*"))
然后进行修改之后
s.matches("#N:\\d+ #Q:.* #A:.*") ||s.matches("#T:\\d+ ?(\\d*-\\d* ?)*") || s.matches("#X:(\\d+ \\w+[-| ]?)*") || s.matches("#S:(\\w+ \\d* ?)?(#A:\\w*-[^-| ]* *)*")
|| s.matches("#D:(N-\\d* ?)*")))
才成功突破这两个测试点。这次修改我增加了对于格式的限制，比如用\\d或\\w替代'.'使得格式匹配更加标准。
然后就是有几个一直过不去的测试点都是答案数据乱序输入的测试点，我在根据题目意思修改输出方式之后，仍然过不了。但我觉得有可能是匹配正则表达式部分错误导致的，因为，其中有一个测试点在最初修改完正则表达式之后从原本正确变成错误的，然后有几个测试点结果为非零返回，我认为因为在分割出答案部分数据的时候分割不正确导致的，就假设出现了”#S2 20201103 #A:1-5 #A2-4“但是正则表达式没匹配到该错误格式的信息然后分割时分割成了”S2 ”这种情况导致使用Integer.parseInt( )方法时因为含有非数字类信息导致系统抛出了错误 ( 当然这个举例只是假设,实际程序中我已经排除了这种情况 ) ，这也有可能是因为正则表达式匹配的时候未把错误格式的信息排除在外导致其进入了后续切割信息的部分导致切割后信息处理错误导致程序抛出了错误。
不过在这次题目中,因为对于多种对象的操作不够熟练导致我在写的时候经常脑子有些混乱,思路不够清晰，这同时也应该也有我设计类中方法的不够简洁的原因。
我认为我以后应该在正则表达式的学习上更加精进一些，以便更加熟练的使用正则表达式。同时应该多多练习学会对多种不同类的对象进行操作。
四、改进建议
第一次大作业
这次大作业中有很多测试点都是没有给出测试提示的，虽然题目不难，但我觉得给出测试点提示后能让更多人根据提示明白自己出错在哪里，并且做出一定的修改。
第二次大作业
我觉得可以再给多一些测试样例给我们测试程序用，这样可以更多的提高我们的正确率。
第三次大作业
我觉得应该给出更多的测试样例，因为这种类型题目本身对于输出信息的要求比较高，我觉得有时候我们不少人其实写出来的程序其实已经符合题目的要求了，但是因为输出的格式和题目所要求的不一样而错，就假设一个例子吧，要输出的是“20201103 Tom: ~0”但是我们因为思路不同输出的可能是“20201103 Tom: “这是因为答卷中没有答卷信息时输出的答卷成绩信息，前一个在没有答案信息的时候还是输出了总分，但后一个因为没有答案信息所以没有输出总分，这其实从本质上我们其实写出的代码逻辑上应该也是对的，但是在输出上不一样导致了测试点错误。所以我认为应该多设置一些测试样例用来规范我们的输出格式的标准型，毕竟这种类型的题目还是偏向于信息输出的部分，而并非那种更看重运算过程的算法类题目，算法类题目在输出格式要求上不高，但是我们这种题目在输出格式上要求格式上要求更高一些，所以我认为以后的题目中，可以设置更多不同的测试样例用以规范我们的输出格式。
五、总结
从这三次练习题中我学到了类的设计，类的封装，类的关联，面向对象的思想，同时对链表类的使用更加熟练，对正则表达式的使用更加熟练。
我认为在接下来的学习中，我应该更加加深对Java的学习，比如如何把类设计的更好，如何更好的运用面向对象的思想，如何更好的运用类与类之间的关联，同时应该多多练习正则表达式的使用，做到能够更加熟练的使用正则表达式，同时慢慢习惯使用哈希表，做到提高程序的运行效率。
浙公网安备 33010602011771号