工厂模式与策略模式的区别及使用

工厂模式与策略模式的区别及使用

工厂模式和策略模式是两种常用的设计模式，它们虽然在结构和目的上有不同之处，但都涉及到对象的创建和行为的动态改变。下面详细介绍它们的区别和使用场景，并提供一个 Python 实现的案例。

一、工厂模式（Factory Pattern）

1. 定义

• 工厂模式是一种创建型设计模式，它定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂模式使得实例化操作延迟到子类进行。

2. 使用场景

• 需要生成不同类型的对象，但不希望指定具体类时。
• 对象的创建过程比较复杂，不希望直接在客户端进行实例化时。
• 需要对创建对象的过程进行控制和管理。

3. 示例

from abc import ABC, abstractmethod

# 抽象产品类
class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

# 具体产品类
class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

# 工厂类
class AnimalFactory:
    @staticmethod
    def create_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError("Unknown animal type")

# 客户端代码
if __name__ == "__main__":
    animal_type = "dog"
    animal = AnimalFactory.create_animal(animal_type)
    print(animal.speak())  # 输出：Woof!

二、策略模式（Strategy Pattern）

1. 定义

• 策略模式是一种行为型设计模式，它定义了一系列算法，并将它们封装起来，使得它们可以相互替换。策略模式使得算法的变化独立于使用算法的客户。

2. 使用场景

• 需要在运行时动态地选择一种算法时。
• 各种算法的区别较小时，可以使用策略模式来消除条件判断的复杂性。
• 需要通过不同方式实现某一行为时。

3. 示例

from abc import ABC, abstractmethod

# 抽象策略类
class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

# 具体策略类
class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        return f"Paid {amount} using Credit Card"

class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        return f"Paid {amount} using PayPal"

# 环境类
class ShoppingCart:
    def __init__(self, payment_strategy: PaymentStrategy):
        self._payment_strategy = payment_strategy

    def checkout(self, amount):
        return self._payment_strategy.pay(amount)

# 客户端代码
if __name__ == "__main__":
    amount = 100
    payment_strategy = PayPalPayment()
    cart = ShoppingCart(payment_strategy)
    print(cart.checkout(amount))  # 输出：Paid 100 using PayPal

三、工厂模式与策略模式的区别

1. 关注点

   • 工厂模式关注的是对象的创建，通过工厂方法来创建对象，隐藏了具体产品类的实例化过程。
   • 策略模式关注的是行为的实现，通过策略接口定义了一系列算法，将具体算法的实现和使用分离。

2. 使用方式

   • 工厂模式常用于需要根据条件创建不同类型对象的场景，隐藏了对象创建的细节。
   • 策略模式常用于需要在不同策略（算法）之间切换的场景，能够在运行时灵活替换算法。

3. 代码结构

   • 工厂模式的核心是创建对象的方法，它可以通过子类来扩展新的产品类型。
   • 策略模式的核心是算法接口和实现类，环境类持有策略接口并在运行时使用不同的策略。

四、综合使用案例

下面是一个结合工厂模式和策略模式的综合案例。通过工厂模式创建支付策略对象，再通过策略模式来执行不同的支付逻辑。

from abc import ABC, abstractmethod

# 抽象策略类
class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

# 具体策略类
class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        return f"Paid {amount} using Credit Card"

class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        return f"Paid {amount} using PayPal"

# 工厂类
class PaymentStrategyFactory:
    @staticmethod
    def create_payment_strategy(strategy_type):
        if strategy_type == "creditcard":
            return CreditCardPayment()
        elif strategy_type == "paypal":
            return PayPalPayment()
        else:
            raise ValueError("Unknown payment strategy type")

# 环境类
class ShoppingCart:
    def __init__(self, payment_strategy: PaymentStrategy):
        self._payment_strategy = payment_strategy

    def checkout(self, amount):
        return self._payment_strategy.pay(amount)

# 客户端代码
if __name__ == "__main__":
    strategy_type = "creditcard"
    payment_strategy = PaymentStrategyFactory.create_payment_strategy(strategy_type)
    cart = ShoppingCart(payment_strategy)
    print(cart.checkout(200))  # 输出：Paid 200 using Credit Card

通过这个综合案例，你可以看到如何使用工厂模式来创建策略对象，并通过策略模式实现灵活的算法选择。