设计模式之抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一个接口，用于创建相关或依赖对象的家族，而无需明确指定具体类。抽象工厂模式的核心思想是定义一组接口或抽象类来创建一系列相关对象的产品，每个具体工厂类负责生产这些产品的具体实例。

抽象工厂模式的结构

抽象工厂模式通常包含以下几个部分：

1. 抽象工厂（Abstract Factory）：定义创建一系列相关对象的接口。
2. 具体工厂（Concrete Factory）：实现抽象工厂接口，负责实例化具体的产品。
3. 抽象产品（Abstract Product）：定义产品的接口。
4. 具体产品（Concrete Product）：实现抽象产品的具体类。
5. 客户端（Client）：使用抽象工厂和抽象产品的接口进行编程，不直接依赖于具体工厂和具体产品。

类图

以下是抽象工厂模式的类图：

    +-------------------+        +-------------------+
    |  AbstractFactory  |        |  AbstractProductA |
    +-------------------+        +-------------------+
    | +CreateProductA() |        |                   |
    | +CreateProductB() |        +-------------------+
    +-------------------+               ▲
           ▲                            |
           |                            |
+-------------------+        +-------------------+
| ConcreteFactory1  |        |  ConcreteProductA1|
+-------------------+        +-------------------+
| +CreateProductA() |        |                   |
| +CreateProductB() |        +-------------------+
+-------------------+                   ▲
           ▲                            |
           |                            |
+-------------------+        +-------------------+
| ConcreteFactory2  |        |  ConcreteProductA2|
+-------------------+        +-------------------+
| +CreateProductA() |        |                   |
| +CreateProductB() |        +-------------------+
+-------------------+                

C++ 示例代码

下面是一个简单的抽象工厂模式的C++代码示例，模拟了创建不同风格的家具（例如现代风格和复古风格）：

#include <iostream>
#include <memory>

// 抽象产品A
class Chair {
public:
    virtual void sit() = 0;
};

// 抽象产品B
class Sofa {
public:
    virtual void lie() = 0;
};

// 具体产品A1
class ModernChair : public Chair {
public:
    void sit() override {
        std::cout << "Sitting on a modern chair." << std::endl;
    }
};

// 具体产品B1
class ModernSofa : public Sofa {
public:
    void lie() override {
        std::cout << "Lying on a modern sofa." << std::endl;
    }
};

// 具体产品A2
class VictorianChair : public Chair {
public:
    void sit() override {
        std::cout << "Sitting on a Victorian chair." << std::endl;
    }
};

// 具体产品B2
class VictorianSofa : public Sofa {
public:
    void lie() override {
        std::cout << "Lying on a Victorian sofa." << std::endl;
    }
};

// 抽象工厂
class FurnitureFactory {
public:
    virtual std::unique_ptr<Chair> createChair() = 0;
    virtual std::unique_ptr<Sofa> createSofa() = 0;
};

// 具体工厂1
class ModernFurnitureFactory : public FurnitureFactory {
public:
    std::unique_ptr<Chair> createChair() override {
        return std::make_unique<ModernChair>();
    }

    std::unique_ptr<Sofa> createSofa() override {
        return std::make_unique<ModernSofa>();
    }
};

// 具体工厂2
class VictorianFurnitureFactory : public FurnitureFactory {
public:
    std::unique_ptr<Chair> createChair() override {
        return std::make_unique<VictorianChair>();
    }

    std::unique_ptr<Sofa> createSofa() override {
        return std::make_unique<VictorianSofa>();
    }
};

// 客户端代码
void clientCode(FurnitureFactory& factory) {
    auto chair = factory.createChair();
    auto sofa = factory.createSofa();
    chair->sit();
    sofa->lie();
}

int main() {
    ModernFurnitureFactory modernFactory;
    VictorianFurnitureFactory victorianFactory;

    std::cout << "Using modern furniture factory:" << std::endl;
    clientCode(modernFactory);

    std::cout << "\nUsing Victorian furniture factory:" << std::endl;
    clientCode(victorianFactory);

    return 0;
}

代码解释

• 抽象工厂（FurnitureFactory）：定义创建椅子和沙发的接口。
• 具体工厂（ModernFurnitureFactory, VictorianFurnitureFactory）：实现了抽象工厂接口，负责生产具体风格的椅子和沙发。
• 抽象产品（Chair, Sofa）：定义椅子和沙发的接口。
• 具体产品（ModernChair, ModernSofa, VictorianChair, VictorianSofa）：实现了抽象产品的具体类。
• 客户端代码（clientCode）：接受一个抽象工厂作为参数，通过工厂接口创建产品，而无需知道具体的产品类。

这种模式的优点是可以很容易地更换工厂，进而更换一整套产品的具体实现，而无需修改客户端代码。