桥接模式：Bridge Pattern

将抽象和实现放在两个不同的类层次中，使它们可以独立地变化。——《Head First 设计模式》

将类的功能层次结构和实现层次结构相分离，使二者能够独立地变化，并在两者之间搭建桥梁，实现桥接。—— 《图解设计模式》

类的功能层次结构：父类具有基本功能，在子类中增加新的功能；

类的实现层次结构：父类通过声明抽象方法来定义接口，子类通过实现具体方法来实现接口；

桥接模式中有四个角色：

抽象化角色：使用实现者角色提供的接口来定义基本功能接口。

持有实现者角色，并在功能接口中委托给它，起到搭建桥梁的作用；

注意，抽象化角色并不是指它就是一个抽象类，而是指抽象了实现。

改善后的抽象化角色：作为抽象化角色的子类，增加新的功能，也就是增加新的接口（方法）；与其构成类的功能层次结构；

实现者角色：提供了用于抽象化角色的接口；它是一个抽象类或者接口。

具体的实现者角色：作为实现者角色的子类，通过实现具体方法来实现接口；与其构成类的实现层次结构。

如果抽象和实现两者做不到独立地变化，就不算桥接模式。

可以这样想：猪八戒投胎，灵魂在河的一边，河对面有两个肉体，红猪和绿猪；

灵魂需要过桥，选择红猪的肉体或者绿猪的肉体完成投胎。

在上面的例子中，红猪和绿猪就是 RedCircle 和 GreenCircle，灵魂是 Circle 类，而那座桥就是 drawAPI 这个接口。

PHP 实现：

/**
 * Interface DrawAPI
 * 实现化(Implementor)角色：这个角色给出实现化角色的接口，但不给出具体的实现。
 */
interface DrawAPI
{
    public function drawCircle(int $radius, int $x, int $y);
}

/**
 * Class RedCircle
 * 具体实现化(ConcreteImplementorA)角色
 * 这个角色给出实现化角色接口的具体实现。
 */
class RedCircle implements DrawAPI
{

    public function drawCircle(int $radius, int $x, int $y)
    {
        echo "Drawing Circle[ color: red, radius: " . $radius . ", x: " . $x . ", " . $y . "]" . PHP_EOL;
    }
}

class GreenCircle implements DrawAPI
{

    public function drawCircle(int $radius, int $x, int $y)
    {
        echo "Drawing Circle[ color: green, radius: " . $radius . ", x: " . $x . ", " . $y . "]" . PHP_EOL;
    }
}

/**
 * Class Shape
 * 抽象化(Abstraction)角色
 * 给出定义,并保存一个对象实例化的引用
 */
abstract class Shape{
    protected $_drawAPI;
    public function __construct(DrawAPI $drawAPI)
    {
        $this->_drawAPI = $drawAPI;
    }
    public abstract function draw();
}

/**
 * Class Circle
 * 修正抽象化角色 RefinedAbstraction
 * 扩展抽象化角色，改变和修正父类对抽象化的定义。
 */
class Circle extends Shape{
    private $_x;
    private $_y;
    private $_radius;

    public function __construct(int $x,int $y,int $radius,DrawAPI $drawAPI)
    {
        parent::__construct($drawAPI);
        $this->_x = $x;
        $this->_y = $y;
        $this->_radius = $radius;
    }

    public function draw()
    {
        // TODO: Implement draw() method.
        $this->_drawAPI->drawCircle($this->_x,$this->_y,$this->_radius);
    }
}

class Demo{
    public static function main(){
        $red = new Circle(100,100,10,new RedCircle());
        $green = new Circle(100,100,10,new GreenCircle());
        $red->draw();
        $green->draw();
    }
}

Demo::main();

C++ 版：

#include <iostream>

using std::cout;
using std::endl;

// 创建桥接实现接口。
__interface DrawAPI {
public:
    virtual void drawCircle(int __radius, int __x, int __y) = 0;
};
// 创建实现了 DrawAPI 接口的实体桥接实现类。
class RedCircle : public DrawAPI {
public:
    void drawCircle(int __radius, int __x, int __y) override {
        cout << "Drawing Circle[ color: red, radius: "
            << __radius << ", x: " << __x << ", " << __y << "]" << endl;
    }
};
class GreenCircle : public DrawAPI {
public:
    void drawCircle(int __radius, int __x, int __y) override {
        cout << "Drawing Circle[ color: green, radius: "
            << __radius << ", x: " << __x << ", " << __y << "]" << endl;
    }
};
// 使用 DrawAPI 接口创建抽象类 Shape。
class Shape {
protected:
    DrawAPI* _drawAPI;
    Shape(DrawAPI* __drawAPI) : _drawAPI(__drawAPI) {}
public:
    virtual void draw() = 0;
};
// 创建实现了 Shape 抽象类的实体类。
class Circle : public Shape {
private:
    int _x, _y, _radius;
public:
    Circle(int __x, int __y, int __radius, DrawAPI* __drawAPI)
        : Shape::Shape(__drawAPI), _x(__x), _y(__y), _radius(__radius) {}
    void draw() override {
        _drawAPI->drawCircle(_radius, _x, _y);
    }
};

// 使用 Shape 和 DrawAPI 类画出不同颜色的圆。
int main() {
    auto pRedCircle = new RedCircle();
    auto pGreenCircle = new GreenCircle();
    auto redCircle = Circle(100, 100, 10, pRedCircle);
    auto greenCircle = Circle(100, 100, 10, pGreenCircle);
    redCircle.draw();
    greenCircle.draw();
    delete pRedCircle;
    delete pGreenCircle;
    return 0;
}