【设计模式】行为型模式(四):备忘录模式、中介者模式

设计模式之行为型模式》系列,共包含以下文章:

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

行为型模式(四):备忘录模式、中介者模式

  • 7.备忘录模式(Memento)
    • [7.1 通俗易懂的解释](#7.1 通俗易懂的解释)
    • [7.2 具体步骤](#7.2 具体步骤)
    • [7.3 代码示例](#7.3 代码示例)
      • [7.3.1 定义发起人](#7.3.1 定义发起人)
      • [7.3.2 定义备忘录](#7.3.2 定义备忘录)
      • [7.3.3 定义管理者](#7.3.3 定义管理者)
      • [7.3.4 客户端](#7.3.4 客户端)
      • [7.3.5 输出](#7.3.5 输出)
    • [7.4 总结](#7.4 总结)
  • 8.中介者模式(Mediator)
    • [8.1 通俗易懂的解释](#8.1 通俗易懂的解释)
    • [8.2 具体步骤](#8.2 具体步骤)
    • [8.3 代码示例](#8.3 代码示例)
      • [8.3.1 定义中介者接口](#8.3.1 定义中介者接口)
      • [8.3.2 定义同事类](#8.3.2 定义同事类)
      • [8.3.3 具体同事类](#8.3.3 具体同事类)
      • [8.3.4 具体中介者类](#8.3.4 具体中介者类)
      • [8.3.5 客户端](#8.3.5 客户端)
      • [8.3.6 输出](#8.3.6 输出)
    • [8.4 总结](#8.4 总结)

7.备忘录模式(Memento)

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

7.1 通俗易懂的解释

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

7.2 具体步骤

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

7.3 代码示例

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

7.3.1 定义发起人

java 复制代码
// 定义发起人
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 定义备忘录

java 复制代码
// 定义备忘录
class Memento {
    private String state;

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

    public String getState() {
        return state;
    }
}

7.3.3 定义管理者

java 复制代码
// 定义管理者
class Caretaker {
    private Memento memento;

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

    public Memento getMemento() {
        return memento;
    }
}

7.3.4 客户端

java 复制代码
// 测试类
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 输出

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

7.4 总结

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

8.中介者模式(Mediator)

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

8.1 通俗易懂的解释

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

8.2 具体步骤

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

8.3 代码示例

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

8.3.1 定义中介者接口

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

8.3.2 定义同事类

java 复制代码
// 定义同事类
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 具体同事类

java 复制代码
// 具体同事类:员工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 具体中介者类

java 复制代码
// 具体中介者类:前台秘书
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 客户端

java 复制代码
// 测试类
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 输出

plain 复制代码
员工B收到消息: 你好,员工B,项目进展如何?
员工A收到消息: 你好,员工A,项目进展顺利。

8.4 总结

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

相关推荐
某不知名網友6 分钟前
Reactor 模式:高并发网络编程的事件驱动利器
网络·设计模式·php
Asort10 分钟前
JavaScript设计模式(六)——适配器模式 (Adapter)
前端·javascript·设计模式
程序员小假23 分钟前
我们来说一说 ThreadLocal 内存泄漏
java·后端
xq952731 分钟前
获取Facebook 散列利器 来了 十六进制到 Base64 转换器
java
我不是混子1 小时前
聊聊Spring事件机制
java·后端
DKPT1 小时前
JVM栈溢出时如何dump栈信息?
java·jvm·笔记·学习·spring
DKPT1 小时前
JVM堆大小如何设置?
java·开发语言·jvm·笔记·学习
铅笔侠_小龙虾1 小时前
JVM 目录
java·jvm
yunxi_051 小时前
让大模型会“说话”:基于 Spring WebSocket 的毫秒级流式 RAG 对话
java·后端
用户6120414922131 小时前
jsp+servlet做的医院挂号看诊管理系统
java·javascript·mysql