第一次博客作业

公告

View Post

一.近来面向对象程序设计总结
1.前言
1）近来面向对象程序设计主要涉及的章节有对象和类，面向对象，以及一些基本的语法。
2）在学习的过程组也附带了老师发布的题目集练习，主要涉及类的创建，数据域的封装，类间关系，以及面向对象思想。
3）自己学习了有关正则表达式和集合的知识。
总的来说这三次题目难度集中于答题判断程序，单一职责原则的实践。
2.设计与分析

点击查看代码

import java.util.Scanner;
class Fan {
    public final int SLOW = 1;
    public final int MEDIUM = 2;
    public final int FAST = 3;
    private int speed;
    private boolean on;
    private double radius;
    private String color;
    public Fan() {
        this.speed = SLOW;
        this.on = false;
        this.radius = 5.0;
        this.color = "white";
    }
    public Fan(int speed, boolean on, double radius, String color) {
        this.speed = speed;
        this.on = on;
        this.radius = radius;
        this.color = color;
    }
    public int getSpeed() {
        return speed;
    }
    public void setSpeed(int speed) {
        this.speed = speed;
    }
    public boolean isOn() {
        return on;
    }
    public void setOn(boolean on) {
        this.on = on;
    }
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String toString() {
        if (on) {
            return "speed " + speed + "\ncolor " + color + "\nradius " + radius + "\nfan is on";
        } else {
            return "speed " + speed + "\ncolor " + color + "\nradius " + radius + "\nfan is off";
        }
    }
}
public class Main {
    public static void main(String[] args) {
        Fan fan1 = new Fan();
        System.out.println("-------\nDefault\n-------");
        System.out.println(fan1.toString());
        Scanner scanner = new Scanner(System.in);
        int speed = scanner.nextInt();
        boolean on = scanner.nextBoolean();
        double radius = scanner.nextDouble();
        String color = scanner.next();
        Fan fan2 = new Fan(speed, on, radius, color);
        System.out.printf("-------\nMy Fan\n-------\n");
        System.out.println(fan2.toString());
    }
}

代码解决的是 https://pintia.cn/problem-sets/1772270732783063040/exam/problems/1772273761729056768?type=7&page=0 中第一题。这个主要涉及到了类的创建，代码不复杂不做过多解释。

点击查看代码

import java.util.Collections;
import java.util.LinkedList;
import java.util.Scanner;
class MobilePhone implements Comparable<MobilePhone> {
    private String type;
    private int price;
    public MobilePhone(String type, int price) {
        this.type = type;
        this.price = price;
    }
    public String settype(){
        return type;
    }
    public int setPrice(){
        return price;
    }
    public String getType() {
        return type;
    }
    public int getPrice() {
        return price;
    }
    public int compareTo(MobilePhone other) {
        return Integer.compare(this.price, other.price);
    }

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

public class Main {
    public static void main(String[] args) {
        LinkedList<MobilePhone> phones = new LinkedList<>();
        Scanner scanner = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            String type = scanner.next();
            int price = scanner.nextInt();
            phones.add(new MobilePhone(type, price));
        }

        System.out.println("排序前，链表中的数据：");
        for (MobilePhone phone : phones) {
            System.out.println(phone);
        }

        Collections.sort(phones);

        System.out.println("排序后，链表中的数据：");
        for (MobilePhone phone : phones) {
            System.out.println(phone);
        }
        String fourthType = scanner.next();
        int fourthPrice = scanner.nextInt();
        MobilePhone fourthPhone = new MobilePhone(fourthType, fourthPrice);
        boolean found = false;
        for (MobilePhone phone : phones) {
            if (phone.getPrice() == fourthPrice) {
                found = true;
                System.out.printf(fourthType + "与链表中的" + phone.getType() + "价格相同");
                break;
            }
        }
        if (!found) {
            System.out.printf("链表中的对象，没有一个与" + fourthType + "价格相同的");
        }
    }
}

改代码是https://pintia.cn/problem-sets/1774798609041944576/exam/problems/1774799251563180032?type=7&page=0 第一题的解决方案。除了基本的类的创建外还涉及到了 Collections.sort() 方法： Collections类提供了一个名为sort()的静态方法，用于对集合进行排序。该方法接受一个实现了Comparable接口的集合作为参数，对集合中的元素进行排序。例如： // 对ArrayList进行排序 ArrayList list = new ArrayList<>(); list.add(5); list.add(3); list.add(7); list.add(1); list.add(9); Collections.sort(list); Linkedlist链表：链表（LinkedList）是一种基本的线性数据结构，由一系列节点（Node）组成，每个节点包含数据以及指向下一个节点的指针（或引用）。链表中的节点不必在内存中相邻，因此在插入和删除元素时，链表可以更灵活地调整结构，而不需要像数组那样进行大量的元素搬移。

链表有几种常见的类型，包括单向链表（Singly Linked List）、双向链表（Doubly Linked List）和循环链表（Circular Linked List）。

单向链表（Singly Linked List）：

每个节点包含数据以及指向下一个节点的指针。
链表的头节点指向第一个节点，尾节点的指针指向 null。
单向链表只能从头节点开始沿着指针方向依次访问下一个节点。
插入和删除节点的时间复杂度为 O(1)，但访问节点需要 O(n) 的时间复杂度。
双向链表（Doubly Linked List）：

每个节点包含数据以及指向前一个节点和后一个节点的指针。
链表的头节点指向第一个节点，尾节点指向最后一个节点。
双向链表可以从任一方向遍历，因为每个节点都有两个指针。
插入和删除节点的时间复杂度为 O(1)，但相对于单向链表，双向链表需要额外的空间存储前向指针。
循环链表（Circular Linked List）：

最后一个节点的指针指向第一个节点，形成一个闭环。
循环链表可以在任何节点开始遍历，并且可以用于实现循环队列等数据结构。
链表的优点在于插入和删除操作的效率高，但查找某个节点的效率较低。链表适用于需要频繁插入和删除操作的场景，但不适用于需要随机访问元素的场景。

点击查看代码

import java.util.Scanner;
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;
        if (age > 0) {
            this.age = age;
        }
        this.major = major;
    }
    public void print() {
        System.out.println("学号：" + sid + "，姓名：" + name + "，年龄：" + age + "，专业：" + major);
    }
    public void setSid(String sid) {
        this.sid = sid;
    }
    public String getSid() {
        return sid;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
    public int getAge() {
        return age;
    }
    public void setMajor(String major) {
        this.major = major;
    }

    // 获取专业
    public String getMajor() {
        return major;
    }
}
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //调用无参构造方法，并通过setter方法进行设值
        String sid1 = sc.next();
        String name1 = sc.next();
        int age1 = sc.nextInt();
        String major1 = sc.next();
        Student student1 = new Student();
        student1.setSid(sid1);
        student1.setName(name1);
        student1.setAge(age1);
        student1.setMajor(major1);
        //调用有参构造方法
        String sid2 = sc.next();
        String name2 = sc.next();
        int age2 = sc.nextInt();
        String major2 = sc.next();
        Student student2 = new Student(sid2, name2, age2, major2);
        //对学生student1和学生student2进行输出
        student1.print();
        student2.print();
    }
}

这段代码主要涉及了类的封装性。通过类的封装特性，保护了学生对象的属性，只能通过公有的 setter 和 getter 方法来访问和修改。

点击查看代码

import java.util.Scanner;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
public class Main {
public static int[]month_day = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String date = input.next();
String start = input.next();
String end = input.next();
String date1 = number(date);
String start1 = number(start);
String end1 = number(end);
int date2 = Integer.parseInt(date1);
int start2 = Integer.parseInt(start1);
int end2 = Integer.parseInt(end1);
int dateDay = date2 % 100;
int dateMonth = date2 / 100 % 100;
int dateYear = date2 / 10000;
int startDay = start2 % 100;
int startMonth = start2 / 100 % 100;
int startYear = start2 / 10000;
int endDay = end2 % 100;
int endMonth = end2 / 100 % 100;
int endYear = end2 / 10000;
int judgeRun = runYear(dateYear);
if (judgeRun == 1) month_day[1] = 29;
int judgeLeg = judgeDate(dateMonth, dateDay, date2);
if (judgeLeg == 0) {
System.out.println(date + "无效!");
} else {
if (judgeRun == 1) System.out.println(date + "是闰年.");
int sum_day = daysOfYear(dateMonth, dateDay);
LocalDate startDate = LocalDate.of(2000, 01, 02);
LocalDate endDate = LocalDate.of(dateYear, dateMonth, dateDay);
long days = Math.abs(ChronoUnit.DAYS.between(startDate, endDate)) % 7;
if (days == 0) days = 7;
System.out.println(date + "是当年第" + sum_day + "天,当月第" + dateDay + "天,当周第" + days + "天.");
}
judgeRun = runYear(startYear);
if (judgeRun == 0) month_day[1] = 28;
int judgeLegS = judgeDate(startMonth, startDay, start2);
judgeRun = runYear(startYear);
if (judgeRun == 0) month_day[1] = 28;
if (judgeRun == 1) month_day[1] = 29;
int judgeLegE = judgeDate(startMonth, startDay, end2);
if (judgeLegS == 0 || judgeLegE == 0)
System.out.println(start + "或" + end + "中有不合法的日期.");
else if (start2 > end2) {
System.out.println(end + "早于" + start + ",不合法!");
} else {
int yearSub = endYear - startYear;
int monthSub = endMonth - startMonth;
LocalDate startDate = LocalDate.of(startYear, startMonth, startDay);
LocalDate endDate = LocalDate.of(endYear, endMonth, endDay);
long days = ChronoUnit.DAYS.between(startDate, endDate);
System.out.print(end + "与" + start + "之间相差" + days + "天,所在月份相差" + monthSub + ",所在年份相差" + yearSub + ".");
}
}
public static String number(String str) {
str = str.trim();
String str2 = "";
if (str != null && !"".equals(str)) {
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) >= 48 && str.charAt(i) <= 57) {
str2 += str.charAt(i);
}
}
}
return str2;
}
public static int runYear(int year) {
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) ? 1 : 0;
}
public static int daysOfYear(int month, int day) {
int sum = 0;
for (int i = 0; i < month - 1; i++) {
sum += month_day[i];
}
sum += day;
return sum;
}
public static int judgeDate(int month, int day, int whole) {
if (whole < 100000000 && whole >= 10000000) {
return day >= 1 && day <= month_day[month - 1] ? 1 : 0;
} else {return 0;
}
}
}

这段代码用了 java.time.LocalDate 和 java.time.temporal.ChronoUnit 两个类。 java.time.LocalDate： LocalDate 是 Java 中的日期类，用于表示一个日期，不包含时间信息。它提供了丰富的方法来处理日期，比如获取年、月、日等，以及进行日期的加减、比较等操作。 LocalDate 类是不可变的，意味着一旦创建了日期对象，其值就不能被修改。 java.time.temporal.ChronoUnit： ChronoUnit 是一个枚举类，定义了各种不同的时间单位，如年、月、日等。它提供了方法来执行日期之间的加减操作，以及计算两个日期之间的差值。这两个类的结合使用可以让我们在 Java 中更方便地处理日期和时间，进行各种常见的日期操作，比如计算日期之间的差距、判断是否是闰年、日期的格式化等。

下面来重点分析这三次题目集的最后一题
1）答题判断程序-1
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。

输入格式:
程序输入信息分三部分：

1、题目数量

格式：整数数值，若超过1位最高位不能为0，

样例：34

2、题目内容

一行为一道题，可以输入多行数据。

格式："#N:"+题号+" "+"#Q:"+题目内容+" "#A:"+标准答案

格式约束：题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。

样例：#N:1 #Q:1+1= #A:2

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

3、答题信息

答题信息按行输入，每一行为一组答案，每组答案包含第2部分所有题目的解题答案，答案的顺序号与题目题号相对应。

格式："#A:"+答案内容

格式约束：答案数量与第2部分题目的数量相同，答案之间以英文空格分隔。

样例：#A:2 #A:78

  2是题号为1的题目的答案
  78是题号为2的题目的答案

答题信息以一行"end"标记结束，"end"之后的信息忽略。

输出格式:
1、题目数量

格式：整数数值，若超过1位最高位不能为0，

样例：34

2、答题信息

一行为一道题的答题信息，根据题目的数量输出多行数据。

格式：题目内容+" ~"+答案

样例：1+1=~2

      2+2= ~4

3、判题信息

判题信息为一行数据，一条答题记录每个答案的判断结果，答案的先后顺序与题目题号相对应。

格式：判题结果+" "+判题结果

格式约束：

 1、判题结果输出只能是true或者false，
 2、判题信息的顺序与输入答题信息中的顺序相同

样例：true false true

输入样例1:
单个题目。例如：

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

#A:2>#A:2 end 输出样例1: 在这里给出相应的输出。例如：

1+1=~2
true
输入样例2:
单个题目。例如：

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

#A:4>#A:4 end 输出样例2: 在这里给出相应的输出。例如：

1+1=~4
false
输入样例3:
多个题目。例如：

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

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

#A:2 #A:4 end 输出样例3: 在这里给出相应的输出。例如：

1+1=~2
2+2=~4
true true
输入样例4:
多个题目。例如：

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

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

#A:2 #A:2 end 输出样例4: 在这里给出相应的输出。例如：

1+1=~2
2+2=~2
true false
输入样例5:
多个题目，题号顺序与输入顺序不同。例如：

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

#N:1 #Q:5+5= #A:10

#A:10 #A:2 end 输出样例5: 在这里给出相应的输出。例如：

5+5=~10
1+1=~2
true true
输入样例6:
含多余的空格符。例如：

#N:1 #Q: The starting point of the Long March is #A:ruijin

#A:ruijin end 输出样例6: 在这里给出相应的输出。例如：

The starting point of the Long March is~ruijin
true

输入样例7:
含多余的空格符。例如：

#N: 1 #Q: 5 +5= #A:10

#A:10 end 输出样例7: 在这里给出相应的输出。例如：

5 +5=~10
true

设计建议:
以下是针对以上题目要求的设计建议，其中的属性、方法为最小集，实现代码中可根据情况添加所需的内容：

题目类（用于封装单个题目的信息）：

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

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

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

点击查看代码

import java.util.*;  
import java.util.stream.Collectors;
class Question {  
    int number;  
    String content;  
    String standardAnswer;  
    public Question(int number, String content, String standardAnswer) {  
        this.number = number;  
        this.content = content;  
        this.standardAnswer = standardAnswer;  
    }  
    public boolean judge(String answer) {  
        return standardAnswer.equals(answer);  
    }  
}  
  
class TestPaper {  
    List<Question> questions = new ArrayList<>();  
    int questionCount;  
  
    public void addQuestion(int number, String content, String standardAnswer) {  
        questions.add(new Question(number, content, standardAnswer));  
    }  
  
    public boolean judge(int number, String answer) {  
        for (Question q : questions) {  
            if (q.number == number) {  
                return q.judge(answer);  
            }  
        }  
        return false; // If no question matches the number, return false.  
    }  
}  
  
class AnswerSheet {  
    TestPaper testPaper;  
    List<String> answers = new ArrayList<>();  
    List<Boolean> judgments = new ArrayList<>();  
  
    public AnswerSheet(TestPaper testPaper) {  
        this.testPaper = testPaper;  
    }  
  
    public void addAnswer(int number, String answer) {  
        while (answers.size() < number) {  
            answers.add(""); // Fill in empty answers for missing question numbers.  
            judgments.add(false);  
        }  
        answers.set(number - 1, answer);  
    }  
  
    public void judgeAll() {  
        judgments.clear();  
        for (int i = 0; i < answers.size(); i++) {  
            for (Question q : testPaper.questions) {  
                if (q.number == i + 1) {  
                    judgments.add(q.judge(answers.get(i)));  
                    break;  
                }  
            }  
        }  
    }  
  
    public void printAnswersAndJudgments() {  
        for (int i = 0; i < answers.size(); i++) {  
            for (Question q : testPaper.questions) {  
                if (q.number == i + 1) {  
                    System.out.println(q.content + "~" + answers.get(i));  
                    break;  
                }  
            }  
        }  
        System.out.printf(judgments.stream().map(Object::toString).collect(Collectors.joining(" ")));  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        TestPaper testPaper = new TestPaper();  
        AnswerSheet answerSheet = null;  
        int questionCount = Integer.parseInt(scanner.nextLine());  
        testPaper.questionCount = questionCount;  
  
        for (int i = 0; i < questionCount; i++) {  
            String line = scanner.nextLine();  
            String[] parts = line.split("#N:|[#QA]:| +");  
            int number = Integer.parseInt(parts[1]);  
            testPaper.addQuestion(number, parts[3], parts[5]);  
        }  
  
        answerSheet = new AnswerSheet(testPaper);  
  
        while (true) {  
            String line = scanner.nextLine();  
            if (line.equals("end")) {  
                break;  
            }  
            if (line.startsWith("#A")) {  
                String[] answers = line.substring(3);  
                for (int i = 0; i < answers.length; i++) {  
                    int number = i + 1;  
                    answerSheet.addAnswer(number, answers[i]);  
                }  
            }  
        }  
        answerSheet.judgeAll();  
        answerSheet.printAnswersAndJudgments();  
        scanner.close();  
    }  
}

代码得分很少，我先解释一下我的代码具体结构。 1.Question 类：这个类表示一道题目，包含题号（number）、题目内容（content）和标准答案（standardAnswer）。构造函数 Question(int number, String content, String standardAnswer) 用于初始化题目对象。方法 judge(String answer) 用于判断给定的答案是否与标准答案相符。 2.TestPaper 类：这个类表示一张试卷，包含题目列表（questions）和题目数量（questionCount）。方法 addQuestion(int number, String content, String standardAnswer) 用于向试卷中添加题目。方法 judge(int number, String answer) 用于判断指定题号的答案是否正确。 3.AnswerSheet 类：这个类表示一张答题卡，包含对应的试卷（testPaper）、答案列表（answers）和判断结果列表（judgments）。构造函数 AnswerSheet(TestPaper testPaper) 用于初始化答题卡对象。方法 addAnswer(int number, String answer) 用于向答题卡中添加答案。方法 judgeAll() 用于对答题卡中的所有答案进行判断。方法 printAnswersAndJudgments() 用于打印答题卡中的答案和判断结果。 4.Main 类：在 main 方法中，首先通过 Scanner 从标准输入读取题目数量和题目信息，然后构建试卷对象。接着，通过循环读取答题卡信息，直到输入 "end" 结束。在读取答题卡信息过程中，通过解析输入的格式，将答案添加到答题卡对象中。最后，调用答题卡对象的 judgeAll() 方法对所有答案进行判断，并打印答案和判断结果。代码主要问题是会出现非零返回错误，主要原因是正则表达式错了导致类型不匹配。没有实行单一职责，应该把字符串判断写成一个类。下面是我的代码类图。

2）答题判断程序2
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-1基础上增补或者修改的内容。

要求输入题目信息、试卷信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。

输入格式:

程序输入信息分三种，三种信息可能会打乱顺序混合输入：

1、题目信息

一行为一道题，可输入多行数据（多道题）。

格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案

格式约束：

1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。

样例：#N:1 #Q:1+1= #A:2

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

2、试卷信息

一行为一张试卷，可输入多行数据（多张卷）。

格式："#T:"+试卷号+" "+题目编号+"-"+题目分值

 题目编号应与题目信息中的编号对应。

 一行信息中可有多项题目编号与分值。

样例：#T:1 3-5 4-8 5-2

3、答卷信息

答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序与试卷信息中的题目顺序相对应。

格式："#S:"+试卷号+" "+"#A:"+答案内容

格式约束：答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。

样例：#S:1 #A:5 #A:22

   1是试卷号 

   5是1号试卷的顺序第1题的题目答案

   22是1号试卷的顺序第2题的题目答案

答题信息以一行"end"标记结束，"end"之后的信息忽略。

输出格式:

1、试卷总分警示

该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100分，该部分忽略，不输出。

格式："alert: full score of test paper"+试卷号+" is not 100 points"

样例：alert: full score of test paper2 is not 100 points

2、答卷信息

一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。

格式：题目内容+"_"+答案++""+判题结果（true/false）

约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"

样例：3+2=₅true

     4+6=~22~false.

  answer is null

3、判分信息

判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。

格式：题目得分+" "+....+题目得分+"~"+总分

格式约束：

1、没有输入答案的题目计0分

2、判题信息的顺序与输入答题信息中的顺序相同
样例：5 8 0~13

根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。

4、提示错误的试卷号

如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”，参见样例9。

设计建议：

参考答题判题程序-1，建议增加答题类，类的内容以及类之间的关联自行设计。

输入样例1:
一张试卷一张答卷。试卷满分不等于100。例如：

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

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

#T:1 1-5 2-8

#S:1>#S:1 #A:5 #A:22 end 输出样例1: 在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
1+1=₅false
2+2=₂₂false
0 0~0
输入样例2:
一张试卷一张答卷。试卷满分不等于100。例如：

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

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

#T:1 1-70 2-30

#S:1>#S:1 #A:5 #A:22 end 输出样例2: 在这里给出相应的输出。例如：

1+1=₅false
2+2=₂₂false
0 0~0
输入样例3:
一张试卷、一张答卷。各类信息混合输入。例如：

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

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

#T:1 1-70 2-30

#N:3 #Q:3+2= #A:5

#S:1>#S:1 #A:5 #A:4 end 输出样例: 在这里给出相应的输出。例如：

1+1=₅false
2+2=₄true
0 30~30
输入样例4:
试卷题目的顺序与题号不一致。例如：

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

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

#T:1 2-70 1-30

#N:3 #Q:3+2= #A:5

#S:1 #A:5 #A:22 end 输出样例: 在这里给出相应的输出。例如：

2+2=₅false
1+1=₂₂false
0 0~0
输入样例5:
乱序输入。例如：

#N:3 #Q:3+2= #A:5

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

#T:1 3-70 2-30

#S:1 #A:5 #A:22

#N:1 #Q:1+1= #A:2 end 输出样例: 在这里给出相应的输出。例如：

3+2=₅true
2+2=₂₂false
70 0~70
输入样例6:
乱序输入+两份答卷。例如：

#N:3 #Q:3+2= #A:5

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

#T:1 3-70 2-30

#S:1 #A:5 #A:22

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

#S:1 #A:5 #A:4 end 输出样例: 在这里给出相应的输出。例如：

3+2=₅true
2+2=₂₂false
70 0~70
3+2=₅true
2+2=₄true
70 30~100
输入样例7:
乱序输入+分值不足100+两份答卷。例如：

#N:3>#N:3 #Q:3+2= #A:5

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

#T:1 3-7 2-6

#S:1 #A:5 #A:22

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

#S:1>#S:1 #A:5 #A:4 end 输出样例: 在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
3+2=₅true
2+2=₂₂false
7 0~7
3+2=₅true
2+2=₄true
7 6~13
输入样例8:
乱序输入+分值不足100+两份答卷+答卷缺失部分答案。例如：

#N:3>#N:3 #Q:3+2= #A:5

#N:2>#N:2 #Q:2+2= #A:4

#T:1 3-7 2-6

#S:1 #A:5 #A:22

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

#T:2 2-5 1-3 3-2

#S:2 #A:5 #A:4 end 输出样例: 在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
3+2=₅true
2+2=₂₂false
7 0~7
2+2=₅false
1+1=₄false
answer is null
0 0 0~0
输入样例9:
乱序输入+分值不足100+两份答卷+无效的试卷号。例如：

#N:3 #Q:3+2= #A:5

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

#T:1 3-7 2-6

#S:3 #A:5 #A:4 end 输出样例: 在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
The test paper number does not exist

点击查看代码

import java.util.*;
class Question {
    String number;
    String content;
    String answer;
    public Question(String number, String content, String answer) {
        this.number = number;
        this.content = content;
        this.answer = answer;
    }
}
class TestPaper {
    String number;
    Map<String, Integer> questions;
    public TestPaper(String number, Map<String, Integer> questions) {
        this.number = number;
        this.questions = questions;
    }
}
class AnswerSheet {
    String number;
    List<String> answers;

    public AnswerSheet(String number, List<String> answers) {
        this.number = number;
        this.answers = answers;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        List<Question> questionList = new ArrayList<>();
        Map<String, TestPaper> testPapers = new HashMap<>();
        List<AnswerSheet> answerSheets = new ArrayList<>();
        String line;
        while (!(line = scanner.nextLine()).equals("end")) {
            if (line.startsWith("#N:")) {
                String[] parts = line.split(" ");
                String number = parts[0].substring(3);
                String content = parts[1].substring(3);
                String answer = parts[2].substring(3);
                questionList.add(new Question(number, content, answer));
            } else if (line.startsWith("#T:")) {
                String[] parts = line.split(" ");
                String testNumber = parts[0].substring(3);
                Map<String, Integer> questions = new HashMap<>();
                for (int i = 1; i < parts.length; i++) {
                    String[] pair = parts[i].split("-");
                    questions.put(pair[0], Integer.parseInt(pair[1]));
                }
                testPapers.put(testNumber, new TestPaper(testNumber, questions));
            } else if (line.startsWith("#S:")) {
                String[] parts = line.split(" ");
                String testNumber = parts[0].substring(3);
                List<String> answers = new ArrayList<>();
                for (int i = 1; i < parts.length; i++) {
                    answers.add(parts[i].substring(3));
                }
                answerSheets.add(new AnswerSheet(testNumber, answers));
            }
        }
        for (Map.Entry<String, TestPaper> entry : testPapers.entrySet()) {
            int totalScore = 0;
            for (Map.Entry<String, Integer> question : entry.getValue().questions.entrySet()) {
                totalScore += question.getValue();
            }
            if (totalScore != 100) {
                System.out.println("alert: full score of test paper" + entry.getKey() + " is not 100 points");
            }
        }  
        for (AnswerSheet answerSheet : answerSheets) {
            List<String> answers = answerSheet.answers;
            TestPaper testPaper = testPapers.get(answerSheet.number);
            List<Integer> scores = new ArrayList<>();
            for (int i = 0; i < answers.size(); i++) {
                String answer = answers.get(i);
                if (i < questionList.size()) {
                    Question question = questionList.get(i);
                    if (testPaper.questions.containsKey(question.number)) {
                        if (question.answer.equals(answer)) {
                            System.out.println(question.content + "~" + answer + "~true");
                            scores.add(testPaper.questions.get(question.number));
                        } else {
                            System.out.println(question.content + "~" + answer + "~false");
                            scores.add(0);
                        }
                    }
                } else {
                    System.out.printf("answer is null");
                    scores.add(0);
                }
            }
            int totalScore = scores.stream().mapToInt(Integer::intValue).sum();
            String scoreInfo = scores.stream().map(Object::toString).reduce((s1, s2) -> s1 + " " + s2).orElse("");
            System.out.println(scoreInfo + "~" + totalScore);
        }
    }
}

让我具体阐释一下我的代码。 1.Question 类：这个类表示一道题目，包含题号（number）、题目内容（content）和答案（answer）。构造函数 Question(String number, String content, String answer) 用于初始化题目对象。 2.TestPaper 类：这个类表示一张试卷，包含试卷编号（number）和题目集合（questions）。题目集合使用 Map 类型，其中键为题目编号，值为题目分值。构造函数 TestPaper(String number, Map questions) 用于初始化试卷对象。 3.AnswerSheet 类：这个类表示一张答题卡，包含答题卡编号（number）和答案列表（answers）。答案列表使用 List 类型，存储每道题目的答案。构造函数 AnswerSheet(String number, List answers) 用于初始化答题卡对象 1）题目信息处理：当程序读取到以 #N: 开头的行时，表示这是题目信息。程序会将该行按空格分割成三个部分，分别是题号、题目内容和答案。然后创建一个 Question 对象，并将其添加到 questionList 中。Question 对象是一个简单的类，用于表示题目的信息，包括题号、题目内容和答案。 2)试卷信息处理：当程序读取到以 #T: 开头的行时，表示这是试卷信息。程序会将该行按空格分割成两部分，试卷编号和一系列题号-分值对。然后创建一个 TestPaper 对象，并将其添加到 testPapers 中。TestPaper 对象包含了试卷的编号和一系列题号及其对应的分值。 3)答题卡信息处理：当程序读取到以 #S: 开头的行时，表示这是答题卡信息。程序会将该行按空格分割成两部分，试卷编号和一系列答案。然后创建一个 AnswerSheet 对象，并将其添加到 answerSheets 中。AnswerSheet 对象包含了试卷的编号和一系列答案。 4)分数计算：对于每张答题卡，程序会遍历其中的答案，并根据题目的正确答案和试卷的分值计算学生的得分。如果答案与正确答案相符，则加上对应题目的分值；否则不加分。最后将总分和每题的得分情况输出。 5)完整性检查：对于每张试卷，程序会遍历其中的题目，并累加每道题目的分值，然后检查总分是否为 100 分。如果总分不为 100 分，则输出警告信息，表示试卷可能存在错误。代码存在的问题和第一次差不多调试过程中非零返回给我逼疯了。啊啊啊啊啊。代码主要问题是会出现非零返回错误，主要原因是正则表达式错了导致类型不匹配。没有实行单一职责，应该把字符串判断写成一个类。下面是我的代码类图。

3）答题判断程序-3
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-2基础上增补或者修改的内容，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。

输入格式:

程序输入信息分五种，信息可能会打乱顺序混合输入。

1、题目信息
题目信息为独行输入，一行为一道题，多道题可分多行输入。

格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案

格式约束：
1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4

2、试卷信息

试卷信息为独行输入，一行为一张试卷，多张卷可分多行输入数据。
格式："#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...

格式约束：
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例：#T:1 3-5 4-8 5-2

3、学生信息

学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名，格式如下。

格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名

格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：
#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
4、答卷信息

答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序号与试卷信息中的题目顺序相对应。答卷中：

格式："#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...

格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
答案内容可以为空，即””。
答案内容中如果首尾有多余的空格，应去除后再进行判断。
样例：
#T:1 1-5 3-2 2-5 6-9 4-10 7-3
#S:1 20201103 #A:2-5 #A:6-4
1是试卷号
20201103是学号
2-5中的2是试卷中顺序号，5是试卷第2题的答案，即T中3-2的答案
6-4中的6是试卷中顺序号，4是试卷第6题的答案，即T中7-3的答案
注意：不要混淆顺序号与题号

5、删除题目信息

删除题目信息为独行输入，每一行为一条删除信息，多条删除信息可分多行输入。该信息用于删除一道题目信息，题目被删除之后，引用该题目的试卷依然有效，但被删除的题目将以0分计，同时在输出答案时，题目内容与答案改为一条失效提示，例如：”the question 2 invalid~0”

格式："#D:N-"+题目号

格式约束：

   题目号与第一项”题目信息”中的题号相对应，不是试卷中的题目顺序号。

   本题暂不考虑删除的题号不存在的情况。

样例：

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

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

#T:1 1-5 2-8

#X:20201103>#X:20201103 Tom-20201104 Jack

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

#D:N-2>#D:N-2 end

输出
alert: full score of test paper1 is not 100 points
1+1=₅false
the question 2 invalid~0
20201103 Tom: 0 0~0
答题信息以一行"end"标记结束，"end"之后的信息忽略。

输出格式:

1、试卷总分警示

该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100 分，该部分忽略，不输出。

格式："alert: full score of test paper"+试卷号+" is not 100 points"

样例：alert: full score of test paper2 is not 100 points

2、答卷信息

一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。

格式：题目内容+"_"+答案++""+判题结果（true/false）

约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"
样例：
3+2=₅true
4+6=₂₂false.
answer is null

3、判分信息

判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。

格式：**学号+" "+姓名+": "**+题目得分+" "+....+题目得分+"~"+总分

格式约束：

 1、没有输入答案的题目、被删除的题目、答案错误的题目计0分
 2、判题信息的顺序与输入答题信息中的顺序相同
样例：20201103 Tom: 0 0~0

   根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。

4、被删除的题目提示信息

当某题目被试卷引用，同时被删除时，答案中输出提示信息。样例见第5种输入信息“删除题目信息”。

5、题目引用错误提示信息

试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。例如：

输入：

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

#T:1 3-8

#X:20201103 Tom-20201104 Jack-20201105 Www

#S:1 20201103 #A:1-4 end

输出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案输出时，一道题目同时出现答案不存在、引用错误题号、题目被删除，只提示一种信息，答案不存在的优先级最高，例如：
输入：

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

#T:1 3-8

#X:20201103 Tom-20201104 Jack-20201105 Www

#S:1 20201103 end

输出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0

6、格式错误提示信息

输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。

  例如：wrong format:2 #Q:2+2= #4

7、试卷号引用错误提示输出

如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出，参见样例8。

8、学号引用错误提示信息

如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。参见样例9。

本题暂不考虑出现多张答卷的信息的情况。

输入样例1:
简单输入，不含删除题目信息。例如：

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

#T:1 1-5

#X:20201103 Tom

#S:1 20201103 #A:1-5 end 输出样例1: 在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
1+1=₅false
20201103 Tom: 0~0
输入样例2:
简单输入，答卷中含多余题目信息（忽略不计）。例如：

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

#T:1 1-5

#X:20201103 Tom

#S:1>#S:1 20201103 #A:1-2 #A:2-3 end 输出样例3 简单测试，含删除题目信息。例如：

alert: full score of test paper1 is not 100 points
1+1=₂true
20201103 Tom: 5~5
输入样例3:
简单测试，含删除题目信息。例如：

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

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

#T:1 1-5 2-8

#X:20201103 Tom-20201104 Jack-20201105 Www

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

#D:N-2 end 输出样例3: 在这里给出相应的输出，第二题由于被删除，输出题目失效提示。例如：

alert: full score of test paper1 is not 100 points
1+1=₅false
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例4:
简单测试，含试卷无效题目的引用信息以及删除题目信息（由于题目本身无效，忽略）。例如：

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

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

#T:1 1-5 3-8

#X:20201103 Tom-20201104 Jack-20201105 Www

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

#D:N-2 end 输出样例4: 输出不存在的题目提示信息。例如：

alert: full score of test paper1 is not 100 points
1+1=₅false
non-existent question~0
20201103 Tom: 0 0~0
输入样例5:
综合测试，含错误格式输入、有效删除以及无效题目引用信息。例如：

#N:1 +1= #A:2

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

#T:1 1-5 2-8

#X:20201103 Tom-20201104 Jack-20201105 Www

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

#D:N-2 end 输出样例5: 在这里给出相应的输出。例如：

wrong format:#N:1 +1= #A:2
alert: full score of test paper1 is not 100 points
non-existent question~0
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例6:
综合测试，含错误格式输入、有效删除、无效题目引用信息以及答案没有输入的情况。例如：

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

#N:2>#N:2 #Q:2+2= #A:4

#T:1 1-5 2-8

#X:20201103 Tom-20201104 Jack-20201105 Www

#S:1 20201103 #A:1-5

#D:N-2 end 输出样例6: 答案没有输入的优先级最高。例如：

wrong format:#N:1 +1= #A:2
alert: full score of test paper1 is not 100 points
non-existent question~0
answer is null
20201103 Tom: 0 0~0
输入样例7:
综合测试，正常输入，含删除信息。例如：

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

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

#T:1>#T:1 1-5 2-8

#X:20201103>#X:20201103 Tom-20201104 Jack-20201105 Www #S:1 20201103 #A:2-4 #A:1-5 #D:N-2 end 输出样例7: 例如：

alert: full score of test paper1 is not 100 points
1+1=₅false
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例8:
综合测试，无效的试卷引用。例如：

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

#T:1 1-5

#X:20201103 Tom

#S:2 20201103 #A:1-5 #A:2-4 end 输出样例8: 例如：

alert: full score of test paper1 is not 100 points
The test paper number does not exist
输入样例9:
无效的学号引用。例如：

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

#T:1 1-5

#X:20201106 Tom

#S:1 20201103 #A:1-5 #A:2-4 end 输出样例9: 答案照常输出，判分时提示错误。例如：

alert: full score of test paper1 is not 100 points
1+1=₅false
20201103 not found

输入样例10:
信息可打乱顺序输入：序号不是按大小排列，各类信息交错输入。但本题不考虑引用的题目在被引用的信息之后出现的情况（如试卷引用的所有题目应该在试卷信息之前输入），所有引用的数据应该在被引用的信息之前给出。例如：

#N:3 #Q:中国第一颗原子弹的爆炸时间 #A:1964.10.16

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

#X:20201103 Tom-20201104 Jack-20201105 Www

#T:1>#T:1 1-5 3-8

#N:2>#N:2 #Q:2+2= #A:4 #S:1 20201103 #A:1-5 #A:2-4 end 输出样例10: 答案按试卷中的题目顺序输出。例如：

alert: full score of test paper1 is not 100 points
1+1=₅false
中国第一颗原子弹的爆炸时间₄false
20201103 Tom: 0 0~0

点击查看代码

import java.util.*;

class Question {
    private String number;
    private String content;
    private String answer;

    private String score;

    private String original;

    private String stuAnswer = "";

    private Integer point = 0;
    private boolean isValid = true;
    private boolean existed = true;
}

class QuestionPoint {

    private String questionId;
    private Integer questionPoint;
}

class TestPaper {
    private String number;
    private List<QuestionPoint> questionPointList = new ArrayList<>();

    private List<Integer> questionOrder = new ArrayList<>();

    public TestPaper() {

    }
}

class Answer {
    private Integer questionOrder;
    private String questionAnswer;

    public Answer(Integer questionOrder, String questionAnswer) {
        this.questionOrder = questionOrder;
        this.questionAnswer = questionAnswer;
    }
}

class AnswerSheet {
    private String number;
    private List<Answer> answers;

    private Map<String, String> answerMap = new HashMap<>();
}

class Student {
    private String studentId;
    private String studentName;
    private AnswerSheet answerSheet;
}

这次对类进行了一些改动，终于没有非零返回的问题了。以下是对我代码的一些解释一·仅在Question类中 1.题目信息处理：当程序读取到以 #N: 开头的行时，它将这一行分割成三个部分：题号、题目内容和答案。题号是题目的唯一标识符，题目内容是学生需要回答的具体问题，而答案则是题目的正确答案。这些信息被封装到一个 Question 对象中，并添加到 questionList 列表中，以便稍后对答题卡中的答案进行比对。 2.试卷信息处理：当程序读取到以 #T: 开头的行时，它将这一行分割成试卷编号和一系列题号-分值对。每个题号-分值对表示试卷中的一个题目及其对应的分值。这些信息被封装到一个 TestPaper 对象中，并添加到 testPapers 列表中，以便稍后根据试卷信息计算学生的得分。 3.答题卡信息处理：当程序读取到以 #S: 开头的行时，它将这一行分割成试卷编号和一系列答案。每个答案对应于学生在答题卡上给出的答案。这些信息被封装到一个 AnswerSheet 对象中，并添加到 answerSheets 列表中，以便稍后根据学生的答案计算得分。 4.分数计算：对于每张答题卡，程序会遍历其中的答案，并根据题目的正确答案和试卷的分值计算学生的得分。如果学生的答案与题目的正确答案相符，则加上对应题目的分值；否则不加分。最后，程序将总分和每道题目的得分情况输出，以便老师或管理员进行查看和记录。 5.完整性检查：对于每张试卷，程序会遍历其中的题目，并累加每道题目的分值。然后，程序检查总分是否为 100 分。如果总分不为 100 分，则输出警告信息，表示试卷可能存在错误，需要进一步检查和修正。 //本来是想将Question类做成中介类来实现单一职责，但是失败了。

二.QuestionPoint：
这个类表示试卷中每个题目的分值。
它包含两个属性：题目编号（questionId）和分值（questionPoint）。
通过提供构造函数和相应的 getter 和 setter 方法，可以方便地创建和访问题目分值信息。

三.TestPaper：
这个类表示一个试卷，包含试卷编号、题目分值列表和题目顺序。
它包含三个属性：试卷编号（number）、题目分值列表（questionPointList）和题目顺序（questionOrder）。
通过提供构造函数和相应的 getter 和 setter 方法，可以方便地创建和访问试卷信息。

四.Answer：
这个类表示学生对某个题目的答案。
它包含两个属性：题目顺序（questionOrder）和学生的答案内容（questionAnswer）。
通过提供构造函数和相应的 getter 和 setter 方法，可以方便地创建和访问答案信息。

五.AnswerSheet：
这个类表示学生的答题卡，包含答题卡编号、答案列表和答案映射。
它包含三个属性：答题卡编号（number）、答案列表（answers）和答案映射（answerMap）。
通过提供构造函数和相应的 getter 和 setter 方法，可以方便地创建和访问答题卡信息。

六Student：
这个类表示一个学生，包含学生编号、学生姓名和答题卡。
它包含三个属性：学生编号（studentId）、学生姓名（studentName）和答题卡（answerSheet）。
通过提供构造函数和相应的 getter 和 setter 方法，可以方便地创建和访问学生信息。

三.踩坑心得
1.对于所存在的错误，有很多的非零返回，原因对于正则表达式掌握不熟练。
2.类的关系把握的不是很准确。
3.没有用到单一职责，main里有很多对于字符串的处理，对以后埋了很大的坑。
4.对于Java中
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
还不会。
四.改进建议
1.增加字符串的判断类，以便更好地符合单一职责。
2.弄清类间关系，做到低耦合。
五.总结
三次题目集，学会了简单的类间关系，类的写法，正则表达式，linkedlist等。
对于这三次题目集，个人存在着极大的问题，首先是正则表达式的掌握还不太清楚，不能把学的东西灵活的实践运用。个人的类的设计存在极大的问题，对集合比如arraylist和map等还需要更深入的学习。
对于教学希望老师可以稍微降低节奏。

posted on 2024-04-20 22:33 守鹤梁梦阅读(26) 评论(1) 编辑收藏举报

刷新页面返回顶部

zhongxiaye

公告

View Post

第一次博客作业