前三次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、改進建議：每一種功能都用函式實現這樣不僅可以使程式碼更加整潔還方便發現錯誤和改正，還有建議老師多增加一些輸入輸出樣例。