7.工厂方法模式

1.简介

工厂模式是一种创建型设计模式，用于动态的创建对象。

组成部分：

1. 抽象产品
   声明具体产品的接口，放在稳定的方法里
2. 具体产品
   产品接口的实现
3. 抽象工厂
   提供创建产品的接口，放在稳定的方法里
4. 具体工厂
   用于创建具体的产品

如果有一个稳定的方法，里面有一个产品对象，当我们需要使用A产品时要在代码里new A，如果想要在里面使用B产品时要new B，这违反了开闭原则，不应该修改代码，工厂模式是为了解决这一问题。

2.问题

现在有一个 产品A类 、 产品B类和一个用于检查产品的CheckProduct类，当我想检查产品A时如下代码

//-----------------
// 产品
//-----------------
// 抽象产品类
class Product {
public:
    virtual ~Product() = default;

    // 展示类信息 抽象方法
    virtual void showInfo() = 0;

};

// 具体产品类A
class ProductA : public Product {
public:
    // 重写 showInfo 方法
    void showInfo() {
        std::cout << "ProductA" << std::endl;
    }

};

// 具体产品类B
class ProductB : public Product {
public:
    // 重写 showInfo 方法
    void showInfo() {
        std::cout << "ProductB" << std::endl;
    }

};


// -----------------
// CheckProduct 类
// -----------------
class CheckProduct {
public:
    // 检查产品
    void check() {
        Product *product = new ProductA;
        product->showInfo();
        delete product;
    }
};

假设 CheckProduct 是稳定的，当我们想 check ProductB 是就需要 new ProductB，这样会修改CheckProduct，这样就不太好。

如何使用工厂模式解决上面的问题？

3.使用工厂模式

根据==依赖倒置原则==，CheckProduct是稳定的，就不能依赖ProductA，因为不稳定，而是依赖Product这个抽象的类，但是这样不能使用new创建产品对象。

为了能创建对象，除了new还可以使用方法返回一个对象。这个创建产品对象的对象就是工厂，用于创建产品对象。

具体实现看代码

产品类

// 抽象产品类
class Product {
public:
    virtual ~Product() = default;
    
    // 展示类信息 抽象方法
    virtual void showInfo() = 0;

};

// 具体产品类A
class ProductA : public Product {
public:
    // 重写 showInfo 方法
    void showInfo() {
        std::cout << "ProductA" << std::endl;
    }
};

// 具体产品类B
class ProductB : public Product {
public:
    // 重写 showInfo 方法
    void showInfo() {
        std::cout << "ProductB" << std::endl;
    }
};

工厂类

// 抽象工厂
class Factory {
public:
    virtual ~Factory() = default;
    
    // 返回产品的抽象类
    virtual Product* createProduct() = 0;
};

// A工厂
class FactoryA : public Factory {
public:
    // 重写 createProduct 方法
    Product* createProduct() {
        return new ProductA;
    }
};

// B工厂
class FactoryB : public Factory {
public:
    // 重写 createProduct 方法
    Product* createProduct() {
        return new ProductB;
    }

};

CheckProduct 类

class CheckProduct {
public:
    Factory *factory;   // 工厂
    
    CheckProduct(Factory *factory) {
        this->factory = factory;
    }
    
    ~CheckProduct() {
        delete factory;
    }
    
    // 检查产品
    void check() {
        Product *product = factory->createProduct();
        product->showInfo();
        delete product;
    }
};

main

int main(int argc, char const *argv[])
{
    // 工厂A
    FactoryA *f_A = new FactoryA;
    
    // CheckProduct 对象
    CheckProduct *check_p = new CheckProduct(f_A);
    check_p->check();   // 输出 ProductA
    
     // 工厂B
    FactoryB *f_B = new FactoryB;
    check_p->factory = f_B;
    check_p->check();   // 输出 ProductB
    
    delete check_p;
    delete f_A;
    delete f_B;
    return 0;
}

这样做的好处是保护了CheckProduct对象，即使在添加新产品对象时也不需要修改CheckProduct。

CheckProduct类有一个factory成员变量，用于创建产品对象，factory由外部传入，保证CheckProduct的稳定。