Python工厂方法和抽象工厂详解

区别

• 工厂方法模式和抽象工厂模式在 Python 中也有类似的区别。Python中的工厂方法模式与其他语言中的实现方式类似，使用一个定义抽象方法的类来创建对象。我们通过编写一个特殊的方法来创建对象，这个方法是抽象的，由具体的子类来实现。

• 抽象工厂模式则通过创建一组相关或相互依赖的对象来工作，而不是单一对象。在 Python中，使用抽象类和接口来创建对象系列，这些系列可以是继承自抽象类的类，或实现由接口定义的方法的类。这样可以更加灵活地创建，扩展和维护对象，并易于避免代码重复。

相同点

• 工厂方法模式和抽象工厂模式的相同点在于它们都提供了一个封装代码的接口。这使得它们可以将代码与客户端解耦，并简化代码实现。这些模式都允许在不修改客户端代码的情况下添加新的对象或系列，并在对象创建过程中灵活制定实例化的规则，从而提供了更高的灵活性和可伸缩性。

总之，Python 中的工厂方法模式和抽象工厂模式的工作原理与其他语言中的实现方式类似，但在具体实现方面会有所不同。在实现时，我们可以选择哪种工厂模式来创建对象，并根据具体需求提供更高的扩展性和灵活性。

实例

工厂方法

假设我们有一个图形类 Shape，它有两个子类 Circle 和 Square，我们想从这些类中创建对象。

from abc import ABC, abstractmethod

class Shape(ABC):

    @abstractmethod
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        print("Circle.draw()")

class Square(Shape):
    def draw(self):
        print("Square.draw()")

class ShapeFactory(ABC):

    @abstractmethod
    def create_shape(self):
        pass

class CircleFactory(ShapeFactory):
    def create_shape(self):
        return Circle()

class SquareFactory(ShapeFactory):
    def create_shape(self):
        return Square()

circle = CircleFactory().create_shape()
circle.draw()

square = SquareFactory().create_shape()

在 ShapeFactory 中创建一个抽象的 create_shape 方法，让 CircleFactory 和 SquareFactory 继承 ShapeFactory 并实现改方法，分别返回 Circle 和 Square 实例。

抽象工厂

假设我们想要创建不同类型的动物和其相应的食物，例如狗和骨头，猫和鱼等。

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 Food(ABC):

    @abstractmethod
    def show_food(self):
        pass

class Bone(Food):
    def show_food(self):
        return "Bone"

class Fish(Food):
    def show_food(self):
        return "Fish"

class AnimalFactory(ABC):

    @abstractmethod
    def create_animal(self):
        pass

    @abstractmethod
    def create_food(self):
        pass

class DogFactory(AnimalFactory):
    def create_animal(self):
        return Dog()

    def create_food(self):
        return Bone()

class CatFactory(AnimalFactory):
    def create_animal(self):
        return Cat()

    def create_food(self):
        return Fish()

dog_factory = DogFactory()
cat_factory = CatFactory()

dog = dog_factory.create_animal()
print(dog.speak())

dog_food = dog_factory.create_food()
print(dog_food.show_food())

cat = cat_factory.create_animal()
print(cat.speak())

cat_food = cat_factory.create_food()
print(cat_food.show_food())

在这个例子中，我们创建了一个抽象工厂类 AnimalFactory，它有两个抽象方法 create_animal 和 create_food。然后我们创建了两个具体的工厂，一个是 DogFactory，另一个是 CatFactory。这些工厂分别应用于创建Dog 和 Cat 对象，以及它们相应的食物。

抽象工厂模式则通过创建一组相关或相互依赖的对象来工作，而不是单一对象。因此，工厂方法模式和抽象工厂模式都可以帮助我们封装对象的创建和实现的细节，简化代码实现同时提高灵活性。