次设计模式 —— 抽象工厂模式

前言


 

工厂?意思是创办变量的工厂?要以此怎么?为什么非直接new new new!!

定义:啊开创同组有关或相互依赖的目标提供一个接口,而不论需点名他们的具体类。

 但是,从今天始发,请不要还以new。

“What?不利用new?你怎么写C++程序,怎么写Java程序?”

自己应该如何阅读?


 

正文将动用优雅的仿风格来报您呀是工厂模式。

注意:

  1.每当看本文之前要保管你早已掌控了 面对对象的盘算以及
多态的基本概念,否则用难以明白。

  2.本文实现以因此C++实现,你不自然得学会C++,这些代码都发生非常丰富的诠释和概括的语法。

  3.请求不要跨越着圈,除非你曾学会。

哟是厂模式?


标准之说,工厂来些许只,一个凡是简单工厂,一个凡纸上谈兵工厂。

以《HeadFrist 设计模式》 一写当中说道:”简单工厂其实不是一个设计模式,更如是一致种植编程习惯,有些开发人员的确误以为是厂模式。“

 

概括工厂是呀?


 

大概工厂顾名思义,十分简便,请看下少量代码

注意:Entity
是一个抽象类,HelicopterA 是直升机A色继承EntityHelicopterB 是直升机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();//

 

 至此,我们的概括工厂便是这样,看起便以开创的代码放到了一个专程的类里了。

即便如此简单?是的,简单工厂便这样简单。

可要我们要创造航天飞机呢?这个时咱们将要采取抽象工厂了。事实上也甚易。设计模式其实还是杀简短的,之所以出现了设计模式就是为缓解问题。

 

泛泛工厂以是什么?


 

兑现框架图:务必仔细看看

航天科工 1

 

说白了就是是咱可创造各种各样的厂,但是当实际上采用的时节,我们是未需要明白究竟是哪位厂。

俺们来看看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 }

 

“很好,这无异涂鸦,你总算没有任何作弊行为和错完成了。等等,为什么而加个总算?(具体故事情节在旁设计模式文章被)”

 这个事例不是生好的体现了 抽象工厂的优势。但是主要是如你上。

证实一下:

脚的话语比较根本,建议仔细瞧(别无认同,我包你早晚过着以圈)

咱声明的

1 AbstractFactory *hFactory;

 

 是一个架空工厂,它可以让外子类/其他函数
赋值任何类型的厂子,但是我们仅仅待用 create 成员函数
就好一直开立,根本无需要管到底是呀工厂,因为对咱们的话是空虚的。

再就是免懂得乃生出无起觉察,我们返回的为是 Entity 抽象类
这意味着我们的主函数为无欲知道到底是 直升机 还是 航天飞机
,反正调用 exec 成员函数 就对了。

全就是抽象,根本无知情处理的到底是呀,但是同时大好之支撑所有。

“其实我个人认为,也许有好多人数吧这么觉得,程序员的严重性解决问题的不二法门就是是拿问题抽象,抽象抽象再抽象。然后我们不怕可适应问题。”

 

 

纵使如此结束了?


“你取了业主的表彰,你的队友也佩服你的才,听说生个月而的工资而如涨( ̄︶ ̄)↗了”

“最重点的凡,你的队友答应你在 Pattern
Art Online
(AR)
空战游戏的《Fly!Fly!Fly!》战队了,而且她们原谅了你之前的坠机阴差阳错。(这件事情有在:
《设计模式——状态模式》)”

 

由来,我深信不疑你早已会了是模式。

嘿?你告诉自己若未曾了亮?这个时实在乃该配合代码和框架图结合来拘禁,你早晚会知晓的。复习复习。

 

最后


 

  但是一旦留意的少数,不是说出矣是模式,就必须使加以进去使用,程序会又棒。

设计模式要和您的次相互协调,不克写单 “HelloWorld”
程序都为此到了设计模式。

毕竟的相同句子话,设计模式不是平整,而是你天天可以变动的模式。这为是过多设计模式书籍强调的少数。

 

不管对而是不是出赞助,还是谢谢君的耐性查看。如发错误的处,还望指教。

发表评论

电子邮件地址不会被公开。 必填项已用*标注