本文介绍桥接模式的概念和应用。

基本思想和原则

将抽象和实现解耦，使得两者可以独立地变化。

动机

当抽象和具体实现无法很好契合时，使用继承会导致产生过多的类，此时可以考虑使用桥接模式，使用聚合的方式来连接抽象和具体实现。另外当对重用性有较高要求时也可以使用桥接模式。

实现

public abstract class Factory {
    IElectronicProduct electronicProduct;

    public Factory(IElectronicProduct electronicProduct) {
        this.electronicProduct = electronicProduct;
    }

    public void produce() {
        this.electronicProduct.beProduced();
    }

    public IElectronicProduct getElectronicProduct() {
        return this.electronicProduct;
    }
}

public class ElectronicProductFactory extends Factory {
    public ElectronicProductFactory(IElectronicProduct electronicProduct) {
        super(electronicProduct);
    }

    @Override
    public void produce() {
        super.produce();
        super.getElectronicProduct().beUsed();
    }
}

public interface IElectronicProduct {
    public void beProduced();
    public void beUsed();
}

public class Radio implements IElectronicProduct {
    @Override
    public void beProduced() {
        System.out.println("Radio be produced.");
    }

    @Override
    public void beUsed() {
        System.out.println("Radio be used.");
    }
}

public class Television implements IElectronicProduct {
    @Override
    public void beProduced() {
        System.out.println("Television be produced.");
    }

    @Override
    public void beUsed() {
        System.out.println("Television be used.");
    }
}

public class Test {
    public static void main(String[] args) {
        Factory electronicProductFactory1 = new ElectronicProductFactory(new Radio());
        electronicProductFactory1.produce();

        Factory electronicProductFactory2 = new ElectronicProductFactory(new Television());
        electronicProductFactory2.produce();
    }
}

输出如下：

Radio be produced.
Radio be used.
Television be produced.
Television be used.

上面代码模拟了一个工厂生产电子产品的场景，抽象类Factory内部聚合了一个实现了IElectronicProduct接口的类的对象，我们可以自由增加具体的产品类，只要实现了IElectronicProduct这个接口即可。同样只要抽象层和具体实现之间的接口不变，这里指的是Factory类的produce方法，抽象层和具体实现就可以各自独立变化互不影响。

优点

桥接模式通过将抽象层聚合具体实现的方式来将抽象和实现分离，使二者可以独立扩展。另外封装了具体实现，使之不会暴露给外部，具有很好的封装性。