备忘录模式（Memento Pattern）

// 原发器与备忘录在同一包中，备忘录的方法为包私有
public class TextEditor {
    // 原发器的私有状态
    private String content;
    private int cursorPosition;
    
    // 创建备忘录（仅原发器能调用备忘录的构造器）
    public TextMemento createMemento() {
        return new TextMemento(content, cursorPosition);
    }
    
    // 从备忘录恢复（仅原发器能调用备忘录的get方法）
    public void restoreFromMemento(TextMemento memento) {
        this.content = memento.getContent();  // 包私有方法，可访问
        this.cursorPosition = memento.getCursorPosition();
    }
}

// 备忘录类（包私有访问权限，仅同一包可见）
class TextMemento {
    private String content;
    private int cursorPosition;
    
    // 构造器为包私有，仅原发器可创建
    TextMemento(String content, int cursorPosition) {
        this.content = content;
        this.cursorPosition = cursorPosition;
    }
    
    // 获取方法为包私有，仅原发器可访问
    String getContent() { return content; }
    int getCursorPosition() { return cursorPosition; }
}

// 增量备忘录：仅保存与上一状态的差异
class IncrementalMemento {
    private int startPos;  // 变化起始位置
    private String oldText;  // 被替换的旧文本
    private String newText;  // 新增的文本
    
    // 构造器：记录差异
    public IncrementalMemento(int startPos, String oldText, String newText) {
        this.startPos = startPos;
        this.oldText = oldText;
        this.newText = newText;
    }
    
    // 恢复逻辑：用旧文本替换新文本
    public void restore(TextEditor editor) {
        String content = editor.getContent();
        String restored = content.substring(0, startPos) 
            + oldText 
            + content.substring(startPos + newText.length());
        editor.setContent(restored);
    }
}

class VersionedMemento extends TextMemento {
    private String version;  // 版本号（如V1.0、V2.0）
    private LocalDateTime timestamp;  // 保存时间
    
    public VersionedMemento(String content, int cursorPos, String version) {
        super(content, cursorPos);
        this.version = version;
        this.timestamp = LocalDateTime.now();
    }
    
    // 获取元数据方法（对负责人可见）
    public String getVersion() { return version; }
    public LocalDateTime getTimestamp() { return timestamp; }
}

public class MementoManager {
    // 按对象ID和类型存储备忘录（键："editor:123"，值：备忘录列表）
    private Map<String, List<Memento>> mementoMap = new HashMap<>();
    
    // 保存指定对象的备忘录
    public void save(String objectId, String type, Memento memento) {
        String key = type + ":" + objectId;
        mementoMap.computeIfAbsent(key, k -> new ArrayList<>()).add(memento);
    }
    
    // 获取指定对象的历史备忘录
    public List<Memento> getHistory(String objectId, String type) {
        return mementoMap.getOrDefault(type + ":" + objectId, new ArrayList<>());
    }
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    // 保存EditText内容（创建备忘录）
    outState.putString("edit_text_content", editText.getText().toString());
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (savedInstanceState != null) {
        // 恢复EditText内容（从备忘录恢复）
        String content = savedInstanceState.getString("edit_text_content");
        editText.setText(content);
    }
}

public class MyViewModel extends ViewModel {
    private final SavedStateHandle savedStateHandle;
    private static final String KEY_USER = "user_data";
    
    public MyViewModel(SavedStateHandle handle) {
        this.savedStateHandle = handle;
    }
    
    // 保存用户数据（创建备忘录）
    public void saveUser(User user) {
        savedStateHandle.set(KEY_USER, user);
    }
    
    // 恢复用户数据（从备忘录恢复）
    public User restoreUser() {
        return savedStateHandle.get(KEY_USER);
    }
}

/**
 * 备忘录：存储文本编辑器的状态（内容和光标位置）
 * 访问权限：包私有（仅同一包中的TextEditor可访问其方法）
 */
class TextMemento {
    private final String content;       // 保存的文本内容
    private final int cursorPosition;   // 保存的光标位置

    // 构造器：仅允许同一包中的类调用（如TextEditor）
    TextMemento(String content, int cursorPosition) {
        this.content = content;
        this.cursorPosition = cursorPosition;
    }

    // 获取文本内容：仅允许同一包中的类调用
    String getContent() {
        return content;
    }

    // 获取光标位置：仅允许同一包中的类调用
    int getCursorPosition() {
        return cursorPosition;
    }
}

/**
 * 原发器：文本编辑器，负责创建备忘录和从备忘录恢复状态
 */
public class TextEditor {
    private String content;       // 当前文本内容
    private int cursorPosition;   // 当前光标位置

    // 初始化：空内容，光标在0位置
    public TextEditor() {
        this.content = "";
        this.cursorPosition = 0;
    }

    // 输入文本（业务逻辑）
    public void type(String text) {
        // 在光标位置插入文本
        content = content.substring(0, cursorPosition) 
                + text 
                + content.substring(cursorPosition);
        // 移动光标到插入后的位置
        cursorPosition += text.length();
        System.out.println("输入后内容：" + content + "，光标位置：" + cursorPosition);
    }

    // 移动光标（业务逻辑）
    public void moveCursor(int position) {
        // 确保光标位置在有效范围内
        this.cursorPosition = Math.max(0, Math.min(position, content.length()));
        System.out.println("光标移动到：" + cursorPosition);
    }

    // 创建备忘录：保存当前状态
    public TextMemento createMemento() {
        System.out.println("创建备忘录，保存状态：" + content + "（光标：" + cursorPosition + "）");
        return new TextMemento(content, cursorPosition);
    }

    // 从备忘录恢复状态
    public void restoreFromMemento(TextMemento memento) {
        this.content = memento.getContent();  // 访问包私有方法
        this.cursorPosition = memento.getCursorPosition();
        System.out.println("恢复后内容：" + content + "，光标位置：" + cursorPosition);
    }

    // 辅助方法：获取当前内容（用于展示）
    public String getContent() {
        return content;
    }
}

import java.util.Stack;

/**
 * 负责人：管理备忘录，提供保存和获取最近备忘录的功能
 */
public class History {
    // 用栈存储备忘录（先进后出，符合撤销逻辑：最近的操作先撤销）
    private final Stack<TextMemento> mementos = new Stack<>();

    // 保存备忘录
    public void saveMemento(TextMemento memento) {
        mementos.push(memento);
        System.out.println("保存备忘录，当前历史记录数：" + mementos.size());
    }

    // 获取最近的备忘录（用于撤销）
    public TextMemento getLastMemento() {
        if (mementos.isEmpty()) {
            throw new IllegalStateException("没有可恢复的历史记录");
        }
        return mementos.pop();
    }

    // 获取历史记录数量（辅助）
    public int getMementoCount() {
        return mementos.size();
    }
}

/**
 * 客户端：模拟用户使用文本编辑器的过程（输入→保存→继续输入→撤销）
 */
public class MementoPatternTest {
    public static void main(String[] args) {
        // 1. 创建原发器（文本编辑器）和负责人（历史记录）
        TextEditor editor = new TextEditor();
        History history = new History();

        // 2. 第一次操作：输入"Hello"并保存状态
        System.out.println("=== 第一次操作 ===");
        editor.type("Hello");
        editor.moveCursor(5);  // 移动光标到末尾
        history.saveMemento(editor.createMemento());  // 保存备忘录

        // 3. 第二次操作：输入" World"并保存状态
        System.out.println("\n=== 第二次操作 ===");
        editor.type(" World");
        editor.moveCursor(11);
        history.saveMemento(editor.createMemento());  // 保存备忘录

        // 4. 第三次操作：输入"!"（不保存）
        System.out.println("\n=== 第三次操作（不保存） ===");
        editor.type("!");
        System.out.println("当前内容：" + editor.getContent());  // 预期：Hello World!

        // 5. 撤销：恢复到上一次保存的状态（Hello World）
        System.out.println("\n=== 执行撤销 ===");
        editor.restoreFromMemento(history.getLastMemento());
        System.out.println("撤销后内容：" + editor.getContent());  // 预期：Hello World

        // 6. 再次撤销：恢复到第一次保存的状态（Hello）
        System.out.println("\n=== 再次执行撤销 ===");
        editor.restoreFromMemento(history.getLastMemento());
        System.out.println("再次撤销后内容：" + editor.getContent());  // 预期：Hello
    }
}