设计模式之桥接模式

文章目录

• 一、介绍
• 二、案例
• • [1. 组件抽象化](#1. 组件抽象化)
  • [2. 桥梁抽象化](#2. 桥梁抽象化)

一、介绍

桥接模式，属于结构型设计模式 。通过提供抽象与实现之间的桥接结构 ，把抽象化 与实现化解耦，使得二者可以独立变化。

《Head First 设计模式》：

将抽象和实现放在两个不同的类层次中，使它们可以独立地变化。

《图解设计模式》：

将类的功能层次结构和实现层次结构相分离，使二者能够独立地变化，并在两者之间搭建桥梁，实现桥接。

从专业术语对交接模式的解释来看，总是让人似懂非懂，即使懂了，从代码上实现又让人无法捉摸。典型的每个字都认识，连在一起就不懂了。

下面我们先通过一个简单的例子来演示一下桥接的结构是什么样的，然后对其进行改造，最终实现桥接模式。

二、案例

我们假设一部手机有三个重要部件：电池(Battery) 、摄像头(Camera) 、屏幕(Screen)。当我们拍摄一张高清照片时，需要充足的电量、高像素的摄像头、高分辨率的屏幕。

于是我们可以通过下面的代码完成拍照动作：

• 电池Battery

  public class Battery {
      public Battery() {
          System.out.println("充足电量的电池");
      }
      
      public void electric() {
          System.out.println("电池供电...");
      }
  }

• 摄像头Camera

  public class Camera {
      public Camera() {
          System.out.println("高清像素的摄像头");
      }
      
      public void catchImg() {
          System.out.println("摄像头捕获图像...");
      }
  }

• 屏幕Screen

  public class Screen {
      public Screen() {
          System.out.println("高分辨率的屏幕");
      }
      
      public void show() {
          System.out.println("屏幕显示照片...");
      }
  }

• 手机Phone

  public class Phone {
      private Battery battery;
      private Camera camera;
      private Screen screen;
  
      public Phone(Battery battery, Camera camera, Screen screen) {
          this.battery = battery;
          this.camera = camera;
          this.screen = screen;
      }
  
      public void takePic() {
          System.out.println("手机拍照开始...");
          // 电池供电
          battery.electric();
          // 摄像头捕获图像
          camera.catchImg();
          // 屏幕显示照片
          screen.show();
      }
  }

• 演示

  public static void main(String[] args) {
      Battery battery = new Battery();
      Camera camera = new Camera();
      Screen screen = new Screen();
  
      Phone phone = new Phone(battery, camera, screen);
      phone.takePic();
  }

• 结果输出

  

从该案例中可以看出，电池、摄像头、屏幕这三个组件是相互独立的，各自干各自的活，通过手机将他们连接起来就可以进行拍照，这时手机就表现为桥梁的角色。通过桥梁，三个组件相互独立。

1. 组件抽象化

在实际现实中，无论是电池、摄像头、还是屏幕，他们都有各自的品牌厂商，因此我们需要将他们抽象化。如电池有南孚和山羊；摄像头有索尼和徕卡；屏幕有三星和京东方。

所有我们需要做出修改：新建电池、摄像头、屏幕的抽象类；再分别按照品牌厂商对这些抽象类进行实现。

• 电池抽象类Battery ，及其实现类：南孚电池(NanFu) 、山羊电池(Sheep)

  public interface Battery {
  
      void electric();
  }
  
  public class NanFu implements Battery {
      public NanFu() {
          System.out.println("南孚电池实例化");
      }
  
      @Override
      public void electric() {
          System.out.println("南孚电池正在供电...");
      }
  }
  
  public class Sheep implements Battery {
      public Sheep() {
          System.out.println("山羊电池实例化");
      }
  
      @Override
      public void electric() {
          System.out.println("山羊电池正在供电...");
      }
  }

• 摄像头抽象类Camera ，及其实现类：徕卡摄像头(Laika) 、索尼摄像头(Sony)

  public interface Camera {
  
      void catchImg();
  }
  
  public class Laika implements Camera {
      public Laika() {
          System.out.println("徕卡摄像头实例化");
      }
  
      @Override
      public void catchImg() {
          System.out.println("徕卡摄像头捕获图像...");
      }
  }
  
  public class Sony implements Camera {
      public Sony() {
          System.out.println("索尼摄像头实例化");
      }
  
      @Override
      public void catchImg() {
          System.out.println("索尼摄像头捕获图像...");
      }
  }

• 屏幕抽象类Screen ，及其实现类：京东方显示屏(JingDongFang) 、三星显示屏(SanXing)

  public interface Screen {
  
      void show();
  }
  
  public class JingDongFang implements Screen {
      public JingDongFang() {
          System.out.println("京东方显示屏实例化");
      }
  
      @Override
      public void show() {
          System.out.println("京东方显示屏显示照片...");
      }
  }
  
  public class SanXing implements Screen {
      public SanXing() {
          System.out.println("三星显示屏实例化");
      }
  
      @Override
      public void show() {
          System.out.println("三星显示屏显示照片...");
      }
  }

这样一来，手机的构造方法的参数就由原来的具体实现类变成了抽象类。

public Phone(Battery battery, Camera camera, Screen screen) {
    this.battery = battery;
    this.camera = camera;
    this.screen = screen;
}

该构造方法参数的实际类型由调用方创建的实例为准。

public static void main(String[] args) {
    // 使用南孚电池
    Battery battery = new NanFu();
    // 索尼相机
    Camera camera = new Sony();
    // 京东方显示屏
    Screen screen = new JingDongFang();

    Phone phone = new Phone(battery, camera, screen);
    phone.takePic();
}

输出如下

2. 桥梁抽象化

其实不仅电池、摄像头、屏幕有自己的品牌厂商，手机也不例外，如华为、oppo、vivo等，因此我们也需要将手机这个桥梁的角色抽象化。但是如果我们将该桥梁设计成一个接口，由不同的手机品牌实现该接口，那么就可能会导致不同的实现类具有不同参数的构造方法，如此一来，所有品牌手机的功能虽然受到约束(实现类手机接口)，但是他们的组成结构却千差万别。如下所示

public interface MyPhone {
    /**
     * 拍照
     */
    void takePic();
    /**
     * 通话
     */
    void call();

    /**
     * 微信聊天
     */
    void wechat();
}

public class Oppo implements MyPhone{

    private ComponentA componentA;
    private ComponentB componentB;

    public Oppo(ComponentA componentA, ComponentB componentB) {
        this.componentA = componentA;
        this.componentB = componentB;
    }

    @Override
    public void takePic() {
        // 照相
    }

    @Override
    public void call() {
        // 打电话
    }

    @Override
    public void wechat() {
        // 聊微信
    }
}

public class Vivo implements MyPhone{

    private ComponentC componentC;
    private ComponentD componentD;

    public Oppo(ComponentC componentC, ComponentD componentD) {
        this.componentC = componentC;
        this.componentD = componentD;
    }

    @Override
    public void takePic() {
        // 照相
    }

    @Override
    public void call() {
        // 打电话
    }

    @Override
    public void wechat() {
        // 聊微信
    }
}

从上面的代码来看，oppo和vivo虽然实现了**手机(MyPhone)**定义的所有功能，但是却乱七八糟的，oppo手机内部组件是ComponentA和ComponentB，vivo手机内部组件却是ComponentC和ComponentD。这样的话手机行业岂不乱套了。

所以我们对桥梁的抽象化不应采用接口，而是抽象类。

使用抽象类有一个好处是，可以使所有子类拥有相同的内部属性，而且对所有子类的构造方法也做出了约束。

如下所示，我们将手机抽象化一个手机接口(Phone)来定义各个功能，再通过一个 抽象子类(AbstractPhone)实现手机接口定义的功能，并规范构造方法，由华为(HuaWei)、**小米(XiaoMi)**两个品牌继承该抽象子类。

public interface Phone {
    /**
     * 拍照
     */
    void takePic();
}

public abstract class AbstractPhone implements Phone {
    private Battery battery;
    private Camera camera;
    private Screen screen;

    public AbstractPhone(Battery battery, Camera camera, Screen screen) {
        this.battery = battery;
        this.camera = camera;
        this.screen = screen;
    }

    @Override
    public void takePic() {
        System.out.println("手机拍照开始...");
        // 电池供电
        battery.electric();
        // 摄像头捕获图像
        camera.catchImg();
        // 屏幕显示照片
        screen.show();
    }
}

public class HuaWei extends AbstractPhone {

    public HuaWei(Battery battery, Camera camera, Screen screen) {
        super(battery, camera, screen);
        System.out.println("华为手机实例化");
    }
}

public class XiaoMi extends AbstractPhone {
    public XiaoMi(Battery battery, Camera camera, Screen screen) {
        super(battery, camera, screen);
        System.out.println("小米手机实例化");
    }
}

通过接口(定义功能) 、抽象子类(桥梁)、**实现类(实现功能)**的方式，就是交接设计模式的实现。

下面我们进行代码测试

public static void main(String[] args) {
    Battery battery = new NanFu();
    Camera camera = new Sony();
    Screen screen = new JingDongFang();

    // 华为将南孚电池、索尼相机、京东方显示屏桥接起来形成一部手机
    Phone phone = new HuaWei(battery, camera, screen);
    // 使用华为手机拍照
    phone.takePic();
}

以上就是桥接模式的演变过程，希望通过本篇文章的阅读，能使各位朋友对桥接模式有更深入的理解。

纸上得来终觉浅，绝知此事要躬行。

------------------------我是万万岁，我们下期再见------------------------