【设计模式】结构型-桥接模式

当抽象与实现，各自独立，桥接模式，如彩虹桥，连接两岸。

文章目录

一、类爆炸与代码重复
二、桥接模式
三、桥接模式的核心组成
四、运用桥接模式
五、桥接模式的应用场景
六、小结
推荐阅读

一、类爆炸与代码重复

场景假设：假设我们正在设计一个模拟城市交通的系统。在这个系统中，我们有各种类型的桥梁，如悬索桥和拱桥，以及各种类型的车辆，如汽车和自行车。我们希望能够模拟各种车辆在各种桥梁上行驶的情况。

// SuspensionBridgeCar 类代表在悬索桥上驾驶汽车的情况
class SuspensionBridgeCar {
    public void drive() {
        System.out.println("Driving a car on a suspension bridge");
    }
}

// ArchBridgeCar 类代表在拱桥上驾驶汽车的情况
class ArchBridgeCar {
    public void drive() {
        System.out.println("Driving a car on an arch bridge");
    }
}

// SuspensionBridgeBicycle 类代表在悬索桥上骑自行车的情况
class SuspensionBridgeBicycle {
    public void drive() {
        System.out.println("Riding a bicycle on a suspension bridge");
    }
}

// ArchBridgeBicycle 类代表在拱桥上骑自行车的情况
class ArchBridgeBicycle {
    public void drive() {
        System.out.println("Riding a bicycle on an arch bridge");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建一个 SuspensionBridgeCar 对象来模拟在悬索桥上驾驶汽车的情况
        SuspensionBridgeCar suspensionBridgeCar = new SuspensionBridgeCar();
        suspensionBridgeCar.drive();  // 输出: "Driving a car on a suspension bridge"

        // 创建一个 ArchBridgeBicycle 对象来模拟在拱桥上骑自行车的情况
        ArchBridgeBicycle archBridgeBicycle = new ArchBridgeBicycle();
        archBridgeBicycle.drive();  // 输出: "Riding a bicycle on an arch bridge"

        // 如果我们想要添加新的桥梁类型或车辆类型，我们需要创建更多的类
        // 例如，如果我们想要添加“跳绳桥”和“摩托车”，我们需要创建四个新的类：
        // JumpRopeBridgeCar, JumpRopeBridgeBicycle, SuspensionBridgeMotorcycle, ArchBridgeMotorcycle
    }
}

在这个例子中，我们可以看到以下问题：

类的数量爆炸：我们需要为每种桥梁和车辆的组合创建一个新的类。这使得代码难以管理和维护。
代码重复：在每个子类中，我们可能需要重复相同的代码，这违反了 DRY（Don`t Repeat Yourself）原则。

二、桥接模式

桥接模式是一种结构型设计模式，它主要解决的是“将抽象部分与实现部分分离，使它们可以独立地变化”。它通过提供一个桥接结构，把抽象和实现解耦，使得二者可以独立地变化和复用。

在桥接模式中，有两个独立变化的维度：抽象化（Abstraction）和实现化（Implementation）。抽象化是主要的业务逻辑，而实现化是抽象化依赖的底层实现。桥接模式的目标是将这两个维度分离，使它们可以独立地变化和复用，而不是创建一个包含所有可能组合的类。

三、桥接模式的核心组成

桥接模式由以下几个关键角色组成：

抽象类（Abstraction）： 定义了抽象部分的接口，并包含一个指向实现部分对象的引用。抽象类可以包含一些基本操作，而具体的实现则由实现部分提供。
扩展抽象类（Refined Abstraction）： 是对抽象类的扩展，可以添加更多的功能或细化抽象类定义的接口。扩展抽象类通过调用实现部分对象的方法来实现具体的功能。
实现接口（Implementor）： 定义了实现部分的接口，通常包含一组操作方法。实现接口不关心抽象部分的接口，它只负责实现具体的功能。
具体实现类（Concrete Implementor）： 实现了实现接口的具体功能。具体实现类负责实现实现接口定义的操作方法，并与抽象部分的接口进行对应。

在这里插入图片描述

在这个类图中：

Abstraction 是抽象化角色，它定义了基于 Implementor 接口（实现化角色）的高级操作。
RefinedAbstraction 是扩展抽象化角色，它提供了对 Implementor 的具体实现。
Implementor 是实现化角色，它定义了抽象化角色依赖的底层操作。
ConcreteImplementorA 和 ConcreteImplementorB 是具体实现化角色，它们实现了 Implementor 接口。

四、运用桥接模式

创建实现接口： 在桥接模式中，首先我们需要创建一个实现接口，该接口定义了实现部分的操作方法。

interface Vehicle {
    // 这个接口定义了一些方法，这些方法将在具体的实现类中实现。
    void operate();
}

创建具体实现类： 接着，我们需要创建具体实现类，实现实现接口中定义的具体功能。

// `Car`实现了`Vehicle`接口，它提供了`operate`方法的具体实现。
class Car implements Vehicle {
    public void operate() {
        System.out.println("car");
    }
}

// `Bicycle`也实现了`Vehicle`接口，它的实现方式与`Car`类似。
class Bicycle implements Vehicle {
    public void operate() {
        System.out.println("bicycle");
    }
}

创建抽象类： 接下来，我们创建一个抽象类，该类将持有一个实现接口的引用，并提供一些操作方法，这些方法将委托给实现接口来实现具体的功能。

abstract class Bridge {
    // 这个类包含一个`Vehicle`类型的成员变量，这个变量是实现部分的接口。
    protected Vehicle vehicle;

    // 构造函数接收一个`Vehicle`对象，并将其赋值给成员变量。
    public Bridge(Vehicle vehicle) {
        this.vehicle = vehicle;
    }

    // 定义抽象方法`drive`，具体的实现将在子类中完成。
    public abstract void drive();
}

创建具体实现类： 进一步，我们创建具体实现类，继承自抽象类，并实现抽象类中的抽象方法。

// `SuspensionBridge`是`Bridge`的子类，它实现了`drive`方法。
class SuspensionBridge extends Bridge {
    public SuspensionBridge(Vehicle vehicle) {
        super(vehicle);
    }

    public void drive() {
        System.out.print("Driving on a suspension bridge in a ");
        vehicle.operate();
    }
}

// `ArchBridge`也是`Bridge`的子类，它的实现方式与`SuspensionBridge`类似。
class ArchBridge extends Bridge {
    public ArchBridge(Vehicle vehicle) {
        super(vehicle);
    }

    public void drive() {
        System.out.print("Driving on an arch bridge in a ");
        vehicle.operate();
    }
}

在客户端使用桥接模式： 最后，在客户端代码中使用桥接模式，通过创建具体的对象并调用其方法来操作电视。

// 在客户端代码中，我们创建了一个`SuspensionBridge`对象和一个`Car`对象，并将它们组合在一起。
public class Main {
    public static void main(String[] args) {
        Bridge bridge = new SuspensionBridge(new Car());
        bridge.drive();  // Output: "Driving on a suspension bridge in a car"
    }
}

通过上面的桥接模式，通过将抽象（桥梁）和实现（车辆）分离，使它们可以独立地变化。这样，可以更灵活地添加新的桥梁或车辆，而不需要为每种组合创建一个新的类。

五、桥接模式的应用场景

桥接模式主要适用于以下几种场景：

独立变化的维度：当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时，可以使用桥接模式。
不希望使用多重继承或因多重继承导致的类爆炸：桥接模式可以替代多重继承方案，它减少了子类的个数。
接口或抽象类不稳定：如果系统的抽象部分和具体部分需要独立地变化，那么桥接模式可以保证系统的持续运行。
重用性要求较高：桥接模式中的抽象部分和实现部分都可以独立地扩展，这有助于提高系统的重用性。

以下是一些具体的应用场景：

跨平台图形和文字处理软件：在这种软件中，形状和颜色、字体和字号等因素可以独立变化，使用桥接模式可以将这些因素的实现从抽象中分离出来，使得它们可以独立地变化。

// 形状的抽象类
abstract class Shape {
    protected Color color;

    protected Shape(Color color) {
        this.color = color;
    }

    abstract void draw();
}

// 圆形
class Circle extends Shape {
    protected Circle(Color color) {
        super(color);
    }

    void draw() {
        System.out.println("Draw a circle with " + color.getColor());
    }
}

// 矩形
class Rectangle extends Shape {
    protected Rectangle(Color color) {
        super(color);
    }

    void draw() {
        System.out.println("Draw a rectangle with " + color.getColor());
    }
}

// 颜色的接口
interface Color {
    String getColor();
}

// 红色
class Red implements Color {
    public String getColor() {
        return "red";
    }
}

// 蓝色
class Blue implements Color {
    public String getColor() {
        return "blue";
    }
}

public static void main(String[] args) {
    Shape redCircle = new Circle(new Red());
    redCircle.draw();

    Shape blueRectangle = new Rectangle(new Blue());
    blueRectangle.draw();
}

驱动程序：驱动程序中的操作系统和硬件设备是两个独立变化的维度，使用桥接模式可以将它们分离，使得操作系统可以在不同的硬件设备上运行，同时硬件设备也可以接入不同的操作系统。

// 操作系统的抽象类
abstract class OperatingSystem {
    protected Device device;

    protected OperatingSystem(Device device) {
        this.device = device;
    }

    abstract void run();
}

// Windows 操作系统
class Windows extends OperatingSystem {
    protected Windows(Device device) {
        super(device);
    }

    void run() {
        System.out.println("Run Windows on " + device.getDevice());
    }
}

// Linux 操作系统
class Linux extends OperatingSystem {
    protected Linux(Device device) {
        super(device);
    }

    void run() {
        System.out.println("Run Linux on " + device.getDevice());
    }
}

// 硬件设备的接口
interface Device {
    String getDevice();
}

// Dell 设备
class Dell implements Device {
    public String getDevice() {
        return "Dell";
    }
}

// HP 设备
class HP implements Device {
    public String getDevice() {
        return "HP";
    }
}

public static void main(String[] args) {
    OperatingSystem windowsOnDell = new Windows(new Dell());
    windowsOnDell.run();

    OperatingSystem linuxOnHP = new Linux(new HP());
    linuxOnHP.run();
}

数据库连接：在数据库连接中，数据库类型（如 MySQL、Oracle）和连接方式（如 ODBC、JDBC）是两个独立变化的维度，使用桥接模式可以将它们分离，使得可以灵活地组合不同的数据库类型和连接方式。

// 数据库的抽象类
abstract class Database {
    protected Connection connection;

    protected Database(Connection connection) {
        this.connection = connection;
    }

    abstract void connect();
}

// MySQL 数据库
class MySQL extends Database {
    protected MySQL(Connection connection) {
        super(connection);
    }

    void connect() {
        System.out.println("Connect to MySQL with " + connection.getConnection());
    }
}

// Oracle 数据库
class Oracle extends Database {
    protected Oracle(Connection connection) {
        super(connection);
    }

    void connect() {
        System.out.println("Connect to Oracle with " + connection.getConnection());
    }
}

// 连接方式的接口
interface Connection {
    String getConnection();
}

// ODBC 连接
class ODBC implements Connection {
    public String getConnection() {
        return "ODBC";
    }
}

// JDBC 连接
class JDBC implements Connection {
    public String getConnection() {
        return "JDBC";
    }
}

public static void main(String[] args) {
    Database mySqlWithODBC = new MySQL(new ODBC());
    mySqlWithODBC.connect();

    Database oracleWithJDBC = new Oracle(new JDBC());
    oracleWithJDBC.connect();
}