19. 桥接模式

定义

桥接模式(Bridge Pattern)：将抽象部分与它的实现部分分离，使它们都可以独立地变化。又称为柄体(Handle and Body)模式或接口(Interface)模式。

通俗理解

我们去下馆子的时候，总会面临很多选择。主食有粉、面；份量有大份、中份、小份；辣度有不辣、微辣、中辣、特辣。他们的组合就有2*3*4=24种之多。一般老板都不会问你，你是不是要吃小份不辣的粉、小份中辣的粉、小份微辣的粉... ...如果他这么问，估计问的人和吃饭的人都会不耐烦。

老板一般都会先问你，你是要粉还是面，如果你选了面；然后他会问你是要大份、中份还是小份？你胃口比较大，选了大份；最后他会问你，你是要不辣的、微辣的、中辣的还是特辣的？你是一个广东人，当然选了一个不辣的。于是老板就拿着一份大份不辣的面去厨房下单了。不到五分钟，你要吃的美食也就呈现到你的面前。

桥接模式就是这个过程，一个东西很多维度的时候，我们不会为每一个维度去设计一个接口，而是把他们相关的部分组合起来，出一个通用的接口。就像上面的点面一样。如果不按照桥接模式设计，那么首先是要设计一个主食的接口，然后份量继承主食的实现并实现份量的接口，最后辣度继承分量的实现并实现辣度接口，得到24个类。但是如果使用桥接模式，我们会为主食设计一个接口、为份量设计一个接口、为辣度设计一个接口，最后通过一个公用的类，把这个三个接口通过注入的方式，实现不同的组合。于是我们就能够通过方法的入参来实现不同的组合。

示例

按上面的实例作为业务。

渣渣程序

不按桥接，我们采用纯继承的形式，可以写出下面的程序。
食物类型

public interface IFoodType {
   void getFoodType();
}
public class Noodles implements IFoodType {
    @Override
    public void getFoodType() {
        System.out.println("面");
    }
}
public class RiceFlour implements IFoodType {
    @Override
    public void getFoodType() {
        System.out.println("粉");
    }
}

食物辣度

public interface IPapperType {
    void getPapperType();
}
public class NoPapperNoodles extends Noodles implements IPapperType {
    @Override
    public void getPapperType() {
        System.out.println("不辣");
    }
}
// 还有7种不同情况的食物

食物份量

public interface IWeightType {
    void weightType();
}
public class LowWeightNoPapperRiceFlour extends NoPapperRiceFlour implements IWeightType {
    @Override
    public void weightType() {
        System.out.println("小份");
    }
}
// 还有23个不同情况的食物

主入口

public class Main {
    public static void main(String[] args) {
        IWeightType food = new LowWeightNoPapperRiceFlour();
        food.weightType();
        ((LowWeightNoPapperRiceFlour) food).getPapperType();
        ((LowWeightNoPapperRiceFlour) food).getFoodType();
    }
}
//小份
//不辣
//粉

类太多了，省略

看到以上密密麻麻的class，我想大家的心情和我都是一样的，真不想写，以上程序存在下列问题：

1. 多层继承的方式，使得类无限膨胀；

2. 不利于扩展，如果店家里面的碗还有黑色的和白色的可供选择，那么还得写48个类才能实现。

优化

类图

image

程序

食物类型接口与实现

public interface IFoodType {
   void getFoodType();
   void want();
}
public class Noodles implements IFoodType {

    private IPapperType papperType;
    private IWeightType weightType;

    public Noodles(IPapperType papperType, IWeightType weightType) {
        this.papperType = papperType;
        this.weightType = weightType;
    }

    @Override
    public void getFoodType() {
        System.out.println("面");
    }

    @Override
    public void want() {
        papperType.getPapperType();
        weightType.getWeightType();
        getFoodType();
    }
}

辣度类型接口与实现

public interface IPapperType {
    void getPapperType();
}
public class LowPapper implements IPapperType {

    @Override
    public void getPapperType() {
        System.out.println("微辣");
    }
}

份量类型接口与实现

public interface IWeightType {
    void getWeightType();
}
public class LargeWeight implements IWeightType {

    @Override
    public void getWeightType() {
        System.out.println("大份");
    }
}

入口

public class Main {
    public static void main(String[] args) {
        IPapperType papperType = new HighPapper();
        IWeightType weightType = new LargeWeight();
        IFoodType foodType = new Noodles(papperType, weightType);
        foodType.want();
    }
}
//特辣
//大份
//面

优点

1. 解耦，通过组合的方式取代继承，进而实现多个组合对象；
2. 取代多层继承，减少子类的个数；
3. 提供系统的扩展性，只需要增加一个维度就可以了。

缺点

1. 难理解，彼此的关系在抽象层，需要认真设计；
2. 需要正确识别系统中独立变化的维度。

应用场景

1. 存在多个变化的维度，并且这个维度要彼此组合；
2. 不希望通过继承实现功能的。

程序

e19_bridge_pattern|给我star

https://www.jianshu.com/p/038cc5030f3c