工厂模式

工厂模式的作用：用于生产类对象

工厂模式分类：简单工厂模式、工厂模式、抽象工厂模式

工厂模式的特点：

　　（1）工厂模式是一种设计模式，遵循开闭原则，

　　 – 开放，对新增的功能是开放的。

– 关闭，对以前的已经完成的功能时不允许修改的。

（2）封装对象的创建过程，可以轻而易举的获得一个可用的对象。

（3）解耦合，降低类和类之间的耦合度，修改一个类不会影响另一个类。

（4）降低代码的重复性，提高代码的可读性

下面主要介绍常用的工厂模式，简单工厂模式和抽象工厂模式在此不介绍，感兴趣的可以自行学习。

工厂模式遵循开闭原则：

　　　　– 每创建一个对象, 就应该对应一个工厂类, 工厂类需要有很多个

　　　　– 这些创建对象的工厂类之间是什么关系?

- - 兄弟关系

　　　　– 这些创建对象的工厂类需要有相同的基类

- - 目的: 为了实现多态, 让代码的调用更加灵活

工厂模式使用流程

　　1. 创建一个工厂类的基类, 在这个基类中添加一个虚函数, 这个虚函数就是用于对象创建的工厂函数。

　　2. 基于这个工厂类创建若干个子工厂类, 在子工厂类中实现父类的虚函数。

　　3. 如果需要创建更多的对象, 再次添加子工厂类即可。

工厂模式的特点: 对于已经实现的代码是不做任何修改的, 如果有新的需求, 添加新的代码。

工厂模式实现代码：

  1 // 对象基类
  2 #include <cstdlib>
  3 #include <iostream>
  4 using namespace std;
  5 class BaseObject
  6 {
  7 public:
  8     BaseObject();
  9     ~BaseObject();
 10     virtual void funcA()
 11     {
 12         cout << "BaseObject-----funcA" << endl;
 13     }
 14 
 15 private:
 16 
 17 };
 18 
 19 BaseObject::BaseObject()
 20 {
 21 }
 22 
 23 BaseObject::~BaseObject()
 24 {
 25 }
 26 /*******************************/
 27 class AObject:public BaseObject
 28 {
 29 public:
 30     AObject();
 31     ~AObject();
 32     void funcA();
 33 
 34 private:
 35 
 36 };
 37 
 38 AObject::AObject()
 39 {
 40 }
 41 
 42 AObject::~AObject()
 43 {
 44 }
 45 
 46 void AObject::funcA()
 47 {
 48     cout << "AObject --- funcA" << endl;
 49 }
 50 
 51 /*************************/
 52 class BObject:public BaseObject
 53 {
 54 public:
 55     BObject();
 56     ~BObject();
 57     void funcA();
 58 
 59 private:
 60 
 61 };
 62 
 63 BObject::BObject()
 64 {
 65 }
 66 
 67 BObject::~BObject()
 68 {
 69 }
 70 void BObject::funcA()
 71 {
 72     cout << "BObject----funcA" << endl;
 73 }
 74 
 75 
 76 /*************************************************************/
 77 // 工厂类基类
 78 class BaseFactory
 79 {
 80 public:
 81     BaseFactory();
 82     ~BaseFactory();
 83     // 创建对象的工厂方法
 84     virtual BaseObject* createObject()
 85     {
 86         cout << "BaseFactory --- createObject" << endl;
 87         return NULL;
 88     }
 89 
 90 private:
 91 
 92 };
 93 
 94 BaseFactory::BaseFactory()
 95 {
 96 }
 97 
 98 BaseFactory::~BaseFactory()
 99 {
100 }
101 /**********************************************************/
102 // 子工厂类， 只生产AObject类对象
103 class AFactory:public BaseFactory
104 {
105 public:
106     AFactory();
107     ~AFactory();
108 
109     BaseObject* createObject();
110 
111 private:
112 
113 };
114 
115 AFactory::AFactory()
116 {
117 }
118 
119 AFactory::~AFactory()
120 {
121 }
122 
123 BaseObject* AFactory::createObject()
124 {
125     cout << "AFactory---createObject" << endl;
126     BaseObject* c = new AObject;
127     return c;
128 }
129 
130 /***************************************************/
131 class BFactory:public BaseFactory
132 {
133 public:
134     BFactory();
135     ~BFactory();
136     BaseObject* createObject();
137 
138 private:
139 
140 };
141 
142 BFactory::BFactory()
143 {
144 }
145 
146 BFactory::~BFactory()
147 {
148 }
149 
150 BaseObject* BFactory::createObject()
151 {
152     cout << "BFactory----createObject" << endl;
153     BaseObject* c = new BObject();
154     return c;
155 }
156 
157 /*************************************************************/
158 int main()
159 {
160     // 工厂类使用
161     BaseFactory* bf = new AFactory();
162     BaseObject* ao = bf->createObject();
163     ao->funcA();
164 
165     bf = new BFactory();
166     ao = bf->createObject();
167     ao->funcA();
168 
169     system("pause");
170     return EXIT_SUCCESS;
171 }