行为型模型 中介者模式

行为型模型 中介者模式

Mediator抽象中介者
        中介者类的抽象父类。
concreteMediator
        具体的中介者类。
Colleague
        关联类的抽象父类。
concreteColleague
        具体的关联类。

适用于:
        用一个中介对象,封装一些列对象(同事)的交换,中介者是各个对象不需要显示的相互作用,从而实现了耦合松散,而且可以独立的改变他们之间的交换。

/**
 * 行为型模型 中介者模式
 * Mediator模式也叫中介者模式,是由GoF提出的23种软件设计模式的一种。
 * Mediator模式是行为模式之一,在Mediator模式中,类之间的交互行为被统一放在Mediator的对象中,对象通过Mediator对象同其他对象交互,Mediator对象起着控制器的作用。
 *
 */

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
#include <list>

// 前置声明
class Mediator;

class Person
{
public:
    Person(std::string name, int sex, int condit, Mediator * mediator)
    {
        m_name = name;
        m_sex = sex;
        m_condit = condit;
        m_mediator = mediator;
    }
    std::string getName()
    {
        return m_name;
    }
    int getSex()
    {
        return m_sex;
    }
    int getCondit()
    {
        return m_condit;
    }
    Mediator * getMediator()
    {
        return m_mediator;
    }
    virtual void getParter(Person *p) = 0;
    virtual ~Person() {};

private:
    std::string m_name;
    int m_sex;
    int m_condit;
    Mediator * m_mediator;
};

class Mediator
{
public:
    Mediator()
    {
        pMan = nullptr;
        pWoman = nullptr;
    }
    void setWoman(Person *p)
    {
        pWoman = p;
    }
    void setMan(Person *p)
    {
        pMan = p;
    }
    void getParter()
    {
        if (pMan->getSex() == pWoman->getSex() )
        {
            std::cout << "No No No 我不是同性恋" << std::endl;
        }
        if (pMan->getCondit() == pWoman->getCondit())
        {
            std::cout << pMan->getName() << " 和 " << pWoman->getName() << " 绝配" << std::endl;
        }
        else
        {
            std::cout << pMan->getName() << " 和 " << pWoman->getName() << " 不配" << std::endl;
        }
    }

private:
    Person * pMan;
    Person * pWoman;
};

class Man: public Person
{
public:
    Man(std::string name, int sex, int contid, Mediator * mediator): Person(name, sex, contid, mediator)
    {

    }
    virtual void getParter(Person *p)
    {
        this->getMediator()->setMan(this);
        this->getMediator()->setWoman(p);
        this->getMediator()->getParter();
    }
};

class Woman: public Person
{
public:
    Woman(std::string name, int sex, int contid, Mediator * mediator): Person(name, sex, contid, mediator)
    {

    }
    virtual void getParter(Person *p)
    {
        this->getMediator()->setMan(p);
        this->getMediator()->setWoman(this);
        this->getMediator()->getParter();
    }
};

void mytest()
{
    Mediator * mediator = new Mediator();
    Woman * w1 = new Woman("小芳", 2, 4, mediator);
    Man * m1 = new Man("张三", 1, 3, mediator);
    Man * m2 = new Man("李四", 1, 4, mediator);

    w1->getParter(m1);
    w1->getParter(m2);

    delete m1;
    m1 = nullptr;
    delete m2;
    m2 = nullptr;
    delete w1;
    w1 = nullptr;
    delete mediator;
    mediator = nullptr;

    return;
}

int main()
{
    mytest();

    system("pause");
    return 0;
}
时间: 2024-11-06 09:58:00

行为型模型 中介者模式的相关文章

行为型模型 空对象模式

行为型模型 空对象模式 /** * 行为型模型 空对象模式 * 创建一个未对该类做任何实现的空对象类,该空对象类将无缝地使用在需要检查空值的地方. * 不要为了屏蔽null而使用空对象,应保持用null,远比用非null的值来替代"无值"要好.(慎用) * */ #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <string> void mytest() { return; } int m

行为型模型 责任链模式

行为型模型 责任链模式 Handler         处理类的抽象父类. concreteHandler         具体的处理类. 责任链优缺点 优点:         1.责任的分担.每个类只需要处理自己该处理的工作(不该处理的传递给下一个对象完成),明确各类的责任范围,符合类的最小封装原则.         2.可以根据需要自由组合工作流程.如工作流程发生变化,可以通过重新分配对象链便可适应新的工作流程.         3.类与类之间可以以松耦合的形式加以组织.缺点:      

设计模式(行为型)之中介者模式(Mediator Pattern)

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 阅读前一篇<设计模式(行为型)之职责链模式(Chain of Responsibility Pattern)>http://blog.csdn.net/yanbober/article/details/45531395 概述 如果对象之间的联系呈现为网状结构,存在大量的多对多联系,在网状结

&quot;围观&quot;设计模式(25)--行为型之中介者模式(Mediator Pattern)

用一个对象封装一系列的对象交互,中介者使对象不需要显示的相互作用,从而使其耦合松散,而且可以独立的改变他们之间的独立. 个人理解 当多个对象之间存在着过多的耦合时,可以通过中介者模式进行解耦,将具体的对象之间的耦合转为中介者与具体对象的耦合,假如说之前是三个对象的相互之间的耦合,转为中介者与具体类的耦合之后,从耦合性上大大的降低了,这样如果再来对其进行修改的话,那么变更部分主要在中介者部分,从而使得该结构更加稳定. 角色分析 中介者角色分以下几个部分: 1. Mediator抽象中介者角色:抽象

行为型模型 观察者模式

行为型模型 观察者模式 Subject(被观察者)         被观察的对象.当需要被观察的状态发生变化时,需要通知队列中所有观察者对象.Subject需要维持(添加,删除,通知)一个观察者对象的队列列表. ConcreteSubject         被观察者的具体实现.包含一些基本的属性状态及其他操作. Observer(观察者)         接口或抽象类.当Subject的状态发生变化时,Observer对象将通过一个callback函数得到通知. ConcreteObserve

设计模式——行为型模式之中介者模式(七)

中介者模式 中介者模式(Mediator Pattern)是用来降低多个对象和类之间的通信复杂性.这种模式提供了一个中介类,该类通常处理不同类之间的通信,并支持松耦合,使代码易于维护.中介者模式属于行为型模式. 介绍 意图:用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互. 主要解决:对象与对象之间存在大量的关联关系,这样势必会导致系统的结构变得很复杂,同时若一个对象发生改变,我们也需要跟踪与之相关联的对象,同时做出相应

行为型模式之中介者模式

概述 如果在一个系统中对象之间存在多对多的相互关系,可以将对象之间的一些交互行为从各个对象中分离出来,并集中封装在一个中介者对象中,并由该中介者进行统一协调,这样对象之间多对多的复杂关系就转化为相对简单的一对多关系.通过引入中介者来简化对象之间的复杂交互,中介者模式是“迪米特法则”的一个典型应用. 定义 中介者模式(Mediator Pattern):用一个中介对象(中介者)来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互.中介者模式

(17):(行为型模式) Mediator 中介者模式

(17):(行为型模式) Mediator 中介者模式,布布扣,bubuko.com

设计模式-行为型模式-中介者模式

中介者要解决的问题 中介者模式(Mediator Pattern)是用来降低多个对象和类之间通信的复杂度.这种模式提供了一个中介类,该类通常用来处理不同类之间的通信.中介者模式符合迪米特原则,即一个类应当尽量减少与其他类的联系. 实例描述 在我们现实生活中就有这样的例子,你如果去租房,你可能会在网站上找一些发布租房的信息,找到对应的房东.为了能够找到性价比高的房子,你可能找好多家,那么你都要和这些房东打交道,留下电话啥的.有时候房子不好出租的情况下,房东还会主动联系你,就有了下面这幅图: 我们可