[设计模式]抽象工厂模式

抽象工厂模式

定义

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它能够将一组相关的对象（即产品）集合到一起，而不需要指定其具体类。这种模式与工厂模式相似，但是它更加抽象。

结构

1. 抽象工厂（AbstractFactory）：定义了一组用于创建抽象产品的方法。
2. 具体工厂（ConcreteFactory）：实现了创建具体产品的方法。
3. 抽象产品（AbstractProduct）：定义了产品通用的接口。
4. 具体产品（ConcreteProduct）：实现抽象产品接口中的具体行为。

示例

以下是一个简单的抽象工厂模式示例。

#include <iostream>

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

// 具体产品 A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void operation() override {
        std::cout << "ConcreteProductA1::operation()" << std::endl;
    }
};

// 具体产品 A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void operation() override {
        std::cout << "ConcreteProductA2::operation()" << std::endl;
    }
};

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

// 具体产品 B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void operation() override {
        std::cout << "ConcreteProductB1::operation()" << std::endl;
    }
};

// 具体产品 B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void operation() override {
        std::cout << "ConcreteProductB2::operation()" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

// 具体工厂 1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA1();
    }

    AbstractProductB* createProductB() override {
        return new ConcreteProductB1();
    }

};

// 具体工厂 2
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA2();
    }

    AbstractProductB* createProductB() override {
        return new ConcreteProductB2();
    }

};

// 客户端
int main() {
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();
    productA1->operation();
    productB1->operation();

    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();
    productA2->operation();
    productB2->operation();
    
    delete factory1;
    delete factory2;
    delete productA1;
    delete productB1;
    delete productA2;
    delete productB2;
    
    return 0;

}

在上面的示例中，我们定义了四个类：

1. AbstractProductA 和 AbstractProductB 是抽象产品，定义了产品通用的接口。
2. ConcreteProductA1 、 ConcreteProductA2 、 ConcreteProductB1 和 ConcreteProductB2 是具体产品，实现了抽象产品接口中的具体行为。
3. AbstractFactory 是抽象工厂，定义了一组用于创建抽象产品的方法。
4. ConcreteFactory1 和 ConcreteFactory2 是具体工厂，实现了创建具体产品的方法。

在客户端代码中，我们首先创建 ConcreteFactory1 对象并使用它创建 ConcreteProductA1 和 ConcreteProductB1 对象。然后我们使用 ConcreteFactory2 对象创建 ConcreteProductA2 和 ConcreteProductB2 对象。最后，我们销毁使用的对象。

使用场景

• 当你需要创建一组相关的对象，并且你不希望将它们的类公开给客户端时，可以使用抽象工厂模式。
• 当你需要创建一组相关的对象，并且你可能需要根据环境或配置的变化使用不同的实现时，可以使用抽象工厂模式。
• 当你需要提供一个类库，让其它开发者能够方便地扩展和替换其中的组件时，可以使用抽象工厂模式。

优点

• 抽象工厂模式能够将一组相关的对象（即产品）集合到一起，而不需要指定其具体类。
• 抽象工厂模式能够使客户端代码与具体产品实现解耦，使其更加灵活和可维护。
• 抽象工厂模式能够在不修改客户端代码的情况下，动态修改所使用的产品族。

缺点

• 当需要添加新产品时，必须更改抽象工厂接口及其所有现有实现。这可能需要大量的工作，特别是在系统已经运行一段时间后。
• 抽象工厂增加了代码的复杂性，因为它需要更多的类和接口。

总结

抽象工厂模式是一种创建型设计模式，它能够将一组相关的对象（即产品）集合到一起，而不需要指定其具体类。抽象工厂模式与工厂方法模式相似，但是它更加抽象。抽象工厂模式能够使客户端代码与具体产品实现解耦，使其更加灵活和可维护。抽象工厂模式能够在不修改客户端代码的情况下，动态修改所使用的产品族。但是抽象工厂模式增加了代码的复杂性，因为它需要更多的类和接口。