在不破坏封闭的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便恢复到原先保存的状态。

    【角色】

    • 创建备忘录角色（Originator）：负责创建一个备忘录，可以记录、恢复自身的内部状态。
    • 备忘录角色（Memento）：用于存储Originator的内部状态，并且可以防止Originator以外的对象访问Mement。

    • 存储备忘录角色（Caretaker）: 负责存储备忘录，不能对备忘录的内容进行操作和访问，只能够将备忘录传递给其他对象。

      1. /**
      2. * 存档（备忘录角色）
      3. */
      4. public class Memento {
      5.   // 关卡
      6.   private int level;
      8.   public int getLevel() {
      9.       return level;
      10.   }
      12.   public void setLevel(int level) {
      13.       this.level = level;
      14.   }
      16.   public Memento(int level) {
      17.       this.level = level;
      18.   }
      19. }
      1. /**
      2. * 游戏类（创建备忘录角色）
      3. */
      4. public class Game {
      6.   // 关卡
      7.   private int level;
      9.   /**
      10.    * 玩游戏
      11.    */
      12.   public void play () {
      13.       System.out.println("恭喜你，通过第" + (++level) + "关" );
      14.   }
      16.   /**
      17.    * 游戏存档
      18.    */
      19.   public Memento save() {
      20.       return new Memento(level);
      21.   }
      23.   /**
      24.    * 恢复游戏
      25.    * @param memento
      26.    */
      27.   public void restore(Memento memento) {
      28.       this.level = memento.getLevel();
      29.       System.out.println("恢复游戏，当前是第" + this.level + "关");
      30.   }
      31. }
      1. /**
      2. * 负责管理备忘者类
      3. */
      4. public class Caretaker {
      6.   private Memento memento;
      8.   /**
      9.    * 存档
      10.    */
      11.   public void archive(Memento memento) {
      12.       System.out.println("存档。。。");
      13.       this.memento = memento;
      14.   }
      16.   /**
      17.    * 获取存档
      18.    */
      19.   public Memento getMemento() {
      20.       return this.memento;
      21.   }
      22. }
      1. public class MementoTest {
      2.   public static void main(String[] args) {
      3.       // 存档管理类
      4.       Caretaker caretaker = new Caretaker();
      5.       // 打开游戏
      6.       Game game = new Game();
      7.       // 玩了第1关
      8.       game.play();
      9.       // 存档
      10.       caretaker.archive(game.save());
      11.       // 玩了第2关
      12.       game.play();
      13.       // 存档
      14.       caretaker.archive(game.save());
      15.       // 读档恢复游戏
      16.       game.restore(caretaker.getMemento());
      17.   }
      18. }
      19. ----输出----
      20. 恭喜你，通过第1关
      21. 存档。。。
      22. 恭喜你，通过第2关
      23. 存档。。。
      24. 恢复游戏，当前是第2关