C++设计模式-AbstractFactory抽象工厂模式
AbstractFactory
要创建一组相关或者相互依赖的对象
作用:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
UML结构图:
抽象基类:
1)AbstractProductA、AbstractProductB:分别代表两种不同类型的产品,由具体的产品派生类对其实现
2)AbstractFactory:抽象工厂类,提供创建两种产品的接口CreateProductA和CreateProductB,由派生的各个具体工厂类对其实现
说明:
AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的类(ConcreteFactory)中
Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象,其中创建的实现其实采用的就是Factory模式的方法,对于某个实现的有一个派生出来的抽象工厂,另一个实现有另一个派生出来的工厂
抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现.显而易见的,如果有n种产品同时有m中不同的实现,那么根据乘法原理可知有n*m个Factory模式的使用
AbstractFactory模式是为创建一组(有多类)相关或依赖的对象提供创建接口,而Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到,AbstractFactory模式通常都是使用Factory模式实现(ConcreteFactory1)。
代码如下:
Product.h
![](/assets/blank.gif)
1 #ifndef _PRODUCT_H_ 2 #define _PRODUCT_H_ 3 4 //抽象基类AbstractProductA,代表A类产品的抽象 5 class AbstractProductA 6 { 7 public: 8 virtual ~AbstractProductA()=0; 9 virtual void operation()=0; 10 protected: 11 AbstractProductA();//屏蔽构造函数 12 }; 13 14 //派生类ProductA1,继承自AbstractProductA,A类产品的一种实现 15 class ProductA1 : public AbstractProductA 16 { 17 public: 18 ProductA1(); 19 virtual void operation(); 20 virtual ~ProductA1(); 21 }; 22 23 //派生类ProductA2,继承自AbstractProductA,A类产品的另一种实现 24 class ProductA2:public AbstractProductA 25 { 26 public: 27 ProductA2(); 28 virtual void operation(); 29 virtual ~ProductA2(); 30 }; 31 32 //抽象基类AbstractProductB,代表B类产品的抽象 33 class AbstractProductB 34 { 35 public: 36 virtual ~AbstractProductB()=0; 37 virtual void operation()=0; 38 protected: 39 AbstractProductB();//屏蔽构造函数 40 }; 41 42 //派生类ProductB1,继承自AbstractProductB,B类产品的一种实现 43 class ProductB1:public AbstractProductB 44 { 45 public: 46 ProductB1(); 47 virtual void operation(); 48 virtual ~ProductB1(); 49 }; 50 51 //派生类ProductB2,继承自AbstractProductB,B类产品的另一种实现 52 class ProductB2:public AbstractProductB 53 { 54 public: 55 ProductB2(); 56 virtual void operation(); 57 virtual ~ProductB2(); 58 }; 59 60 61 #endif
![](/assets/blank.gif)
Factory.h
![](/assets/blank.gif)
1 #ifndef _FACTORY_H_ 2 #define _FACTORY_H_ 3 4 //AbstractFactory,工厂抽象基类,定义生产A类与B类产品的接口 5 class AbstractProductA; 6 class AbstractProductB; 7 class AbstractFactory 8 { 9 public: 10 virtual ~AbstractFactory()=0; 11 virtual AbstractProductA* CreateProductA()=0; 12 virtual AbstractProductB* CreateProductB()=0; 13 protected: 14 AbstractFactory(); 15 }; 16 17 //ConcreteFactory1,派生类,继承自AbstractFactory 18 //实现继承的接口,生产产品A和B的一种实现 19 class ConcreteFactory1:public AbstractFactory 20 { 21 public: 22 ConcreteFactory1(); 23 ~ConcreteFactory1(); 24 virtual AbstractProductA* CreateProductA(); 25 virtual AbstractProductB* CreateProductB(); 26 }; 27 28 //ConcreteFactory2,派生类,继承自AbstractFactory 29 //实现继承的接口,生产产品A和B的另一种实现 30 class ConcreteFactory2:public AbstractFactory 31 { 32 public: 33 ConcreteFactory2(); 34 ~ConcreteFactory2(); 35 virtual AbstractProductA* CreateProductA(); 36 virtual AbstractProductB* CreateProductB(); 37 }; 38 39 #endif
![](/assets/blank.gif)
Product.cpp
![](/assets/blank.gif)
1 #include "Product.h" 2 #include <iostream> 3 4 using namespace std; 5 6 //AbstractProductA 7 AbstractProductA::AbstractProductA() 8 { 9 cout << "AbstractProductA..." << endl; 10 } 11 12 AbstractProductA::~AbstractProductA() 13 { 14 cout << "~AbstractProductA..." << endl; 15 } 16 17 //ProductA1 18 ProductA1::ProductA1() 19 { 20 cout << "ProductA1..." << endl; 21 } 22 23 ProductA1::~ProductA1() 24 { 25 cout << "~ProductA1..." << endl; 26 } 27 28 void ProductA1::operation() 29 {} 30 31 //ProductA2 32 ProductA2::ProductA2() 33 { 34 cout << "ProductA2..." << endl; 35 } 36 37 ProductA2::~ProductA2() 38 { 39 cout << "~ProductA2..." << endl; 40 } 41 42 void ProductA2::operation() 43 {} 44 45 //AbstractProductB 46 AbstractProductB::AbstractProductB() 47 { 48 cout << "AbstractProductB..." << endl; 49 } 50 51 AbstractProductB::~AbstractProductB() 52 { 53 cout << "~AbstractProductB..." << endl; 54 } 55 56 //ProductB1 57 ProductB1::ProductB1() 58 { 59 cout << "ProductB1..." << endl; 60 } 61 62 ProductB1::~ProductB1() 63 { 64 cout << "~ProductB1..." << endl; 65 } 66 67 void ProductB1::operation() 68 {} 69 70 //ProductB2 71 ProductB2::ProductB2() 72 { 73 cout << "ProductB2..." << endl; 74 } 75 76 ProductB2::~ProductB2() 77 { 78 cout << "~ProductB2..." << endl; 79 } 80 81 void ProductB2::operation() 82 {}
![](/assets/blank.gif)
Factory.cpp
![](/assets/blank.gif)
1 #include "Factory.h" 2 #include "Product.h" 3 #include <iostream> 4 5 using namespace std; 6 7 AbstractFactory::AbstractFactory() 8 { 9 cout << "AbstractFactory..." << endl; 10 } 11 12 AbstractFactory::~AbstractFactory() 13 { 14 cout << "~AbstractFactory..." << endl; 15 } 16 17 ConcreteFactory1::ConcreteFactory1() 18 { 19 cout << "ConcreteFactory1..." << endl; 20 } 21 22 ConcreteFactory1::~ConcreteFactory1() 23 { 24 cout << "~ConcreteFactory1..." << endl; 25 } 26 27 AbstractProductA* ConcreteFactory1::CreateProductA() 28 { 29 return new ProductA1(); 30 } 31 32 AbstractProductB* ConcreteFactory1::CreateProductB() 33 { 34 return new ProductB1(); 35 } 36 37 ConcreteFactory2::ConcreteFactory2() 38 { 39 cout << "ConcreteFactory2..." << endl; 40 } 41 42 ConcreteFactory2::~ConcreteFactory2() 43 { 44 cout << "~ConcreteFactory2..." << endl; 45 } 46 47 AbstractProductA* ConcreteFactory2::CreateProductA() 48 { 49 return new ProductA2(); 50 } 51 52 AbstractProductB* ConcreteFactory2::CreateProductB() 53 { 54 return new ProductB2(); 55 }
![](/assets/blank.gif)
main.cpp
![](/assets/blank.gif)
1 #include <iostream> 2 #include "Factory.h" 3 #include "Product.h" 4 5 using namespace std; 6 7 int main() 8 { 9 AbstractFactory* fa1 = new ConcreteFactory1(); 10 AbstractProductA* a1 = fa1->CreateProductA(); 11 AbstractProductB* b1 = fa1->CreateProductB(); 12 13 cout << endl; 14 AbstractFactory* fa2 = new ConcreteFactory2(); 15 AbstractProductA* a2 = fa2->CreateProductA(); 16 AbstractProductB* b2 = fa2->CreateProductB(); 17 18 cout << endl; 19 delete fa1; 20 delete a1; 21 delete b1; 22 23 cout << endl; 24 delete fa2; 25 delete a2; 26 delete b2; 27 28 return 0; 29 }
![](/assets/blank.gif)
C++设计模式-AbstractFactory抽象工厂模式相关推荐
- 乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)
原文:乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern) [索引页] [源码下载] 乐在其中设计模式(C#) - 抽象工厂模式(Abstract Facto ...
- 设计模式之四(抽象工厂模式第三回合)
原文:设计模式之四(抽象工厂模式第三回合) 前言 抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 抽象工厂模式最大的好处便是易于交换产品系列,由于具体工厂类,例如I ...
- 设计模式-04抽象工厂模式
设计模式-04抽象工厂模式 文章中涉及到的代码,请自行下载 https://gitee.com/pan_xiao_lei123/designmode.git 前面介绍的工厂方法模式中考虑的是一类产品的 ...
- C#设计模式(4)——抽象工厂模式
C#设计模式(4)--抽象工厂模式 一.引言 在上一专题中介绍了工厂方法模式,工厂方法模式是为了克服简单工厂模式的缺点而设计出来的,简单工厂模式的工厂类随着产品类的增加需要增加额外的代码),而工厂方法 ...
- 设计模式系列·抽象工厂模式
前言 以小说的笔法写的设计模式系列文章,你绝对看得懂![首发于公众号:"聊聊代码"] 设计模式系列·王小二需求历险记(一) 设计模式系列·王小二需求历险记(二) 设计模式系列·封装 ...
- 设计模式三—抽象工厂模式
设计模式三-抽象工厂模式 一.定义 抽象工厂模式是工厂方法模式的进一步抽象.如果产品簇中只有一种产品,则退化为工厂方法模式. 二.原理图 三.代码实例 * 苹果和土豆是园丁1的杰作 * 葡萄和西红柿是 ...
- 设计模式复习-抽象工厂模式
设计模式复习-抽象工厂模式 有两种硬件,PC和Phone,有两种系统,Windows和Linux,现在假设PC和Phone上全都能安装这两个系统,并且将来硬件不会在变化,但是系统可能需要扩展,比如扩展 ...
- python抽象工厂模式_Python设计模式之抽象工厂模式
Python设计模式之抽象工厂模式 这篇文章主要为大家详细介绍了Python设计模式之抽象工厂模式,感兴趣的小伙伴们可以参考一下 python面向对象编程入门,我们需要不断学习进步 "&qu ...
- 设计模式(4)--AbstractFactory(抽象工厂模式)--创建型
1.模式定义: 抽象工厂是应对产品族概念的,提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们的具体类 2.模式特点: 抽象工厂模式为创建一组对象提供了一种解决方案.与工厂方法模式相比,抽象工 ...
最新文章
- javascript 实现页面显示当前时间 动态读秒
- Nginx 作为web server 的优化要点
- ceph rbdmap遇到的一个问题
- php://input allow_url_include,php allow_url_include的应用和解释_PHP教程
- 栅格像元做地理坐标映射后的坐标值是像元中心点还是其他位置?
- eoeAndroid开发者大会
- android面试(4)---文件存储
- java 7 collection 详解(一)
- 全网首发:gstreamer中正确使用avdec_h264插件
- 人生每一件事都是为自己而做
- 【非参数统计】概念及方法归纳比较(超适合期末复习)
- ps一点等于多少厘米_PS像素与厘米之间的转换
- 【转】关于ATSC与DVB的比较
- 如何用计算机做样本抽样,抽样设计和样本抽选.doc
- html点击按钮弹出悬浮窗_html弹窗,html网页弹窗代码
- 领带的10种打法图解
- 写给大忙人看的进程和线程(内附思维导图)
- 戴尔电脑最新bios设置图解介绍
- storm风暴英雄 tempo_迎接《风暴英雄》世界锦标赛季中大乱斗
- 千兆万兆以太网测试仪
热门文章
- Java 串口 mysql_java串口通讯
- OpenCV中的模板匹配
- Decision Tree学习笔记(基础篇)
- scATAC-seq建库原理,质控方法和新R包Signac的使用
- Mac平台上的一个MarkDown编辑器和静态博客生成工具-mweb mac最新版下载
- java怎么播放不了声音,java – 为什么这段代码不播放声音文件
- 帆软日期控件变灰_数据分析插件FineReport中日期控件如何校验JS
- 十二届蓝桥杯C++ 1月 中 高级组试题 第三题 换算
- java swing 注册事件_比较Java Swing中三种注册事件的方法
- java动态代理_Java中的动态代理一