设计模式学习笔记-结构型模式-Bridge模式

桥模式解决的问题举例

需求1：男人吃
解决：男人吃（算法类）

需求2：男人吃 喝
解决：动作（算法基类） - 男人吃（算法类）
						- 男人喝（算法类）

需求3：男人 女人 会 吃 喝
解决：动作（算法基类）- 男人吃（算法类）
						- 男人喝（算法类）
						- 女人吃（算法类）
						- 女人喝（算法类）

需求4：男人 女人 外星人 会 吃 喝 拉 撒
解决：。。。。。类的迅速膨胀。

Bridge模式解决：

抽象部分：人（基类）- 男人（子类）
实现部分：动作（基类）- 吃 喝（子类）

需求3：增加一个 女人 同样会吃 喝
解决：人（基类）- 男人 女人（子类）

需求4：
解决：
人（基类）- 男人 女人 外星人（子类）
动作（基类）- 吃 喝 拉 撒（子类）

AbstractionImp.h

#pragma once
class AbstractionImp//实现
{
public:
	virtual void Operation() = 0;
	~AbstractionImp();

protected:
	AbstractionImp();
};

class ConcreteAbstractionImpA :public AbstractionImp
{
public:
	ConcreteAbstractionImpA();
	~ConcreteAbstractionImpA();
	virtual void Operation();
protected:
private:
};

class ConcreteAbstractionImpB :public AbstractionImp
{
public:
	ConcreteAbstractionImpB();
	~ConcreteAbstractionImpB();
	virtual void Operation();
protected:
private:
};

AbstractionImp.cpp

#include "AbstractionImp.h"

#include <iostream> 
using namespace std;

AbstractionImp::AbstractionImp()
{
}


AbstractionImp::~AbstractionImp()
{
}

ConcreteAbstractionImpA::ConcreteAbstractionImpA()
{
}

ConcreteAbstractionImpA::~ConcreteAbstractionImpA()
{
}

void ConcreteAbstractionImpA::Operation()
{
	cout << "ConcreteAbstractionImpA...." << endl;
}

ConcreteAbstractionImpB::ConcreteAbstractionImpB()
{
}

ConcreteAbstractionImpB::~ConcreteAbstractionImpB()
{
}

void ConcreteAbstractionImpB::Operation()
{
	cout << "ConcreteAbstractionImpB...." << endl;
}

Abstraction.h

#pragma once

class AbstractionImp;
class Abstraction//抽象
{
public:
	virtual void Operation() = 0;
	~Abstraction();

protected:
	Abstraction();
};

class RefinedAbstraction :public Abstraction//扩充抽象类
{
public:
	RefinedAbstraction(AbstractionImp* imp);
	~RefinedAbstraction();
	void Operation();
protected:
private:
	AbstractionImp* _imp;
};

Abstraction.cpp

#include "Abstraction.h"

#include "AbstractionImp.h"
#include <iostream> 
using namespace std;

Abstraction::Abstraction()
{
}


Abstraction::~Abstraction()
{
}

RefinedAbstraction::RefinedAbstraction(AbstractionImp * imp)
{
	_imp = imp;
}

RefinedAbstraction::~RefinedAbstraction()
{
}

void RefinedAbstraction::Operation()
{
	_imp->Operation();
}

main.cpp

#include <iostream>
using namespace std;

#include "Abstraction.h" 
#include "AbstractionImp.h"

int main(int argc, char* argv[])
{
	/*将抽象部分Abstraction与它的实现部分AbstractionImp分离，
	使他们都可以独立地变化。*/

	AbstractionImp* imp = new ConcreteAbstractionImpA();
	Abstraction* abs = new RefinedAbstraction(imp);
	abs->Operation();

	system("pause");
	return 0;
}

ConcreteAbstractionImpA....
请按任意键继续. . .

在以上代码中，对应到一开始提出的问题，这里的
AbstractionImp类相当于动作基类，
ConcreteAbstractionImpA类相当于吃，
ConcreteAbstractionImpB类相当于喝，
Abstraction类相当于人基类，
RefinedAbstraction类相当于外星人，
此时实现了外星人吃，
如果需要加一个男人也会吃，就需要增加一个子类ManAbstraction继承Abstraction类，如下

AbstractionImp* imp = new ConcreteAbstractionImpA();//吃
Abstraction* abs = new ManAbstraction(imp);//男人
abs->Operation();//男人吃

如果增加一个动作喝，就需要增加一个子类ConcreteAbstractionImpHe继承AbstractionImp类，如下调用

AbstractionImp* imp = new ConcreteAbstractionImpHe();//喝
Abstraction* ab1 = new RefinedAbstraction(imp);//外星人
ab1->Operation();//外星人喝
Abstraction* ab2 = new ManAbstraction(imp);//男人
ab2->Operation();//男人喝

通过桥模式，把人和动作区分开来，避免了类的迅速膨胀。

怎么去区分一个需求的抽象和实现？
这里的实现 不是指抽象基类的具体子类对抽象基类中虚函数（接口）的实现，而是指通过对象组合实现用户的需求
这里的抽象 就是（通过这里的实现）解决具体需求的类

使用组合（委托）的方式将抽象和实现彻底地解耦，这样的好处是抽象和实现可以分别独立地变化，系统的耦合性也得到了很好的降低。