设计模式-工厂模式

简单工厂的实现流程：

1. 设计一个抽象产品类，它包含一些公共方法的实现。
2. 从抽象产品类中派生出多个具体产品类，如篮球类，足球类，排球类，具体产品类中实现具体产品生产的相关代码。
3. 设计一个工厂类，工厂类中提供一个生产各种产品的工厂方法，该方法根据传入参数(产品名称)创建不同的具体产品类对象。
4. 客户只需要调用工厂类的工厂方法，并传入具体产品参数，就可以得到一个具体产品对象。

示例代码1：

// 抽象产品类AbstractProduct
class AbstractProduct
{
public:
    // 抽象方法
};

// 具体产品类Basketball
class ConcreateProduct: public AbstractProduct
{
public:
    // 具体实现方法
};

class Factory
{
public:
    AbstractProduct createProduct(string productName)
    {
        AbstractProduct pro = NULL;
        if (productName == "ProductA") {
            pro = new ProductA();
        } else if (productName == "ProductB") {
            pro = new ProductB();
        }
    }
};

实例代码2： 小明要进行户外运动，他可以选择打篮球，踢足球或者玩排球，它需要去球类保管室拿球，管理员根据小明需要的球提供对应的球。 若使用简单工厂模式来实现上述场景，首先球类保管室是工厂，篮球，足球和排球是具体的产品，而抽象产品类可以定义为运动球类，SprotProduct，工厂根据球类名字，工厂生产出对应的产品即可。

#include <iostream>
#include <memory>
using namespace std;

/*
 * 抽象产品类AbstractProduct
 * 定义抽象产品类AbstrctProduct，抽象方法不提供实现
*/
 class AbstractSportProduct
{
public:
    AbstractSportProduct() {};
    virtual ~AbstractSportProduct() {};
    // 抽象方法
    // virtual void printName() {};
    virtual void printName() = 0;
    // virtual void play() {};
    virtual void play() = 0;
};

/*
 * 定义三个具体产品类
 * */
class Basketball: public AbstractSportProduct
{
public:
    Basketball() {
        printName();
        play();
    }
    ~Basketball() {

    }

    // 具体实现方法
    void printName() {
        printf("Jungle get Baseketball\n");
    }
    void play() {
        printf("Jungle play Baseketball\n");
    }
};

class Football: public AbstractSportProduct
{
public:
    Football() {
        printName();
        play();
    }
    ~Football() {

    }

    // 具体实现方法
    void printName() {
        printf("Jungle get Football\n");
    }
    void play() {
        printf("Jungle play Football\n");
    }
};

class Volleyball: public AbstractSportProduct
{
public:
    Volleyball() {
        printName();
        play();
    }
    ~Volleyball() {

    }

    // 具体实现方法
    void printName() {
        printf("Jungle get Volleyball\n");
    }
    void play() {
        printf("Jungle play Volleyball\n");
    }
};

/*
 * 定义工厂类和工厂方法
 */
class Factory
{
public:
    shared_ptr<AbstractSportProduct> getSportProduct(string productName)
    {
        shared_ptr<AbstractSportProduct> pro;
        if (productName == "Basketball") {
            pro = shared_ptr<AbstractSportProduct>(new Basketball());
        } else if (productName == "Football") {
            pro = shared_ptr<AbstractSportProduct>(new Football());
        } else if (productName == "Volleyball") {
            pro = shared_ptr<AbstractSportProduct>(new Volleyball());
        }
        return pro;
    }
};

/*
 * 客户端使用方法
 */


int main()
{
    printf("简单工厂模式\n");
    // 定义工厂类对象
    shared_ptr<Factory> fac = std::make_shared<Factory>();
    shared_ptr<AbstractSportProduct> product = fac->getSportProduct("Basketball");

    fac = make_shared<Factory>();
    product = fac->getSportProduct("Football");

    fac = make_shared<Factory>();
    product = fac->getSportProduct("Volleyball");

    return 0;
}

简单工厂模式的优点在于：

1. 工厂类提供具体产品的方法，并包含一定判断逻辑，客户不必参与产品的创建过程。
2. 客户只需要知道对应产品的参数即可，参数一般简单好记，如数字，字符或者字符串等。 简单工厂模式的缺点在于： 如果有一天小明想玩其他球了，如果在工厂类的getSportProduct方法中增加"productName == "newBall"，但是这样违反了开闭原则(对扩展开放，对修改关闭)，即在扩展功能时修改了既有的代码，另一方面，简单工厂模式所有的判断逻辑都在工厂类中实现，一旦工厂类设计故障，整个系统都受之影响。