前三次oo作业总结

一、作业总结

前三次的任务都是两题或两题以上关于java类设计的题目加上一道大题，三次的大题都是答题判题程序，除了最后一道题，其它都较为基础，不用费太多力就能完成，除了第三次大作业的“日期类的基本使用”有一些细节没注意到，导致测试点一直过不去，费了有一段时间才完成。

三次作业主要是注重类的设计与使用，还考验观察和思考能力，三次作业的最后一道题都对输入输出的格式有很大要求，因此只用分割、替换字符的函数来获取输入信息会很麻烦和费力，第一次作业时这一方面还体现的不太明显，但到了第二次作业开始就会发现只用常规的函数解决不了输入的问题，前两次我并没有用正则表达式写，因此总有一些测试点过不去，明明样例都能通过，所以第三次作业我开始用了正则表达式，才拿回了更多的分。

从结果来看，我不甚满意，因为三次作业，我没有一次拿到满分，第二次甚至没达到及格线，原因在于想的过于简单，看到题目就按常规方法写了下去，没有全盘思考，结果到后面越写越乱，重新写又太耗费时间，所以就这么马马虎虎过去了，没有拿到多少分。因此，我总结了前三次的作业，并分别对三次作业的最后一道大题做了个简要分析。

1、答题判题程序-1（第一次作业）

这道题目要求设计一个答题判题程序，根据输入的题目信息和答题信息，判断答案的正确性，并输出判题结果。我总结了一下一共有一下几个要注意的点：

1. 面向对象设计：题目要求设计题目类、试卷类和答卷类，需要考虑如何设计它们的属性和方法，以及它们之间的关系，使得程序结构清晰、易于维护和扩展。

2. 数据处理：需要正确解析输入的题目信息和答题信息，将其转化为程序可以处理的数据结构，例如题目对象和答案列表。

3. 逻辑判断：实现判断答案是否正确的逻辑，需要根据输入的答案与对应题目的标准答案进行比较，并输出判题结果。

4. 字符串处理：对于题目和答案的内容，需要正确地提取题号、题目内容和答案内容，并处理可能存在的空格或格式不规范的情况。

5. 输入输出格式处理：需要按照规定的格式正确输出题目信息、答题结果和判题信息，包括题目的编号、内容以及判题结果等。

   难点：

   1. 数据结构选择：选择合适的数据结构来存储题目信息和答案信息，以便于后续的处理和判题。
   2. 题目顺序不相关：题目输入的顺序与题号不相关，这要求程序在处理答题信息时能够正确地匹配答案和题目。
   3. 异常情况处理：需要考虑各种异常情况，例如输入格式不正确、答案数量不匹配等情况，确保程序能够正确处理并给出合理的提示或错误信息。
   4. 输出格式控制：题目要求输出的格式较为严格，需要确保输出的内容符合规定的格式要求，这需要对输出的内容进行精确控制。

   这道题主要注重类的设计与使用，以及对输入信息的处理，对于刚学习Java没多久的我，第一次看到这道题也是思索了很久，做这道题首先要把所有的类构思好，不然无法往下做，我通过构建了三个类：question（题目）类、exampaper（试卷）类以及answersheet（答卷）类来处理接受到的信息，将输入的问题以及该问题的答案储存到题目类里，再在试卷类里创建题目列表，将需要的题目保存在试卷类里，再在答卷类里创建答案列表来保存答案和判题列表来保存每一题的判题结果，再根据样例要求设计输出函数。通过这个思路我顺利地完成了这道题，不过由于接受信息的方法不太完美，导致有一个测试点过不去，后来我想到了要用正则表达式，不过由于我对正则表达式还没有理解透以及改起来太麻烦便打消了这个想法。第一次作业总的来说比较基础，要考虑的点并不多，通过查阅函数的使用方法还是可以顺利通过。不过由于三次作业是环环相扣的，所以第一次作业具有很大意义。

   以下是本题代码：

   import java.util.ArrayList;
   import java.util.List;
   import java.util.Scanner;
   class Question {
   private String number;
   private String content;
   private String standardAnswer;
   public Question(String number, String content, String standardAnswer) {
   this.number=number;
   this.content=content;
   this.standardAnswer=standardAnswer;
   }
   public String getNumber(){
   return number;
   }
   public String getContent(){
   return content;
   }
   public String getStandardAnswer(){
   return standardAnswer;
   }
   public boolean testAnswer(String answer){
   return standardAnswer.equals(answer);
   }
   }
   class ExamPaper{
   private List questions = new ArrayList<>();
   public void addQuestion(Question question) {
   questions.add(question);
   }
   public Question getQuestion(String number) {
   for (Question question : questions) {
   if (question.getNumber().equals(number)) {
   return question;
   }
   }
   return null;
   }
   }
   class AnswerSheet{
   private ExamPaper examPaper;
   private Listanswers=new ArrayList<>();
   private Listresults=new ArrayList<>();
   public AnswerSheet(ExamPaper examPaper) {
   this.examPaper=examPaper;
   }
   public void addAnswer(String answer) {
   answers.add(answer);
   }
   public void testAnswers() {
   for (int i=0;i<answers.size();i++) {
   Question question=examPaper.getQuestion(String.valueOf(i+1));
   if (question!=null){
   results.add(question.testAnswer(answers.get(i)));
   }
   }
   }
   public void tostring() {
   for (int i=0;i<answers.size();i++){
   Question question = examPaper.getQuestion(String.valueOf(i+1));
   if (question!=null){
   System.out.println(question.getContent().replace("#Q:", "")+"~"+answers.get(i));
   }
   }
   for(int i=0;i<answers.size();i++){
   if(ianswers.size()-1){
   System.out.print(results.get(i) ? "true":"false");
   }
   else{
   System.out.print(results.get(i) ? "true ":"false ");
   }
   }
   }
   }
   public class Main {
   public static void main(String[] args) {
   Scanner scanner=new Scanner(System.in);
   int questionsnumber=Integer.parseInt(scanner.nextLine());
   ExamPaper examPaper=new ExamPaper();
   for (int i=0;i<questionsnumber;i++){
   String stu=scanner.nextLine();
   String[] a=stu.split(" #Q:");
   String number= a[0].replace("#N:", "");
   String number1=number.trim();
   String[] c=a[1].split(" #A:");
   String content=c[0];
   String content1=content.trim();
   String standardAnswer =c[1];
   Question question=new Question(number1,content1,standardAnswer);
   examPaper.addQuestion(question);
   }
   AnswerSheet answerSheet = new AnswerSheet(examPaper);
   String[] b=new String[questionsnumber];
   String str=scanner.nextLine();
   String[] d=str.split(" #A:");
   for(int i=0;i<questionsnumber;i++)
   {
   if(i0)
   {
   b[i]=d[i].replace("#A:", "");
   answerSheet.addAnswer(b[i]);
   }
   else{
   b[i]=d[i].trim();
   answerSheet.addAnswer(b[i]);
   }
   }
   answerSheet.testAnswers();
   answerSheet.tostring();
   }
   }

   答题判题程序-2（第二次作业）

   答题判题程序-2在前一次作业的基础上又增加了可以输入多张试卷和答卷的功能，还给试卷中还给每道题赋了分，还要分析每张试卷的总分，以及最终分数，同时还增加了多种输入错误信息时的情况以及乱序输入的情况，相比第一次作业，第二次作业复杂了许多，需要有很强的逻辑思维，做这道题时我选择在上一次作业的基础上进行改进，前几个测试点还是很顺利通过了，只需在类里面再添加几个函数即可，但开始添加多张试卷及答卷功能时我陷入了疑惑，可能是没完全理解题目意思，我一开始想的是在题目类添加一个int类型表示每题分值，构造参数时也添加了分值的获取，但是由于输入样例中题目内容和每题分值不在同一行输入，且每题的分值由试卷而定，于是这里让我卡了很久，后来才想明白真正用到分值信息的试卷类，而不是问题类，所以我将获取分数的函数以及计算总分的函数放在了试卷类，且给试卷和答卷类都设置了号码信息，以此实现多张试卷和答卷时输出结果的情况，不过到了这里我又卡住了，我没有想到可以创建试卷和答卷列表，所以一直无法实现这种情况，另外由于没有用正则表达式，所以无法处理一些输入错误信息的情况。而这也体现了正则表达式的重要性，因为输入的情况是多种多样的，用户可以不按照规定的格式输入，这也是为什么java强调面对对象设计。所以在这之后我重新写过了我的代码，包括类的设计，输入与输出全部改了一遍，获取信息也运用了正则表达式，通过创建试卷和答卷列表实现了多张试卷和多张答卷的输入输出，以及答卷缺失部分答案的情况，以及输入无效试卷号的情况，这次作业我得到的分很低，我也总结了教训，写代码时要全方面考虑，不能想到什么写什么，还要主动去寻找更好的方法，不然很容易会导致逻辑混乱，到之后越写越乱，最后只能重写。

   以下是本题代码：

   import java.util.ArrayList;
   import java.util.List;
   import java.util.Scanner;
   class Question {
   private String number;
   private String content;
   private String standardAnswer;
   private int score;
   public Question(String number, String content, String standardAnswer, int score) {
   this.number = number;
   this.content = content;
   this.standardAnswer = standardAnswer;
   this.score = score;
   }
   public String getNumber() {
   return number;
   }
   public String getContent() {
   return content;
   }
   public String getStandardAnswer() {
   return standardAnswer;
   }
   public int getScore() {
   return score;
   }
   public void setscore(int score){
   this.score=score;
   }
   public boolean testAnswer(String answer) {
   return standardAnswer.equals(answer);
   }
   public int getScore(String answer) {
   return testAnswer(answer) ? score : 0;
   }
   }
   class ExamPaper {
   private List questions = new ArrayList<>();
   public void addQuestion(Question question) {
   questions.add(question);
   }
   public Question getQuestion(String number) {
   for (Question question : questions) {
   if (question.getNumber().equals(number)) {
   return question;
   }
   }
   return null;
   }
   }
   class AnswerSheet {
   private ExamPaper examPaper;
   private List answers = new ArrayList<>();
   private List results = new ArrayList<>();
   private List scores = new ArrayList<>();
   public AnswerSheet(ExamPaper examPaper) {
   this.examPaper = examPaper;
   }
   public void addAnswer(String answer) {
   answers.add(answer);
   }
   public void testAnswers() {
   for (int i = 0; i < answers.size(); i++) {
   Question question = examPaper.getQuestion(String.valueOf(i + 1));
   if (question != null) {
   results.add(question.testAnswer(answers.get(i)));
   scores.add(question.getScore(answers.get(i)));
   }
   }
   }
   public void printAnswersAndResults(int n, String[] a) {
   for(int i=0;i<n;i++){
   Question question = examPaper.getQuestion(a[i]);
   if (question!=null){
   System.out.print(question.getContent().replace("#Q:", "")+"_{"+answers.get(i)+"}");
   System.out.println(results.get(i) ? "true" : "false");
   }
   }
   }
   public void printScores() {
   for (int i = 0; i < scores.size(); i++) {
   if (i == scores.size()-1){
   System.out.print(scores.get(i));
   } else {
   System.out.print(scores.get(i) + " ");
   }
   }
   System.out.print("~");
   }
   public int calculateTotalScore() {
   int totalScore = 0;
   for (int score : scores) {
   totalScore += score;
   }
   return totalScore;
   }
   }
   public class Main {
   public static void main(String[] args) {
   Scanner scanner = new Scanner(System.in);
   ExamPaper examPaper = new ExamPaper();
   List scores = new ArrayList<>();
   boolean alertPrinted = false;
   String[] a = new String[20];
   while (scanner.hasNextLine()) {
   String line = scanner.nextLine();
   if (line.equals("end")) {
   break;
   }
   if (line.startsWith("#N:")) {
   String[] parts = line.split(" #Q:| #A:");
   String number = parts[0].replace("#N:", "").trim();
   String content = parts[1].trim();
   String standardAnswer = parts[2].trim();
   Question question = new Question(number,content,standardAnswer,0);
   examPaper.addQuestion(question);
   } else if (line.startsWith("#T:")) {
   String[] parts = line.split(" ");
   int totalScore = 0;
   for (int i = 1; i < parts.length; i++) {
   String[] questionInfo = parts[i].split("-");
   String number = questionInfo[0];
   a[i-1]=number;
   int score = Integer.parseInt(questionInfo[1]);
   totalScore += score;
   examPaper.getQuestion(number).setscore(score);
   }
   if (totalScore != 100 && !alertPrinted) {
   System.out.println("alert: full score of test paper" + parts[0].replace("#T:", "") + " is not 100 points");
   alertPrinted = true;
   }
   } else if (line.startsWith("#S:")) {
   AnswerSheet answerSheet = new AnswerSheet(examPaper);
   String[] parts = line.split(" ");
   for (int i = 1; i < parts.length; i++) {
   String answer = parts[i].replace("#A:", "").trim();
   answerSheet.addAnswer(answer);
   }
   answerSheet.testAnswers();
   answerSheet.printAnswersAndResults(parts.length,a);
   answerSheet.printScores();
   System.out.print(answerSheet.calculateTotalScore());
   }
   }
   }
   }

   答题判题程序-3（第三次作业）

   答题判题程序-3在前一次的基础上又增加了学生信息，以及每个学生的得分情况，还添加了删除题目的功能，以及还考虑了试卷上的题目是否被删除，还有试卷上的题号是否存在的情况，有了前两次的经验，这次作业我先添加了一个student（学生）类，用来保存学生的学号和姓名信息，还在该类里添加里检查学号是否存在的功能，同时也创建了学生列表，也增添了几个正则表达式来处理输入的信息，最后输出结果也是通过试卷和答卷列表来逐个输出，虽然写的过程中有点把自己绕晕了但还是一一实现了各个样例，但当我实现了所有样例时发现还是有一些测试点没过，于是我开始考虑一些输入时的情况，比如输入题目的答案为空白，以及各种乱序输入但还是一些测试点过不了，甚至之前已经过了的测试点还错了，最后也是山穷水尽了。

   一下是本题代码：

   import java.util.Scanner;
   import java.util.regex.Pattern;
   import java.util.regex.Matcher;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.HashMap;
   import java.util.Map;
   import java.util.Iterator;
   class Question {
   private int num;
   private int score;
   private String str;
   private String answer;
   private int getscore;
   public Question(int num, String str, String answer) {
   this.num = num;
   this.str = str;
   this.answer = answer;
   }
   public void setinscore(int score){
   this.getscore = score;
   }
   public int getGetscore(){
   return this.getscore;
   }
   public int getNum() {
   return this.num;
   }
   public String getStr() {
   return this.str;
   }
   public String getAnswer() {
   return this.answer;
   }
   public void setScore(int score) {
   this.score = score;
   }
   public int getScore() {
   return this.score;
   }
   }
   class Student{
   private String snum;
   private String name;
   public Student(String snum, String name) {
   this.snum = snum;
   this.name = name;
   }
   public void setsnum(String snum){
   this.snum=snum;
   }
   public String getsnum(){
   return this.snum;
   }
   public void setname(String name){
   this.name=name;
   }
   public String getname(){
   return this.name;
   }
   public static boolean isStudentExist(List students, String snum) {
   for (Student student : students) {
   if (student.getsnum().equals(snum)) {
   return true; // 学号存在
   }
   }
   return false; // 学号不存在
   }
   }
   class exampaper {
   private int num;
   public List questions = new ArrayList<>();
   public int getnum(){
   return this.num;
   }
   public void setNum(int num) {
   this.num = num;
   }
   public void addQuestion(Question question) {
   this.questions.add(question);
   }
   public int getSum() {
   int sum = 0;
   for (Question q : this.questions) {
   sum += q.getScore();
   }
   return sum;
   }
   public List getQuestions(){
   return this.questions;
   }
   public boolean isQuestionInPaper(int questionNum) {
   for (Question q : this.questions) {
   if (q.getNum() == questionNum) {
   return true; // 题目存在于试卷中
   }
   }
   return false; // 题目不存在于试卷中
   }
   }
   class AnswerSheet {
   private int num;
   private String snum;
   private String name;
   private List questions = new ArrayList<>();
   private List questionNum = new ArrayList<>();
   public String getsnum(){
   return this.snum;
   }
   public void setSnum(String snum) {
   this.snum = snum;
   }
   public String getname(){
   return this.name;
   }
   public void setname(String name) {
   this.name = name;
   }
   public void setNum(int num) {
   this.num = num;
   }
   public int getNum(){
   return this.num;
   }
   public List getQuestions() {
   return this.questions;
   }
   public List getQuestionNum() {
   return this.questionNum;
   }
   }
   public class Main {
   public static boolean isQuestionExist(List questions, int targetNum) {
   for (Question question : questions) {
   if (question.getNum() == targetNum) {
   return true; // 题目存在
   }
   }
   return false; // 题目不存在
   }
   public static void main(String[] args){
   Scanner scanner=new Scanner(System.in);
   List questions = new ArrayList<>();
   List papers = new ArrayList<>();
   List students = new ArrayList();
   List answerSheets = new ArrayList<>();
   String str;
   while (!(str = scanner.nextLine()).equals("end")) {
   if (str.contains("#N:")) {
   Pattern pattern = Pattern.compile("#N:\s(\d+)\s#Q:\s([^#]+)\s#A:(\s\S+|)");
   Matcher matcher = pattern.matcher(str);
   if (matcher.find()) {
   int num = Integer.parseInt(matcher.group(1));
   String que = matcher.group(2).trim();
   String ans = matcher.group(3);
   Question question = new Question(num, que, ans);
   questions.add(question);
   }
   else{
   System.out.println("wrong format:"+str);
   }
   } else if (str.contains("#T:")) {
   Pattern pattern = Pattern.compile("#T:\s(\d+)");
   Matcher matcher = pattern.matcher(str);
   matcher.find();
   int num = Integer.parseInt(matcher.group(1));
   Pattern pattern2 = Pattern.compile("(\d+)\s-\s([^ ])");
   Matcher matcher2 = pattern2.matcher(str);
   int i = 1;
   exampaper paper = new exampaper();
   while (matcher2.find()) {
   int flag=1;
   for (Question s : questions) {
   if (s.getNum() == Integer.parseInt(matcher2.group(i))) {
   flag=0;
   Question q = new Question(s.getNum(), s.getStr(), s.getAnswer());
   q.setScore(Integer.parseInt(matcher2.group(i + 1)));
   paper.addQuestion(q);
   }
   }
   if(flag1){
   String str1="n";
   Question q= new Question(0,str1,str1);
   paper.addQuestion(q);
   }
   }
   paper.setNum(num);
   papers.add(paper);
   } else if (str.contains("#X:")) {
   String[] a=str.split("-");
   int len=a.length;
   String number= a[0].replace("#X:", "");
   a[0]=number;
   for(int i=0;i<len;i++){
   String[] b=a[i].split(" ");
   Student student=new Student(b[0],b[1]);
   students.add(student);
   }
   }else if (str.contains("#D:")) {
   String[] a = str.split("-");
   int num = Integer.parseInt(a[1]);
   Iterator iterator = questions.iterator();
   while (iterator.hasNext()) {
   Question q = iterator.next();
   if (q.getNum() == num) {
   iterator.remove();
   }
   }
   }
   else if (str.contains("#S:")) {
   Pattern pattern = Pattern.compile("#S:\s(\d+)\s([0-9]{8})");
   Matcher matcher = pattern.matcher(str);
   matcher.find();
   int num = Integer.parseInt(matcher.group(1));
   String snum=matcher.group(2);
   AnswerSheet answerSheet = new AnswerSheet();
   if(Student.isStudentExist(students, snum)){
   for(Student s : students){
   if(s.getsnum().equals(snum)){
   answerSheet.setSnum(s.getsnum());
   answerSheet.setname(s.getname());
   }
   }
   }
   else {
   answerSheet.setSnum(snum);
   answerSheet.setname("null");
   }
   answerSheet.setNum(num);
   Pattern pattern2 = Pattern.compile("#A:\s(\d+)\s-\s*([^#]+|)");
   Matcher matcher2 = pattern2.matcher(str);
   int i = 1;
   while (matcher2.find()) {
   answerSheet.getQuestionNum().add(Integer.parseInt(matcher2.group(1)));
   answerSheet.getQuestions().add(matcher2.group(2));
   }
   answerSheets.add(answerSheet);
   }
   }
   for (exampaper g : papers) {
   if (g.getSum() != 100) {
   System.out.println("alert: full score of test paper" + g.getnum() + " is not 100 points");
   }
   }
   for (AnswerSheet g : answerSheets) {
   int flag = 0;
   int num = g.getNum();
   for (exampaper a : papers) {
   if (num == a.getnum()) {
   flag = 1;
   int x = 0;
   for (Question p : a.getQuestions()) {
   if(x>=g.getQuestions().size()){
   System.out.println("answer is null");
   continue;
   }
   boolean flag1=a.isQuestionInPaper(g.getQuestionNum().get(x));
   boolean flag2=isQuestionExist(questions,p.getNum());
   if(flag1&&flag2){
   int n=0;
   for(Question z : a.getQuestions()){
   if(a.getQuestions().get(n).getNum()g.getQuestionNum().get(x)){
   if (p.getAnswer().equals(g.getQuestions().get(n))) {
   p.setinscore(a.getQuestions().get(n).getScore());
   System.out.println(p.getStr() + "~" + g.getQuestions().get(n) + "~" + "true");
   } else {
   p.setinscore(0);
   System.out.println(p.getStr() + "~" + g.getQuestions().get(n) + "~" + "false");
   }
   }
   n++;
   }
   }
   else{
   if(flag1true&&flag2false){
   p.setinscore(0);
   System.out.println("the question "+p.getNum()+" invalid~0");
   }
   else if(flag2false&&flag1false){
   p.setinscore(0);
   System.out.println("non-existent question~0");
   }
   else if(flag1false&&flag2true){
   if (p.getAnswer().equals(g.getQuestions().get(x))) {
   p.setinscore(a.getQuestions().get(x).getScore());
   System.out.println(p.getStr() + "~" + g.getQuestions().get(x) + "~" + "true");
   } else {
   p.setinscore(0);
   System.out.println(p.getStr() + "~" + g.getQuestions().get(x) + "~" + "false");
   }
   }
   }
   x++;
   }
   int sum = 0;
   int tap = 0;
   if(!g.getname().equals("null")){
   System.out.print(g.getsnum()+" "+g.getname()+": ");
   for(Question p:a.getQuestions()){
   if(tap == 0){
   sum+=p.getGetscore();
   System.out.print(p.getGetscore());
   tap++;
   }else{
   sum+=p.getGetscore();
   System.out.print(" "+p.getGetscore());
   }
   }
   System.out.print("~"+sum);
   }
   else{
   System.out.print(g.getsnum()+" not found");
   }
   }
   }
   if(flag == 0){
   System.out.println("The test paper number does not exist");
   }
   }
   }
   }

   总结心得

   1、通过这三次作业，我主要学到了类的设计与使用方法以及正则表达式的使用，然后就是程序的鲁棒性，实际工程中程序对各种不同状况做出的反应都应该符合用户需求。最最重要的就是面向对象的思维。

   2、改进建议：每一种功能都用函数实现这样不仅可以使代码更加整洁还方便发现错误和改正，还有建议老师多增加一些输入输出样例。