【详解】JAVA设计模式桥接模式（Bridge）

原创

大盘鸡拌面

发布于 2025-03-14 20:11:32

6210

JAVA设计模式桥接模式（Bridge）

在面向对象的设计中，设计模式是一种在特定情况下解决设计问题的通用可重用方案。本文将介绍一种结构型设计模式——桥接模式（Bridge Pattern）。桥接模式用于将抽象部分与实现部分分离，使它们可以独立变化。

1. 桥接模式简介

桥接模式的主要目的是将抽象化（Abstraction）与实现化（Implementor）脱耦，使得二者可以独立地变化。这种类型的设计模式属于结构型模式，因为它通过提供一种结构来组合类或对象。

1.1 主要角色

Abstraction（抽象类）：定义了抽象类的接口，并且持有一个对实现化对象的引用。
RefinedAbstraction（扩展抽象类）：扩展了抽象类，实现了更具体的业务逻辑。
Implementor（实现化接口）：定义了实现化对象的接口，具体实现类需要实现这个接口。
ConcreteImplementor（具体实现化）：实现了实现化接口，提供了具体的实现方法。

2. 实际场景

假设我们正在开发一个图形编辑器，需要支持多种类型的图形（如圆形、矩形等），并且每种图形都可以有不同的绘制方式（如普通绘制、高亮绘制等）。如果不使用桥接模式，可能会导致类的爆炸性增长，因为每增加一个新的图形或者新的绘制方式，都需要新增多个类来支持这些组合。

使用桥接模式，我们可以将图形的形状和绘制方式分开，让它们各自独立变化，从而减少类的数量，提高系统的灵活性。

3. 示例代码

3.1 定义实现化接口

// Implementor 接口
public interface DrawAPI {
    void drawCircle(int radius, int x, int y);
}

3.2 具体实现化

// ConcreteImplementor A
public class RedCircle implements DrawAPI {
    @Override
    public void drawCircle(int radius, int x, int y) {
        System.out.println("Drawing Circle[ color: red, radius: " + radius + ", x: " + x + ", " + y + "]");
    }
}

// ConcreteImplementor B
public class GreenCircle implements DrawAPI {
    @Override
    public void drawCircle(int radius, int x, int y) {
        System.out.println("Drawing Circle[ color: green, radius: " + radius + ", x: " + x + ", " + y + "]");
    }
}

3.3 定义抽象类

// Abstraction
public abstract class Shape {
    protected DrawAPI drawAPI;

    protected Shape(DrawAPI drawAPI){
        this.drawAPI = drawAPI;
    }

    public abstract void draw();
}

3.4 扩展抽象类

// RefinedAbstraction
public class Circle extends Shape {
    private int x, y, radius;

    public Circle(int x, int y, int radius, DrawAPI drawAPI) {
        super(drawAPI);
        this.x = x;
        this.y = y;
        this.radius = radius;
    }

    @Override
    public void draw() {
        drawAPI.drawCircle(radius,x,y);
    }
}

3.5 使用桥接模式

public class BridgePatternDemo {
    public static void main(String[] args) {
        Shape redCircle = new Circle(100,100, 10, new RedCircle());
        Shape greenCircle = new Circle(100,100, 10, new GreenCircle());

        redCircle.draw();
        greenCircle.draw();
    }
}

桥接模式通过将抽象部分与实现部分分离，使得它们可以独立变化，从而提高了系统的灵活性和可扩展性。在实际开发中，当遇到类的组合导致类数量急剧增加时，可以考虑使用桥接模式来简化系统设计，降低维护成本。

这种模式在需要动态地给一个对象增加功能，或希望用户可以独立地选择不同的实现时非常有用。

实际应用场景

假设我们正在开发一个图形编辑器，这个编辑器需要支持多种图形（如圆形、矩形等），并且每种图形还可以有不同的绘制方式（如使用不同的颜色或填充样式）。我们可以使用桥接模式来实现这个需求，这样可以在不修改现有代码的情况下，轻松地添加新的图形或绘制方式。

桥接模式的基本结构

抽象部分（Abstraction）：定义了高层接口，它维护了一个对实现部分的引用。
细化抽象部分（Refined Abstraction）：扩展了抽象部分，提供了更多的功能。
实现部分（Implementor）：定义了实现类的接口，具体实现类必须实现这个接口。
具体实现部分（Concrete Implementor）：实现了实现部分接口的具体类。

示例代码

1. 实现部分（Implementor）

// 绘制接口
public interface DrawAPI {
    void drawCircle(int radius, int x, int y);
}

2. 具体实现部分（Concrete Implementor）

// 红色绘制实现
public class RedCircle implements DrawAPI {
    @Override
 public void drawCircle(int radius, int x, int y) {
        System.out.println("Drawing Circle[ color: red, radius: " + radius + ", x: " + x + ", y: " + y + "]");
    }
}

// 绿色绘制实现
public class GreenCircle implements DrawAPI {
    @Override
    public void drawCircle(int radius, int x, int y) {
        System.out.println("Drawing Circle[ color: green, radius: " + radius + ", x: " + x + ", y: " + y + "]");
    }
}

3. 抽象部分（Abstraction）

// 图形抽象类
public abstract class Shape {
    protected DrawAPI drawAPI;

    protected Shape(DrawAPI drawAPI) {
        this.drawAPI = drawAPI;
    }

    public abstract void draw();
}

4. 细化抽象部分（Refined Abstraction）

// 圆形类
public class Circle extends Shape {
    private int x, y, radius;

    public Circle(int x, int y, int radius, DrawAPI drawAPI) {
        super(drawAPI);
        this.x = x;
        this.y = y;
        this.radius = radius;
    }

    @Override
    public void draw() {
        drawAPI.drawCircle(radius, x, y);
    }
}

5. 客户端代码

public class BridgePatternDemo {
    public static void main(String[] args) {
        // 创建红色圆
        Shape redCircle = new Circle(100, 100, 50, new RedCircle());
        redCircle.draw();

        // 创建绿色圆
        Shape greenCircle = new Circle(150, 150, 40, new GreenCircle());
        greenCircle.draw();
    }
}

运行结果

Drawing Circle[ color: red, radius: 50, x: 100, y: 100]
Drawing Circle[ color: green, radius: 40, x: 150, y: 150]

解释

DrawAPI 接口定义了绘制圆形的方法。
RedCircle 和 GreenCircle 是具体的实现类，分别实现了红色和绿色的绘制方法。
Shape 是抽象类，维护了一个 DrawAPI 的引用，并提供了一个抽象的 draw 方法。
Circle 是具体的形状类，继承自 Shape，并实现了 draw 方法，调用 DrawAPI 的 drawCircle 方法。
BridgePatternDemo 是客户端代码，创建了不同颜色的圆形对象并调用 draw 方法进行绘制。

通过这种方式，我们可以轻松地添加新的图形或绘制方式，而不需要修改现有的代码。这就是桥接模式的优势。桥接模式（Bridge Pattern）是结构型设计模式之一，它的目的是将抽象部分与实现部分分离，使它们可以独立变化。这种类型的设计模式涉及到一个继承层次结构，该层次结构由于其实现细节而不能改变。桥接模式可以将这些实现细节从抽象中解耦，从而使两者可以独立地变化。

桥接模式的组成

Abstraction（抽象类）：定义了抽象类的接口，并且持有一个对Implementor（实现类接口）的引用。
RefinedAbstraction（扩展抽象类）：扩展了Abstraction，实现了在Abstraction中定义的业务方法。
Implementor（实现类接口）：定义了实现类的接口，这个接口不一定要与Abstraction的接口完全一致；事实上这两个接口可以完全不同。通常情况下，Implementor接口仅提供基本操作，而Abstraction定义的接口提供了基于这些基本操作的更高层次的操作。
ConcreteImplementor（具体实现类）：实现了Implementor接口，具体提供实现类的实现方法。

示例代码

假设我们正在开发一个图形绘制程序，需要支持不同类型的图形（如圆形、方形等），并且每种图形都可以用不同的颜色来绘制。我们可以使用桥接模式来设计这个系统，以避免大量子类的组合问题。

1. 实现类接口 (Implementor)

public interface Color {
    void applyColor();
}

2. 具体实现类 (ConcreteImplementor)

public class RedColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("Red color applied");
    }
}

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

3. 抽象类 (Abstraction)

public abstract class Shape {
    protected Color color;

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

    public abstract void draw();
}

4. 扩展抽象类 (RefinedAbstraction)

public class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }

    @Override
    public void draw() {
        System.out.print("Circle drawn - ");
        color.applyColor();
    }
}

public class Square extends Shape {
    public Square(Color color) {
        super(color);
    }

    @Override
    public void draw() {
        System.out.print("Square drawn - ");
        color.applyColor();
    }
}

5. 客户端代码

public class BridgePatternDemo {
    public static void main(String[] args) {
        Shape redCircle = new Circle(new RedColor());
        Shape blueSquare = new Square(new BlueColor());

        redCircle.draw();  // 输出: Circle drawn - Red color applied
        blueSquare.draw(); // 输出: Square drawn - Blue color applied
    }
}

在这个例子中，Shape 是抽象类，它依赖于 Color 接口。Circle 和 Square 是 Shape 的具体实现，而 RedColor 和 BlueColor 则是 Color 接口的具体实现。通过这种方式，形状和颜色的变化可以独立进行，不会相互影响，从而提高了系统的灵活性和可扩展性。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

腾讯技术创作特训营S12#AI进化论

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

腾讯技术创作特训营S12#AI进化论

登录后参与评论

0 条评论

热度