【设计模式|结构型】桥接模式（Bridge Pattern）

背景

假设我们有一个汽车制造公司，该公司可以生产多种型号的汽车，例如轿车、SUV和卡车。同时，公司也提供了多种颜色的汽车，例如红色、蓝色和黑色。后续还会可能会增加车型或者增加颜色。这时，可以使用桥接模式。

概述

桥接模式（Bridge Pattern）是一种结构型设计模式，将抽象部分和实现部分分离，使它们可以独立地变化。桥接模式通过将继承关系转化为关联关系，将抽象部分和实现部分分离开来，从而使它们可以独立地变化。这种分离使得抽象部分和实现部分可以独立地扩展和修改，互不影响。

桥接模式由两个独立的层次结构组成：抽象部分和实现部分。抽象部分定义了抽象类和接口，它包含了对实现部分的引用，并且定义了抽象方法。实现部分定义了接口和具体类，它实现了抽象部分定义的接口，并且提供了具体的实现。抽象部分和实现部分之间通过关联关系进行连接。

说白了，桥接模式使多对多的复杂场景能够解耦，使得它们可以独立地变化，从而更加灵活和可扩展。再举几个例子：

• 手机充电器：不同型号的手机可以使用不同类型的插头进行充电。
• 消息通知系统：不同的消息通知方式可以发送不同类型的消息内容。
• 图形绘制工具：不同类型的图形可以使用不同的绘制工具进行绘制。
• 音频播放器：不同格式的音频可以使用不同的播放器进行播放。

示例一

以汽车制造公司为例

// 实现颜色接口
interface Color {
    void applyColor();
}

// 具体颜色实现类
class RedColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("Applying red color");
    }
}

class BlueColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("Applying blue color");
    }
}

class BlackColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("Applying black color");
    }
}

// 抽象汽车类
abstract class Car {
    protected Color color;

    public Car(Color color) {
        this.color = color;
    }

    abstract void manufacture();
}

// 具体汽车实现类
class SedanCar extends Car {
    public SedanCar(Color color) {
        super(color);
    }

    @Override
    void manufacture() {
        System.out.print("Manufacturing sedan car. ");
        color.applyColor();
    }
}

class SUVCar extends Car {
    public SUVCar(Color color) {
        super(color);
    }

    @Override
    void manufacture() {
        System.out.print("Manufacturing SUV car. ");
        color.applyColor();
    }
}

class TruckCar extends Car {
    public TruckCar(Color color) {
        super(color);
    }

    @Override
    void manufacture() {
        System.out.print("Manufacturing truck car. ");
        color.applyColor();
    }
}

// 示例
public class BridgePatternExample {
    public static void main(String[] args) {
        Color redColor = new RedColor();
        Color blueColor = new BlueColor();
        Color blackColor = new BlackColor();

        Car sedanCar = new SedanCar(redColor);
        sedanCar.manufacture();

        Car suvCar = new SUVCar(blueColor);
        suvCar.manufacture();

        Car truckCar = new TruckCar(blackColor);
        truckCar.manufacture();
    }
}

输出结果：

Manufacturing sedan car. Applying red color
Manufacturing SUV car. Applying blue color
Manufacturing truck car. Applying black color 

示例二

抽象电视和具体电视机制造厂商：电视可以是液晶、等离子和CRT电视机，而抽象电视可以根据不同的电视制造厂商进行操作。

首先定义一个抽象类，代表抽象部分：

public abstract class TV {
    protected Manufacturer manufacturer;

    protected TV(Manufacturer manufacturer) {
        this.manufacturer = manufacturer;
    }

    public abstract void produce();
}

接下来定义一个实现部分的接口：

public interface Manufacturer {
    public void manufacture();
}

为抽象类和接口添加具体的实现，如下所示：

public class Sony implements Manufacturer {
    public void manufacture() {
        System.out.println("Manufacturing TV by Sony");
    }
}

public class Samsung implements Manufacturer {
    public void manufacture() {
        System.out.println("Manufacturing TV by Samsung");
    }
}

最后，我们将实现部分的具体实现注入到抽象类中，如下所示：

public class SmartTV extends TV {
    public SmartTV(Manufacturer manufacturer) {
        super(manufacturer);
    }

    public void produce() {
        System.out.print("Producing Smart TV... ");
        manufacturer.manufacture();
    }
}

现在，我们可以使用桥接模式来生产不同制造商的智能电视，如下所示：

public class BridgePatternDemo {
    public static void main(String[] args) {
        TV sonySmartTV = new SmartTV(new Sony());
        sonySmartTV.produce();

        TV samsungSmartTV = new SmartTV(new Samsung());
        samsungSmartTV.produce();
    }
}

输出结果为：

Producing Smart TV... Manufacturing TV by Sony
Producing Smart TV... Manufacturing TV by Samsung