【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现)

这篇具有很好参考价值的文章主要介绍了【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

案例引入

案例一

普通实现

在租房过程中,客户可能去找房东问房子是否可以租,但是房东可能要和家人进行一系列的沟通,最后还可能派出另一个家庭成员来和客户进行交流,整个沟通过程非常复杂、沟通线路繁多。如果是写成程序的模式,不同成员之间需要留好接口方便成员之间互相进行调用

【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现),设计模式,设计模式,学习,笔记,中介者模式

【分析】

  • 各个成员彼此联系,你中有我,我中有你,不利于松耦合
  • 各个成员之间所传递的消息(参数)容易混乱
  • 当系统增加一个新的成员时,或者执行流程改变时,代码的可维护性、扩展性都不理想

【改进】

  • 使用中介者模式

中介者模式

客户只需要对接中介,其他成员互相之间不进行沟通,由中介来进行沟通。如 屋主—>爸爸 变成 屋主—>中介—>爸爸。通过中介的联络,可以将成员之间的关联关系都搞定
【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现),设计模式,设计模式,学习,笔记,中介者模式

案例二

现在很多家庭都配备了智能家居,包括各种设备,如闹钟、咖啡机、电视机、窗帘……

当主人想要看电视时,会让多个设备协同工作,来自动完成看电视的准备工作,比如流程为: 闹铃响起->咖啡机开始做咖啡->窗帘自动落下->电视机开始播放

介绍

基础介绍

  • 在中介者模式中,团队组员之间不再互相沟通并私自做出决定,而是发生任何事情都向中介者报告,中介者站在整个团队的角度上对组员上报的事情做出决定。当中介者下达指示时,组员会立即执行
  • 用一个中介对象来封装一系列的对象交互方法。中介者使各个对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互
  • 中介者模式属于行为型模式
  • 在MVC模式中,C(Controller控制器) 是M(Model模型) 和V(View视图)的中介者,在前后端交互时起到了中间人的作用

【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现),设计模式,设计模式,学习,笔记,中介者模式

登场角色

尚硅谷

【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现),设计模式,设计模式,学习,笔记,中介者模式

  • Mediator 就是抽象中介者,定义了同事对象到中介者对象的接口
  • Colleague 是抽象同事类
  • ConcreteMediator 具体的中介者对象,实现抽象方法,他需要知道所有的具体同事类,即以HashMap管理所有同事类,并接受某个同事对象的消息,来协调其他同事完成相应的任务
  • ConcreteColleague 具体的同事类,可能会有很多个,每个同事只知道自己的行为,而不了解其他同事类的行为(方法),他们都依赖中介者对象

《图解设计模式》

【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现),设计模式,设计模式,学习,笔记,中介者模式

  • Mediator(仲裁者、中介者):负责定义与 Colleague 角色进行通信和做出决定的接口(API)
  • ConcreteMediator(具体的仲裁者、中介者):负责实现 Mediator 角色的接口(API),负责实际上如何做出决定
  • Colleague(同事):负责定义与Mediator角色进行通信的接口(API)
  • ConcreteColleague(具体的同事):负责实现 Colleague 角色的接口(API)

案例实现

案例一:智能家庭

类图

【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现),设计模式,设计模式,学习,笔记,中介者模式

【操作流程】

  • 创建 ConcreteMediator 对象
  • 创建各个同事类对象,比如: Alarm、CoffeeMachine、TV
  • 在创建同事类对象的时候,就直接通过构造器,加入到 colleagueMap
  • 同事类对象,可以调用sendMessage,最终会去调用ConcreteMediator的getMessage方法
  • getMessage(核心方法)会根据接收到的同事对象发出的消息 来协调调用其它的同事对象来共同完成任务

实现

【抽象中介者类】

package com.atguigu.mediator.smarthouse;

public abstract class Mediator {
   /**
    * 将给中介者对象,加入到集合中
    * @param colleagueName
    * @param colleague
    */
   public abstract void register(String colleagueName, Colleague colleague);

   /**
    * 接收消息, 具体的同事对象发出
    * @param stateChange
    * @param colleagueName
    */
   public abstract void getMessage(int stateChange, String colleagueName);

   public abstract void sendMessage();
}

【具体中介者类】

package com.atguigu.mediator.smarthouse;

import java.util.HashMap;

/**
 * 具体的中介者类
 */
public class ConcreteMediator extends Mediator {
   /**
    * 集合,放入所有的同事对象
    */
   private HashMap<String, Colleague> colleagueMap;
   private HashMap<String, String> interMap;

   public ConcreteMediator() {
      colleagueMap = new HashMap<String, Colleague>();
      interMap = new HashMap<String, String>();
   }

   @Override
   public void register(String colleagueName, Colleague colleague) {
      colleagueMap.put(colleagueName, colleague);

      if (colleague instanceof Alarm) {
         interMap.put("Alarm", colleagueName);
      } else if (colleague instanceof CoffeeMachine) {
         interMap.put("CoffeeMachine", colleagueName);
      } else if (colleague instanceof TV) {
         interMap.put("TV", colleagueName);
      } else if (colleague instanceof Curtains) {
         interMap.put("Curtains", colleagueName);
      }

   }

   /**
    * 具体中介者的核心方法
    * 1. 根据得到消息,完成对应任务
    * 2. 中介者在这个方法,协调各个具体的同事对象,完成任务
    * @param stateChange
    * @param colleagueName
    */
   @Override
   public void getMessage(int stateChange, String colleagueName) {

      //处理闹钟发出的消息
      if (colleagueMap.get(colleagueName) instanceof Alarm) {
         if (stateChange == 0) {
            // 老司机做咖啡
            ((CoffeeMachine) (colleagueMap.get(interMap
                  .get("CoffeeMachine")))).StartCoffee();
            // 启动电视
            ((TV) (colleagueMap.get(interMap.get("TV")))).StartTv();
         } else if (stateChange == 1) {
            // 关掉电视
            ((TV) (colleagueMap.get(interMap.get("TV")))).StopTv();
         }

      } else if (colleagueMap.get(colleagueName) instanceof CoffeeMachine) {
         // 将窗帘升起来
         ((Curtains) (colleagueMap.get(interMap.get("Curtains"))))
               .UpCurtains();
      } else if (colleagueMap.get(colleagueName) instanceof TV) {
         //如果TV发现消息
      } else if (colleagueMap.get(colleagueName) instanceof Curtains) {
         //如果是以窗帘发出的消息,这里处理...
      }

   }

   @Override
   public void sendMessage() {

   }

}

【抽象同事类:Colleague】

package com.atguigu.mediator.smarthouse;

/**
 * 抽象同事类
 */
public abstract class Colleague {
   /**
    * 关联 Mediator
    */
   private Mediator mediator;
   public String name;

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

   public Mediator GetMediator() {
      return this.mediator;
   }

   public abstract void SendMessage(int stateChange);
}

【具体同事类:闹钟】

package com.atguigu.mediator.smarthouse;

/**
 * 具体的同事类 闹钟
 */
public class Alarm extends Colleague {

   /**
    * 构造器
    * @param mediator
    * @param name
    */
   public Alarm(Mediator mediator, String name) {
      super(mediator, name);
      //在创建Alarm 同事对象时,将自己放入到ConcreteMediator 对象的集合中
      mediator.register(name, this);
   }

   public void SendAlarm(int stateChange) {
      SendMessage(stateChange);
   }

   @Override
   public void SendMessage(int stateChange) {
      //调用的中介者对象的getMessage
      this.GetMediator().getMessage(stateChange, this.name);
   }

}

【具体同事类:窗帘】

package com.atguigu.mediator.smarthouse;

/**
 * 窗帘
 */
public class Curtains extends Colleague {

   public Curtains(Mediator mediator, String name) {
      super(mediator, name);
      mediator.register(name, this);
   }

   @Override
   public void SendMessage(int stateChange) {
      this.GetMediator().getMessage(stateChange, this.name);
   }

   public void UpCurtains() {
      System.out.println("I am holding Up Curtains!");
   }

}

【具体同事类:电视】

package com.atguigu.mediator.smarthouse;

public class TV extends Colleague {

   public TV(Mediator mediator, String name) {
      super(mediator, name);
      mediator.register(name, this);
   }

   @Override
   public void SendMessage(int stateChange) {
      this.GetMediator().getMessage(stateChange, this.name);
   }

   public void StartTv() {
      System.out.println("It's time to StartTv!");
   }

   public void StopTv() {
      System.out.println("StopTv!");
   }
}

【主类】

package com.atguigu.mediator.smarthouse;

public class ClientTest {

   public static void main(String[] args) {
      //创建一个中介者对象
      Mediator mediator = new ConcreteMediator();

      //创建Alarm并且加入到 ConcreteMediator 对象的HashMap
      Alarm alarm = new Alarm(mediator, "alarm");

      //创建了CoffeeMachine对象,并且加入到 ConcreteMediator 对象的HashMap
      CoffeeMachine coffeeMachine = new CoffeeMachine(mediator,
            "coffeeMachine");

      //创建 Curtains, 并且加入到 ConcreteMediator 对象的HashMap
      Curtains curtains = new Curtains(mediator, "curtains");
      TV tV = new TV(mediator, "TV");

      //让闹钟发出消息
      alarm.SendAlarm(0);
      //做好咖啡
      coffeeMachine.FinishCoffee();
      alarm.SendAlarm(1);
   }

}

【运行】

It's time to startcoffee!
It's time to StartTv!
After 5 minutes!
Coffee is ok!
I am holding Up Curtains!
StopTv!

Process finished with exit code 0

【分析】

  • 程序拓展性较好:如果添加一个机器,只需要添加一个 ConcreteColleague 并修改 ConcreteMediator 的相关方法就行,客户端不用改变

案例二:登录页面逻辑实现

说明

【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现),设计模式,设计模式,学习,笔记,中介者模式

需要实现一个系统登录表单功能,具体的处理逻辑如下:

  • 如果选择作为游客访问,那么禁用用户名输入框和密码输入框,使用户无法输入
  • 如果选择作为用户登录,那么启用用户名输入框和密码输入框,使用户可以输入
  • 如果在用户名输入框中一个字符都没有输入,那么禁用密码输入框,使用户无法输入密码
  • 如果在用户名输入框中输入了至少一个字符,那么启用密码输入框,使用户可以输入密码(当然,如果选择作为游客访问,那么密码框依然是禁用状态 )
  • 只有当用户名输入框和密码输入框中都至少输入一个字符后,OK 按钮才处于启用状态,可以被按下
  • 用户名输入框或密码输入框中一个字符都没有被输入的时候,禁用OK按钮,使其不可被按下(当然,如果选择作为游客访问,那么OK 按总是处于启用状态)
  • Cancel按钮总是处于启用状态,任何时候都可以按下该按钮

类图

【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现),设计模式,设计模式,学习,笔记,中介者模式

实现

中介者接口和组员接口的方法并非固定就是这些,当中介者和组员需要其他合作的话,就需要定义更多的方法

【中介者接口】

package com.atguigu.mediator.Sample;

public interface Mediator {
    /**
     * 生成 Mediator 管理的组员
     */
    public abstract void createColleagues();

    /**
     * 每个组员都会调用这个方法来向中介者汇报
     */
    public abstract void colleagueChanged();
}

【组员接口】

package com.atguigu.mediator.Sample;

public interface Colleague {
    /**
     * 设置中介者,告诉组员中介者是谁
     *
     * @param mediator
     */
    public abstract void setMediator(Mediator mediator);

    /**
     * 告知组员中介者所下达的指令
     * @param enabled 控制是否启用组员的功能
     */
    public abstract void setColleagueEnabled(boolean enabled);
}

【组员:按钮】

package com.atguigu.mediator.Sample;

import java.awt.*;

public class ColleagueButton extends Button implements Colleague {
    private Mediator mediator;

    public ColleagueButton(String caption) {
        super(caption);
    }

    public void setMediator(Mediator mediator) {
        // 保存Mediator
        this.mediator = mediator;
    }

    public void setColleagueEnabled(boolean enabled) {
        // Mediator下达启用/禁用的指示
        // setEnabled是java.awt.Button定义的方法,用来控制按钮组件是启用还是禁用,当设置为false时,按钮无法被按下
        setEnabled(enabled);
    }
}

【组员:文本输入框】

package com.atguigu.mediator.Sample;

import java.awt.*;
import java.awt.event.TextEvent;
import java.awt.event.TextListener;

/**
 * 实现 TextListener 接口来实现监听事件
 */
public class ColleagueTextField extends TextField implements TextListener, Colleague {
    private Mediator mediator;

    public ColleagueTextField(String text, int columns) {   // 构造函数
        super(text, columns);
    }

    public void setMediator(Mediator mediator) {            // 保存Mediator
        this.mediator = mediator;
    }

    public void setColleagueEnabled(boolean enabled) {      // Mediator下达启用/禁用的指示
        setEnabled(enabled);
        // 控件启用时,背景色变成白色;否则变为灰色
        setBackground(enabled ? Color.white : Color.lightGray);
    }

    /**
     * TextListener 中定义的方法,监听文本内容的变化,并通知中介者
     * @param e
     */
    public void textValueChanged(TextEvent e) {
        // 当文字发生变化时通知Mediator
        mediator.colleagueChanged();
    }
}

【组员:单选按钮】

package com.atguigu.mediator.Sample;

import java.awt.*;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

/**
 * 单选按钮
 */
public class ColleagueCheckbox extends Checkbox implements ItemListener, Colleague {
    private Mediator mediator;

    public ColleagueCheckbox(String caption, CheckboxGroup group, boolean state) {
        // 构造函数
        super(caption, group, state);
    }

    public void setMediator(Mediator mediator) {
        // 保存Mediator
        this.mediator = mediator;
    }

    public void setColleagueEnabled(boolean enabled) {
        // Mediator下达启用/禁用指示
        setEnabled(enabled);
    }

    /**
     * 监听单选按钮的状态变化
     * @param e
     */
    public void itemStateChanged(ItemEvent e) {
        // 当状态发生变化时通知Mediator
        mediator.colleagueChanged();
    }
}

【具体中介者】

package com.atguigu.mediator.Sample;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 * 具体中介者
 */
public class LoginFrame extends Frame implements ActionListener, Mediator {
    private ColleagueCheckbox checkGuest;
    private ColleagueCheckbox checkLogin;
    private ColleagueTextField textUser;
    private ColleagueTextField textPass;
    private ColleagueButton buttonOk;
    private ColleagueButton buttonCancel;

    /**
     * 构造函数
     * 生成并配置各个Colleague后,显示对话框
     *
     * @param title
     */
    public LoginFrame(String title) {
        super(title);
        // 设置登录对话框的背景颜色
        setBackground(Color.lightGray);
        // 使用布局管理器生成4×2窗格
        setLayout(new GridLayout(4, 2));
        // 生成各个 Colleague
        createColleagues();
        // 配置 Colleague
        add(checkGuest);
        add(checkLogin);
        add(new Label("Username:"));
        add(textUser);
        add(new Label("Password:"));
        add(textPass);
        add(buttonOk);
        add(buttonCancel);
        // 设置初始的启用起用/禁用状态
        colleagueChanged();
        // 显示
        pack();
        show();
    }

    /**
     * 生成登录对话框所需要的各个Colleague
     */
    public void createColleagues() {
        // 生成
        CheckboxGroup g = new CheckboxGroup();
        checkGuest = new ColleagueCheckbox("Guest", g, true);
        checkLogin = new ColleagueCheckbox("Login", g, false);
        textUser = new ColleagueTextField("", 10);
        textPass = new ColleagueTextField("", 10);
        textPass.setEchoChar('*');
        buttonOk = new ColleagueButton("OK");
        buttonCancel = new ColleagueButton("Cancel");
        // 设置Mediator
        checkGuest.setMediator(this);
        checkLogin.setMediator(this);
        textUser.setMediator(this);
        textPass.setMediator(this);
        buttonOk.setMediator(this);
        buttonCancel.setMediator(this);
        // 设置Listener
        checkGuest.addItemListener(checkGuest);
        checkLogin.addItemListener(checkLogin);
        textUser.addTextListener(textUser);
        textPass.addTextListener(textPass);
        buttonOk.addActionListener(this);
        buttonCancel.addActionListener(this);
    }

    /**
     * 控制各个成员的状态
     * 接收来自于 Colleague 的通知,然后判断各 Colleague 的启用/禁用状态
     * 
     * 单选按钮的选中状态发生改变 或者 文本输入框的内容发生改变,都会调用这个方法
     */
    public void colleagueChanged() {
        // checkGuest.getState()获取游客模式的按钮是否处于选中状态
        if (checkGuest.getState()) {
            // 游客模式
            textUser.setColleagueEnabled(false);
            textPass.setColleagueEnabled(false);
            buttonOk.setColleagueEnabled(true);
        } else {
            // 登录模式
            textUser.setColleagueEnabled(true);
            userpassChanged();
        }
    }

    /**
     * 当textUser或是textPass文本输入框中的文字发生变化时
     * 判断各Colleage的启用/禁用状态
     */
    private void userpassChanged() {
        if (textUser.getText().length() > 0) {
            textPass.setColleagueEnabled(true);
            if (textPass.getText().length() > 0) {
                buttonOk.setColleagueEnabled(true);
            } else {
                buttonOk.setColleagueEnabled(false);
            }
        } else {
            textPass.setColleagueEnabled(false);
            buttonOk.setColleagueEnabled(false);
        }
    }

    public void actionPerformed(ActionEvent e) {
        System.out.println(e.toString());
        System.exit(0);
    }
}

【主类】

package com.atguigu.mediator.Sample;

public class Main {
    static public void main(String args[]) {
        new LoginFrame("Mediator Sample");
    }
}

【运行】

【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现),设计模式,设计模式,学习,笔记,中介者模式

总结

【优点】

  • 多个类相互耦合,会形成网状结构(通信路线很多),使用中介者模式将网状结构分离为星型结构进行解耦
  • 减少类间依赖,峰低了耦合,符合迪米特原则
  • 如果出现了Bug,比较容易定位Bug的位置
  • ConcreteColleague容易复用(如果需要写一个新的对话框,那么按钮、文本输入框都可以很容易使用到新的对话框中)

【缺点】文章来源地址https://www.toymoban.com/news/detail-634464.html

  • 中介者承担了较多的责任,一旦中介者出现了问题,整个系统就会受到影响
  • 如果设计不当,中介者对象本身变得过于复杂,这点在实际使用时,要特别注意
  • ConcreteMediator难以复用,因为其依赖于特定的应用程序

文章说明

  • 本文章为本人学习尚硅谷的学习笔记,文章中大部分内容来源于尚硅谷视频(点击学习尚硅谷相关课程),也有部分内容来自于自己的思考,发布文章是想帮助其他学习的人更方便地整理自己的笔记或者直接通过文章学习相关知识,如有侵权请联系删除,最后对尚硅谷的优质课程表示感谢。
  • 本人还同步阅读《图解设计模式》书籍(图解设计模式/(日)结城浩著;杨文轩译–北京:人民邮电出版社,2017.1),进而综合两者的内容,让知识点更加全面

到了这里,关于【设计模式——学习笔记】23种设计模式——中介者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 设计模式之中介者模式

    详细介绍         中介者模式(Mediator Pattern)是一种行为设计模式, 它通过定义一个中介类来封装多个对象之间的交互,使各对象不需要显示地相互引用,从而降低耦合度,提高系统的可维护性和灵活性。中介者模式将原本一对多的网状关系转变为一对多的关系,即每个

    2024年04月29日
    浏览(66)
  • Java设计模式-中介者模式

    中介者模式,就是用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地互相引用,从而使其耦合松散,而且可以独立的改变它们之间的交互。 其实中介者模式很简单的,就像它的名字一样,中介,调用某个类的某些方法的时候,我们不直接去跟那个类的实

    2024年02月15日
    浏览(39)
  • 行为型设计模式——中介者模式

    中介者模式主要是将关联关系由一个中介者类统一管理维护,一般来说,同事类之间的关系是比较复杂的,多个同事类之间互相关联时,他们之间的关系会呈现为复杂的网状结构,这是一种过度耦合的架构,即不利于类的复用,也不稳定。例如在下左图中,有六个同事类对象

    2024年01月18日
    浏览(47)
  • 大话设计模式之中介者模式

    中介者模式是一种行为型设计模式,它通过引入一个中介者对象来封装一系列对象之间的交互,从而减少对象之间的直接通信,使得对象之间的耦合度降低,同时提高了系统的可维护性和灵活性。 在中介者模式中,对象之间的通信不再直接发生,而是通过中介者对象来进行。

    2024年04月16日
    浏览(42)
  • 设计模式- 中介者模式(Mediator)

    中介者模式(Mediator Pattern),是一种对象行为型模式。该模式的主要目的是定义一个中介对象来封装一系列对象之间的交互,使原有对象之间的耦合变得松散,并且可以独立地改变它们之间的交互。 抽象中介者(Mediator) :这是中介者模式的核心接口,它定义了同事对象注

    2024年04月26日
    浏览(36)
  • 设计模式—行为型模式之中介者模式

    中介者模式(Mediator Pattern):用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,减少对象间混乱的依赖关系,从而使其耦合松散,而且可以独立地改变它们之间的交互。对象行为型模式。 包含以下角色: Mediator: 抽象中介者 ConcreteMediator: 具体中

    2024年01月16日
    浏览(45)
  • 设计模式-行为型模式之中介者模式

    在用户与用户直接聊天的设计方案中,用户对象之间存在很强的 关联性 ,将导致系统出现如下问题: 对象之间存在大量的相互关联和调用,若有一个对象发生变化,则需要跟踪和该对象关联的其他所有对象,并进行适当处理。 由于一个对象和其他对象具有很强的关联,若没

    2023年04月23日
    浏览(32)
  • 设计模式(十七)中介者

    义一个对象来封装一系列的对象交互。中介者模式使各对象不需要显示地相互引用,从而使其耦合松散,而且可以让你相对独立地改变它们之间的交互。中介者模式又称为调停模式,它是一种对象说行为型模式。 在中介者模式中,引入了用于协调其他对象/类之间的相互调用

    2024年02月04日
    浏览(38)
  • 经典的设计模式17——中介者模式

    定义: 用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变他们之间的交互。 结构: 抽象中介者角色:是中介者的接口,提供了同事对象注册与转发同事对象信息的抽象方法。 具体中介者角色:实现中

    2024年02月09日
    浏览(41)
  • C++ 设计模式之 中介者模式

    【声明】本题目来源于卡码网(题目页面 (kamacoder.com)) 【提示:如果不想看文字介绍,可以直接跳转到C++编码部分】         -- 什么是中介者模式  (第16种模式)          中介者模式 (Mediator Pattern)也被称为 调停者模式 ,是⼀种 ⾏为型设计模式 ,它通过⼀个中介

    2024年01月19日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包