废话不多，说咱们直接开始！

什么是工厂方法模式？

工厂方法模式是一种常见的设计模式，属于创建型模式之一。在工厂方法模式中，我们定义一个用于创建对象的接口，但是让子类决定实例化哪个类。这样，工厂方法模式让一个类的实例化延迟到其子类。

工厂方法模式的核心思想是将对象的创建和使用分离，客户端代码通过调用工厂方法来创建对象，而无需直接实例化对象。这样可以减少代码耦合，提高代码的灵活性和可维护性。

工厂方法模式包含以下角色：

抽象产品（Product）：

定义了工厂方法模式创建的对象的接口或抽象类。抽象产品可以是一个接口，也可以是一个抽象类，它声明了具体产品类所需的各种方法。

通过抽象产品，工厂方法模式将客户端与具体产品的实现解耦，使得客户端可以通过抽象接口操作具体产品，而不需要了解其具体的实现细节。

具体产品（Concrete Product）：

实现了抽象产品接口或继承了抽象产品类的具体类。

具体产品是工厂方法模式中被创建的对象，其具体行为由具体产品类来实现。

每个具体产品类都有其特定的实现，满足了抽象产品所定义的接口。

抽象工厂（Creator）：

声明了工厂方法，该方法用于创建产品对象。

抽象工厂可以是接口、抽象类或者具体类，其中并不包含具体的产品创建逻辑。

抽象工厂通常会包含一个或多个工厂方法，用于创建不同类型的产品。

具体工厂（Concrete Creator）：

实现了抽象工厂接口或继承了抽象工厂类的具体类。

具体工厂负责实际创建具体产品的对象，其内部实现了工厂方法，并根据需要创建不同类型的具体产品，具体工厂决定了工厂方法所返回的具体产品的类型。

Python代码示例

from abc import ABC, abstractmethod

# 抽象产品
class Product(ABC):
    @abstractmethod
    def operation(self):
        pass

# 具体产品A
class ConcreteProductA(Product):
    def operation(self):
        return "具体产品A的操作"

# 具体产品B
class ConcreteProductB(Product):
    def operation(self):
        return "具体产品B的操作"

# 抽象工厂
class Creator(ABC):
    @abstractmethod
    def factory_method(self):
        pass

    def some_operation(self):
        product = self.factory_method()
        result = f"创建了{product.operation()}"
        return result

# 具体工厂A
class ConcreteCreatorA(Creator):
    def factory_method(self):
        return ConcreteProductA()

# 具体工厂B
class ConcreteCreatorB(Creator):
    def factory_method(self):
        return ConcreteProductB()

# 客户端代码
def client_code(creator: Creator):
    print(creator.some_operation())

if __name__ == "__main__":
    # 使用具体工厂A创建具体产品A
    client_code(ConcreteCreatorA())

    # 使用具体工厂B创建具体产品B
    client_code(ConcreteCreatorB())

这个示例包含了四个主要角色：

抽象产品（Product）：定义了产品的接口，即Product抽象类。

具体产品（ConcreteProductA 和 ConcreteProductB）：实现了抽象产品接口的具体类。

抽象工厂（Creator）：声明了工厂方法factory_method()，即Creator抽象类。

具体工厂（ConcreteCreatorA 和 ConcreteCreatorB）：实现了抽象工厂接口的具体类，分别负责创建具体产品A和具体产品B。

下面我们再做一个java代码的示例：

java代码示例

// 抽象产品
interface Product {
    String operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public String operation() {
        return "具体产品A的操作";
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public String operation() {
        return "具体产品B的操作";
    }
}

// 抽象工厂
interface Creator {
    Product factoryMethod();
}

// 具体工厂A
class ConcreteCreatorA implements Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteCreatorB implements Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Main {
    public static void clientCode(Creator creator) {
        Product product = creator.factoryMethod();
        System.out.println("创建了" + product.operation());
    }

    public static void main(String[] args) {
        // 使用具体工厂A创建具体产品A
        clientCode(new ConcreteCreatorA());

        // 使用具体工厂B创建具体产品B
        clientCode(new ConcreteCreatorB());
    }
}

工厂模式小结

工厂方法模式与抽象工厂模式的区别在于：

1）工厂方法只有一个抽象产品类和一个抽象工厂类，但可以派生出多个具体产品类和具体工厂类，每个具体工厂类只能创建一个具体产品类的实例；

2）抽象工厂模式拥有多个产品类（产品族）和一个抽象工厂类，每个抽象产品类可以派生出多个具体产品类；抽象工厂类也可以派生出多个具体工厂类，同时每个具体工厂类可以创建多个具体产品类的实例。

到这里我们的工厂模式就结束啦！