桥接模式

基本介绍

桥接模式（Bridge Pattern）：将抽象部分与其实现部分分离，使它们都可以独立变化。是一种对象结构型模式，又称为柄体模式（Handle and Body Pattern）或接口模式（Interface Pattern）。

桥接模式涉及四个角色：
1.抽象类（Abstraction）：定义抽象类的接口，一般为抽象类，其中定义了一个实现类接口（Implementor）类型的对象，且与该对象具有关联关系
2.扩充抽象类（RefinedAbstraction）：在系统中可能不止一个，扩充由抽象类（Abstraction）定义的接口。一般情况下不是抽象类而是具体类
3.实现类接口（Implementor）：定义实现类接口
4.具体实现类（ConcreteImplementor）：在系统中可能不止一个，具体实现实现类接口（Implementor）

事例说明

上面没看懂没关系，我们现在通过代码去理解：
现在有一个需求，大家都使用手机，手机现在比如有三种类型直立式，折叠式，旋转式，每一种类型下都有对应的品牌手机，每个手机都可以进行开机，关机，上网，打电话，如下图所示：

一般实现:

一般看到这种需求，我们会创建一个手机的抽象类，里面有三个方法，开机，关机，打电话，然后三个类型去继承手机类，去实现父类的方法，最后用华为，小米去继承各自的类型。我们这样做没什么问题，完全可以实现该需求，但是这样是有问题，比如我们想在加入一个类型（旋转式），需要在该类型下面增加各个手机的类，同样如果要加一个手机，比如苹果，则需要在各个类型下去新增苹果的手机类，这样扩展很不方便。

桥接模式实现：

第一步:创建手机品牌的接口

//品牌接口
public interface Brand {

    //开机
    void open();
    //关机
    void close();
    //打电话
    void call();
}

第二步：创建对应品牌的手机

//小米手机
public class XiaoMi implements Brand {
    @Override
    public void open() {
        System.out.println("小米手机开机");
    }

    @Override
    public void close() {
        System.out.println("小米手机关机");
    }

    @Override
    public void call() {
        System.out.println("小米手机打电话");
    }
}

//华为手机
public class HuaWei implements Brand{
    @Override
    public void open() {
        System.out.println("华为手机开机");
    }

    @Override
    public void close() {
        System.out.println("华为手机开机");
    }

    @Override
    public void call() {
        System.out.println("华为手机开机");
    }
}

第三步：创建手机的抽象类，将Brand组合进来

public abstract class Phone {

    //组合品牌
    private Brand brand;

    public Phone(Brand brand) {
        this.brand = brand;
    }

    protected void open(){
        brand.open();
    }

    protected void close(){
        brand.close();
    }

    protected void call(){
        brand.call();
    }
}

第四步：创建具体的手机类型类

//直立手机
public class UpRightPhone extends Phone {

    public UpRightPhone(Brand brand) {
        super(brand);
    }

    public void open(){
        super.open();
        System.out.println(" 直立式手机");
    }

    public void close(){
        super.close();
        System.out.println(" 直立式手机");
    }
    public void call(){
        super.call();
        System.out.println(" 直立式手机");
    }
}

//折叠式手机类，继承 抽象类Phone
public class FoldedPhone extends Phone {

    //构造器
    public FoldedPhone(Brand brand) {
        super(brand);
    }

    public void open(){
        super.open();
        System.out.println(" 折叠式手机");
    }

    public void close(){
        super.close();
        System.out.println(" 折叠式手机");
    }
    public void call(){
        super.call();
        System.out.println(" 折叠式手机");
    }
}

测试：

public class Client {

    public static void main(String[] args) {

        //获取折叠式手机（样式 + 品牌）
        Phone phone = new FoldedPhone(new XiaoMi());
        phone.open();
        phone.call();
        phone.close();

        System.out.println("======================");
        //获取直立式手机（样式 + 品牌）
        Phone phone1 = new UpRightPhone(new XiaoMi());
        phone1.open();
        phone1.call();
        phone1.close();
    }
}

运行结果：

从结果可以看出实现了扩展抽象类与具体实现类的组合，如果增加手机类型，那就新建个类型继承Phone类，就可以了，新建手机类型，只用实现Brand接口。

总结

优点：

1）桥接模式代替多次继承的方案，减少子类的个数，无论新增分类还是手机都比之前方便。
2）对于使用层来说，只用知道抽象部分和实现部分的方法就行了，其他就不用管了。

缺点：

1)桥接模式的使用会增加系统的理解与设计难度，由于关联关系建立在抽象层，要求开发者一开始就针对抽象层进行设计与编程.
2)桥接模式要求正确识别出系统中两个独立变化的维度（抽象和实现），因此使用有一定的局限性。