设计模式之简单工厂模式(Simple Factory Pattern) 创建型模式

工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。工厂模式有以下几种形态：

简单工厂（Simple Factory）模式

工厂方法（Factory Method）模式

抽象工厂（Abstract Factory）模式

Simple Factory模式根据提供给它的数据，返回几个可能类中的一个类的实例。通常它返回的类都有一个公共的父类和公共的方法。

Simple Factory模式实际上不是GoF 23个设计模式中的一员。

工厂类角色Creator (LightSimpleFactory)：工厂类在客户端的直接控制下（Create方法）创建产品对象。

抽象产品角色Product (Light)：定义简单工厂创建的对象的父类或它们共同拥有的接口。可以是一个类、抽象类或接口。

具体产品角色ConcreteProduct (BulbLight, TubeLight)：定义工厂具体加工出的对象。

/* ----------------------------------Light.h-------------------------------------------- */
#ifndef _LIGHT_H_
#define _LIGHT_H_
#include<iostream>
#include<string>
using namespace std;
class Light
{
public:
virtual void turnOn();
virtual void turnOff();
};

class BulbLight:public Light
{
public:
void turnOn();
void turnOff();
};
class TubeLight:public Light
{
public:
void turnOn();
void turnOff();
};
#endif

/*----------------------------------------- Light.cpp--------------------------------------- */
#include<iostream>
using namespace std;
#include "Light.h"
void Light::turnOn()
{
}
void Light::turnOff()
{
}

void BulbLight::turnOn()
{
cout<<"Bulb Light is turned on"<<endl;
}
void BulbLight::turnOff()
{
cout<<"Bulb Light is turned off"<<endl;
}

void TubeLight::turnOn()
{
cout<<"Tube Light is turned on"<<endl;
}

void TubeLight::turnOff()
{
cout<<"Tube Light is turned off"<<endl;
}

/*------------------------------------------- LightSimpleFactory----------------------------------------- */
#ifndef _LIGHTSIMPLEFACTORY_H_
#define _LIGHTSIMPLEFACTORY_H_
#include "Light.h"
class LightSimpleFactory
{
public:
Light * create(const string & lightType);
};
#endif

/* ----------------------------------------LightSimpleFactory.cpp --------------------------------------------*/
#include "LightSimpleFactory.h"
Light* LightSimpleFactory::create(const string & lightType)
{
if(lightType == "Bulb")
return new BulbLight();
else if(lightType == "Tube")
return new TubeLight();
else
return NULL;
}

/* ----------------------------------------------main.cpp -------------------------------------------------------*/
#include "LightSimpleFactory.h"
void main()
{
string name = "Bulb";
LightSimpleFactory lsf;
Light * l = lsf.create(name);
if(l!=NULL)

{
l->turnOn();
l->turnOff();
delete l;
}
cout<<"---------------------------"<<endl;
name = "Tube";
l = lsf.create(name);
if(l!=NULL)

{
l->turnOn();
l->turnOff();
delete l;
}
}

Simple Factory模式演化（一）

程序举例：

/*--------------------------------------Light.h-----------------------------------------*/

#ifndef _LIGHT_H_

#define _LIGHT_H_

#include<iostream>

#include<string>

using namespace std;

class Light

{

public:

virtual void turnOn();

virtual void turnOff();

static Light * create(const string & lightType);

};

class BulbLight:public Light

{

public:

void turnOn();

void turnOff();

};

class TubeLight:public Light

{

public:

void turnOn();

void turnOff();

};

#endif

/*--------------------------------------------------Light.cpp--------------------------------------*/

#include "Light.h"
void Light::turnOn()
{
}
void Light::turnOff()
{
}
Light* Light::create(const string & lightType)
{
if(lightType == "Bulb")
return new BulbLight();
else if(lightType == "Tube")
return new TubeLight();
else
return NULL;
}

void BulbLight::turnOn()
{
cout<<"Bulb Light is turned on"<<endl;
}
void BulbLight::turnOff()
{
cout<<"Bulb Light is turned off"<<endl;
}

void TubeLight::turnOn()
{
cout<<"Tube Light is turned on"<<endl;
}
void TubeLight::turnOff()
{
cout<<"Tube Light is turned off"<<endl;
}

/*----------------------------------------------main.cpp--------------------------------*/

#include "Light.h"
void main()
{
string name = "Bulb";
Light * l = Light::create(name);
if(l!=NULL)

{
l->turnOn();
l->turnOff();
delete l;
}
cout<<"---------------------------"<<endl;
name = "Tube";
l = Light::create(name);
if(l!=NULL)

{
l->turnOn();
l->turnOff();
delete l;
}
}

Simple Factory模式演化（二）

三个角色全部合并：

与单例模式（Singleton）相近，但是有区别.

为了提高内聚（Cohesion）和松耦合（Coupling） ，我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。 这样我们可以通过声明

一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题 n 多的子类继承自抽象基类，我们不得不在每次要

用到子类的地方就编写诸如 new ×××;的代码.

这里带来两个问题

1）客户程序员必须知道实际子类的名称，当系统复杂后，命名将是一个很不好处理的问题，为了处理可能的名字冲突，有的命名可能并不是具有

很好的可读性和可记忆性。 程序的扩展性和维护变得越来越困难.
2）还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。这里的意思为：假设我们在类 A 中要使用到类 B，B 是一个抽象父类

，在 A 中并不知道具体要实例化那一个 B 的子类，但是在类 A的子类 D中是可以知道的。在 A中我们没有办法直接使用类似于 new ×××的

语句，因为根本就不知道×××是什么.

以上两个问题也就引出了 Factory模式的两个最重要的功能
1）定义创建对象的接口，封装了对象的创建;
2）使得具体化类的工作延迟到了子类中.
Factory模式也带来至少以下两个问题;
1）如果为每一个具体的 ConcreteProduct 类的实例化提供一个函数体，那么我们可能不得不在系统中添加了一个方法来处理这个新建的

ConcreteProduct，这样 Factory 的接口永远就不肯能封闭（Close） 。当然我们可以通过创建一个 Factory的子类来通过多态实现这

一点，但是这也是以新建一个类作为代价的.
2）在实现中我们可以通过参数化工厂方法，即给 FactoryMethod（）传递一个参数用以决定是创建具体哪一个具体的 Product 。当然也

可以通过模板化避免 1）中的子类创建子类，其方法就是将具体 Product 类作为模板参数，实现起来也很简单.

优点：
工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅"消费"产品。简单工厂模式通过这种做法实现了对责任的分割。

缺点：
当产品有复杂的多层等级结构时，工厂类只有自己，以不变应万变，就是模式的缺点。因为工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。

同时，系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，有可能造成工厂逻辑过于复杂。

另外，简单工厂模式通常使用静态工厂方法，这使得无法由子类继承，造成工厂角色无法形成基于继承的等级结构。

Factory模式仅仅局限于一类类（就是说Product是一类，有一个共同的基类）,如果我们要为不同的类提供一个对象创建的接口，那就要用AbstractFactory了。

实际使用：

在构造数据库类时，可以用简单工程模式。先抽化出所有数据库操作的公共基类DataBase，比如connect,insert,update,delete等操作,
然后构造实际的数据库类继承改基类，如ORACLE ,SQL SERVER.,TT,DB2,等，最后创建工厂类