桥模式

桥模式是一种设计模式，用于将抽象部分与其具体实现部分解耦，使它们可以独立地变化。桥模式的核心思想是通过将抽象和实现分离，让它们可以独立地进行变化和扩展。

在桥模式中，存在两个独立变化的维度：抽象部分和实现部分。抽象部分定义了高层接口，而实现部分则提供了具体的实现。通过桥接（Bridge）将抽象部分和实现部分连接起来，使它们可以独立进行修改和扩展。

桥模式的关键角色包括：抽象和实现相分离

• 抽象（Abstraction）：定义了高层接口，维护一个对实现的引用，并将客户端的请求委派给实现对象。
• 具体抽象（Concrete Abstraction）：扩展了抽象部分，实现了高层接口，通常包含一些额外的业务逻辑。
• 实现（Implementation）：定义了实现部分的接口，提供基本操作的定义。
• 具体实现（Concrete Implementation）：具体的实现部分，实现了实现部分的接口。

通过桥模式，可以在不修改现有代码的情况下，新增抽象和实现的组合。这种解耦的设计使得系统更加灵活，能够应对变化，并支持扩展和演化。

总结来说，桥模式通过将抽象部分和实现部分分离，提供了一种灵活的设计方式，使得它们可以独立地变化和扩展。这种模式可以提高系统的可维护性、可扩展性和可复用性。

from abc import ABC, abstractmethod


# 实现部分的接口
class Shape(ABC):
    def __init__(self, color):
        self.color = color

    @abstractmethod
    def draw(self):
        pass


# 实现部分的接口
class Color(ABC):
    @abstractmethod
    def paint(self, shape):
        pass


# 长方形
class Rectangle(Shape):
    name = "长方形"

    def draw(self):
        self.color.paint(self)


# 圆形
class Round(Shape):
    name = "圆形"

    def draw(self):
        self.color.paint(self)


class Red(Color):
    def paint(self, shape):
        print("红色的 %s" % shape.name)


class Green(Color):
    def paint(self, shape):
        print("绿色的 %s" % shape.name)


r = Rectangle(Red())
g = Round(Green())
r.draw()
g.draw()

from abc import ABC, abstractmethod


# 实现部分的接口
class Implementor(ABC):
    @abstractmethod
    def operation_implementation(self):
        pass


# 具体实现部分A
class ConcreteImplementorA(Implementor):
    def operation_implementation(self):
        print("Concrete Implementor A operation")


# 具体实现部分B
class ConcreteImplementorB(Implementor):
    def operation_implementation(self):
        print("Concrete Implementor B operation")


# 抽象部分的接口
class Abstraction(ABC):
    def __init__(self, implementor):
        self.implementor = implementor

    @abstractmethod
    def operation(self):
        pass


# 具体抽象部分A
class ConcreteAbstractionA(Abstraction):
    def operation(self):
        print("Concrete Abstraction A operation")
        self.implementor.operation_implementation()


# 具体抽象部分B
class ConcreteAbstractionB(Abstraction):
    def operation(self):
        print("Concrete Abstraction B operation")
        self.implementor.operation_implementation()


# 使用桥模式
implementor_a = ConcreteImplementorA()
abstraction_a = ConcreteAbstractionA(implementor_a)
abstraction_a.operation()

implementor_b = ConcreteImplementorB()
abstraction_b = ConcreteAbstractionB(implementor_b)
abstraction_b.operation()