工厂模式

<1>  介绍：

目的：主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

工厂模式分为三类：
1）简单工厂模式（Simple Factory）

2）工厂方法模式（Factory Method）

3）抽象工厂模式（Abstract Factory）

 GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

<2>简单工厂模式

组成：

1)        工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在Java中它往往由一个具体类实现。

2)        抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

3)        具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

结构图 

对产品部分来说，它是符合开闭原则的；但是工厂部分不太理想，因为每增加一类产品，都要在工厂类中增加相应的业务逻辑或者判断逻辑，这显然是违背开闭原则的。 因此需要后面的工厂方法模式去解决

简单工厂的应用场景：

1当工厂类负责创建的对象比较少时可以考虑使用简单工厂模式（）

2客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时可以考虑使用简单工厂模式

 

简单工厂模式

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #include <iostream>  
  2. using namespace std;  
  3. /**************************************** 
  4. *本程序用来测试分析工厂模               * 
  5. 此程序为简单工厂模式 
  6.   2014.5.10 10:16  
  7. *****************************************/  
  8. class Product  
  9. {  
  10. public:  
  11.      virtual void property()  
  12.      {  
  13.          cout<<"i am product!"<<endl;  
  14.      }  
  15. };  
  16.   
  17. class Product1:public Product  
  18. {  
  19. public :  
  20.     void property()  
  21.     {  
  22.         cout << "i am product 1" << endl;  
  23.     }  
  24. };  
  25.   
  26. class Product2: public Product  
  27. {  
  28. public :  
  29.     void property()  
  30.     {  
  31.         cout << "i am product 2" << endl;  
  32.     }  
  33. };  
  34.   
  35. class factory  
  36. {  
  37. public:  
  38.     Product* GetProduct(int SelectProduct)   
  39.     {     
  40.          switch(SelectProduct)  
  41.          {  
  42.          case 1 : return new Product1;  break;  
  43.          case 2:  return new Product2; break;  
  44.          default:   
  45.              {  
  46.                     cout << "something is wrong so return product" << endl;  
  47.                     return new Product;  
  48.                     break;  
  49.              }  
  50.          }     
  51. }  
  52.    
  53. };  
  54. int main()  
  55. {  
  56.     int sel =1;  
  57.     factory fac;  
  58.     Product *p = fac.GetProduct(1);  
  59.     p->property();  
  60.     delete p;  
  61.     p = NULL;  
  62.     p = fac.GetProduct(2);  
  63.     p->property();  
  64.     delete p;  
  65.     p = NULL;  
  66.     p = fac.GetProduct(3);  
  67.     p->property();  
  68.     delete p;  
  69.     p = NULL;  
  70.     return 0;  
  71. }  

 

简单工厂模式的优缺点

优点 
1.工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅"消费"产品。简单工厂模式通过这种做法实现了对责任的分割。 
缺点 
1.系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，有可能造成工厂逻辑过于复杂,违背了"开放--封闭"原则(OCP).另外，简单工厂模式通常使用静态工厂方法，这使得无法由子类继承，造成工厂角色无法形成基于继承的等级结构。 

 

<3>工厂方法模式

引入原因 ：简单工厂模式系统难以扩展，一旦添加新产品就不得不修改简单工厂方法，这样就会造成简单工厂的实现逻辑过于复杂，然而工厂方法模式可以解决简单工厂模式中存在的这个问题。

组成：

1)        抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。c++中由抽象类实现

2)        具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3)        抽象产品角色：它是具体产品继承的父类或者是实现的接口。 由抽象类或者接口来实现。

4)        具体产品角色：具体工厂角色所创建的对象就是此角色的实例。 由具体的类来实现。

UML结构图


工厂方法模式之所以可以解决简单工厂的模式，是因为它的实现把具体产品的创建推迟到子类中，此时工厂类不再负责所有产品的创建，而只是给出具体工厂必须实现的接口，这样工厂方法模式就可以允许系统不修改工厂类逻辑的情况下来添加新产品，这样也就克服了简单工厂模式中缺点。

具体代码如下：

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #include <iostream>  
  2. using namespace std;  
  3. /**************************************** 
  4. *        工厂方法模式演示程序             * 
  5. *          2014.5.22 17:16               * 
  6. *        by hnust_xiehonghao             * 
  7. *****************************************/  
  8. class Product  
  9. {  
  10. public:  
  11.      virtual void property()  
  12.      {  
  13.          cout<<"i am product!"<<endl;  
  14.      }  
  15. };  
  16.   
  17. class Product1:public Product  
  18. {  
  19. public :  
  20.     void property()  
  21.     {  
  22.         cout << "i am product 1" << endl;  
  23.     }  
  24. };  
  25.   
  26. class Product2: public Product  
  27. {  
  28. public :  
  29.     void property()  
  30.     {  
  31.         cout << "i am product 2" << endl;  
  32.     }  
  33. };  
  34.   
  35. class Factory  
  36. {  
  37. public:   
  38.     virtual Product* GetProduct() = 0;  
  39. };  
  40.   
  41. class Factory1 : public Factory  
  42. {  
  43. public:  
  44.         Product* GetProduct()  
  45.         {  
  46.             return new Product1();  
  47.   
  48.         }  
  49. };  
  50.   
  51. class Factory2 : public Factory  
  52. {  
  53. public :  
  54.         Product* GetProduct()  
  55.         {  
  56.             return new Product2();  
  57.   
  58.         }  
  59. };  
  60.   
  61. int main()  
  62. {  
  63.      Factory* Fac1 = new Factory1();//产生什么类型的产品就生成什么类型的工厂 让这种类型的工厂生成该产品  
  64.      Product* Product1 = Fac1->GetProduct();  
  65.      Product1->property();  
  66.      delete Fac1;  
  67.      delete Product1;  
  68.      Factory* Fac2 = new Factory2();  
  69.      Product* Product2 = Fac2->GetProduct();  
  70.      Product2->property();  
  71.      delete Fac2;  
  72.      delete Product2;  
  73.        
  74.   
  75.     return 0;  
  76. }  
 
常用场景
  1. 在设计的初期，就考虑到产品在后期会进行扩展的情况下，可以使用工厂方法模式；
  2. 产品结构较复杂的情况下，可以使用工厂方法模式；
<4>抽象工厂模式
作用：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。  节省了需要建立的工厂数目 便于管理和扩展
先了解一下一个名词  产品族： 位于不同产品等级结构中，功能相关联的产品组成的家族。
例如 宝马和奔驰 可以归为一个产品族 都是跑车族的   或者说 有一个生产显示屏的工厂 现在想再建一个工厂生产与显示屏配套服务的东西。我们可以把2者归为一个族 用一个工厂去完成2者  这就是抽象工厂
 
抽象工厂模式中的有以下的四种角色：
抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。
具体工厂（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。
抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。
具体产品（Concrete Product）角色：这个角色用以代表具体的产品。
 
结构图：
 
 
如图所示，抽象工厂模式，就好比是两个工厂方法模式的叠加。抽象工厂创建的是一系列相关的对象，其中创建的实现其实就是采用的工厂方法模式。

适用场合

工厂方法模式适用于产品种类结构单一的场合，为一类产品提供创建的接口；而抽象工厂方法适用于产品种类结构多的场合，主要用于创建一组（有多个种类）相关的产品，为它们提供创建的接口；就是当具有多个抽象角色时，抽象工厂便可以派上用场。

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #include <iostream>  
  2. using namespace std;  
  3. /**************************************** 
  4. *          工厂方法模式演示程序           * 
  5. * 以食品和餐具作比喻 若不够形象请尽情吐槽  * 
  6. *            偶会尽力修改                *  
  7. *          2014.5.22 17:16              * 
  8. *        by hnust_xiehonghao            * 
  9. *****************************************/  
  10. class ProductA//A可以看做是高档牛排  
  11. {  
  12. public:  
  13.      virtual void property()  
  14.      {  
  15.          cout<<"我是牛排!"<<endl;  
  16.      }  
  17. };  
  18.   
  19. class ProductA1:public ProductA  
  20. {  
  21. public :  
  22.     void property()  
  23.     {  
  24.         cout << "我是高档牛排" << endl;  
  25.     }  
  26. };  
  27.   
  28. class ProductA2: public ProductA  
  29. {  
  30. public :  
  31.     void property()  
  32.     {  
  33.         cout << "我是低档牛排" << endl;  
  34.     }  
  35. };  
  36.   
  37. class ProductB//我是餐具  叉子  
  38. {  
  39. public:  
  40.      virtual void property()  
  41.      {  
  42.          cout<<"我是餐具!"<<endl;  
  43.      }  
  44. };  
  45.   
  46. class ProductB1:public ProductB  
  47. {  
  48. public :  
  49.     void property()  
  50.     {  
  51.         cout << "我是银餐具" << endl;  
  52.     }  
  53. };  
  54.   
  55. class ProductB2: public ProductB  
  56. {  
  57. public :  
  58.     void property()  
  59.     {  
  60.         cout << "我是钢餐具" << endl;  
  61.     }  
  62. };  
  63.   
  64.   
  65.   
  66. class Factory//抽象工厂 一个工厂是可以生产 高档 和 低档 这两类产品的  
  67. {  
  68. public:   
  69.     virtual ProductA* GetProductA() = 0;//产生牛排  
  70.     virtual ProductB* GetProductB() = 0;//产生餐具  
  71. };  
  72.   
  73. class Factory1 : public Factory//产生高档产品子工厂    
  74. {  
  75. public:  
  76.         ProductA* GetProductA()  
  77.         {  
  78.             return new ProductA1();  
  79.   
  80.         }  
  81.         ProductB* GetProductB()  
  82.         {  
  83.             return new ProductB1();  
  84.   
  85.         }  
  86. };  
  87.   
  88. class Factory2 : public Factory// 产生低档 产品  
  89. {  
  90. public:  
  91.         ProductA* GetProductA()  
  92.         {  
  93.             return new ProductA2();  
  94.   
  95.         }  
  96.         ProductB* GetProductB()  
  97.         {  
  98.             return new ProductB2();  
  99.   
  100.         }  
  101. };  
  102.   
  103. int main()  
  104. {  
  105.      Factory* Fac1 = new Factory1();   
  106.      ProductA* ProductA1 = Fac1->GetProductA();  
  107.      ProductB* ProductB1 = Fac1->GetProductB();  
  108.      ProductA1->property();  
  109.      ProductB1->property();  
  110.      delete Fac1;  
  111.      delete ProductA1;  
  112.      delete ProductB1;  
  113.      Factory* Fac2 = new Factory2();   
  114.      ProductA* ProductA2 = Fac1->GetProductA();  
  115.      ProductB* ProductB2 = Fac1->GetProductB();  
  116.      ProductA2->property();  
  117.      ProductB2->property();  
  118.      delete Fac2;  
  119.      delete ProductA2;  
  120.      delete ProductB2;  
  121.   
  122.     return 0;  
  123. }  

 

简单工厂 与 策略模式 的小区别

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3. /**************************************** 
    4. *本程序用来测试分析工厂模式与策略模式的区别* 
    5. 此程序为策略模式 
    6.   2014.5.10 14:31  
    7. *****************************************/  
    8. class Product  
    9. {  
    10. public:  
    11.      virtual void property()  
    12.      {  
    13.          cout<<"i am product!"<<endl;  
    14.      }  
    15. };  
    16.   
    17. class Product1:public Product  
    18. {  
    19. public :  
    20.     void property()  
    21.     {  
    22.         cout << "i am product 1" << endl;  
    23.     }  
    24. };  
    25.   
    26. class Product2: public Product  
    27. {  
    28. public :  
    29.     void property()  
    30.     {  
    31.         cout << "i am product 2" << endl;  
    32.     }  
    33. };  
    34.    
    35. class  select  
    36. {  
    37. public:  
    38.      select (Product *pro)   
    39.      {    
    40.           product = pro;  
    41.      }  
    42.     void property()  
    43.     {  
    44.         product->property();  
    45.     }  
    46. private:  
    47.     Product *product;  
    48. };  
    49. int main()  
    50. {  
    51.      Product1 *pro1;  
    52.      Product2 *pro2;  
    53.      pro1 = new Product1;  
    54.      pro2 = new Product2;  
    55.      select *slt1 = new select(pro1);  
    56.      slt1->property();  
    57.      select *slt2 = new select(pro2);  
    58.      slt2->property();  
    59.     return 0;  
    60. }  
posted @ 2017-03-09 19:45  Dayu0501  阅读(110)  评论(0)  编辑  收藏  举报