介绍和介绍

桥接模式也成为桥梁模式，是将抽象部分和实现部分分离，使他们可以独立地进行变化。

简单实现

• 实现部分的抽象接口

public interface Implementor {

    /**
     * 抽象部分的具体方法
     */
    void operationImpl();

}

• 实现部分的具体的实现A

public class ImplementorA implements Implementor {
    @Override
    public void operationImpl() {
        //具体实现A
    }
}

• 实现部分具体的实现B

public class ImplementorB implements Implementor {
    @Override
    public void operationImpl() {
        //具体实现B
    }
}

• 抽象类

public abstract class Abstraction {

    Implementor implementor;

    public Abstraction(Implementor implementor) {
        this.implementor = implementor;
    }

    //抽象类的功能
    public void operation(){
        implementor.operationImpl();
    }
}

• 抽象类子类

public class RefinedAbstration extends Abstraction {
    public RefinedAbstration(Implementor implementor) {
        super(implementor);
    }

    /**
     * 对父类方法的扩展
     */
    public void refinedOperation(){

    }
}

实例

现在有四种咖啡， 大杯加糖，大杯原味，小杯不加糖，小杯原味。本质上讲，一共有两种变化，大小杯+是否加糖。

• 首先定义一个抽象类表示咖啡内添加物

public abstract class CoffeeAdditives {

    /**
     * 由子类决定添加何种添加物
     * @return
     */
    abstract String add();

}

• 集成抽象类，实现具体方法

  • 原味

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

  • 加糖

  public class Sugar extends CoffeeAdditives {
      @Override
      String add() {
          return "加糖";
      }
  }
  

• 定义一个咖啡类

public abstract class Coffee {
    protected  CoffeeAdditives coffeeAdditives;

    public Coffee(CoffeeAdditives coffeeAdditives) {
        this.coffeeAdditives = coffeeAdditives;
    }
    
    /**
     * 具体制作过程由子类决定
     */
    public abstract void makeCoffee();
}

• 定义两个子类

  • 大杯

  public class LargeCoffee extends Coffee{
      public LargeCoffee(CoffeeAdditives coffeeAdditives) {
          super(coffeeAdditives);
      }
  
      @Override
      public void makeCoffee() {
          //大杯制作，并由 coffeeAdditives 决定加料
      }
  }
  

  • 小杯

  public class SmallCoffee extends Coffee{
      public LargeCoffee(CoffeeAdditives coffeeAdditives) {
          super(coffeeAdditives);
      }
  
      @Override
      public void makeCoffee() {
          //小杯制作，并由 coffeeAdditives 决定加料
      }
  }
  

• 客户端类

public class Main {

    public static void main(String[] args) {
        Ordinary ordinary = new Ordinary();
        Sugar sugar = new Sugar();

        LargeCoffee largeCoffee1 = new LargeCoffee(ordinary);
        LargeCoffee largeCoffee2 = new LargeCoffee(sugar);
        
        SmallCoffee smallCoffee1 = new SmallCoffee(ordinary);
        SmallCoffee smallCoffee2 = new SmallCoffee(sugar);

    }

}

这样一个简单的桥接模式应用就完成了。如果再增加一种中杯咖啡，只要再扩展一个 MiddleCoffee 子类就可以了。

使用场景

多维度变化类或者说多个树状类之间的耦合就可以使用桥接模式来实现解耦。