抽象工厂模式
抽象工厂模式就变得比工厂模式更为复杂,就像上面提到的缺点一样,工厂模式和简单工厂模式要求产品子类必须要是同一类型的,拥有共同的方法,这就限制了产品子类的扩展。于是为了更加方便的扩展,抽象工厂模式就将同一类的产品子类归为一类,让他们继承同一个抽象子类,我们可以把他们一起视作一组,然后好几组产品构成一族。
此时,客户端要使用时必须知道是哪一个工厂并且是哪一组的产品抽象类。每一个工厂子类负责产生一族产品,而子类的一种方法产生一种类型的产品。在客户端看来只有AbstractProductA和AbstractProductB两种产品,使用的时候也是直接使用这两种产品。而通过工厂来识别是属于哪一族产品。
产品ProductA_1和ProductB_1构成一族产品,对应于有Factory1来创建,也就是说Factory1总是创建的ProductA_1和ProductB_1的产品,在客户端看来只需要知道是哪一类工厂和产品组就可以了。一般来说, ProductA_1和ProductB_1都是适应同一种环境的,所以他们会被归为一族。
常用的场景
例如Linux和windows两种操作系统下,有2个挂件A和B,他们在Linux和Windows下面的实现方式不同,Factory1负责产生能在Linux下运行的挂件A和B,Factory2负责产生能在Windows下运行的挂件A和B,这样如果系统环境发生变化了,我们只需要修改工厂就行了。
优点
1.封装了产品的创建,使得不需要知道具体是哪种产品,只需要知道是哪个工厂就行了。
2.可以支持不同类型的产品,使得模式灵活性更强。
3.可以非常方便的使用一族中间的不同类型的产品。
缺点
1.结构太过臃肿,如果产品类型比较多,或者产品族类比较多,就会非常难于管理。
2.每次如果添加一组产品,那么所有的工厂类都必须添加一个方法,这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。
C++实现代码
1 #ifndef _ABSTRACTPRODUCTA_H_ 2 #define _ABSTRACTPRODUCTA_H_ 3 4 5 #include <stdio.h> 6 7 8 class AbstractProductA{ 9 10 public: 11 AbstractProductA(); 12 virtual ~AbstractProductA(); 13 14 public: 15 virtual void operationA() = 0; 16 }; 17 18 class ProductA_1:public AbstractProductA{ 19 20 public: 21 ProductA_1(); 22 virtual ~ProductA_1(); 23 24 public: 25 void operationA(); 26 }; 27 28 class ProductA_2:public AbstractProductA{ 29 30 public: 31 ProductA_2(); 32 ~ProductA_2(); 33 34 public: 35 void operationA(); 36 }; 37 38 #endif
1 #include "AbstractProductA.h" 2 3 4 5 AbstractProductA::AbstractProductA(){ 6 } 7 8 9 AbstractProductA::~AbstractProductA(){ 10 } 11 12 13 ProductA_1::ProductA_1(){ 14 } 15 16 17 ProductA_1::~ProductA_1(){ 18 } 19 20 21 void ProductA_1::operationA(){ 22 fprintf(stderr,"productA_1 operation!\n"); 23 } 24 25 26 ProductA_2::ProductA_2(){ 27 } 28 29 30 ProductA_2::~ProductA_2(){ 31 } 32 33 34 void ProductA_2::operationA(){ 35 fprintf(stderr,"productA_2 operation!\n"); 36 }
1 #ifndef _ABSTRACTPRODUCTB_H_ 2 #define _ABSTRACTPRODUCTB_H_ 3 4 5 #include <stdio.h> 6 7 8 class AbstractProductB{ 9 10 public: 11 AbstractProductB(); 12 virtual ~AbstractProductB(); 13 14 public: 15 virtual void operationB() = 0; 16 }; 17 18 class ProductB_1:public AbstractProductB{ 19 20 public: 21 ProductB_1(); 22 virtual ~ProductB_1(); 23 24 public: 25 void operationB(); 26 }; 27 28 class ProductB_2:public AbstractProductB{ 29 30 public: 31 ProductB_2(); 32 ~ProductB_2(); 33 34 public: 35 void operationB(); 36 }; 37 38 #endif
1 #include "AbstractProductB.h" 2 3 4 5 AbstractProductB::AbstractProductB(){ 6 } 7 8 9 AbstractProductB::~AbstractProductB(){ 10 } 11 12 13 ProductB_1::ProductB_1(){ 14 } 15 16 17 ProductB_1::~ProductB_1(){ 18 } 19 20 21 void ProductB_1::operationB(){ 22 fprintf(stderr,"productB_1 operation!\n"); 23 } 24 25 26 ProductB_2::ProductB_2(){ 27 } 28 29 30 ProductB_2::~ProductB_2(){ 31 } 32 33 34 void ProductB_2::operationB(){ 35 fprintf(stderr,"productB_2 operation!\n"); 36 }
1 #ifndef _SIMPLEFACTORY_H_ 2 #define _SIMPLEFACTROY_H_ 3 4 #include <stdio.h> 5 #include "AbstractProductA.h" 6 #include "AbstractProductB.h" 7 8 9 class AbstractFactory{ 10 11 public: 12 AbstractFactory(); 13 virtual ~AbstractFactory(); 14 15 public: 16 virtual AbstractProductA* createProductA() = 0; 17 virtual AbstractProductB* createProductB() = 0; 18 }; 19 20 21 class Factory1:public AbstractFactory{ 22 23 public: 24 Factory1(); 25 ~Factory1(); 26 27 public: 28 AbstractProductA* createProductA(); 29 AbstractProductB* createProductB(); 30 }; 31 32 33 class Factory2:public AbstractFactory{ 34 35 public: 36 Factory2(); 37 ~Factory2(); 38 39 public: 40 AbstractProductA* createProductA(); 41 AbstractProductB* createProductB(); 42 }; 43 #endif
1 #include "AbstractFactory.h" 2 3 4 AbstractFactory::AbstractFactory(){ 5 } 6 7 8 AbstractFactory::~AbstractFactory(){ 9 } 10 11 12 Factory1::Factory1(){ 13 } 14 15 16 Factory1::~Factory1(){ 17 } 18 19 20 AbstractProductA* Factory1::createProductA(){ 21 AbstractProductA* temp = NULL; 22 temp = new ProductA_1(); 23 return temp; 24 } 25 26 27 AbstractProductB* Factory1::createProductB(){ 28 AbstractProductB* temp = NULL; 29 temp = new ProductB_1(); 30 return temp; 31 } 32 33 34 Factory2::Factory2(){ 35 } 36 37 38 Factory2::~Factory2(){ 39 } 40 41 42 AbstractProductA* Factory2::createProductA(){ 43 AbstractProductA* temp = NULL; 44 temp = new ProductA_2(); 45 return temp; 46 } 47 48 49 AbstractProductB* Factory2::createProductB(){ 50 AbstractProductB* temp = NULL; 51 temp = new ProductB_2(); 52 return temp; 53 }
1 #include "AbstractFactory.h" 2 3 4 int main(){ 5 6 AbstractFactory* factory = new Factory1(); 7 AbstractProductA* productA = factory->createProductA(); 8 AbstractProductB* productB = factory->createProductB(); 9 productA->operationA(); 10 productB->operationB(); 11 12 delete factory; 13 factory = NULL; 14 delete productA; 15 productA = NULL; 16 delete productB; 17 productB = NULL; 18 19 factory = new Factory2(); 20 productA = factory->createProductA(); 21 productB = factory->createProductB(); 22 productA->operationA(); 23 productB->operationB(); 24 25 delete factory; 26 factory = NULL; 27 delete productA; 28 productA = NULL; 29 delete productB; 30 productB = NULL; 31 return 0; 32 }
1 g++ -o client AbstractProductA.cpp AbstractProductB.cpp AbstractFactory.cpp client.cpp
结果