备忘录模式

定义

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

使用场景

需要保存一个对象在某个时刻的某种状态或部分状态。
如果用一个接口来让其他对象得到这些状态，将会暴露对象的实现细节，并破坏对象的封装性，一个对象不希望外界直接访问内部状态，通过中间对象可以间接访问其内部状态。

UML图如下

Originator负责创建一个备忘录，可以记录，恢复自身内部状态，同时可以根据需要决定存储自身的哪些内部状态

Memoto 备忘录角色，用于存储Originator的内部状态，并且可以防止Originator以外的访问

Caretaker 负责存储备忘录,不能对备忘录的内容进行操作和访问，只能将备忘录传递给其他对象，如果里面加个index 和一个集合就能做到撤回和重做之类的操作了

代码实现

public class Memoto {
    public int mCheckpoint;
    public int mLifeValue;
    public String mWeapon;


}

public class Caretaker {

    Memoto memoto;

    public void archive(Memoto memoto) {
        this.memoto = memoto;
    }


    public Memoto getMemoto() {
        return memoto;
    }
}

package com.example.leak.memoto;

public class CallOfDuty {

    private int mCheckPinot = 1;
    private int mLifeValue = 100;
    private String mWeapon = "沙漠之鹰";

    public void play() {
        System.out.println("开始玩游戏");
        mLifeValue -= 10;
        mCheckPinot++;
    }

    public void quit() {
        System.out.println("退出游戏");
    }


    public Memoto createMemoto() {
        Memoto memoto = new Memoto();
        memoto.mCheckpoint = mCheckPinot;
        memoto.mLifeValue = mLifeValue;
        memoto.mWeapon = mWeapon;
        return memoto;
    }


    public void restore(Memoto memoto) {
        this.mCheckPinot = memoto.mCheckpoint;
        this.mLifeValue = memoto.mLifeValue;
        this.mWeapon = memoto.mWeapon;
    }

}

package com.example.leak.memoto;

public class Client {

    public Client(){
        CallOfDuty game = new CallOfDuty();
        game.play();


        Caretaker caretaker = new Caretaker();
        caretaker.archive(game.createMemoto());

        game.quit();

        CallOfDuty newGame = new CallOfDuty();
        newGame.restore(caretaker.getMemoto());
    }
}

CallOfDuty 这里就是Originator 他这里是具体也业务逻辑 Caretaker是对备忘录的对象进行存储，业务需要把对象存储到这个Caretaker备忘录之中

总结

备忘录是在不破坏封装的条件下，通过备忘录对象储存另外一个对象内部状态的快照，在将来合适的时候把这个对象还原到存储起来的状态的状态。
优点：
给用户提供了一种可以恢复状态的机制，可以使用户能比较方便地回到某个历史状态
实现信息的封装，使得用户不需要关心状态的保存细节。
缺点
消耗资源，如果类的成员变量过多，势必会占用较大的资源，而且每一次的保存都会消耗一定的内存。