【设计模式】【创建型模式（Creational Patterns）】之工厂方法模式

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它提供了一种创建对象的接口，但允许子类决定要实例化的类。这样，工厂方法模式可以让类的实例化推迟到子类。

UML 类图

下面是工厂方法模式的 UML 类图：

复制代码

+-----------------+         +-----------------+
| Creator         |<--------| ConcreteCreator  |
+-----------------+         +-----------------+
| +factoryMethod(): Product | +factoryMethod(): ConcreteProduct |
+-----------------+         +-----------------+
| +anOperation()           |                  |
+-----------------+         +-----------------+

+-----------------+         +-----------------+
| Product         |<--------| ConcreteProduct  |
+-----------------+         +-----------------+
| +interface()    |         | +concreteInterface() |
+-----------------+         +-----------------+

在这个 UML 类图中：

Creator 是一个抽象类，定义了一个 factoryMethod 方法，用于创建 Product 对象。
ConcreteCreator 是 Creator 的具体实现类，实现了 factoryMethod 方法，创建具体的 Product 对象。
Product 是一个抽象类，定义了一个 interface 方法。
ConcreteProduct 是 Product 的具体实现类，实现了 interface 方法。

Java 代码示例

复制代码

// 抽象产品类
interface Product {
    void interfaceMethod();
}

// 具体产品类
class ConcreteProduct implements Product {
    @Override
    public void interfaceMethod() {
        System.out.println("ConcreteProduct method called");
    }
}

// 抽象创建者类
abstract class Creator {
    public abstract Product factoryMethod();

    public void anOperation() {
        Product product = factoryMethod();
        product.interfaceMethod();
    }
}

// 具体创建者类
class ConcreteCreator extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        creator.anOperation();
    }
}

C++ 代码示例

复制代码

#include <iostream>

// 抽象产品类
class Product {
public:
    virtual void interfaceMethod() = 0;
    virtual ~Product() {}
};

// 具体产品类
class ConcreteProduct : public Product {
public:
    void interfaceMethod() override {
        std::cout << "ConcreteProduct method called" << std::endl;
    }
};

// 抽象创建者类
class Creator {
public:
    virtual Product* factoryMethod() = 0;
    virtual ~Creator() {}

    void anOperation() {
        Product* product = factoryMethod();
        product->interfaceMethod();
        delete product;
    }
};

// 具体创建者类
class ConcreteCreator : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProduct();
    }
};

// 客户端代码
int main() {
    Creator* creator = new ConcreteCreator();
    creator->anOperation();
    delete creator;
    return 0;
}

Python 代码示例

复制代码

# 抽象产品类
class Product:
    def interface_method(self):
        pass

# 具体产品类
class ConcreteProduct(Product):
    def interface_method(self):
        print("ConcreteProduct method called")

# 抽象创建者类
class Creator:
    def factory_method(self):
        pass

    def an_operation(self):
        product = self.factory_method()
        product.interface_method()

# 具体创建者类
class ConcreteCreator(Creator):
    def factory_method(self):
        return ConcreteProduct()

# 客户端代码
if __name__ == "__main__":
    creator = ConcreteCreator()
    creator.an_operation()

Go 代码示例

复制代码

package main

import "fmt"

// 抽象产品接口
type Product interface {
    InterfaceMethod()
}

// 具体产品类
type ConcreteProduct struct{}

func (cp *ConcreteProduct) InterfaceMethod() {
    fmt.Println("ConcreteProduct method called")
}

// 抽象创建者接口
type Creator interface {
    FactoryMethod() Product
    AnOperation()
}

// 具体创建者类
type ConcreteCreator struct{}

func (cc *ConcreteCreator) FactoryMethod() Product {
    return &ConcreteProduct{}
}

func (cc *ConcreteCreator) AnOperation() {
    product := cc.FactoryMethod()
    product.InterfaceMethod()
}

// 客户端代码
func main() {
    creator := &ConcreteCreator{}
    creator.AnOperation()
}

代码逻辑详解

产品接口 (Product): 定义了所有具体产品的共同接口。
具体产品 (ConcreteProductA, ConcreteProductB): 实现了产品接口的具体类。
创造者抽象类 (Creator): 声明了工厂方法，该方法返回一个产品对象。同时包含一些通用业务逻辑。
具体创造者 (ConcreteCreatorA, ConcreteCreatorB): 实现了具体的工厂方法，负责创建对应的具体产品。

通过这种方式，客户端不需要知道具体的产品是如何被创建的，只需要调用创造者的工厂方法即可获得所需的产品对象。这样使得系统更加灵活和可扩展。