当前位置：首页 > news >正文

桥接模式_结构型_GOF23

news 2025/7/2 20:07:18

桥接模式

桥接模式（Bridge Pattern）是一种结构型设计模式，核心思想是将抽象与实现分离，使两者能独立变化。它像一座连接两岸的桥梁，让“抽象层”和“实现层”自由组合，避免因多维度变化导致的“类爆炸”问题。例如，手机型号（抽象层）和功能模块（实现层）可以独立升级，无需为每种组合创建新类。

一、通俗理解

想象你设计一款智能遥控器：

传统方式：为每个电器（电视、空调）开发专用遥控器，导致代码冗余。
桥接模式：
- 抽象层：遥控器的通用操作（开关、调音量）。
- 实现层：不同电器的具体功能（电视换台、空调调温）。
  通过桥接，一个遥控器可控制所有电器，新增电器只需扩展实现层，无需修改抽象层。

二、模式结构

桥接模式包含四个角色：

抽象化（Abstraction）：定义高层接口（如遥控器基类）。
扩展抽象化（Refined Abstraction）：扩展功能（如带定时功能的遥控器）。
实现化（Implementor）：定义底层接口（如电器开关标准）。
具体实现化（Concrete Implementor）：实现具体功能（如电视、空调）。

三、适用场景

多维度变化：如形状（圆形/矩形）×颜色（红/蓝）、支付渠道（微信/支付宝）×支付方式（扫码/密码）。
动态组合需求：运行时灵活切换抽象与实现（如跨平台应用适配不同系统）。
避免继承爆炸：替代多层类继承，提升代码可维护性。

四、代码实现

1. C++ 示例（遥控器与电器桥接）

#include <iostream>  

// 实现层：电器接口  
class Device {  
public:  
    virtual void turnOn() = 0;  
    virtual void setMode(int mode) = 0;  
};  

// 具体实现：电视  
class TV : public Device {  
public:  
    void turnOn() override { std::cout << "电视启动\n"; }  
    void setMode(int mode) override {  
        std::cout << "切换到频道：" << mode << std::endl;  
    }  
};  

// 抽象层：遥控器基类  
class RemoteControl {  
protected:  
    Device* device;  
public:  
    RemoteControl(Device* dev) : device(dev) {}  
    virtual void powerOn() { device->turnOn(); }  
    virtual void setMode(int mode) = 0;  
};  

// 扩展抽象：带数字按键的遥控器  
class AdvancedRemote : public RemoteControl {  
public:  
    AdvancedRemote(Device* dev) : RemoteControl(dev) {}  
    void setMode(int mode) override {  
        device->setMode(mode);  
    }  
};  

// 客户端  
int main() {  
    Device* tv = new TV();  
    RemoteControl* remote = new AdvancedRemote(tv);  
    remote->powerOn();        // 输出：电视启动  
    remote->setMode(5);       // 输出：切换到频道：5  
    delete tv;  
    delete remote;  
    return 0;  
}

2. Python 示例（图形绘制：形状×颜色）

from abc import ABC, abstractmethod  

# 实现层：颜色接口  
class Color(ABC):  
    @abstractmethod  
    def apply_color(self):  
        pass  

class Red(Color):  
    def apply_color(self):  
        return "红色"  

# 抽象层：形状基类  
class Shape(ABC):  
    def __init__(self, color):  
        self.color = color  

    @abstractmethod  
    def draw(self):  
        pass  

class Circle(Shape):  
    def draw(self):  
        print(f"绘制{self.color.apply_color()}的圆形")  

# 客户端  
if __name__ == "__main__":  
    red_circle = Circle(Red())  
    red_circle.draw()  # 输出：绘制红色的圆形

3. Java 示例（支付系统：渠道×方式）

// 实现层：支付方式接口  
interface PayMode {  
    boolean securityCheck(String uid);  
}  

class FacePay implements PayMode {  
    public boolean securityCheck(String uid) {  
        System.out.println("人脸识别验证通过");  
        return true;  
    }  
}  

// 抽象层：支付渠道基类  
abstract class Payment {  
    protected PayMode payMode;  
    public Payment(PayMode mode) { this.payMode = mode; }  
    public abstract void pay(String uid, double amount);  
}  

class WeChatPay extends Payment {  
    public WeChatPay(PayMode mode) { super(mode); }  
    public void pay(String uid, double amount) {  
        if (payMode.securityCheck(uid)) {  
            System.out.println("微信支付成功：" + amount);  
        }  
    }  
}  

// 客户端  
public class Client {  
    public static void main(String[] args) {  
        Payment payment = new WeChatPay(new FacePay());  
        payment.pay("user123", 100.0);  // 输出：人脸识别 → 微信支付成功  
    }  
}

五、优缺点分析

优点	缺点
1. 解耦抽象与实现，扩展性强	1. 设计复杂度高（需提前识别变化维度）
2. 动态组合对象，灵活性高	2. 需维护更多类（抽象/实现分离）
3. 避免类爆炸，符合开闭原则	3. 对简单场景可能过度设计