您好，以下是我对“最常用的12种设计模式小结”的完整攻略：

您好，以下是我对“最常用的12种设计模式小结”的完整攻略：

最常用的12种设计模式小结

1. 单例模式（Singleton）

单例模式保证在整个应用程序中只有一个实例被创建。这种模式适用于全局对象的创建方式，并且通常使用延迟加载方式进行初始化。

示例：在游戏开发中，通常只需要一个游戏管理器，这个游戏管理器可以使用单例模式实现，确保只有一个游戏管理器对象，并且可以在整个游戏应用程序中提供全局访问。

class GameManager:
    instance = None

    def __new__(cls):
        if not cls.instance:
            cls.instance = super().__new__(cls)
        return cls.instance

game_manager = GameManager()

2. 工厂模式（Factory）

工厂模式实际上是一种创建型模式，它提供了一种创建对象的最佳方式，而不用让客户端程序直接创建这些对象。客户端程序只需要传递正确的参数，就可以获得所需的对象。

示例：在一个游戏开发中，我们需要创建不同种类的敌人。使用工厂模式可以创建不同种类的敌人，而不需要在客户端代码中编写各种敌人类型的对象创建逻辑。

class Enemy:
    def __init__(self, name):
        self.name = name

class SimpleEnemy(Enemy):
    def __init__(self):
        super().__init__("Simple Enemy")

class StrongEnemy(Enemy):
    def __init__(self):
        super().__init__("Strong Enemy")

class EnemyFactory:
    @staticmethod
    def create_enemy(enemy_type):
        if enemy_type == "simple":
            return SimpleEnemy()
        elif enemy_type == "strong":
            return StrongEnemy()

3. 代理模式（Proxy）

代理模式是一种结构型模式，它允许我们使用一个代理对象来代替一个真实对象。代理对象可以控制对真实对象的访问，并且可以在访问真实对象之前和之后执行一些操作。

示例：在一个游戏服务器中，我们可能需要控制某些玩家的行为，比如停止他们的行动。使用代理模式，我们可以在真正的玩家对象之前放置一个代理对象来拦截并控制他们的行为。

class Player:
    def __init__(self, name):
        self.name = name

    def action(self):
        print(f"{self.name} is running...")

class PlayerProxy(Player):
    def __init__(self, player):
        self.player = player

    def action(self):
        if self.player.name == "Joker":
            print(f"{self.player.name} is not allowed to run.")
        else:
            self.player.action()

player = Player("Alice")
player_proxy = PlayerProxy(player)
player_proxy.action()

player = Player("Joker")
player_proxy = PlayerProxy(player)
player_proxy.action()

4. 观察者模式（Observer）

观察者模式是一种行为型模式，它允许一个对象通知其它对象，当它自身发生改变时。这种模式通常用于事件处理系统。

示例：在一个游戏开发中，我们可能需要在玩家杀死敌人时触发一些事件。使用观察者模式，我们可以让一些事件处理器对象订阅这个事件，并且自动触发它们自己的操作。

class Player:
    def __init__(self, name):
        self.name = name
        self.listeners = []

    def add_listener(self, listener):
        self.listeners.append(listener)

    def remove_listener(self, listener):
        self.listeners.remove(listener)

    def kill_enemy(self):
        print(f"{self.name} killed an enemy.")
        for listener in self.listeners:
            listener.handle_event(self)

class GameEvent:
    def handle_event(self, player):
        pass

class LootEvent(GameEvent):
    def handle_event(self, player):
        print(f"{player.name} got a loot.")

class ScoreEvent(GameEvent):
    def handle_event(self, player):
        print(f"{player.name} got a score.")

player1 = Player("Alice")
loot_listener = LootEvent()
score_listener = ScoreEvent()

player1.add_listener(loot_listener)
player1.add_listener(score_listener)

player1.kill_enemy()

5. 装饰器模式（Decorator）

装饰器模式是一种结构型模式，它允许我们通过在运行时向现有对象添加额外的行为，而不需要修改这个对象的代码。

示例：在一个游戏开发中，我们可能需要给武器添加一些额外的属性，比如攻击力、耐久度等等。使用装饰器模式，我们可以实现代码的可扩展性，并且不需要修改现有的武器对象。

class Weapon:
    def get_damage(self):
        pass

class Sword(Weapon):
    def get_damage(self):
        return 100

class WeaponDecorator(Weapon):
    def __init__(self, weapon):
        self.weapon = weapon

    def get_damage(self):
        return self.weapon.get_damage()

class WeaponAttackDecorator(WeaponDecorator):
    def get_damage(self):
        return super().get_damage() + 20

class WeaponDurabilityDecorator(WeaponDecorator):
    def __init__(self, weapon, durability):
        super().__init__(weapon)
        self.durability = durability

    def get_damage(self):
        durability_coef = self.durability / 100
        return super().get_damage() * durability_coef

sword = Sword()
sword_with_attack = WeaponAttackDecorator(sword)
sword_with_durability = WeaponDurabilityDecorator(sword_with_attack, 50)
print(sword.get_damage()) # 100
print(sword_with_attack.get_damage()) # 120
print(sword_with_durability.get_damage()) # 60

6. 策略模式（Strategy）

策略模式是一种行为型模式，它定义了一系列算法，并且使它们之间可以相互替换。使用这种模式，可以让算法的变化独立于使用它们的客户端程序。

示例：在一个游戏开发中，我们需要计算不同种类的攻击方式的伤害值。使用策略模式，我们可以让攻击方式之间相互独立，可以被单独修改和测试。

class AttackStrategy:
    def calculate_damage(self):
        pass

class SlashAttack(AttackStrategy):
    def calculate_damage(self):
        return 50

class StabAttack(AttackStrategy):
    def calculate_damage(self):
        return 30

class Player:
    def __init__(self, attack_strategy):
        self.attack_strategy = attack_strategy

    def attack(self):
        damage = self.attack_strategy.calculate_damage()
        print(f"You caused {damage} damage.")

player1 = Player(SlashAttack())
player1.attack()

player2 = Player(StabAttack())
player2.attack()

7. 适配器模式（Adapter）

适配器模式是一种结构型模式，它可以将一个类的接口转换为另一个类的接口，从而让原本不兼容的类能够一起工作。

示例：在一个游戏开发中，我们可能需要让不同的音效引擎共同工作。使用适配器模式，我们可以将这些不同的音效引擎的调用接口转换成统一的接口，从而让它们能够互相衔接。

class AudioEngine:
    def play_audio(self, ID):
        pass

class UnityAudioEngine(AudioEngine):
    def play_audio(self, audio_ID):
        print(f"Unity audio engine plays audio clip {audio_ID}.")

class UnrealAudioEngine:
    def play_sound(self, sound_ID):
        print(f"Unreal audio engine plays sound {sound_ID}.")

class AudioEngineAdapter(AudioEngine):
    def __init__(self, adapter):
        self.adapter = adapter

    def play_audio(self, audio_ID):
        self.adapter.play_sound(audio_ID)

unity_audio_engine = UnityAudioEngine()
unreal_audio_engine = UnrealAudioEngine()

adapter_for_unreal = AudioEngineAdapter(unreal_audio_engine)
adapter_for_unreal.play_audio("background_music")

unity_audio_engine.play_audio("jump_sound")

adapter_for_unity = AudioEngineAdapter(unity_audio_engine)
adapter_for_unity.play_audio("shoot_sound")

8. 桥接模式（Bridge）

桥接模式是一种结构型模式，它将一个类的抽象部分和实现部分分离开来，以便它们可以独立变化。使用桥接模式，可以在不破坏现有结构的情况下，更改一个类的实现方式。

示例：在一个游戏开发中，我们可能需要提供不同操作系统平台的支持。使用桥接模式，我们可以隔离不同平台之间的差异，从而让游戏引擎可以在任意平台上运行。

class Renderer:
    def render(self, shape):
        pass

class Shape:
    def render(self, renderer):
        pass

class Square(Shape):
    def __init__(self, x, y, size):
        self.x = x
        self.y = y
        self.size = size

    def render(self, renderer):
        renderer.render_square(self.x, self.y, self.size)

class Circle(Shape):
    def __init__(self, x, y, size):
        self.x = x
        self.y = y
        self.size = size

    def render(self, renderer):
        renderer.render_circle(self.x, self.y, self.size)

class OpenGLRenderer(Renderer):
    def render_square(self, x, y, size):
        print(f"OpenGL renders square ({x},{y}) size {size}.")

    def render_circle(self, x, y, size):
        print(f"OpenGL renders circle ({x},{y}) size {size}.")

class Direct3DRenderer(Renderer):
    def render_square(self, x, y, size):
        print(f"Direct3D renders square ({x},{y}) size {size}.")

    def render_circle(self, x, y, size):
        print(f"Direct3D renders circle ({x},{y}) size {size}.")

square = Square(10, 10, 50)
circle = Circle(100, 100, 20)
opengl_renderer = OpenGLRenderer()
direct3d_renderer = Direct3DRenderer()
square.render(opengl_renderer)
circle.render(direct3d_renderer)

9. 建造者模式（Builder）

建造者模式是一种创建型模式，它使用多个简单的对象一步步构建成一个复杂的对象。它隐藏了对象的创建过程，并且允许以不同的方式构建对象。

示例：在一个游戏开发中，我们可能需要创建不同种类的角色。使用建造者模式，我们可以通过链式调用一些简单的对象构建方法来构建不同角色的实例。

class Character:
    def __init__(self):
        self.name = None
        self.gender = None
        self.armor = None
        self.weapon = None

class CharacterBuilder:
    def __init__(self):
        self.character = Character()

    def set_name(self, name):
        self.character.name = name
        return self

    def set_gender(self, gender):
        self.character.gender = gender
        return self

    def set_armor(self, armor):
        self.character.armor = armor
        return self

    def set_weapon(self, weapon):
        self.character.weapon = weapon
        return self

    def build(self):
        return self.character

builder = CharacterBuilder()
character = builder.set_name("Alice").set_gender("Female").set_armor("Leather Armor").set_weapon("Short Sword").build()
print(character.__dict__)

10. 迭代器模式（Iterator）

迭代器模式是一种行为型模式，它可以让我们逐步访问一个聚合对象的所有元素，并且不需要了解聚合对象的内部结构。这种模式通常用于遍历数据集合。

示例：在一个游戏开发中，我们可能需要迭代一些游戏对象。使用迭代器模式，我们可以使用迭代器对象逐步访问并且操作游戏对象的所有元素。

class GameObject:
    def __init__(self, name):
        self.name = name

class GameCollection:
    def __init__(self):
        self.game_objects = []

    def add_game_object(self, game_object):
        self.game_objects.append(game_object)

    def __iter__(self):
        return GameIterator(self)

class GameIterator:
    def __init__(self, collection):
        self.collection = collection
        self.index = 0

    def __next__(self):
        if self.index >= len(self.collection.game_objects):
            raise StopIteration()
        game_object = self.collection.game_objects[self.index]
        self.index += 1
        return game_object

game_collection = GameCollection()
game_collection.add_game_object(GameObject("Player"))
game_collection.add_game_object(GameObject("Enemy"))
for game_object in game_collection:
    print(game_object.__dict__)

11. 模板方法模式（Template Method）

模板方法模式是一种行为型模式，它定义了一种算法的框架，并且允许子类为其中的一些步骤提供具体实现。使用这种模式，可以确保算法的各个步骤按正确的顺序执行，并且留出接口给子类实现。

示例：在一个游戏开发中，我们可能需要定义一个游戏的基本流程，包括初始化、加载场景、展示场景、更新游戏等等。使用模板方法模式，我们可以定义一个基本流程框架，并且允许子类实现流程中的具体细节。

class Game:
    def initialize(self):
        print("Initialize game.")

    def get_scene(self):
        print("Getting game scene data.")

    def show_scene(self):
        print("Showing game scene.")

    def update_game(self):
        print("Updating game...")

    def run(self):
        self.initialize()
        self.get_scene()
        self.show_scene()
        self.update_game()

class SimpleGame(Game):
    def get_scene(self):
        print("Getting simple game scene data.")

    def show_scene(self):
        print("Showing simple game scene.")

simple_game = SimpleGame()
simple_game.run()

12. 状态模式（State）

状态模式是一种行为型模式，它定义了一个包含状态和行为的类，使得对象在运行时可以在不同的状态之间转换。使用这种模式，可以简化条件语句，使得代码更加清晰易懂。

示例：在一个游戏开发中，我们可能需要控制玩家的行动。使用状态模式，我们可以定义玩家的各种行为，并且允许玩家在各个行为之间切换。

class State:
    def run(self):
        pass

class NormalState(State):
    def run(self):
        print("Player is walking...")

class HurtState(State):
    def run(self):
        print("Player is crawling...")

class DeadState(State):
    def run(self):
        print("Player is dead... Game over.")

class Player:
    def __init__(self):
        self.state = NormalState()

    def set_state(self, state):
        self.state = state

    def run(self):
        self.state.run()

player = Player()
player.run()

player.set_state(HurtState())
player.run()

player.set_state(DeadState())
player.run()

以上是我给您的完整攻略，希望对您有所帮助！