【设计模式】【结构型模式（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 {
@Override
public void operation() {
System.out.println("ConcreteImplementorA operation");
}
}
// 具体实现类 B
class ConcreteImplementorB implements Implementor {
@Override
public 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);
}
@Override
public 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 operation
abstraction = 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 operation
delete abstraction;
abstraction = new RefinedAbstraction(implB);
abstraction->operation(); // 输出: ConcreteImplementorB operation
delete 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 = implementor
def 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 operation
abstraction = RefinedAbstraction(implB)
abstraction.operation() # 输出: ConcreteImplementorB operationGo 代码案例
package main
import "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 operation
abstraction = &RefinedAbstraction{&Abstraction{implementor: implB}}
abstraction.Operation() // 输出: ConcreteImplementorB operation
}4. 总结
桥接模式 是一种结构型设计模式，用于将抽象部分与实现部分分离，使它们可以独立变化。这种模式通过组合而不是继承来达到解耦的目的，从而提高系统的灵活性和可扩展性。
主要优点
- 分离抽象和实现：桥接模式将抽象部分与实现部分分离，使得两者可以独立变化，提高了系统的灵活性和可扩展性。
- 减少子类数量：通过组合而不是继承，减少了子类的数量，简化了类层次结构。
- 提高可维护性：由于抽象和实现是分离的，因此可以独立地修改和扩展，降低了代码的维护成本。
主要缺点
- 增加了系统的复杂性：桥接模式引入了更多的类，增加了系统的复杂性。
- 理解难度增加：对于不熟悉桥接模式的开发者来说，理解和使用桥接模式可能会有一定的难度。
适用场景
- 当一个类存在多种变体，而这些变体需要独立变化时。
- 当不希望使用继承的方式进行扩展，因为这会导致子类数量激增，且难以管理时。
- 当需要在运行时动态地选择或切换实现时。
原文地址：https://blog.csdn.net/ido1ok/article/details/144059957
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！