简单工厂模式

简单工厂模式
定义一个工厂类，它可以根据不同的参数返回不同的实例，被创建的实例通常都有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态方法，所以简单工厂模式又被称为静态工厂模式。

上图解释如下：
Factory 工厂类，是简单工厂模式的核心，负责所有产品实例的逻辑，工厂类可以被外界外界直接调用，创建所需的产品对象，工厂类提供静态工厂方法，返回的类型为抽象产品类型Product。
Product 抽象产品角色，是工厂类创建的所有的对象的父类。封装了各种产品对象的共有方法。他的引入将提高系统的灵活性，使得在工厂类中只需要定义一个通用的工厂方法，以为所有创建的具体产品对象都是其子类的对象。
ConcreteProduct 它是简单工厂模式的创建目标，所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了产品角色，需要实现抽象产品中声明的抽象方法。

C++实现一个简单工厂模式：
AbstractProduct.h

#include <stdio.h>

class AbstractProduct{
public:
    AbstractProduct();
    virtual ~AbstractProduct();
    virtual void operation() = 0;
};

class ProductA:public AbstractProduct
{
public:
    ProductA();
    virtual ~ProductA();
    void operation();
};

class ProductB:public AbstractProduct
{
public:
    ProductB();
    virtual ~ProductB();
    void operation();
};

AbstractProduct.cpp

#include "AbstractProduct.h"

AbstractProduct::AbstractProduct(){}

AbstractProduct::~AbstractProduct(){}

ProductA::ProductA(){}

ProductA::~ProductA(){}

void ProductA::operation(){
    printf("hello productA\n");
}

ProductB::ProductB(){}

ProductB::~ProductB(){}

void ProductB::operation(){
    printf("hello productB\n");
}

SimpleFactory.h

#include <stdio.h>
#include "AbstractProduct.h"

class AbstractFactory
{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    virtual AbstractProduct * createProduct(int type) = 0;
};

class SimpleFactory:public AbstractFactory
{
public:
    SimpleFactory();
    ~SimpleFactory();
    AbstractProduct * createProduct(int type);
};

SimpleFactory.cpp

#include "SimpleFactory.h"


AbstractFactory::AbstractFactory(){}

AbstractFactory::~AbstractFactory(){}

SimpleFactory::SimpleFactory(){}

SimpleFactory::~SimpleFactory(){}

AbstractProduct * SimpleFactory::createProduct(int type)
{
    AbstractProduct * temp = NULL;
    if(1 == type){
        temp = new ProductA();
    }else if(2 == type) {
        temp = new ProductB();
    }
    return temp;
}

client.cpp

int main()
{
    AbstractFactory * factory = new SimpleFactory();
    AbstractProduct * product1 = factory->createProduct(1);
    product1->operation();
    delete product1;
    product1 = NULL;

    AbstractProduct * product2 = factory->createProduct(2);
    product2->operation();
    delete product2;
    product2 = NULL;
    system("pause");
}

运行结果：

可以看出简单工厂模式的优点：
1 隐藏了对象创建的细节，将产品的实例化推迟到子类中实现。
2 客户端不需要知道所创建的具体的类的名称，只提供相应的参数就可以了
缺点：
1 工厂类集中了所有产品的创建逻辑，职责过重。
2 每添加一个产品子类，都必须在工厂类中添加一个判断分支，这违背了开放-封闭原则。
3 要求产品子类的类型差不多，使用的方法名都相同，如果类比较多，而所有的类又必须要添加一种方法，则会是非常麻烦的事情。

对该模式的改进见下篇文章工厂方法模式，又称工厂模式。