桥接模式Bridge Pattern

一 使用场景
我有三种型号的铅笔来绘制4种不同的颜色，需要准备3*4总共12只铅笔。如果我用三种型号的毛笔，来绘制4种不同的颜色，只需要3种毛笔外加4种笔墨即可。同理软件系统中存在两个独立变化的维度，通过桥接模式可以将这两种维度区分开来，使两种可以独立的扩展，让系统更加符合单一的原则。

二 定义
桥接模式：是一种对象结构模型，将抽象部分(Abstraction)与实现部分(Implementation)分离，使得二者可以独立地变化。

Abstraction 抽象类 ，与implementor有关联关系，可以包含抽象业务方法或者具体业务方法。
RefinedAbstraction扩充抽象类，扩充Abstractor定义的接口，通常是具体类，实现了Abstractor定义的方法。
Implemention 实现类接口，定义实现类的接口，一般而言Abstraction定义比较复杂的接口，Implemention定义比较简单的接口。
ConcreteImplemention具体实现类，实现Implemention 的接口。

三 C++实现桥接模式
IAppliance.h

#pragma once 


class IAppliance
{
public:
    IAppliance(){
    }

    virtual ~IAppliance(){
    }

    virtual void run() = 0;
    virtual void off() = 0;
};

TV.h

#pragma once 
#include 
#include "IAppliance.h"
using namespace std;


class TeleVision:public IAppliance
{
private:
    std::string name;
public:
    TeleVision(std::string _name){
        name = _name;
    }

    virtual ~TeleVision(){

    }

    void run(){
        printf("%s is on\n", name);
    }

    void off(){
        printf("%s is off\n", name);
    }
};

AC.h

#pragma once

#include 

#include "IAppliance.h"
using namespace std;

class AC:public IAppliance
{
private:
    std::string name;
public:
    AC(std::string _name){
        name = _name;
    }

    virtual ~AC(){};

    void run(){
        printf("%s is on\n", name);
    }

    void off(){
        printf("%s is off\n",name);
    }
};

Switch.h

#pragma once 


class Switch
{
public:
    Switch(){
    }

    virtual ~Switch(){
    }

    virtual void turnOn() = 0;
    virtual void turnOff() = 0;
};

BridgeSwitch.h

#pragma once
#include "Switch.h"
#include "IAppliance.h"


class BridgeSwitch:public Switch
{
protected:
    IAppliance * i_a;

public:
    BridgeSwitch(IAppliance * backend)
    {
        i_a = backend;
    }

    virtual ~BridgeSwitch(){
        delete i_a;
        i_a = NULL;
    }

    void turnOn(){
        printf("bridge on\n");
        i_a->run();
    }

    void turnOff()
    {
        printf("bridge off\n");
        i_a->off();
    }
};

RemoteControl.h

#pragma once
#include 
#include "Switch.h"
#include "BridgeSwitch.h"


class RemoteControl:public BridgeSwitch
{
public:
    RemoteControl(IAppliance * i):BridgeSwitch(i){}
    void turnOn(){
        printf("using remote\n");
    }
    void turnOff(){
        printf("using remote\n");
    }
};

Normal.h

#pragma once
#include 
#include "BridgeSwitch.h"


class Normal:public BridgeSwitch
{
public:
    Normal(IAppliance * i):BridgeSwitch(i){}
    void turnOn(){
        printf("using normal\n");
        i_a->run();
    }

    void turnOff(){
        printf("using nomal\n");
        i_a->off();
    }
};

main.cpp

#include <string>
#include <string.h>
#include <stdio.h>
using namespace std;
#include "RemoteControl.h"
#include "Normal.h"
#include "AC.h"
#include "TV.h"

int main()
{
    Switch * switch1;
    IAppliance * tv = new TeleVision("my_TV");
    IAppliance * ac = new AC("my_ac");

    switch1 = new RemoteControl(tv);
    switch1->turnOn();

    switch1 = new RemoteControl(ac);
    switch1->turnOn();

    switch1 = new Normal(tv);

    switch1->turnOff();

    system("pause");
}

四 总结
桥接模式实现抽象和现实的分离，使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。但是比较难以理解。