设计模式Java版：18备忘录模式（行为型）

定义

备忘录模式（Memento Pattern）是一种行为型设计模式，它允许在不破坏封装性的前提下捕获对象的内部状态，并在需要时恢复对象到之前的状态。

备忘录模式的核心思想是将对象的状态保存到一个备忘录对象中，以便在需要时可以还原到先前的状态。这样可以在不暴露对象内部细节的情况下，提供对对象状态的恢复和回滚的能力。

备忘录模式涉及以下几个角色：

发起人（Originator）：需要保存状态的对象。它创建一个备忘录对象，并可以将自身的状态保存到备忘录中，也可以从备忘录中恢复状态。

备忘录（Memento）：用于存储发起人对象的内部状态。备忘录可以记录发起人对象的状态，并提供访问发起人对象状态的接口，但不能被其他对象访问或修改。

管理者（Caretaker）：负责保存备忘录对象，并在需要时将备忘录对象还原给发起人对象。管理者通常不直接操作备忘录对象，而是将其存储在某个集合中，以便在需要时进行管理和恢复。

备忘录模式的使用场景包括：

当需要保存对象的历史状态，并能够在需要时回滚到之前的状态时。
当直接访问对象的内部状态会破坏对象的封装性，但又需要保存和恢复对象状态时。
当需要提供撤销和重做操作的功能时，可以使用备忘录模式来实现。

通过备忘录模式，可以有效地管理和恢复对象的状态，提供更灵活的状态操作和历史记录功能。

示例一：保存和恢复对象的状态

// 发起人类
class Originator {
    private String state;

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

    public String getState() {
        return state;
    }

    public Memento createMemento() {
        return new Memento(state);
    }

    public void restoreMemento(Memento memento) {
        this.state = memento.getState();
    }

    public void showState() {
        System.out.println("Current State: " + state);
    }
}

// 备忘录类
class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

// 管理者类
class Caretaker {
    private List<Memento> mementos = new ArrayList<>();

    public void addMemento(Memento memento) {
        mementos.add(memento);
    }

    public Memento getMemento(int index) {
        return mementos.get(index);
    }
}

// 使用备忘录模式进行状态保存和恢复
public class MementoPatternExample {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();

        // 设置并保存初始状态
        originator.setState("State 1");
        originator.showState();
        Memento memento1 = originator.createMemento();
        caretaker.addMemento(memento1);

        // 修改状态并保存
        originator.setState("State 2");
        originator.showState();
        Memento memento2 = originator.createMemento();
        caretaker.addMemento(memento2);

        // 修改状态并保存
        originator.setState("State 3");
        originator.showState();
        Memento memento3 = originator.createMemento();
        caretaker.addMemento(memento3);

        // 恢复到先前状态
        Memento previousMemento = caretaker.getMemento(1);
        originator.restoreMemento(previousMemento);
        originator.showState();
    }
}

输出结果：

Current State: State 1
Current State: State 2
Current State: State 3
Current State: State 2

在上述示例中，Originator类代表发起人，它具有设置状态、创建备忘录和恢复备忘录的功能。Memento类表示备忘录，用于存储发起人的状态。Caretaker类作为管理者，用于保存和获取备忘录对象。

通过创建备忘录并保存到管理者中，我们可以在需要时从备忘录中恢复发起人的状态，实现了状态的保存和恢复功能。

示例二：保存和恢复游戏角色的状态

// 游戏角色类
class GameCharacter {
    private String name;
    private int level;
    private int health;

    public GameCharacter(String name, int level, int health) {
        this.name = name;
        this.level = level;
        this.health = health;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public String getName() {
        return name;
    }

    public int getLevel() {
        return level;
    }

    public int getHealth() {
        return health;
    }

    public GameCharacterMemento createMemento() {
        return new GameCharacterMemento(name, level, health);
    }

    public void restoreMemento(GameCharacterMemento memento) {
        this.name = memento.getName();
        this.level = memento.getLevel();
        this.health = memento.getHealth();
    }

    public void showCharacterInfo() {
        System.out.println("Character Name: " + name);
        System.out.println("Level: " + level);
        System.out.println("Health: " + health);
    }
}

// 备忘录类
class GameCharacterMemento {
    private String name;
    private int level;
    private int health;

    public GameCharacterMemento(String name, int level, int health) {
        this.name = name;
        this.level = level;
        this.health = health;
    }

    public String getName() {
        return name;
    }

    public int getLevel() {
        return level;
    }

    public int getHealth() {
        return health;
    }
}

// 管理者类
class GameCaretaker {
    private GameCharacterMemento memento;

    public void saveMemento(GameCharacterMemento memento) {
        this.memento = memento;
    }

    public GameCharacterMemento getMemento() {
        return memento;
    }
}

// 游戏场景类
public class GameScene {
    public static void main(String[] args) {
        GameCharacter character = new GameCharacter("Player 1", 1, 100);
        GameCaretaker caretaker = new GameCaretaker();

        // 保存初始角色状态
        caretaker.saveMemento(character.createMemento());
        character.showCharacterInfo();

        // 角色升级
        character.setLevel(2);
        character.setHealth(150);
        character.showCharacterInfo();

        // 角色受伤
        character.setHealth(80);
        character.showCharacterInfo();

        // 恢复到初始状态
        character.restoreMemento(caretaker.getMemento());
        character.showCharacterInfo();
    }
}

输出结果：

Character Name: Player 1
Level: 1
Health: 100
Character Name: Player 1
Level: 2
Health: 150
Character Name: Player 1
Level: 2
Health: 80
Character Name: Player 1
Level: 1
Health: 100

在示例中，我们使用了GameCharacter类作为发起人，用于保存和恢复游戏角色的状态。GameCharacterMemento类表示备忘录，用于存储游戏角色的状态信息。GameCaretaker类作为管理者，负责保存和获取备忘录对象。

在游戏场景中，我们可以通过创建备忘录并保存到管理者中，随时保存游戏角色的状态。当需要恢复到之前的状态时，可以从管理者中获取备忘录对象，并将其应用于游戏角色，实现状态的恢复。

上述示例展示了游戏角色升级和受伤的情况，并在需要时恢复到初始状态。你可以根据需要进一步扩展示例，加入更多的状态和操作，以展示备忘录模式在不同场景中的应用。