桥接模式的代码实现非常简单，但是理解起来稍微有点难度，并且应用场景也比较局限，所以，相当于代理模式来说，桥接模式在实际的项目中并没有那么常用，你只需要简单了解，见到能认识就可以，并不是我们学习的重点。

1、什么是桥接模式

桥接模式，也叫作桥梁模式，英文是 Bridge Design Pattern。这个模式可以说是 23 种设计模式中最难理解的模式之一了。我查阅了比较多的书籍和资料之后发现，对于这个模式有两种不同的理解方式。

当然，这其中“最纯正”的理解方式，当属 GoF 的《设计模式》一书中对桥接模式的定义。毕竟，这 23 种经典的设计模式，最初就是由这本书总结出来的。在 GoF 的《设计模式》一书中，桥接模式是这么定义的：“Decouple an abstraction from its implementation so that the two can vary independently。”翻译成中文就是：“将抽象和实现解耦，让它们可以独立变化。”

关于桥接模式，很多书籍、资料中，还有另外一种理解方式：“一个类存在两个（或多个）独立变化的维度，我们通过组合的方式，让这两个（或多个）维度可以独立进行扩展。”通过组合关系来替代继承关系，避免继承层次的指数级爆炸。这种理解方式非常类似于，我们之前讲过的“组合优于继承”设计原则，所以，这里我就不多解释了。重点看下 GoF 的理解方式。

对于第一种 GoF 的理解方式，弄懂定义中“抽象”和“实现”两个概念，是理解它的关键。定义中的“抽象”，指的并非“抽象类”或“接口”，而是被抽象出来的一套“类库”，它只包含骨架代码，真正的业务逻辑需要委派给定义中的“实现”来完成。而定义中的“实现”，也并非“接口的实现类”，而是一套独立的“类库”。“抽象”和“实现”独立开发，通过对象之间的组合关系，组装在一起。

对于第二种理解方式，它非常类似我们之前讲过的“组合优于继承”设计原则，通过组合关系来替代继承关系，避免继承层次的指数级爆炸。

2、为什么要使用桥接模式

1）如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。
2）对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用。
3）一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。

3、例子

3.1、GoF 的定义（简单）

public class Main {
    public static void main(String[] args) {
        Abstraction ab = new RefinedAbstraction();
        ab.setImplmentor(new ConcreteImplementorA());
        ab.Operation();
        ab.setImplmentor(new ConcreteImplementorB());
        ab.Operation();
    }
}
/**
 * 实现
 */
abstract class Implmentor {
    public abstract void Operation();
}
/**
 * 具体实现者A
 */
class ConcreteImplementorA extends Implmentor {
    @Override
    public void Operation() {
        System.out.println("具体实现A的方法执行");
    }
}
/**
 * 具体实现者B
 */
class ConcreteImplementorB extends Implmentor {
    @Override
    public void Operation() {
        System.out.println("具体实现B的方法执行");
    }
}
/**
 * 抽象
 */
class Abstraction {
    protected Implmentor implmentor;
    public void setImplmentor(Implmentor implmentor) {
        this.implmentor = implmentor;
    }
    public void Operation() {
        this.implmentor.Operation();
    }
}
/**
 * 被提炼的抽象
 */
class RefinedAbstraction extends Abstraction {
    @Override
    public void Operation() {
        implmentor.Operation();
    }
}

3.2、画图（简单）

以画图为例，假设有一个画笔，可以画正方形、长方形、圆形等等。但是现在我们需要给这些形状进行上色，这里有三种颜色：白色、灰色、黑色。这里我们可以画出3*3=9中图形：白色正方形、白色长方形、白色圆形。。。。。。到这里了我们几乎到知道了这里存在两种解决方案：

• 方案一：为每种形状都提供各种颜色的版本。
• 方案二：根据实际需要对颜色和形状进行组合。

我们我们采用方案一来实现的话，我们是不是也可以这样来理解呢？为每种颜色都提供各种形状的版本呢？这个是完全的可以的。如下：

但方案一有个问题：假设现在需要加入椭圆，我们得增加三种颜色。假如我们再增加一个绿色，我们就要增加其四种形状了，继续加。继续加……每次增加都会增加若干个类(如果增加颜色则会增加形状个数个类，若增加形状则会增加颜色个数个类)，这样的情况我想每个程序员都不会想要吧！

方案二所提供的就是解决方法是：提供两个父类一个是颜色、一个形状，颜色父类和形状父类两个类都包含了相应的子类，然后根据需要对颜色和形状进行组合。

对于有几个变化的维度，我们一般采用方案二来实现，这样除了减少系统中的类个数，也利于系统扩展。对于方案二的应用我们称之为桥接模式。

public class Main {
    public static void main(String[] args) {
        //白色
        Color white = new White();
        //黑色
        Color black = new Black();

        //正方形
        Shape square = new Square();
        //长方形
        Shape rectange = new Rectangle();

        //白色的正方形
        square.setColor(white);
        square.draw();

        //黑色的正方形
        square.setColor(black);
        square.draw();

        //白色的长方形
        rectange.setColor(white);
        rectange.draw();

        //黑色的长方形
        rectange.setColor(black);
        rectange.draw();
    }
}

/**
 * 颜色
 */
abstract class Color {
    // 颜色名称
    String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void bepaint(String shape);
}

/**
 * 白色
 */
class White extends Color {
    public White() {
        this.setName("白色");
    }

    @Override
    public void bepaint(String shape) {
        System.out.println(this.getName() + "的" + shape);
    }
}

/**
 * 灰色
 */
class Gray extends Color {
    public Gray() {
        this.setName("灰色");
    }

    @Override
    public void bepaint(String shape) {
        System.out.println(this.getName() + "的" + shape);
    }
}

/**
 * 黑色
 */
class Black extends Color {
    public Black() {
        this.setName("黑色");
    }

    @Override
    public void bepaint(String shape) {
        System.out.println(this.getName() + "的" + shape);
    }
}

/**
 * 形状
 */
abstract class Shape {
    // 形状名称
    String name;

    // 颜色
    Color color;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public abstract void draw();
}

/**
 * 圆形
 */
class Circle extends Shape {
    public Circle() {
        this.setName("圆形");
    }

    @Override
    public void draw() {
        color.bepaint(this.getName());
    }
}

/**
 * 长方形
 */
class Rectangle extends Shape {
    public Rectangle() {
        this.setName("长方形");
    }

    @Override
    public void draw() {
        color.bepaint(this.getName());
    }
}

/**
 * 正方形
 */
class Square extends Shape {
    public Square() {
        this.setName("正方形");
    }

    @Override
    public void draw() {
        color.bepaint(this.getName());
    }
}

4、总结

4.1、优缺点

1）优点

• 分离抽象接口及其实现部分。提高了比继承更好的解决方案。
• 桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。
• 实现细节对客户透明，可以对用户隐藏实现细节。

2）缺点

• 桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程。
• 桥接模式要求正确识别出系统中两个独立变化的维度，因此其使用范围具有一定的局限性。

4.2、关于桥接模式的一些问题