（创建型模式）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: }