Python 面向对象设计模式应用场景与代码示例

工厂模式 (Factory Pattern)

应用场景：在一个系统中，有多个类实现了同一个接口，根据不同的条件选择不同的实现类，可以使用工厂模式来创建对象。

作用：将对象的创建和使用分离，通过工厂类来创建对象，使得系统更加灵活、可扩展。

具体程序代码：

class Shape:
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        print('Drawing a circle')

class Rectangle(Shape):
    def draw(self):
        print('Drawing a rectangle')

class ShapeFactory:
    def create_shape(self, shape_type):
        if shape_type == 'circle':
            return Circle()
        elif shape_type == 'rectangle':
            return Rectangle()
        else:
            return None

factory = ShapeFactory()
circle = factory.create_shape('circle')
circle.draw()  # Output: Drawing a circle

rectangle = factory.create_shape('rectangle')
rectangle.draw()  # Output: Drawing a rectangle

代理模式 (Proxy Pattern)

应用场景：当某个对象不适合或者不能直接访问另一个对象时，可以使用代理模式来间接访问。

作用：通过代理类来控制对真实对象的访问，可以增加一些额外的功能，如权限控制、延迟加载等。

具体程序代码：

class Image:
    def display(self):
        pass

class RealImage(Image):
    def __init__(self, filename):
        self.filename = filename
        self.load_image()

    def load_image(self):
        print('Loading image: {}'.format(self.filename))

    def display(self):
        print('Displaying image: {}'.format(self.filename))

class ProxyImage(Image):
    def __init__(self, filename):
        self.filename = filename
        self.real_image = None

    def display(self):
        if self.real_image is None:
            self.real_image = RealImage(self.filename)
        self.real_image.display()

image = ProxyImage('image.jpg')
# 图片加载和显示都是通过代理类进行的
image.display()  # Output: Loading image: image.jpg
                #         Displaying image: image.jpg
image.display()  # Output: Displaying image: image.jpg

观察者模式 (Observer Pattern)

应用场景：当一个对象的状态发生变化时，需要通知其他相关的对象进行更新，可以使用观察者模式来实现对象之间的一对多依赖关系。

作用：使得对象之间的耦合度降低，当一个对象的状态发生变化时，不需要知道具体的观察者，只需要通知观察者即可。

具体程序代码：

class Subject:
    def __init__(self):
        self.observers = []

    def attach(self, observer):
        self.observers.append(observer)

    def detach(self, observer):
        self.observers.remove(observer)

    def notify(self):
        for observer in self.observers:
            observer.update()

class Observer:
    def update(self):
        pass

class ConcreteObserver1(Observer):
    def update(self):
        print('ConcreteObserver1 is notified')

class ConcreteObserver2(Observer):
    def update(self):
        print('ConcreteObserver2 is notified')

subject = Subject()
observer1 = ConcreteObserver1()
observer2 = ConcreteObserver2()

subject.attach(observer1)
subject.attach(observer2)

subject.notify()  # Output: ConcreteObserver1 is notified
                  #         ConcreteObserver2 is notified

subject.detach(observer1)

subject.notify()  # Output: ConcreteObserver2 is notified

策略模式 (Strategy Pattern)

应用场景：当一个对象有多个可以互相替换的行为，根据不同的情况选择不同的行为，可以使用策略模式来实现行为的灵活切换。

作用：将行为和对象分离，使得行为可以独立于对象进行变化和扩展。

具体程序代码：

class Strategy:
    def do_operation(self):
        pass

class OperationAdd(Strategy):
    def do_operation(self):
        return 10 + 5

class OperationSubtract(Strategy):
    def do_operation(self):
        return 10 - 5

class OperationMultiply(Strategy):
    def do_operation(self):
        return 10 * 5

class Context:
    def __init__(self, strategy):
        self.strategy = strategy

    def execute_strategy(self):
        return self.strategy.do_operation()

context = Context(OperationAdd())
result = context.execute_strategy()
print(result)  # Output: 15

context = Context(OperationSubtract())
result = context.execute_strategy()
print(result)  # Output: 5

context = Context(OperationMultiply())
result = context.execute_strategy()
print(result)  # Output: 50

适配器模式 (Adapter Pattern)

应用场景：当一个类的接口不符合另一个类的需求时，可以使用适配器模式来进行接口的转换。

作用：将不兼容的接口转换为可兼容的接口，使得原本无法工作的类能够协同工作。

具体程序代码：

class MediaPlayer:
    def play(self, audio_type, filename):
        pass

class AdvancedMediaPlayer:
    def play_vlc(self, filename):
        pass

    def play_mp4(self, filename):
        pass

class VlcPlayer(AdvancedMediaPlayer):
    def play_vlc(self, filename):
        print('Playing vlc file: {}'.format(filename))

class Mp4Player(AdvancedMediaPlayer):
    def play_mp4(self, filename):
        print('Playing mp4 file: {}'.format(filename))

class MediaAdapter(MediaPlayer):
    def __init__(self, audio_type):
        if audio_type == 'vlc':
            self.advanced_player = VlcPlayer()
        elif audio_type == 'mp4':
            self.advanced_player = Mp4Player()

    def play(self, audio_type, filename):
        if audio_type == 'vlc':
            self.advanced_player.play_vlc(filename)
        elif audio_type == 'mp4':
            self.advanced_player.play_mp4(filename)

class AudioPlayer(MediaPlayer):
    def play(self, audio_type, filename):
        if audio_type == 'mp3':
            print('Playing mp3 file: {}'.format(filename))
        elif audio_type == 'vlc' or audio_type == 'mp4':
            media_adapter = MediaAdapter(audio_type)
            media_adapter.play(audio_type, filename)
        else:
            print('Invalid media type')

audio_player = AudioPlayer()
audio_player.play('mp3', 'music.mp3')  # Output: Playing mp3 file: music.mp3

audio_player.play('vlc', 'movie.vlc')  # Output: Playing vlc file: movie.vlc

audio_player.play('mp4', 'video.mp4')  # Output: Playing mp4 file: video.mp4

audio_player.play('avi', 'video.avi')  # Output: Invalid media type

装饰器模式 (Decorator Pattern)

应用场景：当需要为一个对象动态地添加额外的功能，而不需要修改原有对象的结构，可以使用装饰器模式来实现功能的扩展。

作用：动态地给对象添加额外的功能，使得对象的功能可以灵活地组合和扩展。

具体程序代码：

class Shape:
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        print('Drawing a circle')

class Rectangle(Shape):
    def draw(self):
        print('Drawing a rectangle')

class ShapeDecorator(Shape):
    def __init__(self, decorated_shape):
        self.decorated_shape = decorated_shape

    def draw(self):
        self.decorated_shape.draw()

class RedShapeDecorator(ShapeDecorator):
    def draw(self):
        self.decorated_shape.draw()
        self.set_red_border()

    def set_red_border(self):
        print('Setting red border')

circle = Circle()
decorated_circle = RedShapeDecorator(circle)
decorated_circle.draw()  # Output: Drawing a circle
                         #         Setting red border

rectangle = Rectangle()
decorated_rectangle = RedShapeDecorator(rectangle)
decorated_rectangle.draw()  # Output: Drawing a rectangle
                             #         Setting red border

外观模式 (Facade Pattern)

应用场景：当一个系统的复杂性导致需要与多个子系统进行交互时，可以使用外观模式来定义一个统一的接口，简化客户端与子系统之间的交互。

作用：为复杂的子系统提供一个简单的接口，使得客户端可以更加方便地使用子系统。

具体程序代码：

class Subsystem1:
    def operation1(self):
        print('Subsystem1 operation')

class Subsystem2:
    def operation2(self):
        print('Subsystem2 operation')

class Subsystem3:
    def operation3(self):
        print('Subsystem3 operation')

class Facade:
    def __init__(self):
        self.subsystem1 = Subsystem1()
        self.subsystem2 = Subsystem2()
        self.subsystem3 = Subsystem3()

    def operation(self):
        self.subsystem1.operation1()
        self.subsystem2.operation2()
        self.subsystem3.operation3()

facade = Facade()
facade.operation()  # Output: Subsystem1 operation
                    #         Subsystem2 operation
                    #         Subsystem3 operation

桥接模式 (Bridge Pattern)

应用场景：当一个抽象类有多个维度的变化，可以使用桥接模式将抽象类和具体实现类分离，使得它们可以独立地变化。

作用：将抽象和实现解耦，使得两者可以独立地变化和扩展。

具体程序代码：

class Shape:
    def __init__(self, color):
        self.color = color

    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        print('Drawing a {} circle'.format(self.color))

class Rectangle(Shape):
    def draw(self):
        print('Drawing a {} rectangle'.format(self.color))

class Color:
    def fill(self):
        pass

class RedColor(Color):
    def fill(self):
        return 'red'

class BlueColor(Color):
    def fill(self):
        return 'blue'

circle = Circle(RedColor())
circle.draw()  # Output: Drawing a red circle

rectangle = Rectangle(BlueColor())
rectangle.draw()  # Output: Drawing a blue rectangle