桥接

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

桥接模式的定义非常玄乎，直接理解不太容易，所以我们还是举例子。

假设某个汽车厂商生产三种品牌的汽车：Big、Tiny和Boss，每种品牌又可以选择燃油、纯电和混合动力。如果用传统的继承来表示各个最终车型，一共有3个抽象类加9个最终子类：

  1.                    ┌───────┐
  2.                    │  Car  │
  3.                    └───────┘
  4.                        ▲
  5.     ┌──────────────────┼───────────────────┐
  6.     │                  │                   │
  7. ┌───────┐          ┌───────┐          ┌───────┐
  8. │BigCar │          │TinyCar│          │BossCar│
  9. └───────┘          └───────┘          └───────┘
  10.     ▲                  ▲                  ▲
  11.     │                  │                  │
  12.     │ ┌───────────────┐│ ┌───────────────┐│ ┌───────────────┐
  13.     ├─│  BigFuelCar   │├─│  TinyFuelCar  │├─│  BossFuelCar  │
  14.     │ └───────────────┘│ └───────────────┘│ └───────────────┘
  15.     │ ┌───────────────┐│ ┌───────────────┐│ ┌───────────────┐
  16.     ├─│BigElectricCar │├─│TinyElectricCar│├─│BossElectricCar│
  17.     │ └───────────────┘│ └───────────────┘│ └───────────────┘
  18.     │ ┌───────────────┐│ ┌───────────────┐│ ┌───────────────┐
  19.     └─│ BigHybridCar  │└─│ TinyHybridCar │└─│ BossHybridCar │
  20.       └───────────────┘  └───────────────┘  └───────────────┘

如果要新增一个品牌，或者加一个新的引擎（比如核动力），那么子类的数量增长更快。

所以，桥接模式就是为了避免直接继承带来的子类爆炸。

我们来看看桥接模式如何解决上述问题。

在桥接模式中，首先把Car按品牌进行子类化，但是，每个品牌选择什么发动机，不再使用子类扩充，而是通过一个抽象的“修正”类，以组合的形式引入。我们来看看具体的实现。

首先定义抽象类Car，它引用一个Engine：

  1. public abstract class Car {
  2.     // 引用Engine:
  3.     protected Engine engine;
  5.     public Car(Engine engine) {
  6.         this.engine = engine;
  7.     }
  9.     public abstract void drive();
  10. }

Engine的定义如下：

  1. public interface Engine {
  2.     void start();
  3. }

紧接着，在一个“修正”的抽象类RefinedCar中定义一些额外操作：

  1. public abstract class RefinedCar extends Car {
  2.     public RefinedCar(Engine engine) {
  3.         super(engine);
  4.     }
  6.     public void drive() {
  7.         this.engine.start();
  8.         System.out.println("Drive " + getBrand() + " car...");
  9.     }
  11.     public abstract String getBrand();
  12. }

这样一来，最终的不同品牌继承自RefinedCar，例如BossCar：

  1. public class BossCar extends RefinedCar {
  2.     public BossCar(Engine engine) {
  3.         super(engine);
  4.     }
  6.     public String getBrand() {
  7.         return "Boss";
  8.     }
  9. }

而针对每一种引擎，继承自Engine，例如HybridEngine：

  1. public class HybridEngine implements Engine {
  2.     public void start() {
  3.         System.out.println("Start Hybrid Engine...");
  4.     }
  5. }

客户端通过自己选择一个品牌，再配合一种引擎，得到最终的Car：

  1. RefinedCar car = new BossCar(new HybridEngine());
  2. car.drive();

使用桥接模式的好处在于，如果要增加一种引擎，只需要针对Engine派生一个新的子类，如果要增加一个品牌，只需要针对RefinedCar派生一个子类，任何RefinedCar的子类都可以和任何一种Engine自由组合，即一辆汽车的两个维度：品牌和引擎都可以独立地变化。

  1.        ┌───────────┐
  2.        │    Car    │
  3.        └───────────┘
  4.              ▲
  5.              │
  6.        ┌───────────┐       ┌─────────┐
  7.        │RefinedCar │ ─ ─ ─>│ Engine  │
  8.        └───────────┘       └─────────┘
  9.              ▲                  ▲
  10.     ┌────────┼────────┐         │ ┌──────────────┐
  11.     │        │        │         ├─│  FuelEngine  │
  12. ┌───────┐┌───────┐┌───────┐     │ └──────────────┘
  13. │BigCar ││TinyCar││BossCar│     │ ┌──────────────┐
  14. └───────┘└───────┘└───────┘     ├─│ElectricEngine│
  15.                                 │ └──────────────┘
  16.                                 │ ┌──────────────┐
  17.                                 └─│ HybridEngine │
  18.                                   └──────────────┘

桥接模式实现比较复杂，实际应用也非常少，但它提供的设计思想值得借鉴，即不要过度使用继承，而是优先拆分某些部件，使用组合的方式来扩展功能。

练习

使用桥接模式扩展一种新的品牌和新的核动力引擎。

从桥接 - 图1下载练习：桥接模式练习 （推荐使用IDE练习插件快速下载）

小结

桥接模式通过分离一个抽象接口和它的实现部分，使得设计可以按两个维度独立扩展。

读后有收获可以支付宝请作者喝咖啡：

桥接 - 图2