java4~6次大作业全面总结

爱编程的小菜鸟2024-11-23 16:03

一:前言:

  1. 知识点总结:
  • 面向对象设计:
    • 智能家居强电电路模拟系统：设计了多种控制设备（开关、分档调速器、连续调速器）和受控设备（灯、风扇）的类，并通过继承和多态实现设备的特有行为。
    • 答题判题程序：设计了题目、试卷、学生、答卷等类，通过面向对象的方式管理考试信息。
  • 数据结构:
    • 智能家居强电电路模拟系统：使用图或链表表示电路的连接关系，处理并联和串联电路的组合逻辑。
    • 答题判题程序：使用哈希表（Map）存储题目信息、试卷信息、学生信息、答卷信息和删除题目信息，使用列表（List）存储试卷中的题目及其分值，以及学生的答题信息。
  • 算法：
    • 智能家居强电电路模拟系统：计算电路中的电压、电流、电阻等物理量，处理并联和串联电路的组合逻辑，确保计算结果正确。
    • 答题判题程序：判断答案是否正确，处理多选题和填空题的特殊评分规则，计算总分。
  • 异常处理：
    • 智能家居强电电路模拟系统：处理输入数据的合法性检查，如设备编号、连接信息等，处理边界条件和特殊情况，如电压超出范围、设备未连接等。
    • 答题判题程序：处理输入格式错误的情况，处理题目被删除、题目不存在、试卷总分不为100分等特殊情况。
  1. 题量分析:
  • 智能家居强电电路模拟系统:
    • 类的设计:
      • 控制设备类：开关、分档调速器、连续调速器
      • 受控设备类：白炽灯、日光灯、吊扇、落地扇
      • 电路类：串联电路、并联电路
    • 主控类或函数：
      • 处理输入信息，解析设备和连接信息。
      • 模拟电路行为，计算各设备的状态。
      • 输出设备状态和参数
    • 测试用例：
      • 编写测试用例验证程序的正确性和鲁棒性。
  • 答题判题程序:
    • 类的设计：
      • Question 类：表示题目，包含题目编号、题目内容、标准答案等属性。
      • TestPaper 类：表示试卷，包含试卷号、题目及其分值等属性。
      • Student 类：表示学生，包含学号、姓名等属性。
      • AnswerSheet 类：表示答卷，包含试卷号、学号、答题信息等属性。
    • 主控类或函数：
      • 处理输入信息，解析题目、试卷、学生、答卷、删除题目等信息。
      • 构建题目、试卷、学生、答卷等对象。
      • 模拟答题，计算成绩，处理各种特殊情况。
      • 按照指定格式输出结果。
  1. 难度分析:

  • 智能家居强电电路模拟系统： 题目涉及多个设备和复杂的电路连接，需要综合运用面向对象设计、数据结构、算法等知识。需要处理并联和串联电路的组合逻辑，确保计算结果正确。输入输出处理较为复杂，需要仔细解析和格式化输出,题目难度较大。

  • 答题判题程序: 题目涉及多个数据结构和复杂的逻辑判断，需要综合运用字符串处理、逻辑判断、排序等知识。处理多选题和填空题的特殊评分规则，确保评分结果正确。处理各种特殊情况，如题目被删除、题目不存在、试卷总分不为100分、输入格式错误等。按照指定格式输出结果，确保输出信息的完整性和正确性,题目难度较大。

  1. 综合分析总结:
    这三道题目涵盖了面向对象设计、数据结构、算法、输入输出处理、异常处理等多个方面的知识。每道题目的设计和实现都需要综合运用这些知识，解决实际问题。通过这些题目，可以提升编程能力和问题解决能力，特别是在处理复杂数据结构和逻辑判断方面。

二:设计与分析

1. 第四道大作业:

  • 题目描述: 这道题要求我们设计并实现一个小巧的在线考试系统，能够处理不同类型的问题，比如普通的问答题、选择题和填空题。这个系统不仅要能够接收题目信息（包括题目的编号、内容和正确答案）、试卷信息（包含哪些题目以及每个题目的分数）、学生信息（学号和姓名），还要能够接收学生的答题情况。特别的是，这个系统还需要支持删除题目，即使这些题目已经被包含在试卷里了，删除后这些题目的分数就会变成0分。系统要能够根据学生的答案自动评分，考虑到不同题型的评分规则，最后，系统要能够输出每个学生的答题详情和总成绩，同时还要检查试卷的总分是否达到100分，如果没有达到也要给出提示。此外，系统还需要能够处理一些异常情况，比如输入格式错误或者试卷号、学号引用错误等问题，确保系统的稳定性和准确性。整个过程中，所有的信息都可以以任意顺序输入，系统需要能够灵活应对。

  • 基本思路: 这道题要用Java实现一个小型在线考试系统。首先，用哈希表存储题目、试卷和学生信息，列表存储学生的答题信息，集合记录被删除的题目。然后，读取和解析输入信息，根据前缀（如#N:、#T:、#X:等）将信息存入相应的数据结构。接着，遍历每个学生的答题信息，检查题目是否存在、是否被删除，比对答案并根据题目类型计算得分。最后，按学号和试卷号排序，输出每个学生的答题详情和总分，检查试卷总分是否为100分并给出提示，处理试卷号或学号引用错误的情况。

  • 画类图,缕清关系:

总共定义了以下几个类：

  1. ExamQuestionInfo:主要负责存储题目信息，包括题目ID、内容、正确答案、是否有效、是否为多选题等
  2. DataManipulationClass:包含一些辅助方法，但目前的方法没有实际用途，可以考虑移除或添加实际功能。
  3. ExamPaperDetails:存储试卷信息，包括试卷ID和每个题目的分数。
  4. MainClass:包含一些模拟方法，但目前的方法没有实际用途，可以考虑移除或添加实际功能。
  5. StudentAnswerRecord:存储学生的答题记录，包括试卷ID、学生标识和每题的答案。
  6. Main:主类，包含主方法main，负责读取输入、处理输入和生成输出。

  • ExamQuestionInfo类核心代码:

    class ExamQuestionInfo {
    private int questionId;
    private String questionContent;
    private String correctAnswerText;
    private boolean isValidStatus = true;
    private boolean isMultipleChoiceType;

      public ExamQuestionInfo(int id, String content, String answer, boolean isMultipleChoice) {
      this.questionId = id;
      this.questionContent = content;
      this.correctAnswerText = answer;
      this.isMultipleChoiceType = isMultipleChoice;
  }

  public boolean checkAnswerMatch(String studentAnswer) {
      return correctAnswerText.equalsIgnoreCase(studentAnswer);
  }

  public boolean isAnswerPartiallyCorrect(String studentAnswer) {
      if (isMultipleChoiceType) {
          Set<String> correctAnswerSet = new HashSet<>(List.of(correctAnswerText.split(" ")));
          Set<String> studentAnswerSet = new HashSet<>(List.of(studentAnswer.split(" ")));
          return !correctAnswerSet.equals(studentAnswerSet) && correctAnswerSet.containsAll(studentAnswerSet) && studentAnswerSet.size() < correctAnswerSet.size();
      } else {
          return correctAnswerText.contains(studentAnswer) && !studentAnswer.equals(correctAnswerText);
      }
  }

  public void setInvalidStatus() {
      isValidStatus = false;
  }

  public boolean isValid() {
      return isValidStatus;
  }

  public boolean isMultipleChoice() {
      return isMultipleChoiceType;
  }

    }

  • ExamPaperDetails类核心代码:

    class ExamPaperDetails {
    private int paperId;
    private Map<Integer, Integer> questionScoreMap = new HashMap<>();

      public ExamPaperDetails(int id) {
      this.paperId = id;
  }

  public void addQuestionScore(int questionId, int score) {
      questionScoreMap.put(questionId, score);
  }

  public boolean verifyTotalScore() {
      int totalScore = questionScoreMap.values().stream().mapToInt(Integer::intValue).sum();
      if (totalScore != 100) {
          System.out.println("alert: full score of test paper " + paperId + " is not 100 points");
          return false;
      }
      return true;
  }

  public boolean confirmQuestionExistence(Map<Integer, ExamQuestionInfo> allQuestions) {
      return questionScoreMap.keySet().stream().allMatch(allQuestions::containsKey);
  }

  public Map<Integer, Integer> getQuestionScoreMap() {
      return questionScoreMap;
  }

    }

  • StudentAnswerRecord类核心代码:

    class StudentAnswerRecord {
    private int relatedPaperId;
    private String studentIdentifier;
    private Map<Integer, String> studentAnswers = new HashMap<>();

      public StudentAnswerRecord(int paperId, String studentId) {
      this.relatedPaperId = paperId;
      this.studentIdentifier = studentId;
  }

  public void recordAnswer(int questionId, String answer) {
      studentAnswers.put(questionId, answer);
  }

  public String getStudentIdentifier() {
      return studentIdentifier;
  }

  public int getRelatedPaperId() {
      return relatedPaperId;
  }

  public Map<Integer, String> getStudentAnswers() {
      return studentAnswers;
  }

    }

  • Main类核心代码:

    public class Main {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    Map<Integer, ExamQuestionInfo> questions = new HashMap<>();
    Map<Integer, ExamPaperDetails> examPapers = new HashMap<>();
    Map<String, String> students = new HashMap<>();
    Map<String, List<StudentAnswerRecord>> answers = new HashMap<>();
    Set<Integer> deletedQuestions = new HashSet<>();

          processInput(scanner, questions, examPapers, students, answers, deletedQuestions);
      generateAndOutputResults(questions, examPapers, students, answers, deletedQuestions);
      scanner.close();
  }

  private static void processInput(Scanner scanner, Map<Integer, ExamQuestionInfo> questions, Map<Integer, ExamPaperDetails> examPapers,
                                   Map<String, String> students, Map<String, List<StudentAnswerRecord>> answers,
                                   Set<Integer> deletedQuestions) {
      while (scanner.hasNextLine()) {
          String line = scanner.nextLine().trim();
          if ("end".equals(line)) break;
          if (line.startsWith("#N:") || line.startsWith("#Z:") || line.startsWith("#K:")) {
              handleQuestionInput(line, questions);
          } else if (line.startsWith("#T:")) {
              handleExamPaperInput(line, examPapers, questions);
          } else if (line.startsWith("#X:")) {
              handleStudentInput(line, students);
          } else if (line.startsWith("#S:")) {
              handleStudentAnswerInput(line, examPapers, students, answers);
          } else if (line.startsWith("#D:N-")) {
              handleDeletedQuestionInput(line, questions, deletedQuestions);
          } else {
              System.out.println("wrong format:" + line);
          }
      }
  }

  private static void handleQuestionInput(String line, Map<Integer, ExamQuestionInfo> questions) {
      // Handle question input and populate the questions map
  }

  private static void handleExamPaperInput(String line, Map<Integer, ExamPaperDetails> examPapers, Map<Integer, ExamQuestionInfo> questions) {
      // Handle exam paper input and populate the examPapers map
  }

  private static void handleStudentInput(String line, Map<String, String> students) {
      // Handle student input and populate the students map
  }

  private static void handleStudentAnswerInput(String line, Map<Integer, ExamPaperDetails> examPapers, Map<String, String> students,
                                               Map<String, List<StudentAnswerRecord>> answers) {
      // Handle student answer input and populate the answers map
  }

  private static void handleDeletedQuestionInput(String line, Map<Integer, ExamQuestionInfo> questions, Set<Integer> deletedQuestions) {
      // Handle deleted question input and update the questions and deletedQuestions sets
  }

  private static void generateAndOutputResults(Map<Integer, ExamQuestionInfo> questions, Map<Integer, ExamPaperDetails> examPapers,
                                               Map<String, String> students, Map<String, List<StudentAnswerRecord>> answers,
                                               Set<Integer> deletedQuestions) {
      // Generate and output the results based on the processed data
  }

    }

  • 踩坑心得:

    • 数据结构的选择:

      • 使用 Map 来存储题目、试卷、学生信息等是非常合适的，因为这些数据通常需要通过唯一的标识符（如题目ID、试卷ID、学生ID）快速查找。
      • 使用 List 来存储学生的答题记录，因为一个学生可能多次参加同一份试卷的考试。

    • 性能优化:

      • 对于大数据量的输入，需要考虑性能优化。例如，使用 HashMap 而不是 TreeMap 可以提高查找速度。
      • 在生成结果时，对数据进行预处理和排序可以提高效率。

    • 边界条件:

      • 处理好各种边界条件，如空输入、无效的题目ID、空答案等。这些边界条件很容易被忽略，但在实际运行中可能会导致问题。

  • 改进建议:

    • 模块化设计:
      • 将每个功能模块化，每个模块负责一个特定的任务。这样可以提高代码的可读性和可维护性。
      • 例如，可以将 handleQuestionInput、handleExamPaperInput 等方法封装成独立的类或接口。
    • 异常处理改进:
      • 对异常处理进行细化，区分不同的异常类型，提供更具体的错误信息。
      • 例如，可以区分输入格式错误、数据不存在等不同类型的异常，并给出相应的提示。

2.第五道大作业:

  • 题目描述: 本题要求设计并实现一个智能家居强电电路模拟系统，该系统能够模拟控制设备（包括开关、分档调速器、连续调速器）和受控设备（包括白炽灯、日光灯、吊扇）之间的连接和工作状态。系统需要解析输入的设备信息、连接信息以及控制设备的调节信息，根据这些信息构建电路模型，计算并更新各设备的工作状态或参数，如开关的开启/关闭状态、调速器的档位、灯具的亮度以及风扇的转速。特别地，系统需遵循特定的连接规则，如不考虑调速器之间的串联、控制设备的并联或反馈接入，并且所有连接信息按电路从电源到接地的顺序依次输入。最终，系统应按照指定格式输出所有设备的状态或参数，包括控制设备的档位或状态、灯具的亮度、风扇的转速等。此外，系统还需处理输入电压或电压差的计算，采用截尾规则保留整数部分，并确保所有计算过程中使用double类型以避免精度误差。

  • 基本思路: 解题的核心思路是：首先，定义设备类（开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇），每个类包含必要的属性和方法来表示设备的状态和行为。接着，构建一个电路模型来管理设备之间的连接关系，解析输入的连接信息，确保遵循连接规则，并处理电压的逐级传递。然后，实现状态更新机制，根据用户对控制设备的调节指令（如开关切换、调速器调整），更新设备状态并重新计算受控设备的工作参数（如亮度、转速）。最后，设计输出模块，按照指定格式输出所有设备的当前状态或参数，确保输出顺序和格式符合要求。主程序整合这些模块，处理用户输入，执行状态更新，并生成最终输出。

  • 画类图,缕清关系:

定义了以下类:
Test(主类):处理用户输入，注册设备和电路，执行控制命令，输出设备状态。
CircuitDevice（抽象类）:提供设备的基本属性和方法。
ControlledDevice（抽象类，继承自 CircuitDevice）:提供受控设备的电压计算和状态输出方法。
ControllingDevice（抽象类，继承自 CircuitDevice）:提供控制设备的命令执行方法。
SwitchDevice（继承自 ControllingDevice）:实现开关设备的开关状态切换和电压计算。
GearDevice（继承自 ControllingDevice）:实现分档调速器的档位调整和电压计算。
ContinuousSpeedDevice（继承自 ControllingDevice）:实现连续调速器的档位比例设置和电压计算。
LightDevice（继承自 ControlledDevice）:实现灯具的亮度计算和状态输出
RelayDevice（继承自 ControlledDevice）:实现继电器的亮度计算和状态输出。
MotorDevice（继承自 ControlledDevice）:实现风扇的转速计算和状态输出。
SeriesCircuit（继承自 ControlledDevice）:实现串联电路的电压计算和状态输出。

  • Test类核心代码:

    public class Test {
    private static final double VCC = 220.0;
    private static Map<String, CircuitDevice> devices = new HashMap<>();
    private static List<SeriesCircuit> circuits = new ArrayList<>();

      public static void main(String[] args) {
      // 主程序入口
  }

  private static void handleInput(String input) {
      // 处理输入
  }

  private static void registerConnection(String connectionInfo) {
      // 注册连接
  }

  private static boolean isDevice(String part) {
      // 判断是否为设备
  }

  private static CircuitDevice createDevice(String deviceId) {
      // 创建设备
  }

  private static void executeCommand(String command) {
      // 执行命令
  }

  private static void printDeviceStatuses() {
      // 打印设备状态
  }

  private static int getDeviceOrder(char type) {
      // 获取设备排序顺序
  }

    }

  • CircuitDevice 类核心代码:

    abstract static class CircuitDevice {
    protected final String id;
    protected final char type;

      CircuitDevice(String id) {
      this.id = id;
      this.type = id.charAt(0);
  }

  abstract String getStatus();

    }

  • ControlledDevice 类核心代码:

    abstract static class ControlledDevice extends CircuitDevice {
    ControlledDevice(String id) {
    super(id);
    }

      abstract double calculateVoltage();

    }

  • ControllingDevice 类核心代码:

    abstract static class ControllingDevice extends CircuitDevice {
    ControllingDevice(String id) {
    super(id);
    }

      abstract void executeCommand(String command);

    }

  • SwitchDevice 类核心代码:

    static class SwitchDevice extends ControllingDevice {
    private boolean closed;

      SwitchDevice(String id) {
      super(id);
  }

  @Override
  void executeCommand(String command) {
      // 执行开关命令
  }

  @Override
  String getStatus() {
      // 获取开关状态
  }

  double calculateVoltage() {
      // 计算电压
  }

    }

  • GearDevice 类

    static class GearDevice extends ControllingDevice {
    private int gear;

      GearDevice(String id) {
      super(id);
  }

  @Override
  void executeCommand(String command) {
      // 执行档位命令
  }

  @Override
  String getStatus() {
      // 获取档位状态
  }

  double calculateVoltage() {
      // 计算电压
  }

    }

  • ContinuousSpeedDevice 类核心代码:

    static class ContinuousSpeedDevice extends ControllingDevice {
    private double ratio;

      ContinuousSpeedDevice(String id) {
      super(id);
  }

  @Override
  void executeCommand(String command) {
      // 执行连续速度命令
  }

  @Override
  String getStatus() {
      // 获取连续速度状态
  }

  double calculateVoltage() {
      // 计算电压
  }

    }

  • LightDevice 类核心代码:

    static class LightDevice extends ControlledDevice {
    private double voltage;

      LightDevice(String id) {
      super(id);
  }

  @Override
  double calculateVoltage() {
      // 计算电压
  }

  @Override
  String getStatus() {
      // 获取灯光状态
  }

    }

  • RelayDevice 类核心代码:

    static class RelayDevice extends ControlledDevice {
    private double voltage;

      RelayDevice(String id) {
      super(id);
  }

  @Override
  double calculateVoltage() {
      // 计算电压
  }

  @Override
  String getStatus() {
      // 获取继电器状态
  }

    }

  • MotorDevice 类核心代码:

    static class MotorDevice extends ControlledDevice {
    private double voltage;

      MotorDevice(String id) {
      super(id);
  }

  @Override
  double calculateVoltage() {
      // 计算电压
  }

  @Override
  String getStatus() {
      // 获取电机状态
  }

    }

  • SeriesCircuit 类核心代码:

    static class SeriesCircuit extends ControlledDevice {
    private final List<String> parts;

      SeriesCircuit(String[] parts) {
      super(parts[0].split("-")[0]);
      this.parts = Arrays.asList(parts);
  }

  @Override
  double calculateVoltage() {
      // 计算总电压
  }* 

  @Override
  String getStatus() {
      // 获取电路状态
  }

    }

  • 踩坑心得:

    • 电压计算:
      • 电压计算逻辑复杂，容易出错。特别是在串联电路中，多个设备的电压累加需要特别注意。
      • 具体表现：电压计算结果与预期不符，导致设备状态显示错误。
      • 解决过程：逐个设备调试电压计算逻辑，确保每个设备的电压计算正确无误。
    • 设备状态更新
      • 问题：设备状态更新逻辑复杂，容易遗漏或出错。特别是多个设备之间的交互。
      • 具体表现：设备状态更新不及时或更新错误，导致程序行为异常。
      • 解决过程：在每个设备类中明确实现 executeCommand 方法，并确保状态更新逻辑正确。添加日志记录，便于调试。

  • 改进建议:

    • 模块化设计: 将不同的功能模块化，例如输入解析、设备管理、状态输出等，分别放在不同的类或方法中，提高代码的可读性和可维护性。

    • 异常处理: 增强异常处理机制，确保程序在遇到非法输入或错误时能够优雅地处理，而不是直接崩溃。
      例如:

      private static CircuitDevice createDevice(String deviceId) {
      try {
      char deviceType = deviceId.charAt(0);
      switch (deviceType) {
      case 'K': return new SwitchDevice(deviceId);
      case 'F': return new GearDevice(deviceId);
      case 'L': return new ContinuousSpeedDevice(deviceId);
      case 'B': return new LightDevice(deviceId);
      case 'R': return new RelayDevice(deviceId);
      case 'D': return new MotorDevice(deviceId);
      default: throw new IllegalArgumentException("Unknown device type: " + deviceType);
      }
      } catch (IllegalArgumentException e) {
      System.err.println("Failed to create device: " + deviceId);
      System.err.println(e.getMessage());
      return null; // 返回 null 表示创建失败
      } catch (Exception e) {
      System.err.println("An unexpected error occurred while creating device: " + deviceId);
      System.err.println(e.getMessage());
      e.printStackTrace(); // 打印堆栈跟踪，便于调试
      return null; // 返回 null 表示创建失败
      }
      }

3. 第六道大作业:

  • 题目描述: 这道Java大作业题要求设计一个智能家居强电电路模拟系统，模拟家庭中各种电器设备的连接和控制逻辑，并输出设备的工作状态。系统需要模拟的设备包括开关、分档调速器、连续调速器（控制设备）和白炽灯、日光灯、吊扇、落地扇（受控设备）。输入信息包括设备信息、连接信息、控制设备调节信息、电源接地标识、串联电路信息和并联电路信息。输出信息按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇的顺序依次输出所有设备的状态或参数。计算过程中出现的小数部分用截尾规则处理，最终输出时保留整数部分。所有连接信息按从电源到接地的顺序输入，调速器的输入端只能直连VCC，且整个电路最多只有一个调速器。本次迭代只考虑一条包含并联电路的主电路。
  • 基本思路:难度太大,做不出来.

三:总结:

  • 第一道题目：答题程序

    • 学习收获:

      • 编程实践能力方面：通过这次答题程序的开发，我不仅巩固了对Java编程语言的理解，还提升了处理复杂输入输出的能力。题目涉及多种信息的输入（题目信息、试卷信息、学生信息、答卷信息、删除题目信息），需要对这些信息进行解析、处理和输出。这让我学会了如何使用Map、List等数据结构来管理和处理复杂的数据关系，确保程序的高效运行。

      • 问题解决技巧方面：在实现答题程序的过程中，遇到了许多具体的技术问题，例如如何高效地查找和删除题目信息，如何处理不同类型的题目评分等。这些问题促使我深入学习了Java集合框架的相关知识，以及如何合理设计类和接口来提高代码的复用性和可扩展性。同时，我也更加熟练地使用了调试工具，提高了代码调试效率。

      • 软件工程思想方面：这次作业让我深刻体会到了模块化设计的重要性。通过对题目的分析，我将程序分解为多个模块，如题目管理模块、试卷管理模块、学生信息管理模块等，每个模块负责处理特定的功能，使得整个程序结构清晰，易于维护。此外，我还学会了如何在代码中添加详细的注释和日志，这对于团队协作和后期维护都非常重要。

    • 需要进一步学习及研究的地方:

      • 设计模式的应用：虽然在这次作业中尝试使用了一些简单的设计模式，如单例模式和工厂模式，但在更复杂的设计模式应用上仍然存在不足。例如，如何在大型项目中有效地使用策略模式、观察者模式等，这些都需要在未来的实践中不断学习和积累。

      • 性能优化：这次作业的规模相对较小，但在处理大量数据时，程序的性能表现就显得尤为重要。未来需要加强对算法和数据结构的学习，掌握更多的性能优化技巧，以应对更大规模的数据处理需求。

      • 测试驱动开发（TDD）：虽然这次作业中也有一定的测试要求，但整体上对TDD的理解还不够深入。未来需要更多地学习和实践TDD的思想，学会如何编写高质量的单元测试，确保代码的质量。

    • 对教师、课程、作业、实验、课上及课下组织方式等方面的改进建议及意见

      • 课程内容：建议增加一些实战项目的练习，让我们在实际项目中应用所学知识，增强实战经验。同时，增加一些软件工程方法论的内容，帮助我们了解软件开发的整体流程。

      • 作业和实验：希望作业可以设计得更具有挑战性和实用性，鼓励我们在完成任务的同时，也能发挥创意，探索不同的解决方案。实验环节希望能提供更多指导和支持，特别是在遇到难题时，能够有更多资源可供参考。

      • 课上组织方式：希望课堂上能增加一些互动环节，比如小组讨论，让大家有机会互相交流学习心得，促进共同进步。教师可以分享一些个人经验和行业动态，拓宽我们的视野。

  • 第二道题目：智能家居强电电路模拟系统

    • 学习收获:

      • 编程实践能力方面：通过这次智能家居强电电路模拟系统的开发，我深入了解了物联网技术在家庭自动化中的应用。特别是对控制设备（开关、分档调速器、连续调速器）和受控设备（灯、风扇）的模拟，使我掌握了如何使用Java来建模和处理复杂的电路逻辑。通过处理不同设备的连接和状态变化，我学会了如何使用面向对象的方法来设计和实现系统，使代码更加模块化和可维护。

      • 问题解决技巧方面：在实现智能家居电路模拟系统的过程中，遇到了许多具体的技术问题，例如如何处理不同设备之间的连接关系，如何计算电压和输出状态等。这些问题促使我深入学习了Java中的数据结构和算法，以及如何合理设计类和方法来提高代码的复用性和可扩展性。同时，我也更加熟练地使用了调试工具，提高了代码调试效率。

      • 软件工程思想方面：这次作业让我深刻体会到了模块化设计的重要性。通过对电路设备的分类和建模，我将程序分解为多个模块，如控制设备模块、受控设备模块、连接信息模块等，每个模块负责处理特定的功能，使得整个程序结构清晰，易于维护。此外，我还学会了如何在代码中添加详细的注释和日志，这对于团队协作和后期维护都非常重要。

    • 需要进一步学习及研究的地方

      • 设计模式的应用：虽然在这次作业中尝试使用了一些简单的设计模式，如单例模式和工厂模式，但在更复杂的设计模式应用上仍然存在不足。例如，如何在大型项目中有效地使用策略模式、观察者模式等，这些都需要在未来的实践中不断学习和积累。

      • 性能优化：这次作业的规模相对较小，但在处理大量数据时，程序的性能表现就显得尤为重要。未来需要加强对算法和数据结构的学习，掌握更多的性能优化技巧，以应对更大规模的数据处理需求。

      • 测试驱动开发（TDD）：虽然这次作业中也有一定的测试要求，但整体上对TDD的理解还不够深入。未来需要更多地学习和实践TDD的思想，学会如何编写高质量的单元测试，确保代码的质量。

    • 对教师、课程、作业、实验、课上及课下组织方式等方面的改进建议及意见

      课程内容：建议增加一些实战项目的练习，让我们在实际项目中应用所学知识，增强实战经验。同时，增加一些软件工程方法论的内容，帮助我们了解软件开发的整体流程。

      • 作业和实验：希望作业可以设计得更具有挑战性和实用性，鼓励我们在完成任务的同时，也能发挥创意，探索不同的解决方案。实验环节希望能提供更多指导和支持，特别是在遇到难题时，能够有更多资源可供参考。

    通过这两道题目的总结，我认识到自己在编程实践和理论知识方面都有了进步，但也看到了自己还需要努力的地方。希望在未来的学习中，能够继续提升自己的技能，并将所学应用于实际项目中。

热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10【目标跟踪】相机运动补偿