工厂模式之抽象工厂

抽象工厂概念

        提供了一个封装创建一系列相关或相互依赖具有共同主体的工厂接口，而不指定他们具体的类。简单而言就是允许多个工厂，可生产不同品牌的产品。

抽象工厂优缺点

        （1）优点

                ①封装性高

                        将一种创建一系列相关或依赖对象的统一接口，使得客户端代码与具体产品的创建过程解耦

                ②一致性

                         每个工厂负责一整套产品，保证产品一致性，确保产品间互相匹配和依赖

                ③满足开闭原则

                        可通过添加新的具体工厂类来扩展系统，而无需修改现有代码。

        （2）缺点

                ①不易扩展产品等级结构

                        若要添加新产品等级结构时，需要修改抽象工厂接口和所有子类的实现。

                ②系统复杂性增加

                        每次添加新产品时导致产品等级结构增加，抽象工厂接口和子类也增加。

                ③结构臃肿

抽象工厂使用场景

        （1）产品系列创建

                                需要创建一组关联产品（不同产品等级结构、多个同等级结构），可确保一起创建

        （2）易替换产品

                                将产品创建封装在工厂类中，可以替换整个产品系列，不需要修改客户端代码

抽象工厂代码实现

// 定义ProductA接口
class ProductA {
public:
    virtual ~ProductA() {} // 虚拟析构函数，确保派生类析构时正确释放资源
    virtual void run() const = 0; // 抽象方法
};

// 定义ProductB接口
class ProductB {
public:
    virtual ~ProductB() {} // 虚拟析构函数
    virtual void run() const = 0; // 抽象方法
};

// ProductA的具体实现
class ConcreteProductA1 : public ProductA {
public:
    void run() const override {
        std::cout << "ConcreteProductA1 ProductA " << std::endl; // 产品A的具体实现
    }
};

// ProductB的具体实现
class ConcreteProductB1 : public ProductB {
public:
    void run() const override {
        std::cout << "ConcreteProductB1 ProductB " << std::endl; // 产品B的具体实现
    }
};

// 抽象工厂接口
class AbstractFactory {
public:
    virtual ~AbstractFactory() {} // 虚拟析构函数
    virtual ProductA* createProductA() const = 0; // 创建ProductA
    virtual ProductB* createProductB() const = 0; // 创建ProductB
};

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

    ProductB* createProductB() const override {
        return new ConcreteProductB1(); // 创建ProductB
    }
};


int main() {
    ConcreteFactory1 factory; // 使用具体工厂
    ProductA* productA = factory.createProductA(); // 创建ProductA
    ProductB* productB = factory.createProductB(); // 创建ProductB

    productA->run(); // 调用ProductA的run方法
    productB->run(); // 调用ProductB的run方法

    // 释放内存
    delete productA;
    delete productB;

    return 0;
}