中介者模式
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;
}
观察者模式
Observer模式是行为模式之一,它的作用是当一个对象的状态发生变化时,能够自动通知其他关联对象,自动刷新对象状态。
Observer模式提供给关联对象一种同步通信的手段,使某个对象与依赖它的其他对象之间保持状态同步。
角色及职责
Subject(被观察者)
被观察的对象。当需要被观察的状态发生变化时,需要通知队列中所有观察者对象。Subject需要维持(添加,删除,通知)一个观察者对象的队列列表。
ConcreteSubject
被观察者的具体实现。包含一些基本的属性状态及其他操作。
Observer(观察者)
接口或抽象类。当Subject的状态发生变化时,Observer对象将通过一个callback函数得到通知。
ConcreteObserver
观察者的具体实现。得到通知后将完成一些具体的业务逻辑处理。
适用于:
定义对象间一种一对多的依赖关系,使得每一个对象改变状态,则所有依赖于他们的对象都会得到通知。
案例
侦听事件驱动程序设计中的外部事件
侦听/监视某个对象的状态变化
发布者/订阅者(publisher/subscriber)模型中,当一个外部事件(新的产品,消息的出现等等)被触发时,通知邮件列表中的订阅者
使用场景:定义了一种一对多的关系,让多个观察对象(公司员工)同时监听一个主题对象(秘书),主题对象状态发生变化时,会通知所有的观察者,使它们能够更新自己。
#include <iostream>
#include <string>
#include <list>
using namespace std;
/*前置声明--以便各个类声明的时候使用对方*/
class PlayObserver;
class Secretary;
/*观察者(本案例中没有用抽象观察者)
*--包含被观察对象/主题对象做成员变量
*--如果使用抽象观察者--具体观察者会对主题对象的消息产生不同动作的响应
*/
class PlayObserver
{
public:
PlayObserver(Secretary *sec)//构造函数里有主题对象做参数
{
m_sec = sec;
}
void Update(string action)//观察者接收到被观察者的状态变化消息以后的响应函数
{
cout<<action<<endl;
}
private:
Secretary *m_sec;//主题对象做成员变量
};
/*被观察者--需要维持(添加,删除,通知)一个观察者对象的队列列表。*/
class Secretary
{
public:
Secretary()//构造函数
{
m_list.clear();
}
/*状态发生变化的时候--会调用这个函数通知所有的观察者*/
void Notify(string info)
{
for(list<PlayObserver*>::iterator it = m_list.begin();it != m_list.end();it++)
{
(*it)->Update(info);
}
}
/*设置观察者--添加到观察者队列*/
void setPlayObserver(PlayObserver* o)
{
m_list.push_back(o);
}
private:
list<PlayObserver*> m_list;//观察者队列
};
int main()
{
Secretary * tmp_sec = NULL;//被观察者
/*定义两个观察者对象*/
PlayObserver * po1 = NULL;
PlayObserver * po2 = NULL;
/*实例化被观察者*/
tmp_sec = new Secretary;
/*实例化观察者*/
po1 = new PlayObserver(tmp_sec);
po2 = new PlayObserver(tmp_sec);
/*被观察者设置观察者对象*/
tmp_sec->setPlayObserver(po1);
tmp_sec->setPlayObserver(po2);
/*被观察者状态改变--通知所有观察者*/
tmp_sec->Notify("boss coming");
/*内存回收*/
delete tmp_sec;
delete po1;
delete po2;
return 0;
}