编辑“︁Java备忘录模式”︁

{{DISPLAYTITLE:Java备忘录模式}}

'''备忘录模式'''（Memento Pattern）是一种行为设计模式，允许在不破坏封装性的前提下捕获并外部化对象的内部状态，以便稍后可以恢复到此状态。该模式常用于实现撤销（Undo）或回滚（Rollback）功能。

== 概述 ==
备忘录模式的核心思想是将对象的内部状态保存到一个独立的备忘录对象中，并在需要时恢复。它涉及三个主要角色：
* '''Originator（发起人）'''：需要保存和恢复状态的对象。
* '''Memento（备忘录）'''：存储Originator的内部状态的对象。
* '''Caretaker（管理者）'''：负责保存和恢复备忘录的对象。

该模式的关键优势是保持了封装性——Originator的状态不会直接暴露给其他对象。

== 结构 ==
<mermaid>
classDiagram
    class Originator {
        -state: String
        +createMemento(): Memento
        +restore(memento: Memento): void
    }
    class Memento {
        -state: String
        +getState(): String
    }
    class Caretaker {
        -mementos: List<Memento>
        +addMemento(memento: Memento): void
        +getMemento(index: int): Memento
    }
    Originator --> Memento
    Caretaker o--> Memento
</mermaid>

== 代码示例 ==
以下是一个简单的Java实现示例，展示备忘录模式的基本用法：

<syntaxhighlight lang="java">
// Originator类
public class TextEditor {
    private String text;

    public TextEditor(String text) {
        this.text = text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public String getText() {
        return text;
    }

    // 创建备忘录
    public TextEditorMemento save() {
        return new TextEditorMemento(text);
    }

    // 恢复状态
    public void restore(TextEditorMemento memento) {
        this.text = memento.getSavedText();
    }

    // 备忘录内部类（也可以单独定义）
    public static class TextEditorMemento {
        private final String text;

        private TextEditorMemento(String text) {
            this.text = text;
        }

        private String getSavedText() {
            return text;
        }
    }
}

// Caretaker类
public class History {
    private final List<TextEditor.TextEditorMemento> mementos = new ArrayList<>();

    public void save(TextEditor.TextEditorMemento memento) {
        mementos.add(memento);
    }

    public TextEditor.TextEditorMemento get(int index) {
        return mementos.get(index);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        TextEditor editor = new TextEditor("Initial text");
        History history = new History();

        // 保存状态
        history.save(editor.save());

        // 修改文本
        editor.setText("Modified text");
        System.out.println("Current text: " + editor.getText());

        // 恢复状态
        editor.restore(history.get(0));
        System.out.println("Restored text: " + editor.getText());
    }
}
</syntaxhighlight>

'''输出结果:'''
<pre>
Current text: Modified text
Restored text: Initial text
</pre>

== 实际应用场景 ==
备忘录模式在以下场景中特别有用：

1. '''文本编辑器'''：实现撤销/重做功能
2. '''游戏开发'''：保存游戏进度
3. '''数据库事务'''：实现回滚操作
4. '''GUI应用'''：保存和恢复窗口状态

=== 游戏存档示例 ===
<syntaxhighlight lang="java">
// 游戏角色类
public class GameCharacter {
    private int level;
    private int health;
    private String location;

    public GameCharacter(int level, int health, String location) {
        this.level = level;
        this.health = health;
        this.location = location;
    }

    // 创建存档
    public GameSave save() {
        return new GameSave(level, health, location);
    }

    // 读取存档
    public void load(GameSave save) {
        this.level = save.getLevel();
        this.health = save.getHealth();
        this.location = save.getLocation();
    }

    // 其他方法...
}

// 存档类
public class GameSave {
    private final int level;
    private final int health;
    private final String location;

    public GameSave(int level, int health, String location) {
        this.level = level;
        this.health = health;
        this.location = location;
    }

    // getter方法...
}

// 存档管理器
public class SaveManager {
    private final Map<String, GameSave> saves = new HashMap<>();

    public void saveGame(String saveName, GameSave save) {
        saves.put(saveName, save);
    }

    public GameSave loadGame(String saveName) {
        return saves.get(saveName);
    }
}
</syntaxhighlight>

== 优缺点 ==
'''优点:'''
* 保持封装边界，不暴露对象内部细节
* 简化Originator，将状态保存逻辑分离
* 可以轻松实现撤销/恢复功能

'''缺点:'''
* 如果频繁保存状态，可能消耗大量内存
* Caretaker需要了解何时保存和恢复状态
* 在Java中，可能需要考虑对象的深拷贝问题

== 进阶考虑 ==
1. '''增量备忘录'''：只保存改变的部分而非整个状态
2. '''持久化备忘录'''：将备忘录保存到磁盘或数据库
3. '''多级撤销'''：实现多步撤销功能

数学上，备忘录模式可以表示为状态序列：
<math>
S = \{s_1, s_2, ..., s_n\}
</math>
其中每个<math>s_i</math>代表一个保存的状态。

== 总结 ==
备忘录模式提供了一种优雅的方式来保存和恢复对象状态，特别适合需要实现撤销机制或历史记录功能的场景。通过将状态保存职责与业务逻辑分离，它有助于保持代码的整洁和可维护性。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java设计模式]]