设计模式~工厂

来自维基百科

工厂方法模式（英语：Factory method pattern）是一种实现了“工厂”概念的面向对象设计模式。就像其他创建型模式一样，它也是处理在不指定对象具体类型的情况下创建对象的问题。工厂方法模式的实质是“定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。”[1]

创建一个对象常常需要复杂的过程，所以不适合包含在一个复合对象中。创建对象可能会导致大量的重复代码，可能会需要复合对象访问不到的信息，也可能提供不了足够级别的抽象，还可能并不是复合对象概念的一部分。工厂方法模式通过定义一个单独的创建对象的方法来解决这些问题。由子类实现这个方法来创建具体类型的对象。

对象创建中的有些过程包括决定创建哪个对象、管理对象的生命周期，以及管理特定对象的创建和销毁的概念。

工厂[编辑]

在面向对象程序设计中，工厂通常是一个用来创建其他对象的对象。工厂是构造方法的抽象，用来实现不同的分配方案。

工厂对象通常包含一个或多个方法，用来创建这个工厂所能创建的各种类型的对象。这些方法可能接收参数，用来指定对象创建的方式，最后返回创建的对象。

有时，特定类型对象的控制过程比简单地创建一个对象更复杂。在这种情况下，工厂对象就派上用场了。工厂对象可能会动态地创建产品对象的类，或者从对象池中返回一个对象，或者对所创建的对象进行复杂的配置，或者应用其他的操作。

这些类型的对象很有用。几个不同的设计模式都应用了工厂的概念，并可以使用在很多语言中。例如，在《设计模式》一书中，像工厂方法模式、抽象工厂模式、生成器模式，甚至是单例模式都应用了工厂的概念。

出工厂模式的设计问题

◆ 1.为了提高内聚（Cohesion）和松耦合（Coupling），我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题 n 多的子类继承自抽象基类，我们不得不在每次要用到子类的地方就编写诸如 new ×××;的代码。这里带来两个问题：
客户程序员必须知道实际子类的名称（当系统复杂后，命名将是一个很不好处理的问题，为了处理可能的名字冲突，有的命名可能并不是具有很好的可读性和可记忆性，就姑且不论不同程序员千奇百怪的个人偏好了）。
程序的扩展性和维护变得越来越困难。
◆ 2.还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。这里的意思为：假设我们在类 A 中要使用到类 B，B 是一个抽象父类，在 A 中并不知道具体要实例化那一个 B 的子类，但是在类 A 的子类 D 中是可以知道的。在 A 中我们没有办法直接使用类似于 new ×××的语句，因为根本就不知道×××是什么。

以上两个问题也就引出了工厂模式的两个最重要的功能：
定义创建对象的接口，封装了对象的创建；
使得具体化类的工作延迟到了子类中。

对于工厂模式，为了使其能更好的解决多种情况的问题，将其分为三类：简单工厂模式（Simple Factory），工厂方法模式（Factory Method），抽象工厂模式（Abstract Factory）。下面来一一搞定。

转载：三种工厂模式的C++实现

简单工厂

        具体情形：有一个肥皂厂，生产各种肥皂，有舒肤佳，夏士莲，娜爱斯等。给这个肥皂厂建模。

        UML图如下：

对于简单设计模式的结构图，我们可以很清晰的看到它的组成：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。
简单设计模式存在的目的很简单：定义一个用于创建对象的接口。

缺点：对修改不封闭，新增加产品您要修改工厂。违法了鼎鼎大名的开闭法则（OCP）。

代码实现：

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #include <iostream>  
  2. using namespace std;  
  3. enum PRODUCTTYPE {SFJ,XSL,NAS};  
  4. class soapBase  
  5. {  
  6.     public:  
  7.     virtual ~soapBase(){};  
  8.     virtual void show() = 0;  
  9. };  
  10.   
  11. class SFJSoap:public soapBase  
  12. {  
  13.     public:  
  14.     void show() {cout<<"SFJ Soap!"<<endl;}  
  15. };  
  16.   
  17. class XSLSoap:public soapBase  
  18. {  
  19.     public:  
  20.     void show() {cout<<"XSL Soap!"<<endl;}  
  21. };  
  22.   
  23. class NASSoap:public soapBase  
  24. {  
  25.     public:  
  26.     void show() {cout<<"NAS Soap!"<<endl;}  
  27. };  
  28.   
  29. class Factory  
  30. {  
  31.     public:  
  32.     soapBase * creatSoap(PRODUCTTYPE type)  
  33.     {  
  34.         switch(type)  
  35.         {  
  36.             case SFJ:   
  37.                 return new SFJSoap();  
  38.                 break;  
  39.             case XSL:  
  40.                 return new XSLSoap();  
  41.                 break;  
  42.             case NAS:  
  43.                 return new NASSoap();  
  44.                 break;  
  45.             default:break;  
  46.         }  
  47.           
  48.     }  
  49. };  
  50.   
  51. int main()  
  52. {  
  53.     Factory factory;  
  54.     soapBase* pSoap1 = factory.creatSoap(SFJ);  
  55.     pSoap1->show();  
  56.     soapBase* pSoap2 = factory.creatSoap(XSL);  
  57.     pSoap2->show();  
  58.     soapBase* pSoap3 = factory.creatSoap(NAS);  
  59.     pSoap3->show();  
  60.     delete pSoap1;  
  61.     delete pSoap2;  
  62.     delete pSoap3;  
  63.     return 0;  
  64. }  



运行结果

工厂方法模式

具体情形：最近莫名肥皂需求激增!！ 于是要独立每个生产线，每个生产线只生产一种肥皂。

UML图如下：

        其实这才是真正的工厂模式，简单工厂模式只能算是“坑爹版”的工厂模式。我们能很容易看出工厂方法模式和简单工厂模式的区别之处。工厂方法模式的应用并不是只是为了封装对象的创建，而是要把对象的创建放到子类中实现：Factory中只是提供了对象创建的接口，其实现将放在Factory的子类ConcreteFactory中进行。
对于工厂方法模式的组成：
1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。

缺点：每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。

代码实现：

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #include <iostream>  
  2. using namespace std;  
  3. enum SOAPTYPE {SFJ,XSL,NAS};  
  4.   
  5. class soapBase  
  6. {  
  7.     public:  
  8.     virtual ~soapBase(){};  
  9.     virtual void show() = 0;  
  10. };  
  11.   
  12. class SFJSoap:public soapBase  
  13. {  
  14.     public:  
  15.     void show() {cout<<"SFJ Soap!"<<endl;}  
  16. };  
  17.   
  18. class XSLSoap:public soapBase  
  19. {  
  20.     public:  
  21.     void show() {cout<<"XSL Soap!"<<endl;}  
  22. };  
  23.   
  24. class NASSoap:public soapBase  
  25. {  
  26.     public:  
  27.     void show() {cout<<"NAS Soap!"<<endl;}  
  28. };  
  29.   
  30. class FactoryBase  
  31. {  
  32.     public:  
  33.     virtual soapBase * creatSoap() = 0;  
  34. };  
  35.   
  36. class SFJFactory:public FactoryBase  
  37. {  
  38.     public:  
  39.     soapBase * creatSoap()  
  40.     {  
  41.         return new SFJSoap();  
  42.     }  
  43. };  
  44.   
  45. class XSLFactory:public FactoryBase  
  46. {  
  47.     public:  
  48.     soapBase * creatSoap()  
  49.     {  
  50.         return new XSLSoap();  
  51.     }  
  52. };  
  53.   
  54. class NASFactory:public FactoryBase  
  55. {  
  56.     public:  
  57.     soapBase * creatSoap()  
  58.     {  
  59.         return new NASSoap();  
  60.     }  
  61. };  
  62.   
  63.   
  64.   
  65. int main()  
  66. {  
  67.     SFJFactory factory1;  
  68.     soapBase* pSoap1 = factory1.creatSoap();  
  69.     pSoap1->show();  
  70.     XSLFactory factory2;  
  71.     soapBase* pSoap2 = factory2.creatSoap();  
  72.     pSoap2->show();  
  73.     NASFactory factory3;  
  74.     soapBase* pSoap3 = factory3.creatSoap();  
  75.     pSoap3->show();  
  76.     delete pSoap1;  
  77.     delete pSoap2;  
  78.     delete pSoap3;  
  79.     return 0;  
  80. }  


运行结果

抽象工厂模式

具体情形：这个肥皂厂发现搞牙膏也很赚钱，决定做牙膏。牙膏有高档低档，肥皂也是。现在搞两个厂房，一个生产低档的牙膏和肥皂，一个生产高档的牙膏和肥皂。

比如，厂房一生产中华牙膏、娜爱斯肥皂，厂房二生产黑人牙膏和舒肤佳牙膏

 UML图如下：

对于上面的结构图，可以看出抽象工厂模式，比前两者更为的复杂和一般性，抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。
抽象工厂模式：给客户端提供一个接口，可以创建多个产品族中的产品对象 ，而且使用抽象工厂模式还要满足一下条件：
1)系统中有多个产品族，而系统一次只可能消费其中一族产品。
2)同属于同一个产品族的产品以其使用。

抽象工厂模式的组成（和工厂方法模式一样）：
1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。

代码实现

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #include <iostream>  
  2. using namespace std;  
  3. enum SOAPTYPE {SFJ,XSL,NAS};  
  4. enum TOOTHTYPE {HR,ZH};  
  5.   
  6. class SoapBase  
  7. {  
  8.     public:  
  9.     virtual ~SoapBase(){};  
  10.     virtual void show() = 0;  
  11. };  
  12.   
  13. class SFJSoap:public SoapBase  
  14. {  
  15.     public:  
  16.     void show() {cout<<"SFJ Soap!"<<endl;}  
  17. };  
  18.   
  19. class NASSoap:public SoapBase  
  20. {  
  21.     public:  
  22.     void show() {cout<<"NAS Soap!"<<endl;}  
  23. };  
  24.   
  25. class ToothBase  
  26. {  
  27.     public:  
  28.     virtual ~ToothBase(){};  
  29.     virtual void show() = 0;  
  30. };  
  31.   
  32. class HRTooth:public ToothBase  
  33. {  
  34.     public:  
  35.     void show() {cout<<"Hei ren Toothpaste!"<<endl;}  
  36. };  
  37.   
  38. class ChinaTooth:public ToothBase  
  39. {  
  40.     public:  
  41.     void show() {cout<<"China Toothpaste!"<<endl;}  
  42. };  
  43.   
  44. class FactoryBase  
  45. {  
  46.     public:  
  47.     virtual SoapBase * creatSoap() = 0;  
  48.     virtual ToothBase * creatToothpaste() = 0;  
  49. };  
  50.   
  51. class FactoryA :public FactoryBase  
  52. {  
  53.     public:  
  54.     SoapBase * creatSoap()  
  55.     {  
  56.         return new SFJSoap();  
  57.     }  
  58.       
  59.     ToothBase * creatToothpaste()  
  60.     {  
  61.         return new HRTooth();  
  62.     }  
  63. };  
  64.   
  65. class FactoryB :public FactoryBase  
  66. {  
  67.     public:  
  68.     SoapBase * creatSoap()  
  69.     {  
  70.         return new NASSoap();  
  71.     }  
  72.       
  73.     ToothBase * creatToothpaste()  
  74.     {  
  75.         return new ChinaTooth();  
  76.     }  
  77. };  
  78.   
  79.   
  80. int main()  
  81. {  
  82.     FactoryA factory1;  
  83.     FactoryB factory2;  
  84.     SoapBase *pSoap1 = NULL;  
  85.     ToothBase *pToothpaste1 = NULL;  
  86.     pSoap1 = factory1.creatSoap();  
  87.     pToothpaste1 = factory1.creatToothpaste();  
  88.     pSoap1->show();  
  89.     pToothpaste1->show();  
  90.       
  91.     SoapBase *pSoap2 = NULL;  
  92.     ToothBase *pToothpaste2 = NULL;  
  93.     pSoap2 = factory2.creatSoap();  
  94.     pToothpaste2 = factory2.creatToothpaste();  
  95.     pSoap2->show();  
  96.     pToothpaste2->show();  
  97.       
  98.     delete pSoap1;  
  99.     delete pSoap2;  
  100.     delete pToothpaste1;  
  101.     delete pToothpaste2;  
  102.       
  103.     return 0;  
  104. }  


运行结果

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/sanghai/p/6727564.html