备忘录模式

---

1. 类图

• Memento：备忘录。存储原发器对象的内部状态
• Orginator：原发器。使用备忘录来保存某个时刻原发器自身的状态
• Caretaker：备忘录管理者。保存备忘录对象

2. 示例

保存和恢复内部状态

2.1 备忘录

// 备忘录接口
public interface Memento {}

// 实现类 blod保存原发器信息
public class MementoImpl implements Memento {
    private int blod;

    public MementoImpl(int blod){
        this.blod = blod;
    }

    public int getBlod(){return this.blod;}
}

2.2 原发器

public class PlayRole {
    private String name;
    private int blod;

    public PlayRole(String name, int blod){
        this.name = name;
        this.blod = blod;
    }

    // 创建存档，保存当前血量
    public Memento create(){
        return new MementoImpl(blod);
    }

    // 读档，恢复当时的血量
    public void setMemento(Memento memento) {
        this.blod = ((MementoImpl)memento).getBlod();
    }
    public boolean level1(){
        this.blod -= 10;
        return this.blod > 0;
    }

    public boolean level2(){
        this.blod -= 20;
        return this.blod > 0;
    }

    public String getName() {
        return name;
    }

    public int getBlod() {
        return blod;
    }
}

2.3 备忘录管理者

public class ScheduleManager {
    private Memento memento;

    public void archive(Memento memento){this.memento = memento;}

    public Memento read(){
        return memento;
    }
}

2.4 客户端

public class Client {
    public static void main(String[] args) {
        // 创建游戏角色
        PlayRole tom = new PlayRole("tom", 15);

        // 角色存档
        ScheduleManager scheduleManager = new ScheduleManager();
        scheduleManager.archive(tom.create());

        // 角色闯关
        if (tom.level1()) {
            System.out.println("角色" + tom.getName() + "闯过第一关了");
        }

        if (tom.level2()) {
            System.out.println("角色闯过第二关了，血量为：" + tom.getBlod());
        } else {
            System.out.println("第二关闯关失败，血量为：" + tom.getBlod());
        }

        // 角色读档
        tom.setMemento(scheduleManager.read());
        System.out.println("读档，当前血量为" + tom.getBlod());

    }
}

3. 优点

• 简化了原发器的职责，隔离状态存储与获取，实现了信息的封装，客户端无需关心状态的保存细节
• 提供状态的回滚动能

4. 缺点

• 资源消耗，每保存一次状态都需要消耗资源