工厂模式
工厂模式基本与简单工厂模式差不多,上面也说了,每次添加一个产品子类都必须在工厂类中添加一个判断分支,这样违背了开放-封闭原则,因此,工厂模式就是为了解决这个问题而产生的。
既然每次都要判断,那我就把这些判断都生成一个工厂子类,这样,每次添加产品子类的时候,只需再添加一个工厂子类就可以了。这样就完美的遵循了开放-封闭原则。但这其实也有问题,如果产品数量足够多,要维护的量就会增加,好在一般工厂子类只用来生成产品类,只要产品子类的名称不发生变化,那么基本工厂子类就不需要修改,每次只需要修改产品子类就可以了。
同样工厂模式一般应该于程序中大部分地方都只使用其中一种产品,工厂类也不用频繁创建产品类的情况。这样修改的时候只需要修改有限的几个地方即可。
常用的场景
基本与简单工厂模式一致,只不过是改进了简单工厂模式中的开放-封闭原则的缺陷,使得模式更具有弹性。将实例化的过程推迟到子类中,由子类来决定实例化哪个。
优点
基本与简单工厂模式一致,多的一点优点就是遵循了开放-封闭原则,使得模式的灵活性更强。
缺点
与简单工厂模式差不多。
C++实现代码
1 #ifndef _ABSTRACTPRODUCT_H_ 2 #define _ABSTRACTPRODUCT_H_ 3 4 5 #include <stdio.h> 6 7 8 class AbstractProduct{ 9 10 public: 11 AbstractProduct(); 12 virtual ~AbstractProduct(); 13 14 public: 15 virtual void operation() = 0; 16 }; 17 18 class ProductA:public AbstractProduct{ 19 20 public: 21 ProductA(); 22 virtual ~ProductA(); 23 24 public: 25 void operation(); 26 }; 27 28 class ProductB:public AbstractProduct{ 29 30 public: 31 ProductB(); 32 ~ProductB(); 33 34 public: 35 void operation(); 36 }; 37 38 #endif
1 #include "AbstractProduct.h" 2 3 4 5 AbstractProduct::AbstractProduct(){ 6 } 7 8 9 AbstractProduct::~AbstractProduct(){ 10 } 11 12 13 ProductA::ProductA(){ 14 } 15 16 17 ProductA::~ProductA(){ 18 } 19 20 21 void ProductA::operation(){ 22 fprintf(stderr,"productA operation!\n"); 23 } 24 25 26 ProductB::ProductB(){ 27 } 28 29 30 ProductB::~ProductB(){ 31 } 32 33 34 void ProductB::operation(){ 35 fprintf(stderr,"productB operation!\n"); 36 }
1 #ifndef _SIMPLEFACTORY_H_ 2 #define _SIMPLEFACTROY_H_ 3 4 #include <stdio.h> 5 #include "AbstractProduct.h" 6 7 8 class AbstractFactory{ 9 10 public: 11 AbstractFactory(); 12 virtual ~AbstractFactory(); 13 14 public: 15 virtual AbstractProduct* createProduct() = 0; 16 }; 17 18 19 class FactoryA:public AbstractFactory{ 20 21 public: 22 FactoryA(); 23 ~FactoryA(); 24 25 public: 26 AbstractProduct* createProduct(); 27 }; 28 29 30 class FactoryB:public AbstractFactory{ 31 32 public: 33 FactoryB(); 34 ~FactoryB(); 35 36 public: 37 AbstractProduct* createProduct(); 38 }; 39 #endif
1 #include "AbstractFactory.h" 2 3 4 AbstractFactory::AbstractFactory(){ 5 } 6 7 8 AbstractFactory::~AbstractFactory(){ 9 } 10 11 12 FactoryA::FactoryA(){ 13 } 14 15 16 FactoryA::~FactoryA(){ 17 } 18 19 20 AbstractProduct* FactoryA::createProduct(){ 21 AbstractProduct* temp = NULL; 22 temp = new ProductA(); 23 return temp; 24 } 25 26 27 FactoryB::FactoryB(){ 28 } 29 30 31 FactoryB::~FactoryB(){ 32 } 33 34 35 AbstractProduct* FactoryB::createProduct(){ 36 AbstractProduct* temp = NULL; 37 temp = new ProductB(); 38 return temp; 39 }
1 #include "AbstractFactory.h" 2 3 4 int main(){ 5 AbstractFactory* factory = new FactoryA(); 6 AbstractProduct* product = factory->createProduct(); 7 product->operation(); 8 delete product; 9 product = NULL; 10 delete factory; 11 factory = NULL; 12 13 factory = new FactoryB(); 14 product = factory->createProduct(); 15 product->operation(); 16 delete product; 17 product = NULL; 18 delete factory; 19 factory = NULL; 20 return 0; 21 }
1 g++ -o client client.cpp AbstractFactory.cpp AbstractProduct.cpp
结果