设计模式--桥接模式Bridge（结构性）

桥接模式（Bridge）应用背景

软件设计实现中，继承是扩展对象功能一种常见的手段，通常情况下，继承扩展的功能变化是一纬的，变化的因素只有一类。对于出现变化因素有两类或者更多的情况，继承实现往往比较麻烦。实际使用中，想象一下装操作系统的场景，有多种配置的计算机，同样也有多款操作系统，实际上操作系统和计算机是各自发展，大大减少它们的耦合度，两者之间有标准的接口，这不论是对于计算机，还是操作系统都是非常有利的。又例如日常使用最多的手机，某个特定的游戏需要实现在不同品牌上运行，而同款手机支持安装多种不同的游戏，手机品牌和游戏软件也是各自发展。 诸多此种场景，在软件系统中就要适应两个或者多个方面的变化，那么怎样实现才能应对这种变化呢？ 这就要使用桥接（Bridge）模式。

桥接（Bridge）模式将抽象部分与实现部分分离，使它们都可以独立的变化。听起来比较抽象？相当于没说，在此举个例子就明白了，还是刚才手机的例子，设计中可以让手机按照品牌分类，也可以按照功能分来，使他们在各自的维度上变化，如下示意图所示：

桥接模式的核心思想是将变化的两者独立出来，使它们各自变化， 而不影响其它，从而达到应对多维度变化的目的。

桥接模式（Bridge）UML 图

桥接模式（Bridge）代码示例

class Abstraction
{
public:
    Abstraction(){}
    virtual ~Abstraction(){}

public:
    virtual void Operation() = 0;
};

class RefinedAbstractionA: public Abstraction
{
public:
    RefinedAbstraction(AbstractionImplement* impl):m_pImpl(impl){}
    ~RefinedAbstraction()
    {
        delete m_pImpl;
        m_pImpl = NULL;
    }

private:
    AbstractionImplement* m_pImpl;

public:
    void Operation()
    {
        if(m_pImpl != NULL)
        {
            m_pImpl->Operation();
        }
    }
};

class RefinedAbstractionB: public Abstraction
{
public:
    RefinedAbstractionB(AbstractionImplement* impl):m_pImpl(impl){}
    ~RefinedAbstractionB()
    {
        delete m_pImpl;
        m_pImpl = NULL;
    }

private:
    AbstractionImplement* m_pImpl;

public:
    void Operation()
    {
        if(m_pImpl != NULL)
        {
            m_pImpl->Operation();
        }
    }
};

class AbstractionImplement
{
public:
    AbstractionImplement(){}
    virtual ~AbstractionImplement(){}

public:
    virtual void Operation() = 0;
};

class ConcreteAbstractionImplementA: public AbstractionImplement
{
public:
    ConcreteAbstractionImplementA(){}
    ~ConcreteAbstractionImplementA(){}

public:
    void Operation()
    {
        //do concrete abstraction implement A operation
    }
};

class ConcreteAbstractionImplementB: public AbstractionImplement
{
public:
    ConcreteAbstractionImplementB(){}
    ~ConcreteAbstractionImplementB(){}

public:
    void Operation()
    {
        //do concrete abstraction implement B operation
    }
};

//client usage example
//实现部分ConcreteAbstractionImplementA
AbstractionImplement* impA = new ConcreteAbstractionImplementA(); 
//抽象部分RefinedAbstractionA      
Abstraction* absA = new RefinedAbstractionA(impA); 
absA->Operation();

delete impA;
impA = NULL;
delete absA;
absA = NULL;

//实现部分ConcreteAbstractionImplementB
AbstractionImplement* impB = new ConcreteAbstractionImplementB();        
//抽象部分RefinedAbstractionA
Abstraction* absB = new RefinedAbstractionA(imp);                        
absB->Operation();

delete impB;
impB = NULL;
delete absB;
absB = NULL;

//实现部分ConcreteAbstractionImplementA
AbstractionImplement* impAA = new ConcreteAbstractionImplementA();        
//抽象部分RefinedAbstractionB
Abstraction* absAB = new RefinedAbstractionB(impAA);          
absAB->Operation();

delete impAA;
impAA = NULL;
delete absAB;
absAB = NULL;  

将抽象部分与它的实现部分分离：实现系统可能有多维度分类，每一种分类都可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合。