工厂模式总结(简单工厂,工厂方法,抽象工厂)
2016-07-14 20:24
423 查看
工厂模式属于创建型模式,大致可以分为三类,简单工厂模式、工厂方法模式、抽象工厂模式。
通过两个例子讲解这三种工厂模式
听起来很抽象,还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱,于是决定再开设一个工厂专门用来生产B型号的单核,而原来的工厂专门用来生产A型号的单核。这时,客户要做的是找好工厂,比如要A型号的核,就找A工厂要;否则找B工厂要,不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。
既然有了简单工厂模式和工厂方法模式,为什么还要有抽象工厂模式呢?它到底有什么作用呢?还是举这个例子,这家公司的技术不断进步,不仅可以生产单核处理器,也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。具体这样应用,这家公司还是开设两个工厂,一个专门用来生产A型号的单核多核处理器,而另一个工厂专门用来生产B型号的单核多核处理器,下面给出实现的代码。
工厂模式有一种非常形象的描述,建立对象的类就如一个工厂,而需要被建立的对象就是一个个产品;在工厂中加工产品,使用产品的人,不用在乎产品是如何生产出来的。从软件开发的角度来说,这样就有效的降低了模块之间的耦合。
由于对象的创建过程是我们不需要去关心的,而我们注重的是对象的实际操作,所以,我们需要分离对象的创建和操作两部分,如此,方便后期的程序扩展和维护。
在设计的初期,就考虑到产品在后期会进行扩展的情况下,可以使用工厂方法模式;
产品结构较复杂的情况下,可以使用工厂方法模式;
由于使用设计模式是在详细设计时,就需要进行定夺的,所以,需要权衡多方面的因素,而不能为了使用设计模式而使用设计模式。
举个例子来说:一个显示器电路板厂商,旗下的显示器电路板种类有非液晶的和液晶的;这个时候,厂商建造两个工厂,工厂A负责生产非液晶显示器电路板,工厂B负责生产液晶显示器电路板;工厂一直就这样运行着。有一天,总经理发现,直接生产显示器的其余部分也挺挣钱,所以,总经理决定,再建立两个工厂C和D;C负责生产非液晶显示器的其余部件,D负责生产液晶显示器的其余部件。此时,旁边参谋的人就说了,经理,这样做不好,我们可以直接在工厂A中添加一条负责生产非液晶显示器的其余部件的生产线,在工厂B中添加一条生产液晶显示器的其余部件的生产线,这样就可以不用增加厂房,只用将现有厂房进行扩大一下,同时也方便工厂的管理,而且生产非液晶显示器电路板的技术人员对非液晶显示的其余部件的生产具有指导的作用,生产液晶显示器电路板也是同理。总经理发现这是一个不错的主意。
再回到软件开发的过程中来,工厂A和B就是之前所说的工厂方法模式;总经理再次建立工厂C和D,就是重复工厂方法模式,只是生产的产品不同罢了。这样做的弊端就如参谋所说的那样,增加了管理成本和人力成本。在面向对象开发的过程中,是很注重对象管理和维护的,对象越多,就越难进行管理和维护;如果工厂数量过多,那么管理和维护的成本将大大增加;虽然生产的是不同的产品,但是可以二者之间是有微妙的关系的,如参谋所说,技术人员的一些技术经验是可以借鉴的,这就相当于同一个类中的不同对象,之间是可以公用某些资源的。那么,增加一条流水线,扩大厂房,当然是最好的主意了。
实际问题已经得到了解决,那么如何使用设计模式模拟这个实际的问题呢?那就是接下来所说的抽象工厂模式。
参考:
http://blog.csdn.net/wuzhekai1985/article/details/6660462
通过两个例子讲解这三种工厂模式
示例一
简单工厂模式
首先介绍简单工厂模式,它的主要特点是需要在工厂类中做判断,从而创造相应的产品。当增加新的产品时,就需要修改工厂类。有点抽象,举个例子就明白了。有一家生产处理器核的厂家,它只有一个工厂,能够生产两种型号的处理器核。客户需要什么样的处理器核,一定要显示地告诉生产工厂。下面给出一种实现方案。enum CTYPE {COREA, COREB}; class SingleCore { public: virtual void Show() = 0; }; //单核A class SingleCoreA: public SingleCore { public: void Show() { cout<<"SingleCore A"<<endl; } }; //单核B class SingleCoreB: public SingleCore { public: void Show() { cout<<"SingleCore B"<<endl; } }; //唯一的工厂,可以生产两种型号的处理器核,在内部判断 class Factory { public: SingleCore* CreateSingleCore(enum CTYPE ctype) { if(ctype == COREA) //工厂内部判断 return new SingleCoreA(); //生产核A else if(ctype == COREB) return new SingleCoreB(); //生产核B else return NULL; } };
工厂方法模式
这样设计的主要缺点之前也提到过,就是要增加新的核类型时,就需要修改工厂类。这就违反了开放封闭原则:软件实体(类、模块、函数)可以扩展,但是不可修改。于是,工厂方法模式出现了。所谓工厂方法模式,是指定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。听起来很抽象,还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱,于是决定再开设一个工厂专门用来生产B型号的单核,而原来的工厂专门用来生产A型号的单核。这时,客户要做的是找好工厂,比如要A型号的核,就找A工厂要;否则找B工厂要,不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。
class SingleCore { public: virtual void Show() = 0; }; //单核A class SingleCoreA: public SingleCore { public: void Show() { cout<<"SingleCore A"<<endl; } }; //单核B class SingleCoreB: public SingleCore { public: void Show() { cout<<"SingleCore B"<<endl; } }; class Factory { public: virtual SingleCore* CreateSingleCore() = 0; }; //生产A核的工厂 class FactoryA: public Factory { public: SingleCoreA* CreateSingleCore() { return new SingleCoreA; } }; //生产B核的工厂 class FactoryB: public Factory { public: SingleCoreB* CreateSingleCore() { return new SingleCoreB; } };
抽象工厂模式
工厂方法模式也有缺点,每增加一种产品,就需要增加一个对象的工厂。如果这家公司发展迅速,推出了很多新的处理器核,那么就要开设相应的新工厂。在C++实现中,就是要定义一个个的工厂类。显然,相比简单工厂模式,工厂方法模式需要更多的类定义。既然有了简单工厂模式和工厂方法模式,为什么还要有抽象工厂模式呢?它到底有什么作用呢?还是举这个例子,这家公司的技术不断进步,不仅可以生产单核处理器,也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。具体这样应用,这家公司还是开设两个工厂,一个专门用来生产A型号的单核多核处理器,而另一个工厂专门用来生产B型号的单核多核处理器,下面给出实现的代码。
//单核 class SingleCore { public: virtual void Show() = 0; }; class SingleCoreA: public SingleCore { public: void Show() { cout<<"Single Core A"<<endl; } }; class SingleCoreB :public SingleCore { public: void Show() { cout<<"Single Core B"<<endl; } }; //多核 class MultiCore { public: virtual void Show() = 0; }; class MultiCoreA : public MultiCore { public: void Show() { cout<<"Multi Core A"<<endl; } }; class MultiCoreB : public MultiCore { public: void Show() { cout<<"Multi Core B"<<endl; } }; //工厂 class CoreFactory { public: virtual SingleCore* CreateSingleCore() = 0; virtual MultiCore* CreateMultiCore() = 0; }; //工厂A,专门用来生产A型号的处理器 class FactoryA :public CoreFactory { public: SingleCore* CreateSingleCore() { return new SingleCoreA(); } MultiCore* CreateMultiCore() { return new MultiCoreA(); } }; //工厂B,专门用来生产B型号的处理器 class FactoryB : public CoreFactory { public: SingleCore* CreateSingleCore() { return new SingleCoreB(); } MultiCore* CreateMultiCore() { return new MultiCoreB(); } };
示例二
简单工厂模式
问题描述
之前在公司做了一个windows 8平台的阅读器。首先,需要将电子书中的内容渲染到屏幕上,而电子书每一页都包含各种各样的内容,比如:图形、图像和文字等等;不同的内容,就是不同的对象;在将不同的内容渲染到屏幕上之前,就需要new操作,建立不同的对象,然后再在屏幕上进行描绘。这个时候,就需要进行很多new操作,new操作分布在代码的不同地方,管理起来很麻烦,而且也很乱,到后期扩展和维护的时候,有的时候,对象多的让开发人员不知道这个对象是干什么的,这就增加了难度;同时,new操作,都会有对应的异常处理,最后,就会发现,在代码中,new了一个对象,然后,就跟着一段异常处理代码,这时编码变的极其混乱和臃肿。那么怎么办?怎么办?此时,我们需要一个新的类,专门从事对象的建立和释放,之后,对象的各种操作,和这个类没有任何关系。这个专门建立对象的类,向外暴漏创建对象的接口,供外部调用。工厂模式有一种非常形象的描述,建立对象的类就如一个工厂,而需要被建立的对象就是一个个产品;在工厂中加工产品,使用产品的人,不用在乎产品是如何生产出来的。从软件开发的角度来说,这样就有效的降低了模块之间的耦合。
适用场合
在程序中,需要创建的对象很多,导致对象的new操作多且杂时,需要使用简单工厂模式;由于对象的创建过程是我们不需要去关心的,而我们注重的是对象的实际操作,所以,我们需要分离对象的创建和操作两部分,如此,方便后期的程序扩展和维护。
#include <iostream> #include <vector> using namespace std; typedef enum ProductTypeTag { TypeA, TypeB, TypeC }PRODUCTTYPE; // Here is the product class class Product { public: virtual void Show() = 0; }; class ProductA : public Product { public: void Show() { cout<<"I'm ProductA"<<endl; } }; class ProductB : public Product { public: void Show() { cout<<"I'm ProductB"<<endl; } }; class ProductC : public Product { public: void Show() { cout<<"I'm ProductC"<<endl; } }; // Here is the Factory class class Factory { public: Product* CreateProduct(PRODUCTTYPE type) { switch (type) { case TypeA: return new ProductA(); case TypeB: return new ProductB(); case TypeC: return new ProductC(); default: return NULL; } } }; int main(int argc, char *argv[]) { // First, create a factory object Factory *ProductFactory = new Factory(); Product *productObjA = ProductFactory->CreateProduct(TypeA); if (productObjA != NULL) productObjA->Show(); Product *productObjB = ProductFactory->CreateProduct(TypeB); if (productObjB != NULL) productObjB->Show(); Product *productObjC = ProductFactory->CreateProduct(TypeC); if (productObjC != NULL) productObjC->Show(); delete ProductFactory; ProductFactory = NULL; delete productObjA; productObjA = NULL; delete productObjB; productObjB = NULL; delete productObjC; productObjC = NULL; return 0; }
工厂方法模式
问题描述
由于简单工厂模式的局限性,比如:工厂现在能生产ProductA、ProductB和ProductC三种产品了,此时,需要增加生产ProductD产品;那么,首先是不是需要在产品枚举类型中添加新的产品类型标识,然后,修改Factory类中的switch结构代码。是的,这种对代码的修改,对原有代码的改动量较大,易产生编码上的错误(虽然很简单,如果工程大了,出错也是在所难免的!!!)。这种对代码的修改是最原始,最野蛮的修改,本质上不能称之为对代码的扩展。同时,由于对已经存在的函数进行了修改,那么以前进行过的测试,都将是无效的,所有的测试,都将需要重新进行,所有的代码都需要进行重新覆盖。这种,增加成本,不能提高效率的事情,在公司是绝对不允许的(除非昏庸的PM)。出于种种原因,简单工厂模式,在实际项目中使用的较少。那么该怎么办?怎么办呢?需要对原有代码影响降到最小,同时能对原有功能进行扩展。适用场合
工厂方法模式的意义是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类必须实现的接口,这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。在设计的初期,就考虑到产品在后期会进行扩展的情况下,可以使用工厂方法模式;
产品结构较复杂的情况下,可以使用工厂方法模式;
由于使用设计模式是在详细设计时,就需要进行定夺的,所以,需要权衡多方面的因素,而不能为了使用设计模式而使用设计模式。
#include <iostream> using namespace std; class Product { public: virtual void Show() = 0; }; class ProductA : public Product { public: void Show() { cout<< "I'm ProductA"<<endl; } }; class ProductB : public Product { public: void Show() { cout<< "I'm ProductB"<<endl; } }; class Factory { public: virtual Product *CreateProduct() = 0; }; class FactoryA : public Factory { public: Product *CreateProduct() { return new ProductA (); } }; class FactoryB : public Factory { public: Product *CreateProduct() { return new ProductB (); } }; int main(int argc , char *argv []) { Factory *factoryA = new FactoryA (); Product *productA = factoryA->CreateProduct(); productA->Show(); Factory *factoryB = new FactoryB (); Product *productB = factoryB->CreateProduct(); productB->Show(); if (factoryA != NULL) { delete factoryA; factoryA = NULL; } if (productA != NULL) { delete productA; productA = NULL; } if (factoryB != NULL) { delete factoryB; factoryB = NULL; } if (productB != NULL) { delete productB; productB = NULL; } return 0; }
抽象工厂模式
问题描述
由于工厂方法模式创建的对象都是继承于Product的,所以工厂方法模式中,每个工厂只能创建单一种类的产品,当需要生产一种全新的产品(不继承自Product)时,发现工厂方法是心有余而力不足。举个例子来说:一个显示器电路板厂商,旗下的显示器电路板种类有非液晶的和液晶的;这个时候,厂商建造两个工厂,工厂A负责生产非液晶显示器电路板,工厂B负责生产液晶显示器电路板;工厂一直就这样运行着。有一天,总经理发现,直接生产显示器的其余部分也挺挣钱,所以,总经理决定,再建立两个工厂C和D;C负责生产非液晶显示器的其余部件,D负责生产液晶显示器的其余部件。此时,旁边参谋的人就说了,经理,这样做不好,我们可以直接在工厂A中添加一条负责生产非液晶显示器的其余部件的生产线,在工厂B中添加一条生产液晶显示器的其余部件的生产线,这样就可以不用增加厂房,只用将现有厂房进行扩大一下,同时也方便工厂的管理,而且生产非液晶显示器电路板的技术人员对非液晶显示的其余部件的生产具有指导的作用,生产液晶显示器电路板也是同理。总经理发现这是一个不错的主意。
再回到软件开发的过程中来,工厂A和B就是之前所说的工厂方法模式;总经理再次建立工厂C和D,就是重复工厂方法模式,只是生产的产品不同罢了。这样做的弊端就如参谋所说的那样,增加了管理成本和人力成本。在面向对象开发的过程中,是很注重对象管理和维护的,对象越多,就越难进行管理和维护;如果工厂数量过多,那么管理和维护的成本将大大增加;虽然生产的是不同的产品,但是可以二者之间是有微妙的关系的,如参谋所说,技术人员的一些技术经验是可以借鉴的,这就相当于同一个类中的不同对象,之间是可以公用某些资源的。那么,增加一条流水线,扩大厂房,当然是最好的主意了。
实际问题已经得到了解决,那么如何使用设计模式模拟这个实际的问题呢?那就是接下来所说的抽象工厂模式。
适用场合
工厂方法模式适用于产品种类结构单一的场合,为一类产品提供创建的接口;而抽象工厂方法适用于产品种类结构多的场合,主要用于创建一组(有多个种类)相关的产品,为它们提供创建的接口;就是当具有多个抽象角色时,抽象工厂便可以派上用场。#include <iostream> using namespace std; // Product A class ProductA { public: virtual void Show() = 0; }; class ProductA1 : public ProductA { public: void Show() { cout<<"I'm ProductA1"<<endl; } }; class ProductA2 : public ProductA { public: void Show() { cout<<"I'm ProductA2"<<endl; } }; // Product B class ProductB { public: virtual void Show() = 0; }; class ProductB1 : public ProductB { public: void Show() { cout<<"I'm ProductB1"<<endl; } }; class ProductB2 : public ProductB { public: void Show() { cout<<"I'm ProductB2"<<endl; } }; // Factory class Factory { public: virtual ProductA *CreateProductA() = 0; virtual ProductB *CreateProductB() = 0; }; class Factory1 : public Factory { public: ProductA *CreateProductA() { return new ProductA1(); } ProductB *CreateProductB() { return new ProductB1(); } }; class Factory2 : public Factory { ProductA *CreateProductA() { return new ProductA2(); } ProductB *CreateProductB() { return new ProductB2(); } }; int main(int argc, char *argv[]) { Factory *factoryObj1 = new Factory1(); ProductA *productObjA1 = factoryObj1->CreateProductA(); ProductB *productObjB1 = factoryObj1->CreateProductB(); productObjA1->Show(); productObjB1->Show(); Factory *factoryObj2 = new Factory2(); ProductA *productObjA2 = factoryObj2->CreateProductA(); ProductB *productObjB2 = factoryObj2->CreateProductB(); productObjA2->Show(); productObjB2->Show(); if (factoryObj1 != NULL) { delete factoryObj1; factoryObj1 = NULL; } if (productObjA1 != NULL) { delete productObjA1; productObjA1= NULL; } if (productObjB1 != NULL) { delete productObjB1; productObjB1 = NULL; } if (factoryObj2 != NULL) { delete factoryObj2; factoryObj2 = NULL; } if (productObjA2 != NULL) { delete productObjA2; productObjA2 = NULL; } if (productObjB2 != NULL) { delete productObjB2; productObjB2 = NULL; } }
参考:
http://blog.csdn.net/wuzhekai1985/article/details/6660462
相关文章推荐
- 《编程之法》1.1字符串的旋转
- 使用Maven创建Web项
- Java并发编程核心方法与框架-CountDownLatch的使用
- 简便轻巧的使用SharedPreferences 存储
- AbstractQueuedSynchronizer(十二)——应用之AbstractFuture
- Java并发编程核心方法与框架-exchanger的使用
- 网络流ford-fulkerson方法(代码实现)
- Shellcode的原理及编写
- swust1744: 方格取数问题
- Codeforces Round #321 (Div. 2) D. Kefa and Dishes 状压dp
- HDU 5655 CA Loves Stick(四根棍子能否拼成四边形)
- Sort Colors
- Count and Say
- docker入门
- JS运动从入门到兴奋1
- 【面试题目】Java文件下载(限速、进度条)
- 宁静中的变化,繁华中的人生
- MySQL技术内幕InnoDB存储引擎学习笔记(第二章)
- N个元素集合的M子集问题
- Remove Invalid Parentheses