（创建型模式）ABSTRACT FACTORY——抽象工厂模式

来源：互联网发布：微信支付php 完整源码编辑：程序博客网时间：2024/06/05 23:29

一、意图

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

（1）最大的好处是易于交换产品系列，由于具体工厂类在一个应用中只需要初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。如ACCESS->SQL SERVER；

（2）第二大好处是：它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。如客户端只知道使用IUser和IDepartment,至于它是用SQL Server还是Access来实现就不知道了。

当需要增加功能时，就需要增加很多类

clip_image002

1）ProductA,ProductB：分别代表不同类型的产品，而它们的派生类则是这种产品的一个实现。

2）AbstractFactory：生产这一系列产品的一个抽象工厂，它的派生类是不同的实现。

AbstractFactory::CreateProductA和AbstractFactory::CreateProductB：分别是生产不同产品的不同实现，由各个派生出来的抽象工厂实现之。

Abstract Factory模式和Factory最大的差别是抽象工厂创建的是一系列相关的对象，其中创建的实现其实采用的就是Factory模式的方法，对于某个实现的有一个派生出来的抽象工厂，另一个实现有另一个派生出来的工厂。

需要特别注意的是区分不同类型的产品和这些产品的不同实现，如果有n种产品同时有m种不同的实现，那么根据乘法原理可知有n*m个简单工厂模式在运用。

   1: /************************************************************************

   2:  * FileName    : AbstractFactory.h

   3:  * Author      : steven oyj (steven.oyj@gmail.com)

   4:  * Description : AbstractFactory的演示代码

   5:  * Time        : 2010/5/18

   6:  ************************************************************************/

   7: #ifndef ABSTRACTFACTORY_H

   8: #define ABSTRACTFACTORY_H

9:

  10: // 抽象基类AbstractProductA,代表产品A的抽象

  11: class AbstractProductA

  12: {

  13: public:

  14:     AbstractProductA() {}

  15:     virtual ~AbstractProductA(){};

  16: };

17:

  18: // 派生类ConcreateProductA1,继承自AbstractProductA,代表产品A的第一种实现

  19: class ConcreateProductA1

  20:     : public AbstractProductA

  21: {

  22: public:

  23:     ConcreateProductA1();

  24:     virtual ~ConcreateProductA1();

  25: };

26:

  27: // 派生类ConcreateProductA2,继承自AbstractProductA,代表产品A的第二种实现

  28: class ConcreateProductA2

  29:     : public AbstractProductA

  30: {

  31: public:

  32:     ConcreateProductA2();

  33:     virtual ~ConcreateProductA2();

  34: };

35:

  36: // 抽象基类AbstractProductB,代表产品B的抽象

  37: class AbstractProductB

  38: {

  39: public:

  40:     AbstractProductB() {}

  41:     virtual ~AbstractProductB(){};

  42: };

43:

  44: // 派生类ConcreateProductB1,继承自AbstractProductB,代表产品B的第一种实现

  45: class ConcreateProductB1

  46:     : public AbstractProductB

  47: {

  48: public:

  49:     ConcreateProductB1();

  50:     virtual ~ConcreateProductB1();

  51: };

52:

  53: // 派生类ConcreateProductB2,继承自AbstractProductB,代表产品B的第二种实现

  54: class ConcreateProductB2

  55:     : public AbstractProductB

  56: {

  57: public:

  58:     ConcreateProductB2();

  59:     virtual ~ConcreateProductB2();

  60: };

61:

  62: // 抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B

  63: class AbstractFactory

  64: {

  65: public:

  66:     AbstractFactory(){}

  67:     virtual ~AbstractFactory(){}

68:

  69:     virtual AbstractProductA* CreateProductA() = 0;

  70:     virtual AbstractProductB* CreateProductB() = 0;

  71: };

72:

  73: // 派生类ConcreateFactory1,继承自AbstractFactory

  74: // 生产产品A和产品B的第一种实现

  75: class ConcreateFactory1

  76:     : public AbstractFactory

  77: {

  78: public:

  79:     ConcreateFactory1();

  80:     virtual ~ConcreateFactory1();

81:

  82:     virtual AbstractProductA* CreateProductA();

  83:     virtual AbstractProductB* CreateProductB();

  84: };

85:

  86: // 派生类ConcreateFactory2,继承自AbstractFactory

  87: // 生产产品A和产品B的第二种实现

  88: class ConcreateFactory2

  89:     : public AbstractFactory

  90: {

  91: public:

  92:     ConcreateFactory2();

  93:     virtual ~ConcreateFactory2();

94:

  95:     virtual AbstractProductA* CreateProductA();

  96:     virtual AbstractProductB* CreateProductB();

  97: };

98:

  99: #endif

   1: #include <iostream>

   2: #include "AbstractFactory.h"

3:

   4: ConcreateProductA1::ConcreateProductA1()

   5: {

   6:     std::cout << "construction of ConcreateProductA1\n";

   7: }

8:

   9: ConcreateProductA1::~ConcreateProductA1()

  10: {

  11:     std::cout << "destruction of ConcreateProductA1\n";

  12: }

13:

  14: ConcreateProductA2::ConcreateProductA2()

  15: {

  16:     std::cout << "construction of ConcreateProductA2\n";

  17: }

18:

  19: ConcreateProductA2::~ConcreateProductA2()

  20: {

  21:     std::cout << "destruction of ConcreateProductA2\n";

  22: }

23:

  24: ConcreateProductB1::ConcreateProductB1()

  25: {

  26:     std::cout << "construction of ConcreateProductB1\n";

  27: }

28:

  29: ConcreateProductB1::~ConcreateProductB1()

  30: {

  31:     std::cout << "destruction of ConcreateProductB1\n";

  32: }

33:

  34: ConcreateProductB2::ConcreateProductB2()

  35: {

  36:     std::cout << "construction of ConcreateProductB2\n";

  37: }

38:

  39: ConcreateProductB2::~ConcreateProductB2()

  40: {

  41:     std::cout << "destruction of ConcreateProductB2\n";

  42: }

43:

  44: ConcreateFactory1::ConcreateFactory1()

  45: {

  46:     std::cout << "construction of ConcreateFactory1\n";

  47: }

48:

  49: ConcreateFactory1::~ConcreateFactory1()

  50: {

  51:     std::cout << "destruction of ConcreateFactory1\n";

  52: }

53:

  54: AbstractProductA* ConcreateFactory1::CreateProductA()

  55: {

  56:     return new ConcreateProductA1();

  57: }

58:

  59: AbstractProductB* ConcreateFactory1::CreateProductB()

  60: {

  61:     return new ConcreateProductB1();

  62: }

63:

  64: ConcreateFactory2::ConcreateFactory2()

  65: {

  66:     std::cout << "construction of ConcreateFactory2\n";

  67: }

68:

  69: ConcreateFactory2::~ConcreateFactory2()

  70: {

  71:     std::cout << "destruction of ConcreateFactory2\n";

  72: }

73:

  74: AbstractProductA* ConcreateFactory2::CreateProductA()

  75: {

  76:     return new ConcreateProductA2();

  77: }

78:

  79: AbstractProductB* ConcreateFactory2::CreateProductB()

  80: {

  81:     return new ConcreateProductB2();

  82: }

   1: #include "AbstractFactory.h"

   2: #include <stdlib.h>

   3: #include <stdio.h>

4:

   5: int main()

   6: {

   7:     printf("%d\n",sizeof(long));

   8:     // 生产产品A的第一种实现

   9:     ConcreateFactory1 *pFactory1 = new ConcreateFactory1;

  10:     AbstractProductA *pProductA = pFactory1->CreateProductA();

11:

  12:     // 生产产品B的第二种实现

  13:     ConcreateFactory2 *pFactory2 = new ConcreateFactory2;

  14:     AbstractProductB *pProductB = pFactory2->CreateProductB();

15:

  16:     delete pFactory1;

  17:     delete pProductA;

  18:     delete pFactory2;

  19:     delete pProductB;

20:

  21:     system("pause");

22:

  23:     return 0;

  24: }

0 0