《设计模式之行为型模式》系列，共包含以下文章：

• 行为型模式（一）：模板方法模式、观察者模式
• 行为型模式（二）：策略模式、命令模式
• 行为型模式（三）：责任链模式、状态模式
• 行为型模式（四）：备忘录模式、中介者模式
• 行为型模式（五）：解释器模式、访问者模式、依赖注入

😊 如果您觉得这篇文章有用 ✔️ 的话，请给博主一个一键三连 🚀🚀🚀 吧 （点赞 🧡、关注 💛、收藏 💚）！！！您的支持 💖💖💖 将激励 🔥 博主输出更多优质内容！！！

7.备忘录模式（Memento）

备忘录模式（Memento）是一种行为设计模式，它允许你在不破坏封装性的前提下，捕获一个对象的内部状态，并在之后恢复为之前的状态。简单来说，就是保存一个对象的 快照，以便将来可以恢复到这个状态。

7.1 通俗易懂的解释

想象一下你正在玩一个电子游戏，游戏中有一个 “存档” 功能。当你存档时，游戏会保存你当前的所有状态（比如角色的位置、生命值、装备等）。当你需要时，可以加载这个存档，恢复到之前的状态。这就是备忘录模式的基本思想。

7.2 具体步骤

• 定义发起人：发起人是需要保存和恢复状态的对象。
• 定义备忘录：备忘录是一个用于存储发起人状态的类。
• 定义管理者：管理者是一个用于保存和管理备忘录的类。
• 保存状态：发起人将当前状态保存到备忘录中，并将备忘录交给管理者。
• 恢复状态：发起人从管理者那里获取备忘录，并恢复到之前的状态。

7.3 代码示例

下面是一个简单的 Java 代码示例，展示了备忘录模式的实现。

7.3.1 定义发起人

// 定义发起人
class Originator {
    private String state;

    public String getState() {
        return state;
    }

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

    // 创建备忘录
    public Memento createMemento() {
        return new Memento(state);
    }

    // 恢复备忘录
    public void restoreMemento(Memento memento) {
        this.state = memento.getState();
    }

    @Override
    public String toString() {
        return "Originator [state=" + state + "]";
    }
}

7.3.2 定义备忘录

// 定义备忘录
class Memento {
    private String state;

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

    public String getState() {
        return state;
    }
}

7.3.3 定义管理者

// 定义管理者
class Caretaker {
    private Memento memento;

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

    public Memento getMemento() {
        return memento;
    }
}

7.3.4 客户端

// 测试类
public class MementoPatternExample {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();

        // 设置初始状态
        originator.setState("状态1");
        System.out.println("初始状态: " + originator);

        // 保存状态
        caretaker.setMemento(originator.createMemento());

        // 改变状态
        originator.setState("状态2");
        System.out.println("改变后的状态: " + originator);

        // 恢复状态
        originator.restoreMemento(caretaker.getMemento());
        System.out.println("恢复后的状态: " + originator);
    }
}

7.3.5 输出

初始状态: Originator [state=状态1]
改变后的状态: Originator [state=状态2]
恢复后的状态: Originator [state=状态1]

7.4 总结

备忘录模式通过将对象的状态保存到一个独立的备忘录对象中，使得对象可以在需要时恢复到之前的状态。这样可以避免在对象内部直接暴露状态，保持了对象的封装性。

8.中介者模式（Mediator）

中介者模式（Mediator）是一种行为设计模式，它通过一个中介对象来封装一系列对象之间的交互，使得这些对象不再直接相互依赖，而是通过中介者进行通信。这样可以减少对象之间的耦合，使系统的结构更加清晰和易于维护。

8.1 通俗易懂的解释

想象一下你在一个大型的办公室里，有很多员工需要互相沟通。如果每个员工都直接和其他员工沟通，那么沟通的复杂度会非常高，很容易出现混乱。为了解决这个问题，可以设置一个前台秘书，所有的沟通都通过前台秘书进行。员工只需要告诉秘书他们的需求，秘书会负责协调和传达信息。这样，员工之间的沟通就变得简单和有序了。

8.2 具体步骤

• 定义中介者接口：定义一个中介者接口，声明协调对象之间交互的方法。
• 实现具体中介者：实现具体的中介者类，负责协调对象之间的交互。
• 定义同事类：定义需要通过中介者进行通信的对象类，这些对象称为同事类。
• 注册同事类：同事类在创建时需要注册到中介者中。
• 通过中介者通信：同事类之间的通信都通过中介者进行，而不是直接相互依赖。

8.3 代码示例

下面是一个简单的 Java 代码示例，展示了中介者模式的实现。

8.3.1 定义中介者接口

// 定义中介者接口
interface Mediator {
    void send(String message, Colleague colleague);
}

8.3.2 定义同事类

// 定义同事类
abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void send(String message);
    public abstract void receive(String message);
}

8.3.3 具体同事类

// 具体同事类：员工A
class ColleagueA extends Colleague {
    public ColleagueA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void send(String message) {
        mediator.send(message, this);
    }

    @Override
    public void receive(String message) {
        System.out.println("员工A收到消息: " + message);
    }
}

// 具体同事类：员工B
class ColleagueB extends Colleague {
    public ColleagueB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void send(String message) {
        mediator.send(message, this);
    }

    @Override
    public void receive(String message) {
        System.out.println("员工B收到消息: " + message);
    }
}

8.3.4 具体中介者类

// 具体中介者类：前台秘书
class SecretaryMediator implements Mediator {
    private ColleagueA colleagueA;
    private ColleagueB colleagueB;

    public void setColleagueA(ColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    public void setColleagueB(ColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }

    @Override
    public void send(String message, Colleague colleague) {
        if (colleague == colleagueA) {
            colleagueB.receive(message);
        } else if (colleague == colleagueB) {
            colleagueA.receive(message);
        }
    }
}

8.3.5 客户端

// 测试类
public class MediatorPatternExample {
    public static void main(String[] args) {
        SecretaryMediator mediator = new SecretaryMediator();

        ColleagueA colleagueA = new ColleagueA(mediator);
        ColleagueB colleagueB = new ColleagueB(mediator);

        mediator.setColleagueA(colleagueA);
        mediator.setColleagueB(colleagueB);

        // 员工A发送消息
        colleagueA.send("你好，员工B，项目进展如何？");

        // 员工B发送消息
        colleagueB.send("你好，员工A，项目进展顺利。");
    }
}

8.3.6 输出

员工B收到消息: 你好，员工B，项目进展如何？
员工A收到消息: 你好，员工A，项目进展顺利。

8.4 总结

中介者模式通过引入一个中介者对象，将多个对象之间的直接依赖关系解耦，使得对象之间的通信更加有序和简单。这样可以减少对象之间的耦合，提高系统的可维护性和扩展性。