意图:定义一个用于创建对象的接口,让子类觉定实例化哪一个类。
适用性:1.一个类不知道它必须创建的对象的时候。
2.一个类希望由它的子类指定它所创建的对象的时候。
3.当类将创建对象的职责委托给多个帮助子类中的某一个,并且希望将那一个帮助子类是代理者这一信息局部化的时候。
效果: 1.提供对象的扩展版本。
2.连接平行的类层次。
今天学工厂方法模式,感觉得从几个工厂模式一起去理解,所以我整体的讲一下自己的想法。
开始,老板要求按客户意愿产生对应产品。于是有简单工厂,代码如下:
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#ifndef _PRODUCT_ #define _PRODUCT_ #include <string> using namespace std; class AbsProduct{ public: AbsProduct(){} virtual string GetProduct() = 0; }; class Product_A:public AbsProduct{ public: Product_A(){} virtual string GetProduct(){return "Product_A";} }; class Product_B:public AbsProduct{ public: Product_B(){} virtual string GetProduct(){return "Product_B";} }; class Product_C:public AbsProduct{ public: Product_C(){} virtual string GetProduct(){return "Product_C";} }; #endif
工厂部分代码:
#ifndef _FACTORY_ #define _FACTORY_ #include "Product.h" class Factory{ public: Factory(){} AbsProduct* MakeProduct(char ch) { switch (ch) { case 'A': return new Product_A; break; case 'B': return new Product_B; break; case 'C': return new Product_C; break; default: break; } } }; #endif
实现部分:
#include <iostream> #include <string> using namespace std; #include "Factory.h" #include "Product.h" int main() { Factory factory; AbsProduct* product = factory.MakeProduct('A'); cout<<product->GetProduct()<<endl; product = factory.MakeProduct('B'); cout<<product->GetProduct()<<endl; product = factory.MakeProduct('C'); cout<<product->GetProduct()<<endl; return 0; }
有一天,老板又要求: 将新产品 Product_D 加入到生产。简单工厂模式虽然满足了按要求生产对应的产品,
但无法扩展新产品。于是实现了工厂方法模式:
首先产品部分添加Product_D :
class Product_D:public AbsProduct{ public: Product_D(){} virtual string GetProduct(){return "Product_D";} };
工厂部分改为:
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
class AbsFactory{ public: AbsFactory(){} virtual AbsProduct* MakeFroduct() = 0; }; class Factory_A:public AbsFactory{ public: Factory_A(){} virtual AbsProduct* MakeFroduct(){return new Product_A;} }; class Factory_B:public AbsFactory{ public: Factory_B(){} virtual AbsProduct* MakeFroduct(){return new Product_B;} }; class Factory_C:public AbsFactory{ public: Factory_C(){} virtual AbsProduct* MakeFroduct(){return new Product_C;} }; class Factory_D:public AbsFactory{ public: Factory_D(){} virtual AbsProduct* MakeFroduct(){return new Product_D;} };
实现部分:
#include <iostream> #include <string> using namespace std; #include "Factory.h" #include "Product.h" int main() { AbsFactory* factory = new Factory_A; AbsProduct* product = factory->MakeFroduct(); cout<<product->GetProduct()<<endl; factory = new Factory_B; product = factory->MakeFroduct(); cout<<product->GetProduct()<<endl; factory = new Factory_C; product = factory->MakeFroduct(); cout<<product->GetProduct()<<endl; factory = new Factory_D; product = factory->MakeFroduct(); cout<<product->GetProduct()<<endl; return 0; }
老板又要求了,“现在我们公司就主打这四个产品了,你们要定期更新这些产品。”
这样工厂方法虽然满足了按客户要求生产对应产品,而且也满足了扩展新产品的要求,
但无法满足新产品的更新换代。于是抽象工厂模式出来了......
对于我们的例子而已,假设公司的产品A1,B1,C1,D1为一起产品,A2,B2,C2,D2为二期产品。
则A1,A2,A3......为同一族产品。而A1,B1,C1,D1为同一等级产品。如果只工厂生产同一等级
产品,则是工厂方法模式。如果产生了不同等级产品则为抽象工厂模式。