「补课」进行时：设计模式(22)——桥梁模式

1. 前文汇总

2. 桥梁模式

设计模式的最后一篇文章，还是让我这个拖延症晚期的患者把时间拖到了 2020 年的最后一天。

虽然是最后一篇，但并不是最难的一个模式，比较复杂的两个模式已经在前面介绍过了，一个是访问者模式，另一个是解释器模式。

那么什么是桥梁模式？

2.1 定义

桥梁模式（Bridge Pattern）也叫做桥接模式，是一个比较简单的模式，其定义如下：Decouple an abstraction from its implementation so that the two can vary independently.（将抽象和实现解耦，使得两者可以独立地变化。）

桥梁模式的重点是在「解耦」上，如何让它们两者解耦是桥梁模式的重点，

2.2 通用类图

Abstraction 抽象化角色：定义出该角色的行为，同时保存一个对实现化角色的引用，该角色一般是抽象类
Implementor 实现化角色：它是接口或者抽象类，定义角色必需的行为和属性。
RefinedAbstraction 修正抽象化角色：实现化角色对抽象化角色进行修正。
ConcreteImplementor 具体实现化角色：实现接口或抽象类定义的方法和属性。

桥梁模式中的几个名词比较拗口，核心就一句话：抽象角色引用实现角色，或者说抽象角色的部分实现是由实现角色完成的。

2.3 通用代码

实现化角色：

public interface Implementor {
    // 基本方法
    void doSomething();
    void doAnything();
}

具体实现化角色：

public class ConcreteImplementor1 implements Implementor {
    @Override
    public void doSomething() {

    }

    @Override
    public void doAnything() {

    }
}

public class ConcreteImplementor2 implements Implementor {
    @Override
    public void doSomething() {

    }

    @Override
    public void doAnything() {

    }
}

抽象化角色：

public abstract class Abstraction {
    // 定义对实现化角色的引用
    private Implementor impl;
    // 约束子类必须实现该构造函数
    public Abstraction(Implementor impl){
        this.impl = impl;
    }
    // 自身的行为和属性
    public void request(){
        this.impl.doSomething();
    }
    // 获得实现化角色
    public Implementor getImpl(){
        return impl;
    }
}

具体抽象化角色：

public class RefinedAbstraction extends Abstraction {
    // 覆写构造函数
    public RefinedAbstraction(Implementor impl) {
        super(impl);
    }
    // 修正父类的行为
    @Override
    public void request(){
        // 业务处理
        super.request();
        super.getImpl().doAnything();
    }
}

客户端类：

public class Client {
    public static void main(String[] args) {
        // 定义一个实现化角色
        Implementor imp = new ConcreteImplementor1();
        // 定义一个抽象化角色
        Abstraction abs = new RefinedAbstraction(imp);
        // 执行行文
        abs.request();
    }
}

2.4 优点

抽象和实现分离：桥梁模式完全是为了解决继承的缺点而提出的设计模式。
优秀的扩展能力。
实现细节对客户透明。客户不用关心细节的实现，它已经由抽象层通过聚合关系完成了封装。

2.5 缺点

会增加系统的理解与设计难度。由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程。

2.6 使用场景

不希望或不适用使用继承的场景。
接口或抽象类不稳定的场景。
重用性要求较高的场景。

3. 一个简单的案例

在桥接模式中要把握的很重要的一点就是：类的继承关系和类的组合/聚合关系，何时应该考虑使用何种关系。是不是在编程过程中一味地使用类的继承关系就代表这就是面向对象编程了？有时候并不是这样， Java 的类继承设计成单继承模式我想应该就是不想把类的继承关系搞得过于复杂，实际上我们应该优先使用对象组合/聚合，而不是类继承。

类继承不必多说，先来看看何为组合/聚合关系。

聚合体现的是「弱」的拥有关系，比如雁群可以包含大雁，但雁群不是大雁的一部分。组合体现的是「强」的拥有关系，或者体现的是部分与整体的关系，通过一对翅膀组合成大雁，翅膀是部分，大雁是整体。

我们现在天天使用的一个电器：手机，手机有手机品牌和手机软件等等，每个手机品牌都有多款软件。

这个案例如果使用继承关系的话，不管是已手机品牌还是手机软件作为父类，都会对后续的扩展造成很大的影响，如果我们使用桥梁模式，使用对象的组合/聚合，类图是下面这样：

通过UML类结构图我们可以看到手机品牌和手机软件成功解耦，新增功能并不影响其手机品牌，新增手机品牌也不会影响到手机软件，其中的奥秘就在于利用了聚合而不是继承。

代码如下：

手机品牌抽象类：

public abstract class HandsetBrand {
    protected HandsetSoft soft;
    // 设置手机软件
    public void setHandsetSoft(HandsetSoft soft) {
        this.soft = soft;
    }
    // 运行
    abstract void run();
}

手机软件抽象类：

public abstract class HandsetSoft {
    abstract void run();
}

各类手机品牌实现类：

public class HandsetBrandA extends HandsetBrand {
    @Override
    void run() {
        super.soft.run();
    }
}

public class HandsetBrandB extends HandsetBrand{
    @Override
    void run() {
        super.soft.run();
    }
}

手机软件实现类：

public class HandsetGame extends HandsetSoft{
    @Override
    void run() {
        System.out.println("运行手机游戏");
    }
}

public class HandsetAddressList extends HandsetSoft{
    @Override
    void run() {
        System.out.println("运行手机通讯录");
    }
}