程序设计模式 —— 抽象工厂模式

Posted 2020-08-12 Suwings

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了程序设计模式 —— 抽象工厂模式相关的知识，希望对你有一定的参考价值。

前言

工厂？意思是创建变量的厂子？要这个干什么？为什么不直接new new new！！

定义：为创建一组相关或相互依赖的对象提供一个接口，而无需指定他们的具体类。

但是，从现在开始，请不要再使用new。

“What？不使用new？你怎么写C++程序，怎么写Java程序？”

我应该如何阅读？

本文将使用优雅的文字风格来告诉你什么是工厂模式。

注意：

　　1.在阅读本文之前请保证你已经掌控了面对对象的思想与多态的基本概念，否则将难以理解。

　　2.本文实现将用C++实现，你不一定必须学会C++，这些代码都有非常丰富的注释和简单的语法。

　　3.请不要跳着看，除非你已经学会。

什么是工厂模式？

准确的说，工厂有两个，一个是简单工厂，一个是抽象工厂。

在《HeadFrist 设计模式》一书当中说道：”简单工厂其实不是一个设计模式，更像是一种编程习惯，有些开发人员的确误以为是工厂模式。“

简单工厂是什么？

简单工厂顾名思义，十分简单，请看下面少量代码

注意：Entity 是一个抽象类，HelicopterA 是直升机A类型继承Entity ，HelicopterB 是直升机B类型继承Entity，暂且无需管具体代码，下面代码不影响。

 1 /*这是一个直升机工厂*/
 2 class HelicopterFactory
 3 {
 4 public:
 5     virtual Entity* create(const char* name)
 6     {
 7         Entity *p = NULL;
 8         if(name == "A"){
 9             cout << "[Factory] create: HelicopterA" << endl;
10             p = new HelicopterA();
11         }
12         if(name == "B"){
13             cout << "[Factory] create: HelicopterB" << endl;
14             p = new HelicopterB();
15         }
16         /**
17          if(name == "B"){
18             cout << "[Factory] create: HelicopterB" << endl;
19             p = new HelicopterB();    //更多更多的 产品
20             //这样，你的创建都集中在了一个类中间。当然了工厂模式不止这点点。
21         }
22         */
23         return p;
24     };
25 };

注意：如果你不会 C++，也没有关系，”Virtual” 关键字你可以无视，可以用Java的思想去看待代码

然后我们写主函数：

 1 HelicopterFactory hFactory = new HelicopterFactory();
 2     Entity *heli = hFactory->create("A");
 3     /*报告老板，我已经造好了直升机！*/
 4     heli->exec();
 5     heli = hFactory->create("B");
 6         heli = hFactory->create("B");    //我们这样就可以随意创建
 7         heli = hFactory->create("B");
 8         heli = hFactory->create("B");
 9         heli = hFactory->create("B");
10     /*报告老板，我已经造好了直升机！*/
11     heli->exec();//

至此，我们的简单工厂就是这样，看起来就是将创建的代码放到了一个专门的类里面了。

就这么简单？是的，简单工厂就这么简单。

但是如果我们要创建航天飞机呢？这个时候我们就要用到抽象工厂了。事实上也十分容易。设计模式其实都是很简单的，之所以出现了设计模式就是为了解决问题。

抽象工厂又是什么？

实现框架图：务必仔细看看

说白了就是我们可以创建各种各样的工厂，但是在实际使用的时候，我们是不需要知道究竟是哪个工厂。

我们来看看Entity类

 1 /*实体类 基类抽象类*/
 2 class Entity
 3 {
 4 public:
 5     Entity()
 6     {
 7 
 8     };
 9     virtual ~Entity()
10     {
11 
12     };
13     virtual void exec()=0;    //启动 交给子类实现
14 };

然后我们来实现 直升机 和 航天飞机 类

 1 /*直升机类 类型A*/
 2 class HelicopterA : public Entity
 3 {
 4 public:
 5     virtual void exec()
 6     {
 7         cout << "HelicopterA Fly!" << endl;
 8     }
 9 };
10 /*直升机类 类型B*/
11 class HelicopterB : public Entity
12 {
13 public:
14     virtual void exec()
15     {
16         cout << "HelicopterB Fly!" << endl;
17     }
18 };
19 
20 /*航天飞机 类型A*/
21 class ShuttleA : public Entity
22 {
23 public:
24     virtual void exec()
25     {
26         cout << "ShuttleA Fly!" << endl;
27     }
28 };
29 
30 /*航天飞机 类型B*/
31 class ShuttleB : public Entity
32 {
33 public:
34     virtual void exec()
35     {
36         cout << "ShuttleB Fly!" << endl;
37     }
38 };

好的，到现在为止我们已经有了 “产品”，现在我们应该来制作 “工厂”了：

首先实现抽象工厂类：

 1 /*抽象工厂类*/
 2 class AbstractFactory
 3 {
 4 public:
 5     virtual ~AbstractFactory()
 6     {
 7     
 8     };
 9     virtual Entity* create(const char*)=0;//交给子类去实现，这是创建实例的方法
10 };

现在我们来写两个具体工厂，直升机工厂和航天飞机工厂（你总不可能认为直升机工厂能制造出航天飞机吧？）

 1 /*这是一个直升机工厂*/
 2 class HelicopterFactory : public AbstractFactory
 3 {
 4 public:
 5     HelicopterFactory()
 6     {
 7         cout << "--Create HelicopterFactory--" << endl;
 8     };
 9     virtual ~HelicopterFactory()
10     {
11 
12     };
13     virtual Entity* create(const char* name)
14     {
15         Entity *p = NULL;
16         if(name == "A"){　　//根据你要的名字来进行相应的new
17             cout << "[Factory] create: HelicopterA" << endl;
18             p = new HelicopterA();
19         }
20         if(name == "B"){　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
21             cout << "[Factory] create: HelicopterB" << endl;
22             p = new HelicopterB();　　　　//根据你要的名字来进行相应的new
23         }
24         /**
25          if(name == "B"){
26             cout << "[Factory] create: HelicopterB" << endl;
27             p = new HelicopterB();    //更多更多的 产品
28             //这样，你的创建都集中在了一个类中间。当然了工厂模式不止这点点。
29         }
30         */
31         return p;
32     };
33 };
34 
35 /*这是一个航天飞机工厂*/
36 class ShuttleFactory : public AbstractFactory
37 {
38 public:
39     ShuttleFactory()
40     {
41         cout << "--Create ShuttleFactory--" << endl;
42     };
43     virtual ~ShuttleFactory()
44     {
45 
46     };
47     virtual Entity* create(const char* name)
48     {
49         Entity *p = NULL;
50         if(name == "A"){//根据你要的名字来进行相应的new
51             cout << "[Factory] create: ShuttleA" << endl;
52             p = new ShuttleA();
53         }
54         if(name == "B"){//根据你要的名字来进行相应的new
55             cout << "[Factory] create: ShuttleB" << endl;
56             p = new ShuttleB();
57         }
58         /*更多 种类的航天飞机*/
59         return p;
60     };
61 };

厂子应该要开工了！

现在我们写主函数：

“很好，你现在是 Pattern Art Online (R) 公司的员工，现在老板希望你为他在 Pattern Art Online 世界里面开个厂子，你十分肯定的说对于OO（object orient）程序员来说，这尼玛太简单了。。 ”

“你的大脑中已经出现了老板表扬的场景....”

 1 int main(int argc, char const *argv[])
 2 {
 3     /*好的，我们现在来创建一个抽象工厂*/
 4     AbstractFactory *hFactory;
 5     /*具体化成 直升机工厂*/
 6     hFactory = new HelicopterFactory();
 7     /*然而我们并不需要管到底是什么，反正create就对了！*/
 8     Entity *heli = hFactory->create("A");
 9     /*报告老板，我已经造好了直升机！*/
10     heli->exec();
11     /*并且已经 可以启动了*/
12     /*什么？客户换需求了？要求航天飞机？好吧*/
13     /*幸好我用的是抽象的工厂，反正代码还是那样,只是需要换一个...*/
14     delete hFactory;    //嘿！别忘记释放原先了，
15     //这可不是Java语言，老实说我挺喜欢手动释放的，让我感觉什么都是我操作。好吧不扯这些了
16     hFactory = new ShuttleFactory();
17     /*制造*/
18     Entity *ent = hFactory->create("B");
19     ent->exec();//运行
20     Entity *www = hFactory->create("A");//制造
21     www->exec();//运行
22 
23     /*恭喜你，我相信你已经学会了 抽象工厂模式*/
24     cin.get();//无视。由于我没有使用IDE，所以cin.get只是用于 暂停控制台
25     return 0;
26 }