创建型 简单工厂(工厂方法)模式

工厂模式 ：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

​ 属于创建型模式。

工厂模式(Factory Pattern)： 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

简单工厂模式的实现：

1：逻辑分析：

​ 1：产品的创建交给一个单独的类来管理

​ 2：此类提供全局的访问接口，根据输入条件的不同来创建不同的对象

2：使用分析

​ 1：创建工厂，根据输入的条件来创建对应的产品

​ 2：在创建产品时，返回产品的接口指针

​ 3：通过此指针来操作相应的对象

3：参考demo源码

/**************************************************************
简单工厂：
    1.产品的创建交给一个单独的类来管理
    2.此类提供全局的访问接口，根据输入条件的不同来创建不同的对象
使用：
    1.创建工厂，根据输入的条件来创建对应的产品
    2.在创建产品时，返回产品的接口指针
    3.通过此指针来操作相应的对象
***************************************************************/
#include <iostream>
#include <string.h>
using namespace std;
class Fruit
{ 
public:
    virtual void getFruit() = 0;
    virtual ~Fruit() {};
};

class Banana : public Fruit
{
public:
    virtual void getFruit()
    {
        cout << "香蕉" << endl;
    }
};

class Pear : public Fruit
{
public:
    virtual void getFruit()
    {
        cout << "梨子" << endl;
    }
};

class Factory
{
public:
    static Fruit* Create(const char *name)
    {
        Fruit *tmp = NULL;
        if (strcmp(name, "pear") == 0)
        {
            tmp = new Pear();
        }
        else if (strcmp(name, "banana") == 0)
        {
            tmp = new Banana();
        }
        else
        {
            return NULL;
        }
        return tmp;
    }
};
int main()
{
    Fruit *pear = Factory::Create("pear");
    if (pear == NULL)
    {
        cout << "创建pear失败\n";
    }
    pear->getFruit();
    Fruit *banana = Factory::Create("banana");
    if (banana == NULL)
    {
        cout << "创建banana失败\n";
    }
    banana->getFruit();

    if(pear != nullptr)
    {
        delete pear;
        pear = nullptr;
    }

    if(banana != nullptr)
    {
        delete banana;
        banana = nullptr;
    }
    return 0;
}

思考：这里的工厂类依赖函数的入参决定，内部做判断进行初始化，可以用继承的方式，用特定的类来对其特定工厂进行初始化。

工厂方法模式

逻辑分析：

​ 父类负责定义创建对象的公共接口，子类负责具体以的对象。

​ 类的实例化操作延迟到子类中完成，子类决定创建的对象实例类型。

源码demo:

/*********************************************************
工厂方法：
    与简单工厂的区别，将产品的创建分别委托给单独的类，即一个工厂对应一个产品
    而不是将所有产品的创建交给一个类来管理
    1.首先创建工厂
    2.通过此工厂来获取对应的产品（将对象的创建放到工厂中创建）
***********************************************************/
#include <iostream>
#include <string.h>
using namespace std;

//工厂具体产品基类 
class Fruit
{
public:
    virtual void sayname() = 0;
    virtual ~Fruit(){};
};

//工厂对象基类
class FruitFactory
{
public:
    virtual Fruit* getFruit() = 0;
    virtual void destroyFruit() = 0;
    virtual ~FruitFactory() {};
};

//每个产品对应一个产品属性类和工厂创建类
class Banana : public Fruit
{
public:
    virtual void sayname()
    {
        cout << "Banana " << endl;
    }
};

//每一个对象的实例化其实就是一个产品
class BananaFactory : public FruitFactory
{
public:
    virtual Fruit* getFruit()
    {
        _ba = new Banana;
        return _ba;
    }

    virtual void destroyFruit()
    {
        if(_ba != nullptr)
        {
            delete _ba;
            _ba = nullptr;
        } 
    }
public:
    Banana* _ba;
};

//每个产品对应一个产品属性类和工厂创建类
class Apple : public Fruit
{
public:
    virtual void sayname()
    {
        cout << "Apple " << endl;
    }
};

class AppleFactory : public FruitFactory
{
public:
    virtual Fruit* getFruit()
    {
        _ap = new Apple;
        return _ap;
    }

    virtual void destroyFruit()
    {
        if(_ap != nullptr)
        {
            delete _ap;
            _ap = nullptr;
        } 
    }
public:
    Apple * _ap;
};
int main()
{
    FruitFactory * ff = new BananaFactory();
    Fruit *fruit = ff->getFruit();
    fruit->sayname();
    ff->destroyFruit();
    // delete fruit;
    delete ff;

    ff = new AppleFactory();
    fruit = ff->getFruit();
    fruit->sayname();
    ff->destroyFruit();
    // delete fruit;
    delete ff;
    return 0;
}

思考如何扩展：如果产品有多个属性时，可以扩展工厂的函数参数来构造产品。