大家好，欢迎来到设计模式系列文章（基础篇）的第二十八篇内容。在上一篇中，我们学习了行为型模式的第十七种常用模式——中介者模式，其核心是定义中介对象，封装多个对象之间的交互逻辑，使对象无需直接引用，从而降低耦合度，广泛应用于对象间交互复杂的场景。今天，我们将学习行为型模式的第十八种常用模式——备忘录模式，它的核心是在不破坏对象封装性的前提下，捕获对象的内部状态并保存到对象之外，当需要时可将对象恢复到之前保存的状态，轻松实现撤销、回滚等功能。
在日常开发和生活中，备忘录模式的应用无处不在。比如我们使用的文本编辑器，编辑文字时可以随时保存草稿，若编辑错误，可通过“撤销”操作恢复到上一次保存的状态；再比如游戏中的存档功能，玩家在关键节点存档，若后续游戏失败，可加载存档恢复到之前的游戏进度；还有办公软件中的“撤销/重做”、数据库的事务回滚、配置文件的版本管理等，本质上都是备忘录模式的落地应用。这些场景的核心需求的是“保存对象状态、支持状态恢复”，而若直接暴露对象的内部状态，会破坏对象的封装性，增加系统的耦合度，备忘录模式则完美解决了这一痛点。
备忘录模式通过拆分“状态保存”“状态管理”“状态恢复”三个核心职责，实现了对象状态的安全保存与灵活恢复。它将对象的内部状态封装在备忘录中，对象本身无需关心状态的保存和恢复细节，只需提供创建备忘录和从备忘录恢复状态的方法；同时引入管理者角色，负责管理所有备忘录，避免备忘录的混乱管理。这种设计不仅保证了对象的封装性，还让状态的保存和恢复逻辑更加清晰、可扩展，适用于所有需要撤销操作、状态回滚的场景。今天，我们就从核心定义、结构、实战实现、场景对比、避坑指南全维度讲解，帮大家彻底掌握这种“保存对象状态”的实用设计模式。

一、备忘录模式的核心定义与设计初衷

1. 核心定义
备忘录模式（Memento Pattern）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。备忘录模式的核心是封装对象内部状态，实现状态的安全保存与恢复，同时不破坏对象的封装性。
通俗理解：备忘录模式就像我们生活中的“笔记本”，我们（对应需要保存状态的对象）在笔记本上记录重要信息（对应保存状态），当需要回忆这些信息时，可翻开笔记本（对应恢复状态）。笔记本（对应备忘录）只负责存储信息，不关心信息的具体含义；我们无需将自己的想法（内部状态）暴露给别人，只需自己记录和查看笔记本；若有多个重要节点，可记录多个笔记本，由我们自己（对应管理者）统一管理。再比如手机的备份功能，手机系统（对象）将自身的配置、数据（内部状态）备份到云端（备忘录），当手机出现故障时，可通过云端备份恢复到之前的状态，备份过程中无需暴露手机的内部实现细节。

2. 设计初衷（解决的核心问题）
备忘录模式的出现，核心是解决“需要保存对象内部状态、支持状态恢复，且不破坏对象封装性”的痛点，具体解决3个核心问题：

• 保护对象封装性：无需暴露对象的内部状态和实现细节，通过备忘录间接保存和恢复状态，避免破坏对象的封装性；
• 实现状态保存与恢复：捕获对象在关键节点的内部状态，保存到备忘录中，支持后续将对象恢复到任意保存的状态，实现撤销、回滚功能；
• 统一管理状态：通过管理者角色，统一管理所有备忘录，避免状态混乱，便于维护和使用（如管理多个存档、多个版本的配置）。

3. 设计原则适配
备忘录模式严格贴合面向对象设计核心原则，尤其在“封装原则”和“单一职责原则”上表现突出，是实现状态保存与恢复的最佳实践：

• 封装原则：对象的内部状态被封装在备忘录中，外部对象无法直接访问对象的内部状态，只能通过对象提供的方法创建和恢复备忘录，保护了对象的封装性；
• 单一职责原则：备忘录只负责存储对象的内部状态，管理者只负责管理备忘录，需要保存状态的对象只负责自身的业务逻辑和状态管理，各司其职；
• 开闭原则：新增状态保存维度或修改状态保存逻辑时，只需修改备忘录和对应对象，无需修改管理者和其他相关类，扩展性强；
• 迪米特法则（最少知道原则）：管理者只需知道备忘录的存储和获取方法，无需知道备忘录的内部结构和对象的内部状态；对象只需知道备忘录的创建和恢复方法，无需知道管理者的存在。

二、备忘录模式的核心结构（3个核心角色）

备忘录模式的结构围绕“状态保存、状态管理、状态恢复”展开，核心包含3个角色，各司其职、协同完成对象状态的保存与恢复，我们以“文本编辑器撤销功能”为场景，逐一拆解角色职责与交互逻辑：

1. 发起人（Originator）
   需要保存内部状态的对象，定义了创建备忘录和从备忘录恢复状态的核心方法。发起人负责创建备忘录，将自身当前的内部状态存储到备忘录中；同时能够通过备忘录，恢复到之前保存的状态。发起人不关心备忘录的存储和管理，只负责与备忘录交互。对应文本编辑器场景中的“文本编辑对象”，负责编辑文本、创建文本状态备忘录、从备忘录恢复文本状态。
2. 备忘录（Memento）
   用于存储发起人的内部状态，封装了发起人的状态信息，不对外暴露发起人的内部实现细节。备忘录只提供获取状态的方法（供发起人恢复状态时使用），不允许其他对象直接访问其内部状态，确保发起人的封装性。对应文本编辑器场景中的“文本状态备忘录”，存储文本编辑对象的当前文本内容、光标位置等状态信息。
3. 管理者（Caretaker）
   负责管理所有备忘录，提供存储和获取备忘录的方法，不关心备忘录的内部结构和状态内容，也不直接与发起人交互。管理者可以存储多个备忘录，实现对多个状态的管理（如多个存档、多个版本），支持发起人恢复到任意保存的状态。对应文本编辑器场景中的“撤销管理器”，存储所有文本状态备忘录，供文本编辑对象恢复到任意历史状态。
   核心关系总结：发起人创建备忘录并存储自身状态，备忘录封装发起人状态并提供状态获取方法，管理者管理所有备忘录。发起人与备忘录直接交互，创建和恢复状态；管理者与备忘录直接交互，存储和获取备忘录；发起人与管理者不直接交互，实现了解耦。当需要保存状态时，发起人创建备忘录并传递给管理者存储；当需要恢复状态时，管理者将对应的备忘录传递给发起人，发起人从备忘录中恢复状态。

三、备忘录模式的核心逻辑与执行流程

备忘录模式的核心逻辑是“封装状态、保存状态、恢复状态”，标准执行流程分为六步，全程保证发起人的封装性，逻辑闭环，我们以“文本编辑器撤销操作”为例，拆解执行流程：

1. 定义备忘录类：封装发起人的内部状态，提供状态获取方法，不对外暴露内部细节；
2. 定义发起人类：实现创建备忘录（将自身状态存储到备忘录）和从备忘录恢复状态的方法；
3. 定义管理者类：实现备忘录的存储和获取方法，管理所有备忘录；
4. 保存状态：发起人在关键节点（如用户点击保存、编辑换行）创建备忘录，将当前状态存储到备忘录中，并将备忘录交给管理者存储；
5. 恢复状态：当需要撤销操作时，管理者将对应的备忘录（如上一次保存的备忘录）传递给发起人；
6. 发起人从备忘录中获取状态，恢复到之前保存的状态，完成撤销操作。
   关键要点：备忘录的封装性是核心，它只允许发起人访问其内部状态，其他对象（包括管理者）无法直接访问；管理者只负责存储和获取备忘录，不参与状态的创建和恢复；发起人无需关心备忘录的存储位置和管理方式，只需专注于自身的业务逻辑和状态交互，确保了系统的解耦和可维护性。

四、备忘录模式的实战实现（文本编辑器撤销功能场景）

我们以高频的文本编辑器撤销功能为场景，使用Java代码实现备忘录模式，文本编辑器（发起人）支持编辑文本、保存文本状态、撤销到上一次保存的状态；备忘录（文本状态）存储文本内容和光标位置；撤销管理器（管理者）存储所有保存的文本状态，支持多步撤销，直观体现备忘录模式“保存状态、实现撤销”的核心优势。
场景说明：文本编辑器可输入文本、移动光标，用户点击“保存”时，保存当前文本内容和光标位置到备忘录，由撤销管理器存储；用户点击“撤销”时，撤销管理器获取上一次保存的备忘录，文本编辑器从备忘录中恢复文本内容和光标位置；支持多步保存和多步撤销，最多保存10个历史状态，超过则覆盖最早的状态。

1. 第一步：定义备忘录类（Memento）

// 备忘录：文本状态备忘录，存储文本编辑器的内部状态（文本内容、光标位置）
public class TextMemento {
    // 文本内容（发起人的内部状态）
    private String textContent;
    // 光标位置（发起人的内部状态）
    private int cursorPosition;

    // 构造方法：由发起人调用，初始化状态（仅发起人可访问，可通过包访问权限控制）
    TextMemento(String textContent, int cursorPosition) {
        this.textContent = textContent;
        this.cursorPosition = cursorPosition;
    }

    // 提供获取状态的方法，供发起人恢复状态时使用（仅发起人可访问）
    String getTextContent() {
        return textContent;
    }

    int getCursorPosition() {
        return cursorPosition;
    }
}

2. 第二步：定义发起人类（Originator）

// 发起人：文本编辑器，需要保存内部状态（文本内容、光标位置）
public class TextEditor {
    // 文本内容（内部状态）
    private String textContent = "";
    // 光标位置（内部状态）
    private int cursorPosition = 0;

    // 编辑文本：修改内部状态
    public void editText(String content) {
        this.textContent += content;
        // 光标移动到文本末尾
        this.cursorPosition = this.textContent.length();
        System.out.println("编辑文本，当前内容：" + textContent + "，光标位置：" + cursorPosition);
    }

    // 移动光标：修改内部状态
    public void moveCursor(int position) {
        if (position >= 0 && position <= textContent.length()) {
            this.cursorPosition = position;
            System.out.println("移动光标，当前光标位置：" + cursorPosition);
        } else {
            System.out.println("光标位置无效，无法移动");
        }
    }

    // 创建备忘录：将当前内部状态存储到备忘录中
    public TextMemento createMemento() {
        System.out.println("保存状态，当前内容：" + textContent + "，光标位置：" + cursorPosition);
        // 返回备忘录，将当前状态传入
        return new TextMemento(textContent, cursorPosition);
    }

    // 从备忘录恢复状态：根据备忘录中的状态，恢复自身内部状态
    public void restoreFromMemento(TextMemento memento) {
        if (memento == null) {
            System.out.println("无保存状态，无法撤销");
            return;
        }
        this.textContent = memento.getTextContent();
        this.cursorPosition = memento.getCursorPosition();
        System.out.println("撤销成功，恢复后内容：" + textContent + "，光标位置：" + cursorPosition);
    }

    // 辅助方法：获取当前状态（用于测试）
    public String getCurrentState() {
        return "当前文本内容：" + textContent + "，光标位置：" + cursorPosition;
    }
}

3. 第三步：定义管理者类（Caretaker）

// 管理者：撤销管理器，负责管理所有文本状态备忘录
import java.util.Stack;

public class UndoManager {
    // 使用栈存储备忘录，栈的特性（先进后出）适合实现撤销功能（先撤销最近保存的状态）
    private Stack<TextMemento> mementoStack = new Stack<>();
    // 最大保存状态数，防止内存溢出
    private static final int MAX_MEMENTO_COUNT = 10;

    // 存储备忘录：将发起人创建的备忘录存储到栈中
    public void saveMemento(TextMemento memento) {
        if (memento == null) {
            return;
        }
        // 若超过最大保存数，移除最早保存的状态
        if (mementoStack.size() >= MAX_MEMENTO_COUNT) {
            mementoStack.remove(0);
            System.out.println("保存状态数量已达上限，移除最早保存的状态");
        }
        mementoStack.push(memento);
        System.out.println("状态保存成功，当前保存的状态数：" + mementoStack.size());
    }

    // 获取备忘录：获取最近保存的备忘录（用于撤销）
    public TextMemento getLastMemento() {
        if (mementoStack.isEmpty()) {
            return null;
        }
        // 弹出栈顶元素（最近保存的状态），实现撤销后无法再次撤销该状态（可根据需求调整为不弹出）
        return mementoStack.pop();
    }

    // 辅助方法：获取当前保存的状态数（用于测试）
    public int getMementoCount() {
        return mementoStack.size();
    }
}

4. 第四步：客户端测试

// 客户端测试：文本编辑器撤销功能场景
public class MementoPatternTest {
    public static void main(String[] args) {
        // 1. 创建发起人（文本编辑器）、管理者（撤销管理器）
        TextEditor textEditor = new TextEditor();
        UndoManager undoManager = new UndoManager();

        System.out.println("=== 第一步：编辑文本并保存状态 ===");
        textEditor.editText("Hello, ");
        textEditor.saveMemento(); // 创建备忘录
        undoManager.saveMemento(textEditor.createMemento()); // 管理者存储备忘录

        System.out.println("\n=== 第二步：继续编辑文本并保存状态 ===");
        textEditor.editText("Design Pattern!");
        textEditor.moveCursor(7); // 移动光标到第7个位置（"Hello, "之后）
        undoManager.saveMemento(textEditor.createMemento());

        System.out.println("\n=== 第三步：撤销一次（恢复到上一次保存的状态） ===");
        TextMemento lastMemento = undoManager.getLastMemento();
        textEditor.restoreFromMemento(lastMemento);

        System.out.println("\n=== 第四步：继续撤销（恢复到第一次保存的状态） ===");
        lastMemento = undoManager.getLastMemento();
        textEditor.restoreFromMemento(lastMemento);

        System.out.println("\n=== 第五步：再次撤销（无保存状态） ===");
        lastMemento = undoManager.getLastMemento();
        textEditor.restoreFromMemento(lastMemento);

        System.out.println("\n=== 第六步：测试状态保存上限（超过10个） ===");
        for (int i = 1; i <= 11; i++) {
            textEditor.editText("Test" + i + " ");
            undoManager.saveMemento(textEditor.createMemento());
        }
    }
}

运行结果

=== 第一步：编辑文本并保存状态 ===
编辑文本，当前内容：Hello, ，光标位置：7
保存状态，当前内容：Hello, ，光标位置：7
保存状态，当前内容：Hello, ，光标位置：7
状态保存成功，当前保存的状态数：1

=== 第二步：继续编辑文本并保存状态 ===
编辑文本，当前内容：Hello, Design Pattern!，光标位置：21
移动光标，当前光标位置：7
保存状态，当前内容：Hello, Design Pattern!，光标位置：7
状态保存成功，当前保存的状态数：2

=== 第三步：撤销一次（恢复到上一次保存的状态） ===
撤销成功，恢复后内容：Hello, Design Pattern!，光标位置：7

=== 第四步：继续撤销（恢复到第一次保存的状态） ===
撤销成功，恢复后内容：Hello, ，光标位置：7

=== 第五步：再次撤销（无保存状态） ===
无保存状态，无法撤销

=== 第六步：测试状态保存上限（超过10个） ===
编辑文本，当前内容：Hello, Test1 ，光标位置：13
保存状态，当前内容：Hello, Test1 ，光标位置：13
状态保存成功，当前保存的状态数：1
编辑文本，当前内容：Hello, Test1 Test2 ，光标位置：19
保存状态，当前内容：Hello, Test1 Test2 ，光标位置：19
状态保存成功，当前保存的状态数：2
编辑文本，当前内容：Hello, Test1 Test2 Test3 ，光标位置：25
保存状态，当前内容：Hello, Test1 Test2 Test3 ，光标位置：25
状态保存成功，当前保存的状态数：3
编辑文本，当前内容：Hello, Test1 Test2 Test3 Test4 ，光标位置：31
保存状态，当前内容：Hello, Test1 Test2 Test3 Test4 ，光标位置：31
状态保存成功，当前保存的状态数：4
编辑文本，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 ，光标位置：37
保存状态，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 ，光标位置：37
状态保存成功，当前保存的状态数：5
编辑文本，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 ，光标位置：43
保存状态，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 ，光标位置：43
状态保存成功，当前保存的状态数：6
编辑文本，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 Test7 ，光标位置：49
保存状态，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 Test7 ，光标位置：49
状态保存成功，当前保存的状态数：7
编辑文本，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 Test7 Test8 ，光标位置：55
保存状态，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 Test7 Test8 ，光标位置：55
状态保存成功，当前保存的状态数：8
编辑文本，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 Test7 Test8 Test9 ，光标位置：61
保存状态，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 Test7 Test8 Test9 ，光标位置：61
状态保存成功，当前保存的状态数：9
编辑文本，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 Test7 Test8 Test9 Test10 ，光标位置：67
保存状态，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 Test7 Test8 Test9 Test10 ，光标位置：67
状态保存成功，当前保存的状态数：10
编辑文本，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 Test7 Test8 Test9 Test10 Test11 ，光标位置：73
保存状态，当前内容：Hello, Test1 Test2 Test3 Test4 Test5 Test6 Test7 Test8 Test9 Test10 Test11 ，光标位置：73
保存状态数量已达上限，移除最早保存的状态
状态保存成功，当前保存的状态数：10

从运行结果可以看出，备忘录模式成功实现了文本编辑器的状态保存与撤销功能：文本编辑器（发起人）创建备忘录保存自身状态，撤销管理器（管理者）存储所有备忘录，支持多步撤销；撤销时，通过管理者获取对应的备忘录，文本编辑器从备忘录中恢复状态，且整个过程中，文本编辑器的内部状态（文本内容、光标位置）被封装在备忘录中，未对外暴露，保证了封装性。同时，管理者实现了状态的上限控制，避免了内存溢出，体现了系统的健壮性；新增状态保存维度（如文本格式）时，只需修改备忘录和发起人，无需修改管理者，符合开闭原则。

五、备忘录模式的高频应用场景

备忘录模式适用于所有需要保存对象内部状态、支持状态恢复（撤销、回滚），且需要保护对象封装性的业务场景，核心作用是实现状态的安全保存与灵活恢复，以下是四大高频落地场景：

1. 撤销/重做功能（最经典应用）
各类编辑工具、办公软件中，需要支持用户撤销操作、恢复到之前的状态，是备忘录模式最核心的应用场景：

• 文本编辑工具：如实战场景中的文本编辑器、Word、记事本，保存文本编辑过程中的历史状态，支持撤销/重做；
• 图形编辑工具：PS、AI等，保存图层编辑、颜色调整等历史状态，支持撤销到上一步操作；
• 代码编辑器：IDEA、VS Code等，保存代码编辑历史，支持撤销/重做、回滚到指定版本。

2. 状态存档与恢复
需要保存对象在关键节点的状态，便于后续恢复到该节点，适用于游戏、配置管理等场景：

• 游戏存档：玩家在游戏关键节点（如通关、升级）存档，失败后可加载存档恢复到之前的游戏进度；
• 配置文件版本管理：系统配置文件修改后，保存不同版本的配置状态，若修改出错，可回滚到之前的配置版本；
• 表单填写：用户填写复杂表单时，定期保存表单状态，若页面刷新或出错，可恢复之前填写的内容。

3. 事务回滚
数据库、分布式系统中，需要保证事务的原子性，若事务执行失败，需回滚到事务开始前的状态：

• 数据库事务：数据库执行SQL操作时，保存事务开始前的数据状态，若事务执行失败，通过备忘录恢复数据到初始状态；
• 分布式事务：分布式系统中，各节点执行操作前保存自身状态，若分布式事务失败，各节点通过备忘录回滚到初始状态。

4. 框架底层与工具类设计
主流开源框架和工具类中，大量使用备忘录模式实现状态管理，提升框架的灵活性和健壮性：

• Spring框架：Spring的事务管理，底层使用备忘录模式保存事务开始前的状态，事务失败时执行回滚；
• Android开发：Activity的状态保存（onSaveInstanceState），将Activity的状态保存到Bundle（备忘录），屏幕旋转时恢复状态；
• 版本控制工具：Git、SVN等，保存代码的历史版本（备忘录），支持回滚到任意历史版本。

六、备忘录模式 vs 中介者模式（重点区分）

备忘录模式与上一篇学习的中介者模式，都属于行为型模式，且都涉及“对象间的交互与逻辑封装”，但核心目标、使用场景、核心逻辑完全不同，极易混淆，通过表格清晰对比，帮大家彻底区分：

对比维度	备忘录模式	中介者模式
核心目标	封装对象内部状态，实现状态的保存与恢复（撤销、回滚）	封装对象间的交互逻辑，解耦对象依赖，让对象独立交互
核心逻辑	发起人创建备忘录保存状态，管理者管理备忘录，发起人从备忘录恢复状态	所有对象通过中介者间接通信，中介者封装交互逻辑并转发消息
适用场景	需要撤销操作、状态回滚（关注“状态管理”）	对象间交互复杂、耦合度高（关注“交互解耦”）
核心角色	发起人、备忘录、管理者	抽象中介者、具体中介者、抽象同事类、具体同事类
核心关注点	对象内部状态的保存与恢复，保护对象封装性	对象间的交互解耦，集中管理交互逻辑

一句话总结：备忘录模式管“状态保存与恢复”，中介者模式管“交互解耦”；需要撤销、回滚操作，保存对象状态用备忘录模式，对象间交互复杂、需要解耦用中介者模式，两者可结合使用（如分布式事务中，通过中介者协调各节点交互，通过备忘录模式保存各节点状态，实现事务回滚）。

七、备忘录模式的常见坑与避坑指南

坑1：备忘录过度暴露发起人状态，破坏封装性
备忘录模式的核心是保护发起人的封装性，但部分开发者在实现时，让备忘录对外暴露发起人的内部状态（如提供公共setter方法、将状态定义为public），导致发起人状态被随意修改，破坏封装性。
避坑指南：备忘录仅提供获取状态的方法（供发起人恢复状态使用），不提供修改状态的方法；通过访问权限控制（如包访问权限、私有方法），确保只有发起人能访问备忘录的内部状态，其他对象（包括管理者）无法直接访问。

坑2：备忘录存储过多状态，导致内存溢出
若频繁保存状态，且不限制备忘录的数量，会导致大量备忘录占用内存，引发内存溢出（如文本编辑器无限制保存历史状态）。
避坑指南：在管理者中设置备忘录的最大存储数量，超过数量时覆盖最早保存的状态；定期清理过期的备忘录（如超过一定时间的状态）；对于大型对象的状态，可采用序列化、压缩等方式存储，减少内存占用。

坑3：发起人状态过于复杂，导致备忘录体积过大
若发起人包含大量内部状态，备忘录会存储所有状态，导致备忘录体积过大，影响系统性能（如保存大型对象的完整状态）。
避坑指南：只保存发起人关键的内部状态，无需保存所有状态（如文本编辑器只需保存文本内容和光标位置，无需保存编辑记录）；对于复杂状态，可拆分备忘录，按模块保存状态，提升性能和可维护性。

坑4：忽略备忘录的序列化与持久化需求
部分场景中，需要将备忘录持久化到磁盘（如游戏存档、配置版本），若未实现备忘录的序列化，会导致状态无法持久化，重启系统后状态丢失。
避坑指南：若需要持久化备忘录，让备忘录类实现Serializable接口，支持序列化；在管理者中实现备忘录的持久化（如写入文件、存入数据库）和反序列化（如读取文件、从数据库获取），确保状态可长期保存。

坑5：过度使用备忘录模式，导致逻辑复杂化
部分开发者在无需保存状态、无需撤销操作的场景中，强行使用备忘录模式，新增发起人、备忘录、管理者等角色，导致代码冗余、逻辑复杂化，反而降低了代码的可读性和可维护性。
避坑指南：只有当需要保存对象状态、支持撤销或回滚操作，且需要保护对象封装性时，才使用备忘录模式；无需状态保存的场景，直接简化设计，不使用备忘录模式。

八、系列文章预告

本篇文章，我们详细讲解了备忘录模式的核心定义、三大核心角色、标准执行流程、文本编辑器撤销功能实战代码、高频应用场景和避坑指南，同时区分了易混淆的中介者模式。备忘录模式凭借“封装状态、保存与恢复状态”的优势，成为需要撤销、回滚操作场景的首选设计模式，能够在不破坏对象封装性的前提下，灵活实现状态管理，也是框架底层、办公软件、游戏开发的核心设计思想之一。
下一篇，我们将学习行为型模式的第十九种常用模式——迭代器模式，它的核心是提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。迭代器模式专注于“聚合对象的遍历”，广泛应用于集合、容器等场景，如Java集合框架中的Iterator、ListIterator，能够简化聚合对象的遍历逻辑，解耦聚合对象与遍历逻辑。
迭代器模式——统一聚合对象遍历，解耦遍历与实现。我们不见不散！