BridgePattern：通过桥梁链接抽象部分与实现部分，使它们都能独立的变化。好吧，这个设计模式最难理解，抽象部分与实现部分很难理解。

使用场景

  • 一个类存在两个独立变化的维度，且这两个维度都需要进行拓展

    UML

    桥梁模式-基础 - 图1```java // 抽象部分 public abstract class Abstraction { private Implementro mImpl; public Abstraction(Implementor impl) {
    1.   mImpl = impl;
    } public abstract void operation() {
    1.   mImpl.operationImpl();
    } }
    1. ```java
    2. // 实现部分的抽象接口
    3. public interface Implementor {
    4.   public void operationImpl();
    5. }
    1. // 实现部分的具体实现
    2. public class ConcreteImplementorA {
    3.   @Override
    4.   public void operationImpl() {}
    5. }
    1. // 抽象部分的子类
    2. public class RefinedAbstraction extends Abstraction {
    3.   public RefinedAbstraction(Implementor implementor) {
    4.       super(implementor)
    5.   }
    6.   // 
    7. }
    Abstraction：抽象部分，持有实现部分引用
    RefinedAbstraction：抽象部分子类
    Implementor：实现部分
    ConreteImplementorA：实现部分子类

    Coding

桥梁模式-基础 - 图2```kotlin public abstract class Coffee { // Coffee持有CoffeeAdditives引用 protected CoffeeAdditives impl; public Coffee(CoffeeAdditives impl) { this.impl = impl; } public abstract void makeCoffee(); }

  1. ```kotlin
  2. public class LargeCoffee extends Coffee {
  3.     public LargeCoffee(CoffeeAdditives impl) {
  4.         super(impl);
  5.     }
  6.     @Override
  7.     public void makeCoffee() {
  8.         System.out.println("大杯的" + impl + "咖啡☕️");
  9.     }
  10. }
  1. public class SmallCoffee extends Coffee {
  2.     public SmallCoffee(CoffeeAdditives impl) {
  3.         super(impl);
  4.     }
  5.     @Override
  6.     public void makeCoffee() {
  7.         System.out.println("小杯的" + impl + "咖啡☕️");
  8.     }
  9. }
  1. public abstract class CoffeeAdditives {
  2.     public abstract String add();
  3. }
public class Suger extends CoffeeAdditives {
    @Override
    public String add() {
        return "加糖";
    }
}

public class Oridinary extends CoffeeAdditives {
    @Override
    public String add() {
        return "原味";
    }
}

public class BridgePattern {
    Oridinary ord = new Oridinary();
    Suger sug = new Suger();
    // 大杯原味咖啡
    LargeCoffee lco = new LargeCoffee(ord);
    lcoc.makeCoffee();
    // 大杯加糖咖啡
    LargeCoffee lcs = new LargeCoffee(sug);
    lcs.makeCoffee();
    // 小杯原味咖啡
    SmallCoffee sco = new SmallCoffee(ord);
    soc.makeCoffee();
    // 小杯加糖咖啡
    SmallCoffee scs = new SmallCoffee(sug);
    scs.makeCoffee();
}

Coffe有子类发生了变化，CoffeeAdditives有子类也发生了变化，但都是独立的，这里的桥梁体现在Coffee持有CoffeeAdditives的引用上。谁是抽象部分，谁是实现部分，此刻并不重要了。