国产亚洲精品中文字幕,最新国产AV最新国产在钱,亚洲精品一区二区动漫

oop前三次作業(yè)總結(jié)

前言：

這是我第一次寫oop的設(shè)計(jì)作業(yè)，其中不乏踩坑，亂設(shè)計(jì)，瞎設(shè)計(jì)，但三次題目都能很好的提高個人能力，這是我跨入面向?qū)ο蟮牡谝徊剑挥械谝徊阶咛?shí)了，后面的課中，才能走的更快更穩(wěn)，更穩(wěn)更遠(yuǎn)。

寫前三次作業(yè)的過程中，每個題目都要求合理正確設(shè)計(jì)各種類，要求實(shí)現(xiàn)類的封裝性，合理設(shè)計(jì)類間關(guān)系，符合類的單一職責(zé)原則，熟悉正則表達(dá)式。
第一次題目集較為簡單，需要設(shè)計(jì)的類較少，即可完成題目。
第二次題目集前三題仍然比較簡單，第四題在第一次題目集最后一題的基礎(chǔ)上進(jìn)行迭代，增加類的數(shù)量，題目難度較第一次加大，總體來說，不算太難。
第三次題目集共三題，前兩題題目內(nèi)容較少，稍花時間設(shè)計(jì)即可順利完成，最后一題依舊在前倆次題目的基礎(chǔ)上進(jìn)行進(jìn)一步迭代，難度中等。

設(shè)計(jì)與分析：

對于第一次作業(yè)最后一題：

點(diǎn)擊查看代碼

class Question {
    private int number;
    private String content;
    private String standardAnswer;

    public Question(int number, String content, String standardAnswer) {
        this.number = number;
        this.content = content;
        this.standardAnswer = standardAnswer;
    }

    public int getNumber() {
        return number;
    }

    public String getContent() {
        return content;
    }

    public String getStandardAnswer() {
        return standardAnswer;
    }

    public boolean checkAnswer(String answer) {
        return answer.equals(standardAnswer);
    }
}

class Paper {
    private List<Question> questions = new ArrayList<>();

    public void addQuestion(Question question) {
        questions.add(question);
    }

    public Question getQuestion_Number(int number) {
        for (Question question : questions) {
            if (question.getNumber() == number) {
                return question;
            }
        }
        return null;
    }
}

class Answer {
    private Paper paper;
    private ArrayList<String> answers = new ArrayList<>();
    private ArrayList<Boolean> results = new ArrayList<>();

    public Answer(Paper paper) {
        this.paper = paper;
    }

    public void saveOne_Your_answer(String answer) {
        answers.add(answer);
    }

    public void saveAnswers() {
        for (int i = 0; i < answers.size(); i++) {
            Question question = paper.getQuestion_Number(i + 1);
            if (question != null) {
                results.add(question.checkAnswer(answers.get(i)));
            }
        }
    }

    public void outputResults() {
        for (int i = 0; i < answers.size(); i++) {
            Question question = paper.getQuestion_Number(i + 1);
            if (question != null) {
                System.out.println(question.getContent() + "~" + answers.get(i));
            }
        }
        int i=0;
        for (boolean result : results) {
            if(i!=0){
                System.out.print(" " + result);
            } else {
                System.out.print(result);
            }
            i++;
        }

    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int questionNumber = sc.nextInt();
        sc.nextLine();

        Paper paper = new Paper();
        Answer answerSheet = new Answer(paper);

        for(int i=0;i<questionNumber;i++){
            String line = sc.nextLine();
            Matcher matcher = Pattern.compile("#N:(\\s+)?(\\S+)(\\s+)?#Q:(\\s+)?(.+)#A:(\\s+)?(.+)").matcher(line);
            if (matcher.find()) {
                int number = Integer.parseInt(matcher.group(2));
                String content = matcher.group(5);
                content=content.trim();
                String standardAnswer = matcher.group(7);
                paper.addQuestion(new Question(number, content, standardAnswer));
            }
        }

        while(true){
            String line = sc.nextLine();
            if (line.equals("end")) {
                break;
            }
            String regex = "#A:(\\s+)?(\\S+)";
            Matcher matcher = Pattern.compile(regex).matcher(line);
            int matchCount = 0;
            while (matcher.find()) {
                matchCount++;
                String your_answer = matcher.group(2);
                answerSheet.saveOne_Your_answer(your_answer);
            }
        }
        answerSheet.saveAnswers();
        answerSheet.outputResults();
    }
}

定義了如下的幾個類：
Question 類：定義了問題的編號、內(nèi)容以及標(biāo)準(zhǔn)答案，并提供了檢查答案的方法。
Paper 類：包含了一個問題的列表，并提供添加問題和通過編號獲取問題的方法。
Answer 類：包含了一個試卷的引用，存儲了用戶的答案和每個答案的檢查結(jié)果。
代碼邏輯：
主類 Main 的 main 方法開始執(zhí)行時，
讀取問題數(shù)量，然后根據(jù)題目數(shù)量循環(huán)使用正則表達(dá)式讀取每個問題的編號、內(nèi)容和標(biāo)準(zhǔn)答案，并添加到試卷中。
保存答案，并檢查每個答案的正確性。

第一次類圖

代碼分析：
輸入處理：代碼使用正則表達(dá)式解析輸入行，這是處理此類問題的有效方法。
錯誤處理：代碼中沒有對于輸入內(nèi)容的錯誤處理機(jī)制。如果輸入格式不正確，程序可能會崩潰。
代碼可讀性：正則表達(dá)式較為復(fù)雜，不易于理解。另外，一些變量和方法命名可以更具描述性。
代碼效率：在 Answer 類的 saveAnswers 方法中，每次循環(huán)都調(diào)用 paper.getQuestion_Number(i + 1)，這并不高效的，因?yàn)榭梢允孪全@取所有問題，再保存試卷中，可以有效提高效率
對于第二次作業(yè)最后一題：
第二次類圖
分析：
定義了如下的類：
Question 類：定義了問題的編號、內(nèi)容以及標(biāo)準(zhǔn)答案，并提供了檢查答案的方法。
Paper 類：包含了一個問題的列表和每個問題的分?jǐn)?shù)，提供了添加問題和通過編號獲取問題的方法。
Answersheet 類：包含了一個試卷的引用和用戶的答案，提供了保存答案、獲取結(jié)果、輸出結(jié)果等方法。
代碼邏輯：
主類 Main 的 main 方法開始執(zhí)行時，創(chuàng)建了一個二維數(shù)組用于存儲試卷問題的編號和分?jǐn)?shù)，以及一些集合用于存儲試卷、答題卡和結(jié)果。
通過正則表達(dá)式解析輸入行，處理題目、試卷編號、分?jǐn)?shù)、用戶答案等信息。
根據(jù)試卷編號和題目編號，獲取用戶答案并檢查結(jié)果，最后輸出每道題目的內(nèi)容、用戶答案、正確與否以及得分。
代碼分析：
輸入處理：代碼使用多個正則表達(dá)式來解析不同格式的輸入，這在處理復(fù)雜輸入時是必要的。
數(shù)據(jù)結(jié)構(gòu)：使用了合適的數(shù)據(jù)結(jié)構(gòu)，如列表、哈希表等來存儲題目、試卷、答題卡等信息。
邏輯設(shè)計(jì)：通過循環(huán)嵌套來處理多個試卷、多個題目。
對于第三次作業(yè)最后一題：

點(diǎn)擊查看部分代碼

class Question{
    private int question_num;
    private String question_content;
    private String question_standardAnswer;
    private boolean if_effective = true;

    public Question() {
    }

    public Question(int question_num, String question_content, String question_standardAnswer) {
        this.question_num = question_num;
        this.question_content = question_content;
        this.question_standardAnswer = question_standardAnswer;
    }

    public int getQuestion_num() {
        return question_num;
    }

    public String getQuestion_content() {
        return question_content;
    }

    public String getQuestion_standardAnswer() {
        return question_standardAnswer;
    }

    public boolean isIf_effective() {
        return if_effective;
    }

    public void setIf_effective(boolean if_effective) {
        this.if_effective = if_effective;
    }

    public boolean judge_right_or_wrong(String answer){
        return answer.equals(question_standardAnswer);
    }
}

class Question_Set{
    HashMap<Integer, Question> question_set = new HashMap<>();

    public Question_Set() {
    }

    public  void addQuestion_set(Integer question_num, Question question){
        question_set.put(question_num,question);
    }

    public Question getQuestion_of_set(Integer paper_question_number){
        return question_set.get(paper_question_number);
    }

    public boolean containsKey(int remove_number) {
        return question_set.containsKey(remove_number);
    }
}

class Paper{
    ArrayList<Question> questions = new ArrayList<>();
    HashMap<Integer,Integer> questions_score = new HashMap<>();
    ArrayList<Integer> answer_order = new ArrayList<>();
    Question new_question = new Question(0,"0","0");

    public Paper() {
        questions.add(new_question);
    }

    public void addQuestion(Question question){
        questions.add(question);
    }

    public void addQuestion_score(int question_number,int score){
        questions_score.put(question_number,score);
    }

    public void addAnswer_order(int order_num){
        answer_order.add(order_num);
    }//答題順序
}

class Answersheet{
    private int total_answer_number = 0;
    //    Answer new_answer = new Answer();
//    ArrayList<Answer> answers = new ArrayList<>();
    HashMap<Integer,Answer> answers = new HashMap<>();

//    public Answersheet() {answers.add(new_answer);
//    }

    public int getTotal_answer_number() {
        return total_answer_number;
    }

    public void add_your_answer(int order_num,Answer answer){
        answers.put(order_num,answer);
        this.total_answer_number++;
    }
}
class Student{
    private String id;
    private String name;

    HashMap<String,Answersheet> students_to_answersheet = new HashMap<>();//id->答卷卷子

    public Student() {
    }

    public void setId(String id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

class Output{
    HashMap<String,Integer> id_for_answer = new HashMap<>();
    ArrayList<String> student_order = new ArrayList<>();
    ArrayList<Student> students = new ArrayList<>();
    HashMap<Integer,Paper> papers = new HashMap<>();
    Question_Set question_set = new Question_Set();
    ArrayList <Integer> un_question_set = new ArrayList<>();

    public Output() {
    }

    public void save_paper_set(Integer paper_num,Paper paper){
        papers.put(paper_num,paper);
    }

    public void save_student_answer(String id,Integer paper_num){
        id_for_answer.put(id,paper_num);
        student_order.add(id);
    }

    public void output_question_and_result(){
        for(String student : student_order){//確定答題學(xué)生
            int []score  = new int[105];
            Arrays.fill(score, 0);
            int count_answer_question = 0;
            for(Student new_student : students){//尋找該學(xué)生
                if(new_student.getId().equals(student)){
                    int answer_paper_num = id_for_answer.get(student);//尋找所答試卷編號
                    Paper paper = papers.get(answer_paper_num);
                    if(paper!=null){
                        for(Integer answer_num : paper.answer_order){//找所答題目    T
                            for(Question question : paper.questions){//2    N
                                if(question!=null) {
                                    if(question.getQuestion_num()==0){
                                        continue;
                                    }
//                                    System.out.println(question.getQuestion_num());
                                    if (question.getQuestion_num() == answer_num) {
                                        if (question.isIf_effective() && !question.getQuestion_content().equals("null_content")) {//題目有效
                                            System.out.print(question.getQuestion_content() + "~");//輸出題目內(nèi)容
                                            String your_answer = new_student.students_to_answersheet.get(student).answers.get(count_answer_question+1).getYour_answer();//你的答案
                                            System.out.println(your_answer + "~" + question.judge_right_or_wrong(your_answer));//結(jié)果
                                            if (question.judge_right_or_wrong(your_answer)) {//題目正確
                                                score[count_answer_question] = paper.questions_score.get(question.getQuestion_num());
                                            }
                                        } else {//題目無效
                                            if (answer_num > new_student.students_to_answersheet.get(student).getTotal_answer_number()) {
                                                System.out.println("answer is null");
                                            } else {
//                                                int Num = new_student.students.get(student).answers.get(answer_num).getOrder_num();
//                                            System.out.println(Num);
//                                            System.out.print("*");System.out.println(answer_num);
                                                if (question.getQuestion_content().equals("null_content")||question.getQuestion_standardAnswer().equals("null_answer")) {
                                                    System.out.println("non-existent question~0");
                                                } else {
                                                    System.out.print("the question ");
                                                    System.out.print(question.getQuestion_num());
                                                    System.out.println(" invalid~0");
                                                }
                                            }
                                        }
                                        count_answer_question++;
                                        break;
                                    } else{
                                        for(Integer a : un_question_set){
                                            if(Objects.equals(a, answer_num)){
                                                System.out.println("non-existent question~0");
                                                count_answer_question++;
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        System.out.print(new_student.getId() + " " + new_student.getName() + ":");
                        int sum_score = 0;
                        for(int i=0;i<count_answer_question;i++){
                            System.out.print(" ");System.out.print(score[i]);
                            sum_score += score[i];
                        }
                        System.out.print("~");System.out.println(sum_score);
                    } else {
                        System.out.println("The test paper number does not exist");
                    }
                }
            }
        }
    }
}

**第三次類圖** ![](https://img2024.cnblogs.com/blog/3430062/202404/3430062-20240419214232450-470367923.png) * 分析： * 定義了如下的類： Question 類：定義了題目的編號、內(nèi)容、標(biāo)準(zhǔn)答案以及是否有效的屬性，提供了判斷答案是否正確的方法。 Question_Set 類：題目集合，用于存儲題目，并提供了添加題目、獲取題目等方法。 Paper 類：試卷類，包含題目列表、題目分?jǐn)?shù)、答題順序等屬性，提供了添加題目、分?jǐn)?shù)、答題順序的方法。 Answersheet 類：答題卡類，用于存儲學(xué)生的答題情況，包括答案和總答題數(shù)。 Answer 類：答案類，存儲答案的順序和內(nèi)容。 Student 類：學(xué)生類，包含學(xué)生的學(xué)號、姓名以及答題卡的映射關(guān)系。 Output 類：輸出類，用于保存試卷、學(xué)生答題情況等信息，并輸出題目和結(jié)果。

代碼邏輯：
主類的Main中的main中，利用while（true）死循環(huán)循環(huán)輸入各種題目，試卷，學(xué)生信息，經(jīng)過正則表達(dá)式進(jìn)行匹配后存入各個List對應(yīng)相應(yīng)的類中，然后，遍歷學(xué)生列表，根據(jù)學(xué)生答題情況輸出題目內(nèi)容、學(xué)生答案、結(jié)果以及得分。
代碼分析：
數(shù)據(jù)結(jié)構(gòu)：使用了合適的數(shù)據(jù)結(jié)構(gòu)來存儲題目、試卷、學(xué)生答題情況等信息，HashMap、ArrayList 等。
邏輯設(shè)計(jì)：通過多個類的組合和方法調(diào)用，實(shí)現(xiàn)了題目、試卷、學(xué)生答題等功能。

采坑心得：

第一次作業(yè)：
1.這道題目需要正確讀入輸入的數(shù)據(jù)，注意錯誤的格式輸入，例如空白字符等，要運(yùn)用正則表達(dá)式進(jìn)行匹配正確輸入的字符
2.輸入的題號可能不連續(xù)，因此直接使用數(shù)組索引可能不合適，需要邏輯映射題號到數(shù)組或List索引
第二次作業(yè)：
1.在使用List儲存類時，容易遇到存儲不當(dāng)，使得類有可能會出現(xiàn)為null的情況
2.沒有合理設(shè)計(jì)各個類的作用，使用大量方法在Main類中，代碼冗雜，不易讀
3.拘泥于第一題的模板和格式，沒有新增類用于處理第二題新增的輸入和處理，導(dǎo)致單獨(dú)一個類中的方法很冗余，復(fù)雜，在運(yùn)行第二題時，沒有設(shè)計(jì)多個類的方式高效簡潔和可復(fù)用性，使得下面的第三題需要重新設(shè)計(jì)類和結(jié)構(gòu)。（怎么會這么愚蠢還只設(shè)計(jì)三個類TT）
第三次作業(yè)：
1.類間關(guān)系設(shè)計(jì)的很復(fù)雜，沒有完全符合類的單一職責(zé)原則，有的類中甚至只有屬性和getter setter，和構(gòu)造方法，沒有盡到這個類中該盡的職責(zé)。

2.各個方法之間有重復(fù)代碼，沒有理清題目含義，出現(xiàn)大量無效、低效代碼
3.對于輸入的錯誤格式（如空白字符等），容易遺漏判斷錯誤的格式情況，沒有能正確處理輸入，輸出對應(yīng)應(yīng)該輸出的答案。

4.對于遍歷各個列表進(jìn)行遍歷輸出數(shù)據(jù)的時候，循環(huán)過于繁雜，遇到出現(xiàn)null或者輸入的是錯誤格式的代碼時，只會一昧的在循環(huán)的各個地方加上if判斷，沒有復(fù)用性，且不易理解TT

5.對于新增的輸出，學(xué)生，需要新建一個Student類，但在設(shè)計(jì)類時思路出現(xiàn)一點(diǎn)問題，Student應(yīng)該在答卷類內(nèi)，而我卻由Student之內(nèi)儲存答卷，這會使得一些題目輸入的無效格式難以處理，極不方便。

踩坑總結(jié)：

在寫題時，需要先認(rèn)真審題，好好厘清題目需求，不能寫一步看一步，要注重整體，對類要物盡其用，充分發(fā)揮類的職責(zé)，不能把活全交給一個或幾個類里面去處理，要合理利用類間關(guān)系，將輸入的數(shù)據(jù)整合題目需求，高效簡潔的輸出，同時滿足設(shè)計(jì)時應(yīng)滿足的幾個原則（例如：里氏代換，依賴倒轉(zhuǎn)，單一職責(zé)等）。（還得加油TT）

改進(jìn)建議：

第一次作業(yè)：
可以單獨(dú)設(shè)計(jì)一個類用于儲存題目到試卷中，防止違反類的單一職責(zé)原則，讓類的用途更清晰
第二次作業(yè)：
題目的需求其實(shí)用三個類有點(diǎn)不足，可以設(shè)計(jì)答案類和試卷題目類，答案類可以用于保存答卷的題目，試卷題目類可以應(yīng)對輸入中相同一道題目在不同試卷中不同分值的情況，刪除一些在第一次作業(yè)中在類中編寫的不必要和重復(fù)的代碼，統(tǒng)一調(diào)用在新類的方法，可以使代碼更加高效，更加簡潔，增加可復(fù)用性。
第三次作業(yè)：
這次作業(yè)的場景需處理多張?jiān)嚲恚鄰埓鹁恚鄠€學(xué)生，新增了學(xué)生信息、刪除題目信息以及多種異常輸入的監(jiān)測。
應(yīng)該新增試卷題目類（Question_Paper）：用于保存試卷中的題目信息。由于試卷中的題目序號與題目本身的題號不一致。且題目在不同試卷中的分值可能不一樣，因此，設(shè)計(jì)試卷題目類轉(zhuǎn)門用于處理
其次對于題目可能輸入的各種錯誤輸入，需要在各個對應(yīng)的類中，專門添加一些類來處理這些信息，將其試卷或者題目或者答卷給定為無效，刪除改進(jìn)前在Output類中的多層嵌套循環(huán)，改為調(diào)用類的方法內(nèi)的循環(huán)，將復(fù)雜循環(huán)簡單化

總結(jié)

前三次的作業(yè)中，答題判題程序題目由淺入深，在題目中，學(xué)會了處理以下幾點(diǎn)：
1.學(xué)會使用正則表達(dá)式處理不同格式的輸入信息，包括題目信息、試卷信息、學(xué)生信息、答題信息以及刪除題目信息等，對信息進(jìn)行解析和分類處理。
2.需要設(shè)計(jì)合適的數(shù)據(jù)結(jié)構(gòu)來存儲題目信息、試卷信息、學(xué)生信息以及答題信息，以方便后續(xù)的操作和管理。
3.需要設(shè)計(jì)邏輯來判斷答題的正確性、計(jì)算得分，處理刪除題目信息等情況，要考慮各種可能的異常情況并給出合適的處理方式。
4.需要合理設(shè)計(jì)類間關(guān)系
5.需要考慮各種可能的異常情況，如格式錯誤、題目引用錯誤、學(xué)號引用錯誤等，給出相應(yīng)的提示信息，保證程序的健壯性。
但是，我在這三次作業(yè)中，仍然有很多不足，只有第一題在規(guī)定時間內(nèi)，通過了全部測試點(diǎn)，自己的編程，設(shè)計(jì)能力仍然還需提高，對于老師上課講的基本的類間關(guān)系還不太熟悉，處理題目的邏輯也很亂，需要加強(qiáng)對題目的理解能力。
在這些題目中我需要加深對于需求不斷的題目的處理問題能力，提高一定編程能力，加深設(shè)計(jì)能力，以處理之后難度逐漸加大，題目更加復(fù)雜的需求。
對于老師的授課方式，我覺得很合理，線上線下相結(jié)合，對于線下沒有理解的方面，可以在線上反復(fù)觀看。但是對于題目中一些難以理解的一些輸入輸出，可以適當(dāng)添加一些樣例來輔助理解題目含義，題目內(nèi)最好不要出現(xiàn)自相矛盾的地方，比如刪除了某些題目的試卷已不再是100分，卻無警告信息輸出，但能通過測試樣例，可以適當(dāng)增加測試樣例更加符合現(xiàn)實(shí)中的對應(yīng)情況
最后我希望后面三次作業(yè)能夠彌補(bǔ)前面出現(xiàn)的不足，再接再厲，oop我來辣 ^O^/

posted on 2024-04-20 16:59 oblivioner 閱讀(73) 評論(0) 收藏舉報(bào)

刷新頁面返回頂部

obvion-double12

oop前三次作業(yè)總結(jié)

前言：

設(shè)計(jì)與分析：

采坑心得：

改進(jìn)建議：

總結(jié)

導(dǎo)航

公告