【设计模式】【结构型模式（Structural Patterns）】之桥接模式（Bridge Pattern

1. 设计模式原理说明

桥接模式（Bridge Pattern） 是一种结构型设计模式，用于将抽象部分与实现部分分离，使它们可以独立变化。这种模式有助于解决因实现细节的变化而导致的代码膨胀问题。桥接模式的核心思想是通过组合而不是继承来达到解耦的目的，从而提高系统的灵活性和可扩展性。

主要角色

Abstraction（抽象类）：定义了抽象类的接口，并持有一个对实现部分的引用。
RefinedAbstraction（扩展抽象类）：扩展了抽象类，可能包含更多的业务逻辑或责任。
Implementor（实现接口）：定义了实现类的接口，通常由多个具体实现类实现。
ConcreteImplementorA/B（具体实现类）：实现了 Implementor 接口，提供了具体的实现。

2. UML 类图及解释

UML 类图

+-----------------+                +-----------------+
|   Abstraction   |                | Implementor     |
|-----------------|                |-----------------|
| - implementor: Implementor       | + operation(): void|
| + operation(): void              |                   |
+-----------------+                +-----------------+^                             ^|                             ||                             |v                             v
+-----------------+                +-----------------+
| RefinedAbstraction|              | ConcreteImplementorA |
|-----------------|                |-----------------|
| + refinedOperation(): void       | + operation(): void |
+-----------------+                +-----------------++||v
+-----------------+
| ConcreteImplementorB |
|-----------------|
| + operation(): void |
+-----------------+

类图解释

Abstraction：定义了抽象类的接口，并持有一个对 Implementor 的引用。客户端通过这个接口与具体实现进行交互。
RefinedAbstraction：扩展了 Ab abstraction，可能包含更多的业务逻辑或责任。
Implementor：定义了实现类的接口，通常由多个具体实现类实现。
ConcreteImplementorA 和 ConcreteImplementorB：实现了 Implementor 接口，提供了具体的实现。

3. 代码案例及逻辑详解

Java 代码案例

// 实现接口
interface Implementor {void operation();
}// 具体实现类 A
class ConcreteImplementorA implements Implementor {@Overridepublic void operation() {System.out.println("ConcreteImplementorA operation");}
}// 具体实现类 B
class ConcreteImplementorB implements Implementor {@Overridepublic void operation() {System.out.println("ConcreteImplementorB operation");}
}// 抽象类
abstract class Abstraction {protected Implementor implementor;public Abstraction(Implementor implementor) {this.implementor = implementor;}public abstract void operation();
}// 扩展抽象类
class RefinedAbstraction extends Abstraction {public RefinedAbstraction(Implementor implementor) {super(implementor);}@Overridepublic void operation() {implementor.operation();}
}// 客户端
public class Client {public static void main(String[] args) {Implementor implA = new ConcreteImplementorA();Implementor implB = new ConcreteImplementorB();Abstraction abstraction = new RefinedAbstraction(implA);abstraction.operation(); // 输出: ConcreteImplementorA operationabstraction = new RefinedAbstraction(implB);abstraction.operation(); // 输出: ConcreteImplementorB operation}
}

C++ 代码案例

#include <iostream>// 实现接口
class Implementor {
public:virtual void operation() = 0;virtual ~Implementor() {}
};// 具体实现类 A
class ConcreteImplementorA : public Implementor {
public:void operation() override {std::cout << "ConcreteImplementorA operation" << std::endl;}
};// 具体实现类 B
class ConcreteImplementorB : public Implementor {
public:void operation() override {std::cout << "ConcreteImplementorB operation" << std::endl;}
};// 抽象类
class Abstraction {
protected:Implementor* implementor;public:Abstraction(Implementor* impl) : implementor(impl) {}virtual ~Abstraction() { delete implementor; }virtual void operation() = 0;
};// 扩展抽象类
class RefinedAbstraction : public Abstraction {
public:RefinedAbstraction(Implementor* impl) : Abstraction(impl) {}void operation() override {implementor->operation();}
};// 客户端
int main() {Implementor* implA = new ConcreteImplementorA();Implementor* implB = new ConcreteImplementorB();Abstraction* abstraction = new RefinedAbstraction(implA);abstraction->operation(); // 输出: ConcreteImplementorA operationdelete abstraction;abstraction = new RefinedAbstraction(implB);abstraction->operation(); // 输出: ConcreteImplementorB operationdelete abstraction;return 0;
}

Python 代码案例

# 实现接口
class Implementor:def operation(self):pass# 具体实现类 A
class ConcreteImplementorA(Implementor):def operation(self):print("ConcreteImplementorA operation")# 具体实现类 B
class ConcreteImplementorB(Implementor):def operation(self):print("ConcreteImplementorB operation")# 抽象类
class Abstraction:def __init__(self, implementor):self.implementor = implementordef operation(self):pass# 扩展抽象类
class RefinedAbstraction(Abstraction):def operation(self):self.implementor.operation()# 客户端
if __name__ == "__main__":implA = ConcreteImplementorA()implB = ConcreteImplementorB()abstraction = RefinedAbstraction(implA)abstraction.operation()  # 输出: ConcreteImplementorA operationabstraction = RefinedAbstraction(implB)abstraction.operation()  # 输出: ConcreteImplementorB operation

Go 代码案例

package mainimport "fmt"// 实现接口
type Implementor interface {Operation()
}// 具体实现类 A
type ConcreteImplementorA struct{}func (c *ConcreteImplementorA) Operation() {fmt.Println("ConcreteImplementorA operation")
}// 具体实现类 B
type ConcreteImplementorB struct{}func (c *ConcreteImplementorB) Operation() {fmt.Println("ConcreteImplementorB operation")
}// 抽象类
type Abstraction struct {implementor Implementor
}func (a *Abstraction) Operation() {a.implementor.Operation()
}// 扩展抽象类
type RefinedAbstraction struct {*Abstraction
}// 客户端
func main() {implA := &ConcreteImplementorA{}implB := &ConcreteImplementorB{}abstraction := &RefinedAbstraction{&Abstraction{implementor: implA}}abstraction.Operation() // 输出: ConcreteImplementorA operationabstraction = &RefinedAbstraction{&Abstraction{implementor: implB}}abstraction.Operation() // 输出: ConcreteImplementorB operation
}