设计模式之桥接模式(Bridge)之三（典型结构图） 结构型模式

Bridge是设计模式中比较复杂和难理解的模式之一,也是OO开发和设计中经常会用到的模式之一。使用组合的方式将抽象和实现彻底的解耦，这样的好处是抽象和实现可以独立地变化，系统的耦合性也得到了很好的降低。

GOF在说明Bridge模式时，指出"将抽象部分与它的实现部分分离，使得他们可以独立变化"，这句话很简单，但是也很复杂。原因就在于GOF的那句话中"实现"该怎么去理解:"实现"特别是和"抽象"放在一起的时候我们默认的理解是"实现"就是"抽象"的具体子类的实现,但是这里GOF所谓的"实现"的含义不是指抽象基类的具体子类对抽象基类中虚函数（接口）的实现，是和继承结合在一起的。

而这里的"实现"的含义指的是怎么去实现用户的需求，并且指的是通过组合的方式实现的，因此这里的实现不是指的继承基类，实现基类接口，而是指通过对象组合实现用户的需求,理解了这一点，也就理解了Bridge模式。

实际上使用Brigde模式和使用带来的问题方式的解决方案的根本区别在于通过继承还是通过组合的方式去实现一个功能需求,因此面向对象分析和设计中有一个原则就是 Favor Comosition Over Inheritance.

 

Brideg模式典型结构图

 --------------------------------------Abstraction.h----------------------------------------------------

#ifndef _ABSTRACTION_H_

#define _ABSTRACTION_H_

 

class AbstractionImp;

 

class Abstraction

{

public:

        virtual ~Abstraction();

        virtual void Operation() = 0;

protected:

         Abstraction();

};

 

class RefinedAbstraction:public:Abstraction

{

public:

        RefinedAbstraction(AbstractionImp *imp);

        ~RefinedAbstraction();

        void Operation();

private:

         AbstractionImp *m_imp;

};

 

#endif

 

 

-------------------------------------Abstraction.cpp--------------------------------

#include "Abstraction.h"

#include "AbstractionImp.h"

#include<iostream>

 

using namespace std;

 

Abstraction::Abstraction()

{}

 

Abstraction::~Abstraction()

{}

 

RefinedAbstraction::RefinedAbstraction(AbstractionImp *imp)

{

        m_imp = imp;

}

 

RefinedAbstraction::~RefinedAbstraction()

{}

 

void RefinedAbstraction::Operation()

{

       imp->Operation();

}

 

--------------------------------------AbstractionIMp.h-----------------------------------

#ifndef _ABSTRACTIONIMP_H_

#define _ABSTRACTION_H_

 

class AbstractionImp

{

public:

         virtual ~AbstractionImp();

         virtual void Operaction() = 0;

protected:

          AbstractionImp();

};

 

 

class ConcreateAbstractionImpA:public AbstractionImp

{

 public:

          ConcreateAbstractionImpA();

         ~ConcreateAbstractionImpA();

          virtual void Operation();

};

 

 

class ConcreateAbstractionImpB:public AbstractionImp

{

public:

          ConcreateAbstractionImpB();

         ~ ConcreateAbstractionImpB();

          virtual void Operation();

};

 

 

----------------------------------------------AbstractionImp.cpp-------------------------------

#include "AbstractionImp.h"

#include <iostream>

using namespact std;

 

AbstractionImp::AbstractionImp()

{}

 

AbstractionImp::~AbstractionImp()

{}

 

void AbstractionImp::Operation()

{

         cout <<"AbstractionImp....imp..."<<endl;

 }

 

ConcreateAbstractionImpA::ConcreateAbstractionImpA()

{}

 

ConcreateAbstractionImpB::~ConcreateAbstractionImpA()

{}

 

void ConcreateAbstractionImpA::Operation()

{

        cout<<"ConcreateAbstractionImpA..."<<endl;

}

 

ConcreateAbstractionImpB::ConcreateAbstractionImpB()

{}

 

ConcreateAbstractionImpB::~ConcreateAbstractionImpB()

{}

 

void ConcreateAbstractionImpB::Operation()

{
         cout<<"ConcreateAbstractionImpB..."<<endl;

}

 

-----------------------------------------main.cpp---------------------------------------

#include"Abstraction.h"

#include"AbstractionImp.h"

 

#include<iostream>

using namespact std;

 

int main(int argc,char * argv[])

{

       AbstractionImp * imp = new ConcreateAbstractionImpA();

       Abstraction *abs = new RefinedAbstraction(imp);

       abs->Operation();

       return 0;

 

}