中介者模式

中介者模式

概念

　　Mediator（中介者）模式是行为模式之一，在Mediator模式中，类之间的交互行为被统一放在Mediator的对象中，对象通过Mediator对象同其他对象交互，Mediator对象起着控制器的作用。
　　用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示的相互引用，从而降低耦合；而且可以独立地改变它们之间的交互。

角色和职责

• Mediator抽象中介者
  中介者类的抽象父类。–定义了同事到中介的接口,包含了至少两个抽象同事/关联类相关的实例做成员变量，否则不能做中介！她得知道两个（或以上）关联类对象的信息，才能做媒介！–抽象的婚介机构.
• concreteMediator
  具体的中介者类。–包含了具体的同事对象（成员变量）–好比世纪佳缘
• Colleague
  关联类/同事类的抽象父类。–包含了中介者（成员变量、函数参数）–所有的人类。
• concreteColleague
  具体的关联类/同事类。–只知道自己的属性和行为，对其他对象不关心，都认识中介。–男人和女人/中国人和老外

适用于：
用一个中介对象，封装多个对象（同事）的交换，中介者使得各个对象不需要显示的相互作用，从而实现了解耦合，而且可以独立的改变他们之间的交换。

模式优点

1，将系统按功能分割成更小的对象，符合类的最小设计原则
2，对关联对象的集中控制
3，减小类的耦合程度，明确类之间的相互关系：当类之间的关系过于复杂时，其中任何一个类的修改都会影响到其他类，不符合类的设计的开闭原则 ，而Mediator模式将原来相互依存的多对多的类之间的关系简化为Mediator控制类与其他关联类的一对多的关系，当其中一个类修改时，可以对其他关联类不产生影响（即使有修改，也集中在Mediator控制类）。
4，有利于提高类的重用性

案例

/*******************************
 * 对要进行处理的关联类进行抽象--抽象关联类
 * --共同属性和公共接口（纯虚函数）
 * --包含了中介者做成员变量和函数参数
 * --公共接口里面含有自身类型的指针或引用做函数参数
 *
 * 具体关联类实现公共接口和构造函数
 *
 * 抽象中介者--包含多个关联类的实例（获取信息）
 * --封装多个关联类的交互行为
 *
 * 案例中只使用了一个具体中介者，没有进行派生
 *
*******************************/


#include <iostream>
#include <string>
using namespace std;


/*中介者的前置声明--抽象关联类要用到中介者实例进行类的声明--所以前置声明*/
class Mediator;


/*抽象关联类*/
class Person
{
public:
    Person(string name,int condi,int sex,Mediator * mediator)//公共属性的初始化--构造函数--
                                                            //里面含有中介者做参数--将自己的信息提供给中介者
    {
        m_name = name;
        m_condi = condi;
        m_sex = sex;
        m_mediator = mediator;
    }

    virtual void getParter(Person * p) = 0;//公共接口--实现交互--在这里指匹配两个关联对象

    /*返回关联对象的相关属性*/
    string getName()
    {
        return m_name;
    }

    int getSex()
    {
        return m_sex;
    }

    int getCondi()
    {
        return m_condi;
    }


protected:
    string m_name;
    int m_condi;
    int m_sex;
    Mediator * m_mediator;//中介者实例做成员变量
};


/*中介者--会在关联类对象中被调用*/
class Mediator
{
public:
    void setWoman(Person *woman)//设置一个关联类信息
    {
        m_pWoman = woman;
    }

    void setMan(Person *man)//设置另一个关联类信息
    {
        m_pMan = man;
    }

    void getParter()//对多个关联类进行交互
    {
        if(m_pMan->getSex() == m_pWoman->getSex())
        {
            cout <<"i am not gay"<<endl;
            return ;
        }
        if(m_pMan->getCondi() == m_pWoman->getCondi())
        {
            cout<<m_pMan->getName()<<" and "<<m_pWoman->getName()<<" are OK "<<endl;
        }else{
            cout<<m_pMan->getName()<<" and "<<m_pWoman->getName()<<" not OK!FUCK! "<<endl;
        }
    }

private:
    /*将关联类实例做成员变量--毕竟中介需要知道双方信息*/
    Person *m_pMan;
    Person *m_pWoman;
};


/*具体关联类*/
class Man:public Person
{
public:
    /*调用父类构造函数--实例化子类对象*/
    Man(string name,int condi,int sex,Mediator * mediator):Person(name,condi,sex,mediator)
    {

    }

    /*抽象关联类的纯虚函数的实现--关联类的交互--最终调用中介者里面的交互函数完成和另一个关联对象的交互*/
    virtual void getParter(Person * p)
    {
        m_mediator->setMan(this);
        m_mediator->setWoman(p);
        m_mediator->getParter();
    }
};


/*具体关联类*/
class Woman:public Person
{
public:
    Woman(string name,int condi,int sex,Mediator * mediator):Person(name,condi,sex,mediator)
    {

    }

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


int main()
{
    Mediator *mediator = new Mediator;//中介者实例化

    Person * lzj = new Man("lzj",3,1,mediator);//男人实例化

    Person * sqn = new Man("sqn",2,2,mediator);//女人实例化
    Person * yrm = new Man("yrm",3,2,mediator);

    /*男人通过调用自己和其他对象的交互函数完成交互
    *自己的交互函数会调用中介者的交互函数实现交互行为的打包封装
    * 实现关联类之间的交互行为且解耦合
    */
    lzj->getParter(sqn);
    lzj->getParter(yrm);

    return 0;
}