OO第一次博客作业

前言：
本学期开设了面向对象程序设计这门课，通过这门课我系统性地学到了JAVA的一些知识，下面是我对于前三次大作业的部分题目以及最后一道大题的心得分析以及总结。
第一次作业：
7-1 设计一个风扇Fan类
这是一个简单的程序，通过这个程序我理解了：
1. 确定类的作用和职责：Fan类用于表示一个风扇，它应该包含风扇的所有相关属性和行为。
2.定义类的属性（成员变量）：Fan类有四个属性：speed（速度）、on（开关状态）、radius（半径）、color（颜色）。这些属性用来描述风扇的状态。
3.确定属性的访问级别：所有属性都被定义为private，这意味着它们只能在Fan类内部被访问和修改，这实现了封装，防止了外部直接访问和修改风扇的状态。
4.提供构造函数：
类提供了两个构造函数：①默认构造函数，用于创建具有默认属性值的风扇对象。
②带有多个参数的构造函数，允许用户在创建风扇对象时指定所有属性。
5.实现访问器和修改器方法（getter和setter）：对于每个属性，类提供了访问器方法（例如getSpeed）来获取属性的值，以及修改器方法（例如setSpeed）来设置属性的值。
代码实现不作展示，写完这道题让我明白这个类的设计是一个典型的面向对象编程实践，通过它我切实体会到了面向对象程序设计思想和面向过程程序设计思想的不同，前者要更注重模块化和封装。
7-3 成绩计算-1-类、数组的基本运用
看到这道题目，我知道了这道题的解决思想是运用数组
于是我使用了数组来存储学生的信息
Student[ ] students = new Student[5];
for (int i = 0; i < students.length; i++) {
String studentID = scanner.next();
String name = scanner.next();
int chineseGrade = scanner.nextInt();
int mathGrade = scanner.nextInt();
int physicsGrade = scanner.nextInt();
students[i] = new Student(studentID, name, chineseGrade, mathGrade, physicsGrade);}
以下是我认为使用数组的好处：
对于Student类：
减少成员变量：不需要为每个科目单独设置一个成员变量，只需要一个数组即可。
易于扩展：如果未来需要添加更多科目的成绩，只需调整数组大小即可，而不需要修改类的结构。
对于成绩计算：
易于遍历：通过循环遍历数组来计算总分和平均分，使得代码更加直观和易于理解。
减少代码重复：不需要为每个科目编写单独的加法操作，可以通过循环来处理。
对于数据输入和输出：
统一处理：在读取和打印学生信息时，可以统一处理成绩数组，而不是分别处理每个成绩。

7-5 大作业第一题 答题判题程序-1
这是我第一次写JAVA的大作业加上之前大量接触代码编程是在大一上时候学C语言，所以说这次的大作业用了我很长的时间来编程，也出了不少的问题，一开始我的思维局限在了之前向过程的思路里，发现写了很多还是不能很好的完成这个题目，于是我参考了大作业下面的设计建议：
题目类（用于封装单个题目的信息）：

属性：题目编号、题目内容、标准答案-standardAnswer
方法：数据读写set\get方法、
判题方法(答案-answer）：判断答案-answer是否符合标准答案-standardAnswer
试卷类（用于封装整套题目的信息）

属性：题目列表(题目类的对象集合)、题目数量
方法：判题方法(题号-num、答案-answer）：判断答案-answer是否符合对应题号的题目标准答案-standardAnswer
保存题目(题号-num、题目-question）：将题目保存到题目列表中，保存位置与num要能对应
答卷类（用于封装答题信息）

属性：试卷（试卷类的对象）、答案列表（保存每一题的答案）、判题列表（保存每一题的判题结果true/false）
方法：判题方法(题号-num）：判断答案列表中第num题的结果是否符合试卷中对应题号的题目标准答案
输出方法(题号-num）：按照题目的格式要求，输出题号为num的题目的内容和答题结果。
保存一个答案(题号-num,答案-answer)：保存题号为num的题目的答题结果answer。
以下是我大作业一的类图：

关键代码的分析(其中模块部分的代码逻辑省略，只保留框架部分）
`Main 类（主模块）

public static void main(String[] args){
Scanner sc = new Scanner (System.in);
int n = sc.nextInt();
Answer[] answers = new Answer[n];
Issue[] issues = new Issue[n];
String str = new String("0");
String end = new String("end");

// 读取输入并创建 Issue 和 Answer 对象
for(int i = 0; i < n + 3 && !str.equals(end); i++){
    str = sc.nextLine();
    String[] str1 = str.split("([ ]*[#NQA:][ ]*)+");
    if(i >= 1 && i < n + 1){
        Issue issue = new Issue();
        issue.setIssueNum(str1[1]);
        issue.setIssueMain(str1[2]);
        issue.setIssueAnswer(str1[3]);
        issues[i - 1] = issue;
    }
    if(i == n + 1){
        for(int j = 0; j < n; j++){
            Answer answer = new Answer();
            answer.setAnswer(str1[j + 1]);
            answers[j] = answer;
        }
    }
}

// 创建 Paper 对象并处理考卷
Paper paper = new Paper(answers, issues);
paper.sort();
paper.judge();
paper.printlnof();

}
`
在这段代码中：

main 方法是程序的入口点，负责读取用户输入，创建 Answer 和 Issue 对象，并存储在数组中。
使用 Scanner 读取输入，直到遇到 "end" 标记。
根据输入创建 Issue 对象存储在 issues 数组中，并在读取到特定行时创建 Answer 对象存储在 answers 数组中。
创建 Paper 对象，并调用其 sort、judge 和 printlnof 方法来处理和输出考卷。

Paper 类（考卷处理模块）

`public class Paper {
private Answer[] answers;
private Issue[] issues;

public Paper(Answer[] answers, Issue[] issues){
    this.answers = answers;
    this.issues = issues;
}

public void sort(){
    // 排序逻辑
}

public void judge(){
    // 评分逻辑
}

public void printlnof(){
    // 输出逻辑
}

}
`

在这段代码中：
Paper 类负责处理考卷，包括排序、评分和输出结果。
通过构造方法接收 Answer 和 Issue 数组。
sort 方法用于对问题进行排序。
judge 方法用于根据问题答案判断学生答案的正确性。
printlnof 方法用于输出考卷结果。

Answer 类和 Issue 类（数据模型模块）

`class Answer {
private String answer;
private boolean judge;

// Getter 和 Setter 方法

}

class Issue {
private String issueNum;
private String issueMain;
private String issueAnswer;

// Getter 和 Setter 方法

}
`

Answer 类和 Issue 类是数据模型，用于存储答案和问题的信息。
每个类都有相应的属性和 getter/setter 方法，用于访问和修改对象的属性。

下面是我代码的UML调用图：

测试类图如下：

第二次作业：
在7-1 手机按价格排序、查找
7-2 sdut-oop-4-求圆的面积（类与对象）
7-3 Java类与对象-汽车类中主要还是考察了JAVA编程中的一些基本概念比如类的定义和实现、继承和多态、集合框架的使用、输入输出、异常处理、构造方法的重载、封装和代码风格。
在这三个代码中我学到了：
类的定义和实现:
这三个题目中我的代码都定义了一个类，其中包含了成员变量、构造方法、getter和setter方法，以及业务逻辑方法。
类的实例化（创建对象）和对象的使用。
我接触到了继承和多态的内容并且通过编写代码得到了锻炼:
7-1中的MobilePhone类实现了Comparable接口，这涉及到继承和多态的概念，因为Comparable是一个接口，MobilePhone类通过实现compareTo方法来提供比较逻辑。
`
class MobilePhone implements Comparable {
private String type;
private int price;

public MobilePhone(String type, int price) {
    this.type = type;
    this.price = price;
}

public String getType() {
    return type;
}

public int getPrice() {
    return price;
}

@Override
public int compareTo(MobilePhone other) {
    return Integer.compare(this.price, other.price);
}

@Override
public String toString() {
    return "型号：" + type + "，价格：" + price;
}

}

我在MobilePhone 类用了 Comparable 接口

接口:
Comparable 是一个接口，它定义了一个 compareTo 方法，该方法用于比较两个对象。当一个类实现了 Comparable 接口时，它必须提供 compareTo 方法的实现。
实现接口:
MobilePhone 类通过实现 Comparable 接口，表明它具有比较能力。这意味着 MobilePhone 类的对象可以相互比较。
compareTo 方法:
MobilePhone 类重写了 compareTo 方法，该方法接受一个 MobilePhone 类型的参数，并返回一个整数。这个整数表示当前对象与参数对象在价格上的比较结果：
如果当前对象的价格小于参数对象的价格，则返回负数。
如果当前对象的价格等于参数对象的价格，则返回零。
如果当前对象的价格大于参数对象的价格，则返回正数。
多态:

多态体现在 MobilePhone 类实现了 Comparable 接口。
class MobilePhone implements Comparable<MobilePhone> { // ... }
通过实现 Comparable 接口，MobilePhone 类的对象现在可以与任何其他 Comparable 对象进行比较，只要这些对象也是 MobilePhone 类型或者其子类型。以下是多态的具体应用：

Collections.sort(list)
方法使用了多态。Collections 类并不知道 list 中的具体元素类型，但它知道这些元素实现了 Comparable 接口，因此可以调用 compareTo 方法进行比较和排序。
Collections.sort(list);
在这里，list 是一个 ArrayList 类型的对象，但 Collections.sort 方法不需要知道这一点。它只关心列表中的元素是否可以比较，这是通过实现 Comparable 接口实现的。

继承：
MobilePhone 类通过重写 Comparable 接口中的 compareTo 方法，提供了自己的比较逻辑。
/@Override public int compareTo(MobilePhone other) { return Integer.compare(this.price, other.price); }/
在这里，MobilePhone 类继承了 Comparable 接口的方法，并提供了具体的实现。这意味着任何 MobilePhone 类型的对象都可以使用 compareTo 方法来与其他 MobilePhone 类型的对象进行比较。

第二次大作业7-4 答题判题程序-2

首先题目相当于第一次作业更加复杂，以下是更复杂的点：
输入的三种信息可以乱序混合输入
由一张试卷的内容判断变为了多张试卷，并且每张试卷信息都需要存储
在测试点中存在答卷没有答案或多余答案的情况
新增了试卷总分的内容输入，并且有了试卷总分不足100分的预警
空答案的答卷有单独的输出情况
新增了判分信息的输出

以下我的代码相较于大作业一的代码进行的更新迭代的内容分析总结：

1. 增加了标准输入的处理：
   在 Main 类的 main 方法中，使用 Scanner 类读取标准输入，直到遇到非特定格式的输入为止。
   `
   public static void main(String[] args) {
   Scanner scanner = new Scanner(System.in);
   QuestionBank questionBank = new QuestionBank();
   AnswerSheetsCollection answerSheets = new AnswerSheetsCollection();
   TestPapersCollection testPapers = new TestPapersCollection(questionBank);

    while (true) {
        String input = scanner.nextLine();
        if (input.startsWith("#N")) {
            questionBank.addQuestion(input);
        } else if (input.startsWith("#T")) {
            testPapers.addTestPaper(input);
        } else if (input.startsWith("#S")) {
            answerSheets.addAnswerSheet(input);
        } else {
            break;
        }
    }
    
    Evaluation evaluation = new Evaluation();
    evaluation.processAnswerSheets(questionBank, testPapers, answerSheets);
    scanner.close();
   

   }
   }
   `
   2.引入了面向对象的设计：

QuestionSet 类封装了题目的信息。
QuestionBank 类管理所有题目。
TestPaper 类封装了试卷的信息。
TestPapersCollection 类管理所有试卷。
AnswerSheet 类封装了答案卷的信息。
AnswerSheetsCollection 类管理所有答案卷。
Evaluation 类负责处理答案卷并计算得分。

3.增加了正则表达式处理输入：

在 QuestionBank 类的 addQuestion 方法中，使用正则表达式提取题目编号、内容和答案。
private String extractString(String prefix, String input) {
Matcher matcher = Pattern.compile(prefix + "(.*?)(?=(\\s|$))").matcher(input);
return matcher.find() ? matcher.group(1).trim() : null;
}

在 TestPaper 类的 setData 方法中，使用正则表达式提取试卷编号和题目分数。
public void setData(String input) {
this.number = extractInt("#T:", input);
for (String part : input.split(" ")) {
if (part.startsWith("#T:")) continue; // Skip paper number part>
String[] pair = part.split("-");
questionScores.add(new QuestionScore(Integer.parseInt(pair[0]), Integer.parseInt(pair[1])));
}
}
在 AnswerSheet 类的 setData 方法中，使用正则表达式提取答案卷编号和答案。
public void setData(String input) {
this.number = extractInt("#S:", input);
Matcher matcher = Pattern.compile("#A:(\\S+)").matcher(input);
while (matcher.find()) {
answers.add(matcher.group(1));
}
}

4.增加了分数和试卷验证：

在 Evaluation 类的 processAnswerSheets 方法中，检查试卷的总分是否为100分。
public void processAnswerSheets(QuestionBank questionBank, TestPapersCollection testPapers, AnswerSheetsCollection answerSheets) {
for (TestPaper paper : testPapers.getPapers()) {
int totalScore = paper.getQuestionScores().stream().mapToInt(QuestionScore::getScore).sum();
if (totalScore != 100) {
System.out.println("alert: full score of test paper" + paper.getNumber() + " is not 100 points");
}
}

5.增加了详细的评分过程：

在 Evaluation 类的 processAnswerSheets 方法中，详细处理每个答案的正确性并计算得分。

6.优化了数据结构：

在 QuestionBank, TestPapersCollection, AnswerSheetsCollection 类中，使用 ArrayList 来存储 QuestionSet, TestPaper, AnswerSheet 等对象。
例如在类QuestionBank中
public QuestionBank() {
this.questions = new ArrayList<>();
}

7.增加了错误处理：
在 Evaluation 类的 processAnswerSheets 方法中，处理用户没有提供答案的情况，并输出 "answer is null"。
在 Evaluation 类的 processAnswerSheets 方法中，处理试卷编号不存在的情况，并输出错误信息。
List<QuestionScore> questions = paper.getQuestionScores();
for (int i = 0; i < questions.size(); i++) {
QuestionScore questionScore = questions.get(i);
String userAnswer = i < answerSheet.getAnswers().size() ? answerSheet.getAnswers().get(i) : null;
QuestionSet question = questionBank.getQuestionByNumber(questionScore.getNumber());

        if (userAnswer == null) {
           System.out.println("answer is null");
            scoreDetails.append("0 ");
        } else {
           if (question != null && userAnswer.equals(question.getAnswerKey())) {
                System.out.println(question.getContent() + "~" + userAnswer + "~true");
                score += questionScore.getScore();
                scoreDetails.append(questionScore.getScore()).append(" ");
            } else {
               System.out.println(question.getContent() + "~" + userAnswer + "~false");
                scoreDetails.append("0 ");
           }
        }
    }

类图如下

下面是我代码的UML调用图：

测试图如下：

总体体会

本次作业对所有新增的属性都进行了封装，让我更好的体会到了JAVA面向对象的在迭代更新的优势所在；
由于不知道有多少题目多少试卷，本次大作业中我灵活使用了ArrayList处理数据，使得数据在处理上更为灵活；
各类基本实现了单一职责。
对于上次作业的结构进行了较大改变，使其符合题目要求的同时更好得进行拓展。
唯一不足对于那些没有做到正确的测试点没有一个较好的思绪去更改成功，导致这次的代码没有拿到满分。

第三次大作业
7-1 面向对象编程(封装性)
在代码中代码中，我在Student 类装了学生的属性和行为（方法）。通过使用构造方法和setter方法，创建了对象并设置其属性。
并且了两种构造方法：无参构造方法和有参构造方法。无参构造方法用于创建对象，而有参构造方法允许在创建对象时直接初始化其属性。
在代码中我也体会到了封装的好处
Student 类的属性被声明为私有（private），这意味着它们只能通过公共的getter和setter方法被访问和修改。

class Student {
// 私有成员变量
private String sid; // 学号
private String name; // 姓名
private int age; // 年龄
private String major; // 专业

// 无参构造方法
public Student() {}

// 有参构造方法
public Student(String sid, String name, int age, String major) {
    this.sid = sid;
    this.name = name;
    setAge(age); // 使用 setter 方法设置年龄
    this.major = major;
}

7-2 jmu-java-日期类的基本使用
我认为这道题是着重考察了我对日期和时间处理：
在代码中我使用了 SimpleDateFormat 类来解析和格式化日期字符串，以及 Calendar 类来获取日期的详细信息，如年份、月份、日、星期等。

1. 使用 SimpleDateFormat 类解析日期字符串：
   在 formatDates 方法中，SimpleDateFormat 被用来将输入的日期字符串解析为 Date 对象。

private static String[] formatDates(String[] dates) throws ParseException {
String[] formattedDates = new String[dates.length];
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (int i = 0; i < dates.length; i++) {
Date date = sdf.parse(dates[i]); // 解析日期字符串
formattedDates[i] = sdf.format(date); // 格式化Date对象为字符串
}
return formattedDates;
}

2.使用 SimpleDateFormat 类格式化日期：
同样在 formatDates 方法中，在解析日期后，我使用 SimpleDateFormat 将 Date 对象格式化为标准格式的日期字符串。
formattedDates[i] = sdf.format(date); // 格式化Date对象为字符串

3.在 judgeSecondAndThirdDates 方法中，Calendar 类也被用来获取日期的年份、月份和一年中的日数。

private static void judgeSecondAndThirdDates(String[] inputDates, String[] formattedDates) throws ParseException {
// ...
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (int i = 1; i < inputDates.length; i++) {
Date date = sdf.parse(formattedDates[i]);
Calendar c = Calendar.getInstance();
c.setTime(date);
years[i - 1] = c.get(Calendar.YEAR);
months[i - 1] = c.get(Calendar.MONTH); // 月份，注意：月份从0开始计数
daysOfYear[i - 1] = c.get(Calendar.DAY_OF_YEAR);
}
// ...
}

第三次大作业 7-3 答题判题程序-3

首先题目在第二次大作业的基础上进行迭代：
新增了删除题目信息。被删除的题目有单独的输出方法。
新增了学生信息如学号和姓名，需要进行单独地存储。
在答卷信息中新增了学生学号的属性。
并且在答卷时存在题目引用错误的情况。
考察了答卷的题目与试卷题目顺序相对应。

具体阅读分析了题目后，我认为第三个的大作业考察以下内容：

主要是处理字符串、正则表达式、数据结构（如列表、字典）以及逻辑判断的能力。具体来说，它要求实现一个答题判题程序，能够处理多种输入信息，并根据输入的题目信息、试卷信息、答题信息、学生信息以及删除题目信息来判断答题结果。
输入解析：程序需要能够解析不同格式的输入信息，包括题目信息、试卷信息、学生信息、答题信息和删除题目信息。这要求使用正则表达式来匹配和提取输入中的关键数据。
数据结构管理：程序需要使用合适的数据结构来存储题目、试卷、学生和答题信息。例如，可以使用列表来存储题目和试卷，使用字典来存储学生信息。
逻辑判断：程序需要根据题目信息中的标准答案来判断答题结果。这包括处理答案为空、答案错误、题目被删除以及题目不存在等情况。
错误处理：程序需要能够处理输入格式错误、试卷号引用错误以及学号引用错误等情况，并给出相应的提示信息。
输出格式：程序需要按照指定的格式输出试卷总分警示、答卷信息、判分信息、被删除的题目提示信息以及题目引用错误提示信息。
代码结构：程序需要具有良好的代码结构，例如使用类和方法来组织代码，以提高代码的可读性和可维护性。
输入顺序：程序需要能够处理输入信息的顺序，即使输入信息不是按照题目、试卷、学生、答题和删除题目的顺序输入。
异常情况：程序需要能够处理异常情况，例如删除不存在的题目、试卷号引用错误以及学号引用错误等。

以下我的代码相较于大作业二的代码进行的更新迭代的内容分析总结：

1.题目删除标记：
代码一中，QuestionSet 类有一个 deleted 属性，用于标记题目是否被删除。在 Evaluation 类的 processAnswerSheets 方法中，会检查题目是否被删除，并相应地处理评分。

2.题目内容输出：
在 Evaluation 类的 processAnswerSheets 方法中，代码会输出每个题目的内容，包括正确答案和用户答案。

3.学生信息输出：
在 Evaluation 类的 processAnswerSheets 方法中，代码会输出学生的学号和姓名，以及每个题目的得分情况。

4.错误格式记录：
在 QuestionBank 类的 addQuestion 方法中，如果输入格式不正确，代码会输出错误信息。

5.不存在的题目处理：
在 Evaluation 类的 processAnswerSheets 方法中，如果答题卡中包含不存在的题目编号，代码一会输出相应的错误信息。
``
for (AnswerSheet answerSheet : answerSheets.getSheets()) {
int score = 0;
StringBuilder scoreDetails = new StringBuilder();

TestPaper paper = testPapers.getTestPaperByNumber(answerSheet.getPaperNumber());
if (paper == null) {
    System.out.println("The test paper number does not exist");
    continue;
}

List<QuestionScore> questions = paper.getQuestionScores();
for (int i = 0; i < questions.size(); i++) {
    QuestionScore questionScore = questions.get(i);
    String userAnswer = (i < answerSheet.getAnswers().size()) ? answerSheet.getAnswers().get(i) : null;
    QuestionSet question = questionBank.getQuestionByNumber(questionScore.getNumber());

    if (question != null) {
        if (question.isDeleted()) {
            System.out.println("the question " + questionScore.getNumber() + " invalid~0");
            scoreDetails.append("0 "); // Add zero score for this question
        } else {
            // 正常评分逻辑
            if (userAnswer == null || !userAnswer.trim().equals(question.getAnswerKey())) {
                System.out.println(question.getContent() + "~" + userAnswer + "~false");
                scoreDetails.append("0 ");
            } else {
                System.out.println(question.getContent() + "~" + userAnswer + "~true");
                score += questionScore.getScore();
                scoreDetails.append(questionScore.getScore()).append(" ");
            }
        }
    } else {
        // 处理不存在的题目
        System.out.println("non-existent question~0");
        scoreDetails.append("0 "); // Add zero score for this question
    }
}

Student student = studentMap.get(answerSheet.getStudentId());
if (student == null) {
    System.out.println(answerSheet.getStudentId() + " not found");
} else {
    System.out.printf("%s %s: %s~%d%n", student.getId(), student.getName(), scoreDetails.toString().trim(), score);
}

}

6.测试试卷总分检查：
在 Evaluation 类的 processAnswerSheets 方法中，代码会检查测试试卷的总分是否为100，并在总分不为100时输出警告信息。

7.输入格式错误处理：
在 Main 类中，代码增加了对输入格式错误的处理，并在发现错误格式时输出错误信息。
代码结构优化：
代码中的 QuestionBank 类和 TestPapersCollection 类都使用了 getQuestionByNumber 和 getTestPaperByNumber 方法来查找题目和试卷，提高了代码的可读性和可维护性。

总的来说，代码在大作业代码二的基础上增加了题目删除标记、题目内容输出、学生信息输出、错误格式记录、不存在的题目处理、测试试卷总分检查、输入格式错误处理以及代码结构优化等内容。

遇到的错误
在我进行测试点测试时，不管是示例几，总是出现学号找不见的问题，比如：
我输入

N:1 #Q:1+1= #A:2

T:1 1-5

X:20201106 Tom

S:1 20201103 #A:1-5 #A:2-4

输出：
alert: full score of test paper1 is not 100 points
The test paper number does not exist
而正确答案的输出是：
alert: full score of test paper1 is not 100 points
1+1=₅false
20201103 not found
end
针对这个问题，我对代码进行了详细的分析，并且与几个同学进行了一些讨论，找到了部分原因（可能不全）：
在TestPapersCollection类中，添加试卷的方法addTestPaper中创建了新的TestPaper对象并调用setData方法进行设置，但没有检查试卷编号是否已经存在或者是其它内容中否有重复的编号。如果在输入过程中有多个内容编号的试卷被添加，可能会导致获取试卷时出现错误。
而在“20201103 not found” 是因为在Evaluation类的processAnswerSheets方法中，当查找学生时，遍历学生列表students中并没有找到学号为 “22201103” 的学生，所以输出 “20201103 not found”。也就是遍历时候判断代码的逻辑错误或者在学号与学生存储时没有一一对应。
故我修改了代码：
tudent student = studentMap.get(answerSheet.getStudentId());

其逻辑如下：

从 AnswerSheet 对象中获取学生的学号（answerSheet.getStudentId()）。
使用 studentMap.get() 方法，通过学号作为键来查找对应的学生对象。
如果找到了对应的学生对象，则将其赋值给 student 变量，以便后续输出学生的信息。

而不是通过判断语句去遍历寻找，也算是提高了代码的部分效率。

类图如下：

下面是我代码的UML调用图：

测试图如下：

学习总结：
这三次作业只有在最简单的第一次拿了满分，后面的题目在第一次基础上有了更深层次的考察，我在进行完这三次大作业之后，感觉到了自己的不足与欠缺，我也在代码类图的绘制中，编写中，
以及后续的测试与不断改进中积累了一些经验，并且切实感受到了作为一名编程人员的充实感与乐趣，总结了前三次作业之后，我也对于自己这阶段对JAVA的学习有了一个总结，希望可以在后面
的学习和作业中我能取得更大的进步，为自己今后工作或者需要用到JAVA时候不会有书到用时方恨少的悔恨，以上便是我对三次大作业的全部总结与心得。