设计模式之桥接模式(Bridge)摘录

最新推荐文章于 2021-12-13 11:41:47 发布

iteye_13202

最新推荐文章于 2021-12-13 11:41:47 发布

阅读量260

点赞数

文章标签：设计模式 c/c++ 数据结构与算法

23种GOF设计模式一般分为三大类：创建型模式、结构型模式、行为模式。

创建型模式包括：1、FactoryMethod(工厂方法模式)；2、Abstract Factory(抽象工厂模式)；3、Singleton(单例模式)；4、Builder(建造者模式、生成器模式)；5、Prototype(原型模式).

结构型模式包括：6、Bridge(桥接模式)；7、Adapter(适配器模式)；8、Decorator(装饰模式)；9、Composite(组合模式)；10、Flyweight(享元模式)；11、Facade(外观模式)；12、Proxy(代理模式).

行为模式包括：13、TemplateMethod(模板方法模式)；14、Strategy(策略模式)；15、State(状态模式)；16、Observer(观察者模式)；17、Memento(备忘录模式)；18、Mediator(中介者模式)；19、Command(命令模式)；20、Visitor(访问者模式)；21、Chain of Responsibility(责任链模式)；22、Iterator(迭代器模式)；23、Interpreter(解释器模式).

Factory Method：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。Factory Method使一个类的实例化延迟到其子类。

Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

Singleton：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

Builder：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

Prototype：用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。

Bridge：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

Adapter：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

Decorator：动态地给一个对象添加一些额外的职责。就扩展功能而言， Decorator模式比生成子类方式更为灵活。

Composite：将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得客户对单个对象和复合对象的使用具有一致性。

Flyweight：运用共享技术有效地支持大量细粒度的对象。

Facade：为子系统中的一组接口提供一个一致的界面， Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

Proxy：为其他对象提供一个代理以控制对这个对象的访问。

Template Method：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

Strategy：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。

State：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它所属的类。

Observer：定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。

Memento：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。

Mediator：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

Command：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作。

Visitor：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

Chain of Responsibility：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。

Iterator：提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。

Interpreter：给定一个语言, 定义它的文法的一种表示，并定义一个解释器, 该解释器使用该表示来解释语言中的句子。

Bridge：(1)、意图：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

(2)、适用性：A、你不希望在抽象和它的实现部分之间有一个固定的绑定关系。例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换；B、类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充；C、对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译；D、(C++)你想对客户完全隐藏抽象的实现部分。在C++中，类的表示在类接口中是可见的；E、你想在多个对象间共享实现(可能使用引用计数)，但同时要求客户并不知道这一点。

(3)、优点：A、分离接口及其实现部分：一个实现未必不变地绑定在一个接口上。抽象类的实现可以在运行时刻进行配置，一个对象甚至可以在运行时刻改变它的实现。将Abstraction与 Implementor分离有助于降低对实现部分编译时刻的依赖性，当改变一个实现类时，并不需要重新编译Abstraction类和它的客户程序。为了保证一个类库的不同版本之间的二进制兼容性，一定要有这个性质。另外，接口与实现分离有助于分层，从而产生更好的结构化系统，系统的高层部分仅需知道Abstraction和Implementor即可。B、提高可扩充性：你可以独立地对Abstraction和Implementor层次结构进行扩充。C、实现细节对客户透明：你可以对客户隐藏实现细节，例如共享Implementor对象以及相应的引用计数机制(如果有的话)。

(4)、注意事项：A、仅有一个Implementor：在仅有一个实现的时候，没有必要创建一个抽象的Implementor类。这是Bridge模式的退化情况，在Abstraction和Implementor之间有一种一对一的关系。尽管如此，当你希望改变一个类的实现不会影响已有的客户程序时，模式的分离机制还是非常有用的----也就是说，不必重新编译它们，仅需重新连接即可。B、创建正确的Implementor对象：当存在多个Implementor类的时候，你应该用何种方法，在何时何处确定创建哪一个Implementor类呢？如果Abstraction知道所有的ConcreteImplementor类，它就可以在它的构造器中对其中的一个类进行实例化，它可以通过传递给构造器的参数确定实例化哪一个类。例如，如果一个collection类支持多重实现，就可以根据collection的大小决定实例化哪一个类。链表的实现可以用于较小的collection类，而hash表则可用于较大的collection类。另外一种方法是首先选择一个缺省的实现，然后根据需要改变这个实现。例如，如果一个collection的大小超出了一定的阈值时，它将会切换它的实现，使之更适合用于表目较多的collection.也可以代理给另一个对象，由它一次决定。C、共享Implementor对象。D、采用多重继承机制：在C++中可以使用多重继承机制将抽象接口和它的实现部分结合起来。例如，一个类可以用public方式继承Abstraction而以private方式继承ConcreteImplementor。但是由于这种方式依赖于静态继承，它将实现部分与接口固定不变的绑定在一起。因此不可能使用多重继承的方法实现真正的Bridge模式----至少用C++不行。

(5)、Abstract Factory模式可以用来创建和配置一个特定的Bridge模式。Adapter模式用来帮助无关的类协同工作，它通常在系统设计完成后才会被使用。然而，Bridge模式则是在系统开始时就被使用，它使得抽象接口和实现部分可以独立进行改变。

Bridge将抽象部分与实现部分分离，使它们可以独立变化。这里说的意思不是让抽象基类与具体类分离，而是现实系统可能有多角度分类，每一种分类都有可能变化，那么把这种多角度分离出来让它们独立变化，减少它们之间的耦合性，即如果继承不能实现”开放----封闭原则”的话，就应该考虑用桥接模式。

GoF在说明Bridge模式时，在意图中指出Bridge模式“将抽象部分与它的实现部分分离，使得它们可以独立地变化”。这句话很简单，但是也很复杂。原因就在于GoF的那句话中的“实现”该怎么去理解：“实现”特别是和“抽象”放在一起的时候我们“默认”的理解是“实现”就是“抽象”的具体子类的实现，但是这里GoF所谓的“实现”的含义不是指抽象基类的具体子类对抽象基类中虚函数(接口)的实现，是和继承结合在一起的。而这里的“实现”的含义指的是怎么去实现用户的需求，并且指的是通过组合(委托)的方式实现的，因此这里的实现不是指的继承基类、实现基类接口，而是指的是通过对象组合实现用户的需求。

示例代码1：

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

//手机软件
class HandsetSoft
{
public:
	virtual void Run() = 0;
};

//游戏软件
class HandsetGame : public HandsetSoft
{
public:
	virtual void Run()
	{
		cout<<"运行手机游戏"<<endl;
	}
};

//通讯录软件
class HandSetAddressList : public HandsetSoft
{
public:
	virtual void Run()
	{
		cout<<"手机通讯录"<<endl;
	}
};

//手机品牌
class HandsetBrand
{
protected:
	HandsetSoft* m_soft;
public:
	void SetHandsetSoft(HandsetSoft* temp)
	{
		m_soft = temp;
	}
	virtual void Run() = 0;
};

//M品牌
class HandsetBrandM : public HandsetBrand
{
public:
	virtual void Run()
	{
		m_soft->Run();
	}
};

//N品牌
class HandsetBrandN : public HandsetBrand
{
public:
	virtual void Run()
	{
		m_soft->Run();
	}
};

//客户端
int main()
{
	HandsetBrand* brand;
	brand = new HandsetBrandM();
	brand->SetHandsetSoft(new HandsetGame());
	brand->Run();
	brand->SetHandsetSoft(new HandSetAddressList());
	brand->Run();
	/* result:
		运行手机游戏
		手机通讯录
	*/

	return 0;
}

示例代码2：

abstraction.h:

#ifndef _ABSTRACTION_H_
#define _ABSTRACTION_H_

class AbstractionImp;

class Abstraction
{
public:
	virtual ~Abstraction();
	virtual void Operation() = 0;
protected:
	Abstraction();
private:
};

class RefinedAbstraction : public Abstraction
{
public:
	RefinedAbstraction(AbstractionImp* imp);
	~RefinedAbstraction();
	void Operation();
protected:
private:
	AbstractionImp* _imp;
};

#endif//_ABSTRACTION_H_

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();
}

abstractionImp.h:

#ifndef _ABSTRACTIONIMP_H_
#define _ABSTRACTIONIMP_H_

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

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

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

#endif //_ABSTRACTIONIMP_H_

abstractionImp.cpp:

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

AbstractionImp::AbstractionImp()
{

}

AbstractionImp::~AbstractionImp()
{

}

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

ConcreteAbstractionImpA::ConcreteAbstractionImpA()
{

}

ConcreteAbstractionImpA::~ConcreteAbstractionImpA()
{

}

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

ConcreteAbstractionImpB::ConcreteAbstractionImpB()
{

}

ConcreteAbstractionImpB::~ConcreteAbstractionImpB()
{

}

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

main.cpp:

#include "abstraction.h"
#include "abstractionImp.h"

#include <iostream>
using namespace std;

int main()
{
	AbstractionImp* imp = new ConcreteAbstractionImpA();
	Abstraction* abs = new RefinedAbstraction(imp);
	abs->Operation();
	/* result:
		ConcreteAbstractionImpA ....
	*/

	return 0;
}

桥接模式结构图：