备忘录模式

案例引入

游戏角色状态恢复问题

游戏角色有攻击力，防御力等，在大战BOSS前保存自身的状态(攻击力，防御力)，当大战BOSS后攻击力和防御力下降，从备忘录对象恢复到大站前的状态。

传统方式实现案例

创建一个游戏角色类对应的状态类，给每个游戏角色对象，对应一个对应状态类的对象，用来保存状态。

传统方式实现问题分析

1.一个游戏对象，就对应一个保存游戏状态的对象，这样如果游戏中有很多游戏角色，也会产生很多与之对应的状态角色，不利于管理，其内存开销很大。
2.传统的方式，就是简单的备份，new一个另外的对象来，再把需要备份的数据放到这个新对象，但这就暴露了对象内部的细节。
3.解决方案 => 备忘录模式。

基本介绍

1.备忘录模式(Memento Pattern)在不破坏封装性的前提下，捕获了一个对象的内部状态，并在该对象之外保存了该状态。这样需要恢复到原有状态时，就可将该对象恢复到原先保存时的状态。
2.也可以这样理解备忘录模式，现实生活中的备忘录是用来记录某些要去做的事情，或者是记录已经达成的共同意见的事情，以防忘记了。在软件层面，备忘录也有着相同的含义，备忘录对象主要用来记录一个对象的某种状态，或者数据，当要做回退时，可用从备忘录对象里获取原有的状态数据进行恢复。
3.备忘录模式属于行为型模式。

备忘录模式原理类图

角色分析

1.Originator是原始类，代表需要保存状态和数据信息的类。
2.Memento是备忘录类，是保存Originator类对象状态和数据信息的类。
3.Caretaker是一个管理备忘录的类，其中有一个保存备忘录对象的集合属性。
4.说明，如果希望保存多个Originator对象的不同时间的状态，只需要用HashMap<String,Map<String,Object>>保存就可以了

原理的代码

/**
 * @author 长名06
 * @version 1.0
 * 保存对象的状态/数据
 */
public class Memento {
    //保存的状态
    private String savedState;

    public Memento(String s){
        savedState = s;
    }

    public String getStateInfo(){//获取状态信息
        return savedState;
    }
}
/**
 * @author 长名06
 * @version 1.0
 * 游戏角色类 需要保存状态的类
 */
public class Originator {

    //状态信息
    private String state;

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    //可以保存状态信息到备忘录对象中，并返回该备忘录对象
    public Memento saveStateMemento(){
        return new Memento(state);
    }

    //通过备忘录对象，恢复对象状态
    public void restoreStateFromMemento(Memento memento){
        state = memento.getStateInfo();
    }
}
/**
 * @author 长名06
 * @version 1.0
 * 管理所有的备忘录对象
 */
public class Caretaker {
    private List<Memento> mementoList = new ArrayList<>();

    public void add(Memento memento){
        mementoList.add(memento);
    }

    /**
     * 根据索引获取 原始对象 对应的 备忘录对象
     * @param index
     * @return
     */
    public Memento get(int index){
        return mementoList.get(index);
    }

    public void delete(Memento memento){
        mementoList.remove(memento);
    }
}
public class Client {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();
        originator.setState(" 状态#1 攻击力是100 ");
        //保存了状态1
        caretaker.add(originator.saveStateMemento());
        //保存了状态2
        originator.setState(" 状态#2 攻击力是80 ");
        caretaker.add(originator.saveStateMemento());
        //保存了状态3
        originator.setState(" 状态#2 攻击力是60 ");
        caretaker.add(originator.saveStateMemento());

        System.out.println("当前状态" + originator.getState());
        //恢复到状态1
        originator.restoreStateFromMemento(caretaker.get(0));
        System.out.println("恢复后的装态" + originator.getState());
    }
}

备忘录模式实现案例

案例要求

游戏角色有攻击力和防御力，在打BOSS前保存自身的状态(攻击力和防御力)，当大战BOSS后攻击力和防御力下降，从备忘录对象恢复到大战前的状态。

类图

代码

/**
 * @author 长名06
 * @version 1.0
 * 游戏角色的备忘录类
 */
public class Mementor {

    private int attackPower;//攻击力

    private int defensePower;//防御力

    public Mementor(int attackPower,int defensePower){
        this.attackPower = attackPower;
        this.defensePower = defensePower;
    }

    public int getAttackPower() {
        return attackPower;
    }

    public void setAttackPower(int attackPower) {
        this.attackPower = attackPower;
    }

    public int getDefensePower() {
        return defensePower;
    }

    public void setDefensePower(int defensePower) {
        this.defensePower = defensePower;
    }
}
/**
 * @author 长名06
 * @version 1.0
 * 游戏角色
 */
public class GameRole {

    private int attackPower;

    private int defensePower;


    public Mementor createMementor(){
        return new Mementor(attackPower,defensePower);
    }

    public void restoreStateFromMementor(Mementor mementor){
        attackPower = mementor.getAttackPower();
        defensePower = mementor.getDefensePower();
    }

    public void showState(){
        System.out.println("游戏角色当前攻击力" + this.attackPower + "防御力" + this.defensePower);
    }

    public int getAttackPower() {
        return attackPower;
    }

    public void setAttackPower(int attackPower) {
        this.attackPower = attackPower;
    }

    public int getDefensePower() {
        return defensePower;
    }

    public void setDefensePower(int defensePower) {
        this.defensePower = defensePower;
    }
}
/**
 * @author 长名06
 * @version 1.0
 * 守护者对象，用于管理(保存游戏状态/数据对象)的对象
 */
public class Caretaker {

    //只保存一个角色的一次状态
    private Mementor mementor;

    //对于一个游戏角色的多个状态
//    private List<Mementor> mementorList = new ArrayList<>();

    //保存多个游戏角色的状态
//    private HashMap<String,ArrayList<Mementor>> rolesMap;


    public Mementor getMementor() {
        return mementor;
    }

    public void setMementor(Mementor mementor) {
        this.mementor = mementor;
    }
}
public class Client {
    public static void main(String[] args) {
        GameRole gameRole = new GameRole();
        gameRole.setAttackPower(100);
        gameRole.setDefensePower(200);
        System.out.print("打BOSS前状态\t");
        gameRole.showState();

        //将当前状态保存到一个备忘录类中
        Caretaker caretaker = new Caretaker();
        caretaker.setMementor(gameRole.createMementor());

        //打BOSS状态下降
        gameRole.setDefensePower(100);
        gameRole.setAttackPower(50);
        //打BOSS后状态
        System.out.print("打BOSS后状态\t");
        gameRole.showState();

        //恢复状态
        gameRole.restoreStateFromMementor(caretaker.getMementor());
        //展示恢复后的状态
        System.out.print("恢复后的状态\t");
        gameRole.showState();
    }
}