设计模式-工厂方法 简单工厂 抽象工厂 模板方法

简单工厂模式：
创建多种不同类型的产品，根据传入参数的类型进行创建。

只有一个Creator方法，负责多种不同的产品的创建，传入参数的类型来决定具体创建哪种产品，实现简单，但是如果需要扩展产品的话，就需要修改Creator方法的实现。

有一个Pizza店，可以生产不同种类的Pizza，对于此代码简单如下：

//这是一个抽象的pizza，有很多不同种类的pizza，继承于它。

class AbstractPizza
{
public:
AbstractPizza(void);
virtual ~AbstractPizza(void);
virtual void Taste() = 0;
int m_nPizzaType;
};

//具体的pizza，继承于抽象pizza。还有其他的多种不同类型的Pizza。

class SimplePizzaFactory
{
public:
enum PizzaType{
CheesePizzaTpe,
GreekPizzaType,
PipperPizzaType,
//..可以继续后续添加
};
SimplePizzaFactory(void);
~SimplePizzaFactory(void);
AbstractPizza* CreatePizzaByType(PizzaType type){
switch (type)
{
case SimplePizzaFactory::CheesePizzaTpe:
{
return new CheesePizza;
//if you want, you can do additional initialization for new CheesePizza;
//like:
//AbstractPizza* pizza = new CheesePizza;
//assert(pizza);
//pizza->Initialize();
}
case SimplePizzaFactory::GreekPizzaType:
{
return new GreekPizza;
//if you want, you can do additional initialization for new CheesePizza;
}
case SimplePizzaFactory::PipperPizzaType:
{
return new PipperPizza;
//if you want, you can do additional initialization for new CheesePizza;
}
default:
break;
}
}
};

为了我们更好的管理Pizza的创建过程，一般我们会创建一个管理类，它负责创建不同种类的pizza产品。通过SimplePizzaFactory工厂的管理，我们通过传入不同的类型就可以不同种类的pizza产品，外部的调用者只需要传入类型，Creator方法就会返回正确的AbstractPizza的具体类型。甚至于你可以将SimplePizzaFactory定义为单例模式(如果工厂需要数据成员的话)便于以全局变量的方式使用。或者将CreatePizzaByType定义为静态方法(如果没有相关任何数据成员)，这样的话就不用创建任何工程对象，直接SimplePizzaFactory::CreatePizzaByType(nPizzaType)就可以，操作更简答。它既然叫简单工厂，确实足够简单，只有一个Creator方法(不过不能叫做工厂方法，注意没有继承)，当有新的产品添加进来，必须需要修改Creator方法，以满足新的产品创建的需要，不过说实话这种简单工厂模式对于平常的很多程序都足够。

class SimplePizzaFactory
{
public:
enum PizzaType{
CheesePizzaTpe,
GreekPizzaType,
PipperPizzaType,
//..可以继续后续添加
};
SimplePizzaFactory(void);
~SimplePizzaFactory(void);
AbstractPizza* CreatePizzaByType(PizzaType type){
switch (type)
{
case SimplePizzaFactory::CheesePizzaTpe:
{
return new CheesePizza;
//if you want, you can do additional initialization for new CheesePizza;
//like:
//AbstractPizza* pizza = new CheesePizza;
//assert(pizza);
//pizza->Initialize();
}
case SimplePizzaFactory::GreekPizzaType:
{
return new GreekPizza;
//if you want, you can do additional initialization for new CheesePizza;
}
case SimplePizzaFactory::PipperPizzaType:
{
return new PipperPizza;
//if you want, you can do additional initialization for new CheesePizza;
}
default:
break;
}
}
};

工厂方法模式：

对扩展开放，对修改关闭，对于上面的简单工厂，creator方法以后可能需要修改，因此我们可以通过将要改的方面单独提炼出来。这就构造出了工厂方法模式。有一个抽象的工厂方法，它的出现将外部的调用统一化，由具体的工厂负责产品的创建过程。工厂方法模式就是将产品的创建过程延迟到子类，由子类负责具体的产品创建，而且一种工厂只生产一种产品。具体工厂和具体产品一一对应，抽象的Creator方法和抽象的产品对应。

这经常用在抽象类中，专为创建对象定义一个方法。子类就可以覆盖这个方法来定义要创建的特定对象。通常与模板方法和并使用，模板方法在定义模板算法时一般需要先创建产品，然后再利用产品的方法创建一个流程。

一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

还用上面的例子，现在首先需要一个抽象的Creator方法，你可以把它看成一个抽象工厂，其实也是它是一个特殊的抽象工厂，只生产一种产品.

不过下面的比普通的工厂方法模式又稍微高级了一点，它是参数化的工厂方法模式，灵活性更大。

class PizzaFactory
{
public:
enum PizzaType{
CheesePizzaTpe,
GreekPizzaType,
PipperPizzaType,
};
PizzaFactory(void);
~PizzaFactory(void);
AbstractPizza* PizzaFactory(PizzaType type)();
};

//具体的工厂，负责生产BeiJing的pizza。
class BeiJingPizzaFactory : public PizzaFactory
{
public:

BeiJingPizzaFactory(void);
~BeiJingPizzaFactory(void);
AbstractPizza* CreatePizzaByType(PizzaType type)(){
switch (type){
case PizzaFactory::CheesePizzaTpe:
return new BeiJingCheesePizza;
case PizzaFactory::GreekPizzaType:
return new BeiJingGreekPizza;
case PizzaFactory::PipperPizzaType:
return new BeiJingPipperPizza;
default:
return NULL;
};
}
};

关于BeiJingCheesePizza， BeiJingGreekPizza， BeiJingPipperPizza这些就不写了，就是继承于抽象的Pizza。

对扩展开放，对修改关闭:

如果再有天津的，河南的，意大利的等等Pizza。通过使用工厂方法模式，以后即使再有其他地区的pizza店，只需要添加另外的一个具体工厂和具体的产品就行了。不要纠结于增加新的PizzaType怎么办？工厂方法模式专注的点是有新地区的产品，而不是有新的PizzaType。因为最基本的工厂方法模式是一个工厂一个产品，一一对应。如果想着眼于type而忽略地区，可以考虑一种PizzaType一个Pizza工厂，那样添加了新的type，就添加新的工厂和产品就可以了，完美符合对扩展开放，对修改关闭。

子类实例化：

工厂方法模式对外部提供的是一个工厂方法，它是一个抽象接口，这样外部依赖的就是抽象而不是具体，减少代码耦合性。将具体的new的操作放到子类工厂来实现。

应用：

说实话，找应用费了好久，毕竟整天Pizza，Pizza的很难给我们以启发，仅仅是知道模式，而没有看到它的巨大潜力和价值。

学习MFC的都知道Document和Application的关系。不同的Application对应不同的Document。app负责创建doc。app就是工厂，doc就是产品，一个工厂一个产品。

//App是工厂，它保存着创建的产品
//App
class Application
{
public:
void OpenDocument(){//模板方法
m_pDoc = CreateDocment();
m_pDoc->Open();
m_pDoc->Read();
}
void CloseDocument(){//模板方法
m_pDoc->Write();
m_pDoc->Close();
}
private:
virtual Document* CreateDocment() = 0;//工厂方法
private:
Document* m_pDoc;//这个
}

//抽象产品类，文档可以打开关闭，读写。
class Document
{
public:
void Open();
void Close();
void Read();
void Write();
}

解释：

上面两个类一看到就会有种欣喜的感觉，将模板方法和工厂方法完美的组合了起来。工厂方法关心的是创建对象，由具体的工厂MyApp负责创建实现具体的产品MyDocument.同时，模板方法OpenDocument面向抽象的创建接口编程，负责定义了一套算法，子类继承了Application，就继承了一套算法，子类不用关心算法执行的步骤，子类只需要实现方法，父类负责调用子类的方法。

像经常看到的状态机代码，状态机的跳转流程是由预先定义的流程定义的，但是OnStateEnter和OnStateExit这样的方法的实现是由具体应用定义的。父类负责调用子类OnStateEnter和OnStateExit方法的具体的实现，模板方法的典型应用。

抽象工厂：

抽象工厂关注的是创建一系列的产品，它是使用工厂方法实现的，不过是拥有多个工厂方法。

代码就不写了。

总结(摘录的一段，感觉写的不错，地址 http://stan001140.iteye.com/blog/1737817):
简单工厂能把具体实现包装起来，让客户端真正达到面向接口编程

工厂方法可以在高层进行编码，让服务端的产品线真正达到面向接口编程

抽象工厂能聚合整个产品簇，让整个服务端的多个产品线真正达到面向接口编程

模板方法同样是在高层进行编码，也同样是面向接口编程。

但工厂方法及抽象工厂方法着重抽象的是产品，而模板方法着重抽象的是步骤。

而我们通常会两者一起结合起来使用。