工厂方法模式（Factory Method Pattern）

概念

工厂方法模式是一种创建型设计模式，它提供了一种将对象的创建委托给子类的方式。在工厂方法模式中，定义一个创建对象的接口，但让子类决定实例化哪个类。这样，工厂方法模式让类的实例化推迟到子类中进行。

思想

工厂方法模式的核心思想是将对象的创建与使用分离，通过引入工厂类，将具体产品的创建过程封装在工厂类中，客户端只需要通过工厂类来创建产品对象，而无需关心具体的创建过程。

角色

• 抽象产品（AbstractProduct）：定义产品的共同接口，所有具体产品都必须实现这个接口。
• 具体产品（ConcreteProduct）：实现抽象产品接口的具体产品类。
• 抽象工厂（AbstractFactory）：定义创建产品对象的接口，声明了工厂方法。
• 具体工厂（ConcreteFactory）：实现抽象工厂接口，具体负责创建具体产品的对象。

优点

• 将对象的创建与使用分离，客户端代码只依赖于抽象产品和抽象工厂，与具体产品无关，从而实现了解耦。
• 可以在运行时动态切换具体工厂，实现灵活的产品创建。

缺点

• 增加了系统的复杂度，引入了许多新的类和接口。
• 当产品族数量较多时，会导致类的数量增加。

类图

@startuml

class Client {
  +createProduct(): AbstractProduct
}

note right of Client::createProduct
  Client通过抽象工厂创建产品
end note

abstract class AbstractProduct {
  +operation(): void
}

class ConcreteProductA {
  +operation(): void
}

class ConcreteProductB {
  +operation(): void
}

abstract class AbstractFactory {
  +createProduct(): AbstractProduct
}

class ConcreteFactoryA {
  +createProduct(): AbstractProduct
}

class ConcreteFactoryB {
  +createProduct(): AbstractProduct
}

Client --> AbstractFactory
AbstractProduct <|-- ConcreteProductA
AbstractProduct <|-- ConcreteProductB
AbstractFactory <|-- ConcreteFactoryA
AbstractFactory <|-- ConcreteFactoryB
ConcreteFactoryA --> ConcreteProductA
ConcreteFactoryB --> ConcreteProductB

@enduml

时序图

@startuml

actor Client

Client -> AbstractFactory: createProduct()
AbstractFactory -> ConcreteFactoryA: createProduct()
ConcreteFactoryA -> ConcreteProductA: new ConcreteProductA()
ConcreteFactoryA --> AbstractProduct
AbstractProduct -> ConcreteProductA: operation()

@enduml

示例代码

下面是一个使用C++实现的工厂方法模式的示例代码：

#include <iostream>

// 抽象产品
class AbstractProduct {
public:
    virtual void operation() = 0;
};

// 具体产品 A
class ConcreteProductA : public AbstractProduct {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation." << std::endl;
    }
};

// 具体产品 B
class ConcreteProductB : public AbstractProduct {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation." << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual AbstractProduct* createProduct() = 0;
};

// 具体工厂 A
class ConcreteFactoryA : public AbstractFactory {
public:
    AbstractProduct* createProduct() override {
        return new ConcreteProductA();
    }
};

// 具体工厂 B
class ConcreteFactoryB : public AbstractFactory {
public:
    AbstractProduct* createProduct() override {
        return new ConcreteProductB();
    }
};

int main() {
    AbstractFactory* factoryA = new ConcreteFactoryA();
    AbstractProduct* productA = factoryA->createProduct();
    productA->operation();  // 输出：ConcreteProductA operation.

    AbstractFactory* factoryB = new ConcreteFactoryB();
    AbstractProduct* productB = factoryB->createProduct();
    productB->operation();  // 输出：ConcreteProductB operation.

    delete productA;
    delete factoryA;
    delete productB;
    delete factoryB;

    return 0;
}

代码运行结果：

ConcreteProductA operation.
ConcreteProductB operation.

示例代码中创建了抽象产品（AbstractProduct）及其两个具体产品（ConcreteProductA 和 ConcreteProductB），抽象工厂（AbstractFactory）及其两个具体工厂（ConcreteFactoryA 和 ConcreteFactoryB）。客户端通过具体工厂来创建具体产品对象，并调用产品对象的操作（operation）方法。示例代码输出了具体产品的操作结果。