设计模式七：抽象工厂模式(Abstract Factory Pattern)

抽象工厂模式(Abstract Factory Pattern)是一种创建型设计模式，它提供了一种方式来封装一组具有共同主题的独立工厂，而不需要指定它们的具体类。

基本概念

抽象工厂模式主要解决的是创建一系列相关或依赖对象的问题，而不需要指定它们的具体类。它通常包含：

1. 抽象工厂(Abstract Factory)：声明创建抽象产品对象的接口

2. 具体工厂(Concrete Factory)：实现创建具体产品对象的操作

3. 抽象产品(Abstract Product)：为一类产品对象声明接口

4. 具体产品(Concrete Product)：定义具体工厂创建的产品对象

实现示例

#include <iostream>
#include <memory>

// 抽象产品A
class AbstractProductA {
public:
    virtual ~AbstractProductA() = default;
    virtual void use() = 0;
};

// 具体产品A1
class ProductA1 : public AbstractProductA {
public:
    void use() override {
        std::cout << "Using Product A1" << std::endl;
    }
};

// 具体产品A2
class ProductA2 : public AbstractProductA {
public:
    void use() override {
        std::cout << "Using Product A2" << std::endl;
    }
};

// 抽象产品B
class AbstractProductB {
public:
    virtual ~AbstractProductB() = default;
    virtual void operate() = 0;
};

// 具体产品B1
class ProductB1 : public AbstractProductB {
public:
    void operate() override {
        std::cout << "Operating Product B1" << std::endl;
    }
};

// 具体产品B2
class ProductB2 : public AbstractProductB {
public:
    void operate() override {
        std::cout << "Operating Product B2" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() = default;
    virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA1>();
    }
    
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB1>();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA2>();
    }
    
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB2>();
    }
};

// 客户端代码
void clientCode(const AbstractFactory& factory) {
    auto productA = factory.createProductA();
    auto productB = factory.createProductB();
    
    productA->use();
    productB->operate();
}

int main() {
    std::cout << "Client: Testing client code with the first factory type:\n";
    ConcreteFactory1 factory1;
    clientCode(factory1);
    
    std::cout << "\nClient: Testing client code with the second factory type:\n";
    ConcreteFactory2 factory2;
    clientCode(factory2);
    
    return 0;
}

UML结构

优点

1. 隔离具体类：客户端代码只与抽象接口交互，不依赖于具体实现

2. 产品一致性：确保从同一工厂创建的产品是兼容的

3. 易于交换产品系列：只需改变具体工厂即可切换整个产品系列

4. 符合开闭原则：添加新产品系列时不需要修改现有代码

缺点

1. 扩展困难：添加新产品需要修改抽象工厂接口及其所有子类

2. 复杂性增加：代码结构变得更加复杂，增加了理解和维护的难度

适用场景

1. 系统需要独立于其产品的创建、组合和表示时

2. 系统需要配置多个产品系列中的一个时

3. 需要强调一系列相关产品对象的设计以便进行联合使用时

4. 提供一个产品类库，只想显示它们的接口而非实现时

抽象工厂模式是工厂方法模式的进一步抽象，适用于产品结构较复杂、产品系列较多的情况。