（创建型模式）FACTORY METHOD——工厂方法模式

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端输入的选择条件动态的实例化相关的类，对于客户端来说，去除了与具体产品的依赖。

但是简单工厂方法违背了开放——封闭模式。

1、意图

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

2、核心思想

     核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给了子类去做，成为一个抽象工厂角色，仅仅负责具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化的细节。

3、优缺点分析

GOOD：修正了简单工厂模式中不遵守开放－封闭原则。工厂方法模式把选择判断移到了客户端去实现，如果想添加新功能就不用修改原来的类，直接修改客户端即可，从而保持了封装对象创建过程的优点。使得更换对象时，不需要做大的改动就可以实现，降低了客户程序与产品对象的耦合。

BAD：每增加一个产品，就需要增加一个产品工厂类，即增加了额外的开发量

4、标准UML

 

(1)抽象基类：

product：创建出来的对象的抽象基类

factory：创建对象的工厂方法的抽象基类

(2)接口函数：

Creator::FactoryMethod:纯虚函数，由派生类实现，创建出对应的Product.

（3）解析：

   在这个模式中，有两个抽象基类，一个是product为创建产品对象的抽象基类，一个是Factory为工厂的抽象基类，在互相协作的时候都是由相应的factory派生类来生成product派生类。

     也就是说，如果要新增一种product，那么也要对应新增一个factory,创建的过程委托给了facotory。所以factory和一个product是一一对应的关系。

5、标准源码

   1: #ifndef FACTORY_H

   2: #define FACTORY_H

   3:  

   4: class Product

   5: {

   6: public:

   7:     Product(){}

   8:     virtual ~Product(){}

   9: };

  10:  

  11: class ConcreateProduct

  12:     : public Product

  13: {

  14: public:

  15:     ConcreateProduct();

  16:     virtual ~ConcreateProduct();

  17: };

  18:  

  19: class Creator

  20: {

  21: public:

  22:     Creator(){}

  23:     virtual ~Creator(){}

  24:  

  25:     void AnOperation();

  26:  

  27: protected:

  28:     virtual Product* FactoryMethod() = 0;

  29: };

  30:  

  31: class ConcreateCreator

  32:     : public Creator

  33: {

  34: public:

  35:     ConcreateCreator();

  36:     virtual ~ConcreateCreator();

  37:  

  38: protected:

  39:     virtual Product* FactoryMethod();

  40: };

  41:  

  42: #endif

   1: #include "Factory.h"

   2: #include <iostream>

   3:  

   4: using namespace std;

   5:  

   6: ConcreateProduct::ConcreateProduct()

   7: {

   8:     std::cout << "construction of ConcreateProduct\n";

   9: }

  10:  

  11: ConcreateProduct::~ConcreateProduct()

  12: {

  13:     std::cout << "destruction of ConcreateProduct\n";

  14: }

  15:  

  16: void Creator::AnOperation()

  17: {

  18:     Product* p = FactoryMethod();

  19:  

  20:     std::cout << "an operation of product\n";

  21: }

  22:  

  23: ConcreateCreator::ConcreateCreator()

  24: {

  25:     std::cout << "construction of ConcreateCreator\n";

  26: }

  27:  

  28: ConcreateCreator::~ConcreateCreator()

  29: {

  30:     std::cout << "destruction of ConcreateCreator\n";

  31: }

  32:  

  33: Product* ConcreateCreator::FactoryMethod()

  34: {

  35:     return new ConcreateProduct();

  36: }

   1: #include "Factory.h"

   2: #include <stdlib.h>

   3:  

   4: int main(int argc,char* argv[])

   5: {

   6:     Creator *p = new ConcreateCreator();

   7:     p->AnOperation();

   8:  

   9:     delete p;

  10:  

  11:     system("pause");

  12:  

  13:     return 0;

  14: }