设计模式（结构型）---桥接模式

概述

桥接模式的定义：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

举例说明

假设有两种包，品牌分别是Coach与Prada，种类有钱包，单肩包，双肩包，颜色有红色，黄色，蓝色，那么一共有233=18种，需要新建18个类来买描述这些产品吗，如果颜色又增加了1个黑色，一共有234=24种，描述产品的类的数量会迅速膨胀，为避免类的数量激增，需要使用组合关系代替继承关系
关系图如下

定义Color接口

/**
 * 颜色
 */
public interface Color {

    void getColor();

}

红色

public class RedColor implements Color {
    @Override
    public void getColor() {
        System.out.print("红色");
    }
}

蓝色

public class BlueColor implements Color {
    @Override
    public void getColor() {
        System.out.print("蓝色");
    }
}

黄色

public class YellowColor implements Color {
    @Override
    public void getColor() {
        System.out.print("黄色");
    }
}

定义种类Type接口

/**
 * 种类
 */
public interface Type {

    void getType();

}

钱包

public class Wallet implements Type {
    @Override
    public void getType() {
        System.out.println("钱包");
    }
}

单肩包

public class HandBag implements Type {
    @Override
    public void getType() {
        System.out.println("单肩包");
    }
}

双肩包

public class BackPack implements Type {
    @Override
    public void getType() {
        System.out.println("双肩包");
    }
}

定义Bag抽象类，持有Color与Type类型的成员变量

public abstract class Bag {

    protected Color color;

    protected Type type;

    public void setColor(Color color){
        this.color = color;
    }

    public void setType(Type type){
        this.type = type;
    }

    abstract public void getBagName();

}

CoachBag类

public class CoachBag extends Bag{

    public CoachBag(Color color, Type type){
        super.setColor(color);
        super.setType(type);
    }

    @Override
    public void getBagName() {
        color.getColor();
        System.out.print("Coach");
        type.getType();
    }
}

PradaBag

public class PradaBag extends Bag{

    public PradaBag(Color color, Type type){
        super.setColor(color);
        super.setType(type);
    }

    @Override
    public void getBagName() {
        color.getColor();
        System.out.print("Prada");
        type.getType();
    }
}

测试

public class BridgeTest {
    public static void main(String[] args) {
        Bag redCoachWallet = new CoachBag(new RedColor(), new Wallet());
        redCoachWallet.getBagName();

        Bag redCoachHandBag = new CoachBag(new RedColor(), new HandBag());
        redCoachHandBag.getBagName();

        Bag redCoachBackPack = new CoachBag(new RedColor(), new BackPack());
        redCoachBackPack.getBagName();

        Bag yellowCoachWallet = new CoachBag(new YellowColor(), new Wallet());
        yellowCoachWallet.getBagName();

        Bag yellowCoachHandBag = new CoachBag(new YellowColor(), new HandBag());
        yellowCoachHandBag.getBagName();

        Bag yellowCoachBackPack = new CoachBag(new YellowColor(), new BackPack());
        yellowCoachBackPack.getBagName();

        Bag blueCoachWallet = new CoachBag(new BlueColor(), new Wallet());
        blueCoachWallet.getBagName();

        Bag blueCoachHandBag = new CoachBag(new BlueColor(), new HandBag());
        blueCoachHandBag.getBagName();

        Bag blueCoachBackPack = new CoachBag(new BlueColor(), new BackPack());
        blueCoachBackPack.getBagName();
    }
}

输出

8个类的组合可以产生18种产品，有效避免了类数量的膨胀。

优缺点

优点

抽象与实现分离，扩展能力强
符合开闭原则
符合合成复用原则
其实现细节对客户透明

缺点

由于聚合关系建立在抽象层，要求开发者针对抽象化进行设计与编程，能正确地识别出系统中两个独立变化的维度，这增加了系统的理解与设计难度。