《设计模式》学习笔记——中介者模式

        中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

意图：
    用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
主要解决：
    对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。
何时使用：
    多个类相互耦合，形成了网状结构。
如何解决：
    将上述网状结构分离为星型结构。
关键代码：
    对象 Colleague 之间的通信封装到一个类中单独处理。
应用实例： 
    1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。 
    2、机场调度系统。 
    3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。
优点： 
    1、降低了类的复杂度，将一对多转化成了一对一。
    2、各个类之间的解耦。 3、符合迪米特原则。
缺点：
    中介者会庞大，变得复杂难以维护。
使用场景： 
    1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。 
    2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。
注意事项：
    不应当在职责混乱的时候使用。

MediatorPattern.h

#pragma once
#include<iostream>
#include<string>

// 中介者抽象接口类的前向声明
class Mediator;

// 抽象的人类接口
class Person
{
public: 
	Person(std::string personName, int age, std::string personSex, int level, Mediator* mediator)
		:m_personName_string(personName), m_age_int(age), m_personSex_string(personSex), m_level_int(level), m_mediator(mediator)
	{
	}
	int getAge() { return m_age_int; }
	std::string getSex() { return m_personSex_string; }
	int getLevel() { return m_level_int; }
	virtual void getParter(Person* person) = 0;		// 找对象接口
	~Person() {}
private:

protected:
	std::string		m_personName_string;
	int				m_age_int;
	std::string		m_personSex_string;
	int				m_level_int;
	Mediator*		m_mediator;

};
class Mediator
{
public:
	void setMan(Person* person) { m_man =  person; }
	void setWoman(Person* person) { m_woman= person; }

	virtual void getParterFor() = 0;		// 给人找对象接口
private:
	
protected:
	Person * m_man;
	Person*	m_woman;
	//如果使用list容器，就可以实现批量操作
};

// 女人
class Woman:public Person
{
public:
	Woman(std::string personName, int age, std::string personSex, int level, Mediator* mediator)
		:Person(personName, age, personSex, level, mediator)
	{
	}
	~Woman() {}

	// 找对象
	virtual void getParter(Person* person)
	{
		m_mediator->setMan(person);
		m_mediator->setWoman(this);
		m_mediator->getParterFor();
	}
private:
protected:

};

// 男人
class Man :public Person
{
public:
	Man(std::string personName, int age, std::string personSex, int level, Mediator* mediator)
		:Person(personName, age, personSex, level, mediator)
	{
	}
	~Man() {}

	// 找对象
	virtual void getParter(Person* person)
	{ 
		m_mediator->setMan(this);
		m_mediator->setWoman(person);
		m_mediator->getParterFor();
	}
private:
protected:
};



// 具体实现的中介者类
class MediatorPattern :public Mediator
{
public:
	MediatorPattern() {};
	~MediatorPattern() {};

	virtual void getParterFor()// 给人找对象接口的具体实现
	{
		if (m_man->getSex() != m_woman->getSex())	// 性别
		{
			if (m_man->getAge() == m_woman->getAge())		// 年龄
			{
				if (m_man->getLevel() == m_woman->getLevel())
				{
					std::cout << "绝配" << std::endl;
					return;
				}
				std::cout << "合适" << std::endl;
				return;
			}
			std::cout << "可以考虑" << std::endl;
			return;
		}
		std::cout << "莫非是真爱？" << std::endl;
		return;
	}
private:
	

};

 

MediatorPattern.cpp

#include "MediatorPattern.h"

 

mainTest.cpp

#include<iostream>
#include<string>
#include "MediatorPattern.h"

int main(void)
{
	// 创建一个中介
	Mediator* mediator = new MediatorPattern;
	// 创建一些男女,男女比例失调
	Person* p_man1 = dynamic_cast<Person*> (new Man("张三", 49, "男", 0, mediator));
	Person* p_man2 = dynamic_cast<Person*> (new Man("李四", 31, "男", 5, mediator));
	Person* p_man3 = dynamic_cast<Person*> (new Man("王五", 23, "男", 9, mediator));
	Person* p_woman = dynamic_cast<Person*> (new Woman("小燕子", 23, "女", 9, mediator));

	p_woman->getParter(p_man1);
	p_woman->getParter(p_man2);
	p_woman->getParter(p_man3);


	system("pause");
	return 0;
}