精华内容
下载资源
问答
  • #Mediator设计模式我的测试代码可以理解Mediator设计模式的基础知识
  • 一种基于Mediator设计模式的车载多媒体系统设计,宋飞,郭文明,如今,车载多媒体系统已经在汽车产业发展中扮演了越来越重要的角色,而车载系统的设计方式也必将受到越来越多的重视。本文从系统
  • 设计模式20——Mediator设计模式

    千次阅读 2012-06-01 14:41:08
    Mediator中介者设计模式是通过一个中介对象封装一系列关于对象交互行为. Mediator中介者设计模式中的角色如下: (1).中介者(Mediator):抽象定义了“同事”(colleagues,稍后有定义)们通信的接口。 (2).具体...

    Mediator中介者设计模式是通过一个中介对象封装一系列关于对象交互行为.

    Mediator中介者设计模式中的角色如下:

    (1).中介者(Mediator):抽象定义了“同事”(colleagues,稍后有定义)们通信的接口。

    (2).具体中介者(Concrete Mediator):实现了“同事”间的通信接口。

    (3).同事(Colleague):参与通信的实体抽象。

    (4).具体同事(Concrete Colleague):实现的参与通信的实体。

    Mediator中介者设计模式结构如下:


    以私信聊天为例来简单演示Mediator中介者设计模式,例子代码如下:

    //中介者
    interface Mediator{
    	public void send(String msg, Person person);
    }
    //具体中介者
    class ConcreteMediator implements Mediator{
    	//中介者所联系的交互对象
    	private PersonA personA;
    	private PersonA personB;
    	public void setPersonA(PersonA  personA){
    	this.personA = personA;
    }
    Public void setPersonB(PersonB personB){
    	this.personB = personB;
    }
    public void send(String msg, Person person){
    	if(person.equals(personA)){
    	personA.greeting(msg);
    }else{
    	personB.greeting(msg);
    }
    }
    } 
    //抽象同事
    abstract class Person{
    	//同事和中介者打交道
    	protected Mediator mediator;
    	public Person(Mediator mediator){
    	this.mediator = mediator;
    }
    }
    //具体同事
    class PersonA extends Person{
    	public PersonA(Mediator mediator){
    	super(mediator);
    }
    public void send(String msg){
    	mediator.send(msg, this);
    }
    public void greeting(string msg){
    	System.out.println(“PersonA: ” + msg);
    }
    } 
    class PersonB extends Person{
    	public PersonB(Mediator mediator){
    	super(mediator);
    }
    public void send(String msg){
    	mediator.send(msg, this);
    }
    public void greeting(string msg){
    	System.out.println(“PersonB: ” + msg);
    }
    } 
    public class MediatorDemo{
    	public static void main(String[] args){
    		//创建中介
    		Mediator mediator = new ConcreteMediator();
    //创建同事,并为同事设置中介
    Person personA = new PersonA(mediator);
    Person personB = new PersonB(mediator);
    
    //向中介设置同事
    mediator.setPersonA(personA);
    mediator.setPersonB(personB);
    
    //开始聊天
    personA.send(“Hi, B!”);
    personB.send(“Hello, A!”);
    }
    } 

    在对象之间的交互操作非常多的情况下;每个对象的行为操作都可能依赖很多其他对象,修改一个对象的行为的同时可能会影响到很多其他对象的行为,如果使用Mediator模式,可以使各个对象间的耦合松散,只需关心和 Mediator的关系,使多对多的关系变成了一对多的关系,在降低系统复杂性的同时提高可修改扩展性. 

    展开全文
  • 这是一个运用了中介者设计模式的登录对话框练习题。 该案例改编自结城浩《设计模式-java语言中的应用》一书。 This is a program about a login dialog, wich try to illustrate the design pattern of Mediator. ...
  • 作这个习作的时候并不知道有设计模式这回事情。之后了解了,才顿悟。 所谓的设计模式我认为并不是单独提出来的一门技术。 而是对编写设计软件经验的一些总结,综合,提炼。 这个习作的意图是: 设计一个颜色控件...


    作这个习作的时候并不知道有设计模式这回事情。之后了解了,才顿悟。
    所谓的设计模式我认为并不是单独提出来的一门技术。
    而是对编写设计软件经验的一些总结,综合,提炼。

    这个习作的意图是:
    设计一个颜色控件(MyColorChooser),并应用于窗体(Test).达到调控窗体背景色的目的

    完整的UML图


    运行效果图

    现在和正统的Media模式比较下
     
    展开全文
  • 设计模式学习笔记——中介者(Mediator)模式@(设计模式)[设计模式, 中介者模式, Mediator]设计模式学习笔记中介者Mediator模式 基本介绍 中介者案例 类图 实现代码 Mediator接口 Colleague接口 ColleagueButton类 ...

    设计模式学习笔记——中介者(Mediator)模式

    @(设计模式)[设计模式, 中介者模式, Mediator]

    基本介绍

    中介者模式一般用于调整多个对象之间的关系,当对象状态改变时,将信息先传递给中介者,中介者进行处理,再反馈给相应的对象。

    中介者案例

    类图

    中介者案例类图

    实现代码

    Mediator接口

    package com.pc.mediator.example;
    
    /**
     * 中介者接口
     * Created by Switch on 2017/3/30.
     */
    public interface Mediator {
        /**
         * 创建中介者管理成员
         */
        void createColleagues();
    
        /**
         * 成员状态改变
         */
        void colleagueChanged();
    
    }

    Colleague接口

    package com.pc.mediator.example;
    
    /**
     * 成员接口
     * Created by Switch on 2017/3/30.
     */
    public interface Colleague {
        /**
         * 设置中介者
         *
         * @param mediator 中介者对象
         */
        void setMediator(Mediator mediator);
    
        /**
         * 设置成员状态
         *
         * @param enabled 启用true,不启用false
         */
        void setColleagueEnabled(boolean enabled);
    }

    ColleagueButton类

    package com.pc.mediator.example;
    
    import java.awt.Button;
    
    /**
     * 按钮成员类
     * Created by Switch on 2017/3/30.
     */
    public class ColleagueButton extends Button implements Colleague {
        /**
         * 中介者
         */
        private Mediator mediator;
    
        /**
         * 构造方法,设置标题
         *
         * @param caption 标题
         */
        public ColleagueButton(String caption) {
            super(caption);
        }
    
        @Override
        public void setMediator(Mediator mediator) {
            this.mediator = mediator;
        }
    
        @Override
        public void setColleagueEnabled(boolean enabled) {
            setEnabled(enabled);
        }
    }

    ColleagueTextField类

    package com.pc.mediator.example;
    
    import java.awt.TextField;
    import java.awt.Color;
    import java.awt.event.TextEvent;
    import java.awt.event.TextListener;
    
    /**
     * 文本域成员类
     * Created by Switch on 2017/3/30.
     */
    public class ColleagueTextField extends TextField implements TextListener, Colleague {
        /**
         * 中介者
         */
        private Mediator mediator;
    
        /**
         * 构造方法,设置文本和字数
         *
         * @param text       文本
         * @param wordNumber 字数
         */
        public ColleagueTextField(String text, int wordNumber) {
            super(text, wordNumber);
        }
    
        @Override
        public void setMediator(Mediator mediator) {
            this.mediator = mediator;
        }
    
        @Override
        public void setColleagueEnabled(boolean enabled) {
            setEnabled(enabled);
            setBackground(enabled ? Color.white : Color.lightGray);
        }
    
        /**
         * 当文字发生变化时通知Mediator
         *
         * @param e 文本事件
         */
        @Override
        public void textValueChanged(TextEvent e) {
            mediator.colleagueChanged();
        }
    }

    ColleagueCheckbox类

    package com.pc.mediator.example;
    
    import java.awt.Checkbox;
    import java.awt.CheckboxGroup;
    import java.awt.event.ItemEvent;
    import java.awt.event.ItemListener;
    
    /**
     * 复选框成员类
     * Created by Switch on 2017/3/30.
     */
    public class ColleagueCheckbox extends Checkbox implements ItemListener, Colleague {
        /**
         * 中介者
         */
        private Mediator mediator;
    
        /**
         * 构造方法,设置复选框标题、组、初始状态
         *
         * @param caption 标题
         * @param group   组
         * @param state   初始状态
         */
        public ColleagueCheckbox(String caption, CheckboxGroup group, boolean state) {
            super(caption, group, state);
        }
    
        @Override
        public void setMediator(Mediator mediator) {
            this.mediator = mediator;
        }
    
        @Override
        public void setColleagueEnabled(boolean enabled) {
            setEnabled(enabled);
        }
    
        /**
         * 当状态发生变化时通知Mediator
         *
         * @param e 选项事件
         */
        @Override
        public void itemStateChanged(ItemEvent e) {
            mediator.colleagueChanged();
        }
    }

    LoginFrame类

    package com.pc.mediator.example;
    
    import java.awt.Frame;
    import java.awt.Label;
    import java.awt.GridLayout;
    import java.awt.Color;
    import java.awt.CheckboxGroup;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    /**
     * 登录界面类
     * Created by Switch on 2017/3/30.
     */
    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;
    
        /**
         * 构造方法,设置标题
         *
         * @param title 标题
         */
        public LoginFrame(String title) {
            super(title);
            setBackground(Color.lightGray);
            // 使用布局管理器生成4×2窗格
            setLayout(new GridLayout(4, 2));
            // 生成各个Colleague
            createColleagues();
            // 配置
            add(checkGuest);
            add(checkLogin);
            add(new Label("Username:"));
            add(textUser);
            add(new Label("Password:"));
            add(textPass);
            add(buttonOk);
            add(buttonCancel);
            // 设置初始的启用起用/禁用状态
            colleagueChanged();
            // 显示
            pack();
            show();
        }
    
        @Override
        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);
        }
    
        @Override
        public void colleagueChanged() {
            if (checkGuest.getState()) { // Guest mode
                textUser.setColleagueEnabled(false);
                textPass.setColleagueEnabled(false);
                buttonOk.setColleagueEnabled(true);
            } else { // Login mode
                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);
            }
        }
    
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println(e.toString());
            System.exit(0);
        }
    }

    测试类

    package com.pc.mediator.example.test;
    
    import com.pc.mediator.example.LoginFrame;
    import org.junit.Test;
    
    /**
     * LoginFrame Tester.
     *
     * @author Switch
     * @version 1.0
     */
    public class LoginFrameTest {
        /**
         * 测试中介者模式
         *
         * @throws InterruptedException 中断异常
         */
        @Test
        public void testLoginFrame() throws InterruptedException {
            new LoginFrame("Mediator Sample");
            Thread.sleep(100000);
        }
    
    }

    运行结果

    这里写图片描述

    中介者模式中的角色

    Mediator(仲裁者、中介者)

    Mediator角色负责定义与Colleague角色进行通信和做出决定的接口(API)。在案例中,由Mediator接口扮演此角色。

    ConcreteMediator(具体的仲裁者、中介者)

    ConcreteMediator角色负责实现Mediator角色的接口(API),负责实际做出决定。在案例中,由LoginFrame类扮演此角色。

    Colleague(同事)

    Colleague角色负责定义与Mediator角色进行通信的接口(API)。在案例中,由Colleague接口扮演此角色。

    ConcreteColleague (具体的同事)

    ConcreteColleague角色负责实现Colleague角色的接口(API)。在案例中,由ColleagueButton类、ColleagueTextField类和ColleagueCheckbox类扮演此角色。

    类图

    中介者模式类图

    GitHub:DesignPatternStudy

    ——————参考《图解设计模式》

    展开全文
  • 主要介绍了Java设计模式之中介模式(Mediator模式)介绍,本文讲解了为何使用Mediator模式、如何使用中介模式等内容,需要的朋友可以参考下
  • 23种设计模式(C++)之 中介者(Mediator)模式23种设计模式(C++)之 中介者(Mediator)模式意图适用性角色实例 23种设计模式(C++)之 中介者(Mediator)模式 意图 用一个中介对象来封装一系列的对象交互。中介...

    23种设计模式(C++)之 中介者(Mediator)模式

    23种设计模式(C++)之 中介者(Mediator)模式

    意图

    用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

    适用性

    • 一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
    • 一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。
    • 想定制一个分布在多个类中的行为,而又不想生成太多的子类。

    角色

    • Mediator
      • 中介者定义一个接口用于与各同事(Colleague)对象通信。
    • ConcreteMediator
      • 具体中介者通过协调各同事对象实现协作行为。
      • 了解并维护它的各个同事。
    • Colleague Class
      • 每个同事类都知道它的中介者对象
      • 每个同事对象在需与其他同事通信的时候,与它的中介者通信。

    实例

    1. 创建同事抽象接口
    class Mediator;
    
    class Colleague
    {
    protected:
    	Mediator* mediator;
    	string name;
    public:
    	virtual string getName() = 0;
    	virtual void sendMsg2SomeOne(string msg, string receiverName) = 0;
    	virtual void receiveMsg(string msg, string senderName) = 0;
    };
    
    1. 创建具体同事类
    class ColleagueA :public Colleague
    {
    private:
    	string name;
    public:
    	ColleagueA(string name, Mediator* mediator)
    	{
    		this->name = name;
    		this->mediator = mediator;
    	}
    	string getName()
    	{
    		return this->name;
    	}
    	void sendMsg2SomeOne(string msg, string receiverName);
    	void receiveMsg(string msg, string senderName)
    	{
    		cout << this->name + " received a msg from " + senderName << " and the msg is " << msg << endl;
    	}
    };
    
    class ColleagueB :public Colleague
    {
    private:
    	string name;
    public:
    	ColleagueB(string name, Mediator* mediator)
    	{
    		this->name = name;
    		this->mediator = mediator;
    	}
    	string getName()
    	{
    		return this->name;
    	}
    	void sendMsg2SomeOne(string msg, string receiverName);
    	void receiveMsg(string msg, string senderName)
    	{
    		cout << this->name+" received a msg from " + senderName << " and the msg is " << msg << endl;
    	}
    };
    
    1. 创建中介者抽象接口
    class Mediator 
    {
    public:
    	virtual void setColleagueA(Colleague* colleagueA) = 0;
    	virtual void setColleagueB(Colleague* colleagueB) = 0;
    	virtual void sendMessage(string msg, string receiverName, string senderName) = 0;
    };
    
    1. 创建具体中介者类
    class ConcreteMediator: public Mediator
    {
    private:
    	Colleague* colleagueA;
    	Colleague* colleagueB;
    public:
    	void setColleagueA(Colleague* colleagueA)
    	{
    		this->colleagueA = colleagueA;
    	}
    	void setColleagueB(Colleague* colleagueB)
    	{
    		this->colleagueB = colleagueB;
    	}
    	void sendMessage(string msg, string receiverName, string senderName)
    	{
    		if (receiverName == this->colleagueA->getName())
    		{
    			this->colleagueA->receiveMsg(msg, senderName);
    		}
    		else if (receiverName == this->colleagueB->getName())
    		{
    			this->colleagueB->receiveMsg(msg, senderName);
    		}
    	}
    };
    
    void ColleagueA::sendMsg2SomeOne(string msg, string receiverName)
    {
    	this->mediator->sendMessage(msg, receiverName, this->name);
    }
    
    void ColleagueB::sendMsg2SomeOne(string msg, string receiverName)
    {
    	this->mediator->sendMessage(msg, receiverName, this->name);
    }
    
    1. Client
    int main()
    {
    	//Create a mediator
    	Mediator* mediator = new ConcreteMediator();
    	//Instance each colleague with mediator
    	Colleague* colleagueA = new ColleagueA("colleagueA", mediator);
    	Colleague* colleagueB = new ColleagueB("colleagueB", mediator);
    	//Let mediator know each colleague
    	mediator->setColleagueA(colleagueA);
    	mediator->setColleagueB(colleagueB);
    	//Communicate between colleagues
    	colleagueA->sendMsg2SomeOne("'Hello, I'm colleagueA!'", colleagueB->getName());
    	colleagueB->sendMsg2SomeOne("'Hello, I'm colleagueB!'", colleagueA->getName());
    }
    
    1. 结果
    colleagueB received a msg from colleagueA and the msg is 'Hello, I'm colleagueA!'
    colleagueA received a msg from colleagueB and the msg is 'Hello, I'm colleagueB!'
    
    展开全文
  • 设计模式Mediator模式

    千次阅读 2018-06-09 11:18:33
    Mediator模式——只有一个仲裁者 想象一个乱糟糟的开发小组的工作状态,组员之间虽然在一起协同工作,但是意见难以统一,总是相互指挥,导致工作进度滞后。这时候,就需要一个仲裁者。所有的组员将自己的情况汇报给...
  • 设计模式java之Mediator模式,仲裁者模式,一个仲裁者
  • 设计模式:仲裁者(Mediator)模式 一、前言 Mediator模式又称为仲裁者模式或者中介者模式,所起的作用是仲裁和中介,帮助其它类之间进行交流。在仲裁者模式之中,我们要明确两个概念,那就是仲裁者(Mediator)...
  • 模式定义 用一个中介对象来封装(封装变化)一系列的对象交互,...将多个对象间复杂的关联关系解耦,Mediator模式将多个对象间的控制逻辑进行集中管理,变“多个对象互相关联”为“多个对象和一个中介者关联”,简化
  • 主要介绍了javascript设计模式之中介者模式Mediator,需要的朋友可以参考下
  • 设计模式mediator模式

    千次阅读 2011-11-02 10:38:45
    Mediator中介者模式定义:用一个中介对象来封装一系列关于对象交互行为. 为何使用Mediator? 各个对象之间的交互操作非常多;每个对象的行为操作都依赖彼此对方,修改一个对象的行为, 同时会涉及到修改很多其他对象的...
  • 读书笔记 仅供参考简述Mediator 就是 仲裁者(中介者)模式。如果将程序看作许多类作为一个团队进行工作,那么团队的交流过程就是组员向仲裁者报告,仲裁者向组员下达指标,组员之间不再相互询问。角色和 ...
  • 将导致关系极其复杂,这些对象称为“同事关系”,而我们可以 引进一个中介者对象,使各个同事对象只跟中介者对象打交道,将复杂的网络结构化解为如下星形结构: 四、模式结构 中介者模式结构图: 抽象中介者(Mediator)...
  • 目的:解决多组件之间的通信问题,使得组件之间的通信变得简单 核心:提供一个管理类,用来处理组件...class Mediator { public: virtual void Send(string &message, Person *person) = 0; virtual vo...
  • Mediator中介者模式,又称调停者模式,实现了多个类之间交互的解耦。
  • 主要介绍了C#设计模式Mediator中介者模式解决程序员的七夕缘分问题,简单说明了中介者模式的定义并结合七夕缘分问题实例分析了中介者模式的具体使用技巧,需要的朋友可以参考下
  • php /** * 中介者模式 * * 用一个中介对象来封装一系列的对象交互,使各对象不需要显式地相互引用从而使其耦合松散,而且可以独立地改变它们之间的交互 */ abstract class Mediator { abstract public function send($...
  • Mediator(仲裁者/中介者):Mediator角色负责定义与Colleague角色进行通信和做出决定的接口 ConcreteMediator(具体的仲裁者/中介者):负责实现Mediator角色的接口,负责实际做出决定 Colleague(同事):负责定义...
  • 等同于Facade模式,Facade模式针对是多个子系统,Mediator模式针对是对象。
  • Mediator模式也叫中介者模式,是由GoF提出的23种软件设计模式的一种。Mediator模式是行为模式之一,Mediator模式定义一个“中介”对象来封装对象的交互行为。 本文介绍设计模式中的(Mediator)模式的概念,用法,...
  • 本文已搬家至【HeadFirst 设计模式学习笔记】17 中介者(Mediator)模式拾零

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,218
精华内容 9,287
关键字:

mediator设计模式