桥梁模式

介绍

桥梁模式的定义是讲抽象和实现解耦，使得两者可以独立的变化。常用语多层次继承结构中，由于变化导致类图增长很多的情况。

例子

例如设计一个生产衣服的程序，衣服有各自的品牌，而每个品牌都会生产裤子，t-shirt, polo衫等，当冬天来临需要生产夹克时，我们需要对两个品牌的衣服进行扩展，使得他们有个各自的夹克衣服。那么需要新增两个品牌的夹克扩展类。类图层次如下。

如果需要新增一个品牌，那么该品牌需要重新增加对现有衣服所有的实现类。系统将会越来越庞大。这里需要对系统重新进行抽象化，品牌应该和具体的衣服是分开的模块，品牌变化和衣服变化都只应该影响到自身，衣服增加不影响品牌变化，新增一个品牌也不应该在扩展已有的所有的衣服类型。

新的类图

实现

定义Clothes衣服接口

public interface Clothes {
    void produce();
}

定义PoloClothes，实现Clothes接口

public class PoloClothes implements Clothes{
    @Override
    public void produce() {
        System.out.println("生产Polo衣服");
    }
}

定义ShirtColthes，实现Clothes接口

public class ShirtClothes implements Clothes {
    @Override
    public void produce() {
        System.out.println("生产t-shirt");
    }
}

定义品牌类Brand,Brand类是关联到Clothes类，通过构造函数来传递。Brand类有一个show方法，依赖于Clothes类的方法。

public class Brand {
    private Clothes clothes;

    public Brand(Clothes clothes) {
        this.clothes = clothes;
    }

    public void show() {
        this.clothes.produce();
    }
}
 

定义一个Brand子类，Brand1

public class Brand1 extends Brand{
    public Brand1(Clothes clothes) {
        super(clothes);
    }

    @Override
    public void show() {
        super.show();
        System.out.println("这是品牌1生产的衣服");
    }
}

定义一个Brand子类，Brand2

public class Brand2 extends Brand{
    public Brand2(Clothes clothes) {
        super(clothes);
    }

    @Override
    public void show() {
        super.show();
        System.out.println("这是品牌2生产的衣服");
    }
}

定义场景类,创建了两个Clothes实例,Polo衣服和T-shirt衣服,然后创建的不同的Brand都能用到上述衣服。

public class Client {
    public static void main(String[] args) {
        Clothes poloClothes = new PoloClothes();
        Clothes shirtClothes = new ShirtClothes();

        Brand brand1 = new Brand1(poloClothes);
        brand1.show();

        brand1 = new Brand1(shirtClothes);
        brand1.show();

        System.out.println("==============");
        Brand2 brand2 = new Brand2(poloClothes);
        brand2.show();

        brand2 = new Brand2(shirtClothes);
        brand2.show();
    }
}

那么对于新增的Brand，比如Brand3,他就只需要继承于Brand就行，不用像上面提到的要对Polo和T-shirt等实现。
如图：

public class Brand3 extends Brand{
    public Brand3(Clothes clothes) {
        super(clothes);
    }

    @Override
    public void show() {
        super.show();
        System.out.println("这是品牌3生产的衣服");
    }
}

那么场景类变化如下：

public class Client {
    public static void main(String[] args) {
        Clothes poloClothes = new PoloClothes();
        Clothes shirtClothes = new ShirtClothes();

        Brand brand1 = new Brand1(poloClothes);
        brand1.show();

        brand1 = new Brand1(shirtClothes);
        brand1.show();

        System.out.println("==============");
        Brand2 brand2 = new Brand2(poloClothes);
        brand2.show();

        brand2 = new Brand2(shirtClothes);
        brand2.show();

        System.out.println("==============");
        Brand brand3 = new Brand3(poloClothes);
        brand3.show();

        brand3 = new Brand3(shirtClothes);
        brand3.show();
    }
}

优缺点

他是为了解决继承的缺点而提出的设计模式。在该模式下，实现可以不受抽象的约束，不用再绑定在一个固定的抽象层次上。对于重用性较高的场景适用度较高。