桥接模式（Bridge Pattern）定义如下：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

桥接模式组成如下：

组成
Abstraction（抽象化） 定义抽象类，并包含一个对实现化对象的引用
Refined Abstraction（扩展抽象化） 是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法
Implementor（实现化） 定义实现化角色的接口，供扩展抽象化角色调用
Concrete Implementor（具体实现化） 给出实现化角色接口的具体实现

桥接模式结构图如下：

设计模式—桥接模式 - 图1

桥接模式的优点

  1. 抽象与实现分离，扩展能力强
  2. 符合开闭原则
  3. 符合合成复用原则
  4. 其实现细节对客户透明

桥接模式的缺点

由于聚合关系建立在抽象层，要求开发者针对抽象化进行设计与编程，能正确地识别出系统中两个独立变化的维度，这增加了系统的理解与设计难度。

桥接模式的应用场景

  1. 当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时
  2. 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时
  3. 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时

桥接模式使用示例

假设某个汽车厂商生产三种品牌的汽车：Big、Tiny和Boss，每种品牌又可以选择燃油、纯电和混合动力。如果用传统的继承来表示各个最终车型，一共有3个抽象类加9个最终子类：
image.png
如果要新增一个品牌，或者加一个新的引擎（比如核动力），那么子类的数量增长更快。

为了避免这种直接继承带来的子类爆炸，可以使用桥接模式。在桥接模式中，首先把Car按品牌进行子类化，但是，每个品牌选择什么发动机，不再使用子类扩充，而是通过一个抽象的“修正”类，以组合的形式引入。

  1.  public class BridgePattern {
  4.     public static abstract class Car {
  6.         // 引用Engine:
  7.         protected Engine engine;
  9.         public Car(Engine engine) {
  10.             this.engine = engine;
  11.         }
  13.         public abstract void drive();
  14.     }
  16.     public interface Engine {
  17.         void start();
  18.     }
  21.     // 修正的抽象类RefinedCar中定义一些额外操作
  22.     public static abstract class RefinedCar extends Car {
  24.         public RefinedCar(Engine engine) {
  25.             super(engine);
  26.         }
  28.         @Override
  29.         public void drive() {
  30.             this.engine.start();
  31.             System.out.println("Drive " + getBrand() + " car...");
  32.         }
  34.         public abstract String getBrand();
  35.     }
  37.     public static class BossCar extends RefinedCar {
  39.         public BossCar(Engine engine) {
  40.             super(engine);
  41.         }
  43.         @Override
  44.         public String getBrand() {
  45.             return "Boss";
  46.         }
  47.     }
  49.     public static class BigCar extends RefinedCar {
  51.         public BigCar(Engine engine) {
  52.             super(engine);
  53.         }
  55.         @Override
  56.         public String getBrand() {
  57.             return "big";
  58.         }
  59.     }
  61.     public static class TinyCar extends RefinedCar {
  63.         public TinyCar(Engine engine) {
  64.             super(engine);
  65.         }
  67.         @Override
  68.         public String getBrand() {
  69.             return "tiny";
  70.         }
  71.     }
  73.     public static class HybridEngine implements Engine {
  75.         public void start() {
  76.             System.out.println("Start Hybrid Engine...");
  77.         }
  78.     }
  80.     public static class FuelEngine implements Engine {
  82.         public void start() {
  83.             System.out.println("Start Fuel Engine...");
  84.         }
  85.     }
  87.     public static class ElectricEngine implements Engine {
  89.         public void start() {
  90.             System.out.println("Start Electric Engine...");
  91.         }
  92.     }
  94.     public static void main(String[] args) {
  95.         RefinedCar car = new BossCar(new HybridEngine());
  96.         car.drive();
  98.         car = new BigCar(new FuelEngine());
  99.         car.drive();
  101.         car = new TinyCar(new ElectricEngine());
  102.         car.drive();
  103.     }
  104. }

程序运行结果如下：

:::success Start Hybrid Engine…
Drive Boss car… ::: :::success Start Fuel Engine… ::: :::success Drive big car… ::: :::success Start Electric Engine… ::: :::success Drive tiny car… :::