设计模式3——创建型模式之抽象工厂模式

 

定义：抽象工厂模式(Abstract Factory)，提供一个创建一系列相关或相互依赖对象的接口，而无需要指定它们具体的类。

类型：创建型模式。

类图：

 

参与角色:

　　1. FeaturePhone、SmartPhone，分别是功能手机和智能手机的两个抽象类，分别抽象出来了功能机的制造流程，智能机的制造流程。

　　2. NokiaFeaturePhone、SamsungFeaturePhone，分别实现了功能机的制造流程。

　　3. NokiaSmartPhone、SamsungSamrtPhone，分别实现了智能机的生产制造流程。

　　4. Factory，抽象工厂，即手机生产厂所必须具备的基本要求都抽象出来了。

　　5. NokiaFactory，根据Nokia手机生产的要求，在已经建设好的抽象工厂上完成了Nokia功能机以及智能机生产的基本要求。

　　6. SamsungFactory，根据Samsung手机生产的要求，在已经建设好的抽象工厂上完成了Samsung功能机和智能机生产的工厂基本要求。

概述：

        随着科技的发展，手机越来越强大，智能手机(Smart Phone)越来越普及，而传统的功能手机(Feature Phone)销量在进一步下滑。各家手机生产商都在裁剪功能手机的生产线，但是手机生产线能够减少，厂房却不能减少。为了节约成本，代工厂决定将Nokia的手机放在一个工厂里生产，Samsung手机放在另外一个工厂里生产。这样就不用再新建工厂了，工厂的利用率得到提升。

       抽象工厂模式就是为了解决这一问题而产生的。当不同的产品越来越多时，如果给每个产品新建一个工厂，会显得很浪费，并且如果工厂过多，管理工厂本身也会成为一个问题。这个时候，一系列比较有共性的产品共用一个工厂是个比较好的选择。将已经改造好的Nokia功能手机以及智能手机生产线，直接对接到已经根据要求改造过的Nokia手机生产厂就可以直接生产Nokia功能机以及智能机了。

代码：

  1 #include <iostream>
  2 #include <afxcom_.h> 
  3 using namespace std;
  4 
  5 
  6 class CFeaturePhone
  7 {
  8 public:
  9     virtual void ProducePhone() = 0;
 10 };
 11 
 12 class CSmartPhone
 13 {
 14 public:
 15     virtual void ProducePhone() = 0;
 16 };
 17 
 18 class CNokiaFeaturePhone : public CFeaturePhone
 19 {
 20 public:
 21     virtual void ProducePhone()
 22     {
 23         cout<<"Produce Nokia feature Phone."<<endl;
 24     }
 25 };
 26 
 27 class CsamsungFeaturePhone : public CFeaturePhone
 28 {
 29 public:
 30     virtual void ProducePhone()
 31     {
 32         cout<<"Produce Samsung feature phone."<<endl;
 33     }
 34 };
 35 
 36 class CNokiaSmartPhone : public CSmartPhone
 37 {
 38 public:
 39     virtual void ProducePhone()
 40     {
 41         cout<<"Produce Nokia smart phone."<<endl;
 42     }
 43 };
 44 
 45 class CSamsungSmartPhone : public CSmartPhone
 46 {
 47 public:
 48     virtual void ProducePhone()
 49     {
 50         cout<<"Produce Samsung smart phone."<<endl;
 51     }
 52 };
 53 
 54 class CFactory
 55 {
 56 public:
 57     virtual CFeaturePhone* CreateFeaturePhone() = 0;
 58     virtual CSmartPhone* CreateSmartPhone() = 0;
 59 };
 60 
 61 class CNokiaPhoneFactory : public CFactory
 62 {
 63 public:
 64     virtual CFeaturePhone* CreateFeaturePhone()
 65     {
 66         CFeaturePhone* pPhone = new CNokiaFeaturePhone();
 67 
 68         return pPhone;
 69     }
 70 
 71     virtual CSmartPhone* CreateSmartPhone()
 72     {
 73         CSmartPhone* pPhone = new CNokiaSmartPhone();
 74 
 75         return pPhone;
 76     }
 77 };
 78 
 79 class CSamsungPhoneFactory : public CFactory
 80 {
 81 public:
 82     virtual CFeaturePhone* CreateFeaturePhone()
 83     {
 84         CFeaturePhone* pPhone = new CsamsungFeaturePhone();
 85 
 86         return pPhone;
 87     }
 88 
 89     virtual CSmartPhone* CreateSmartPhone()
 90     {
 91         CSmartPhone* pPhone = new CSamsungSmartPhone();
 92 
 93         return pPhone;
 94     }
 95 };
 96 
 97 int _tmain(int argc, _TCHAR* argv[])
 98 {
 99     // Nokia phone factory
100     CFactory* pNokiaFactory = new CNokiaPhoneFactory();
101     CFeaturePhone* pNokiaFeaturePhone = pNokiaFactory->CreateFeaturePhone();
102     pNokiaFeaturePhone->ProducePhone();
103     CSmartPhone* pNokiaSmartPhone = pNokiaFactory->CreateSmartPhone();
104     pNokiaSmartPhone->ProducePhone();
105 
106     delete pNokiaFeaturePhone;
107     pNokiaFeaturePhone = NULL;
108     delete pNokiaSmartPhone;
109     pNokiaSmartPhone = NULL;
110     delete pNokiaFactory;
111     pNokiaFactory = NULL;
112 
113     // Samsung phone factory
114     CFactory* pSamsungFactory = new CSamsungPhoneFactory();
115     CFeaturePhone* pSamsungFeaturePhone = pSamsungFactory->CreateFeaturePhone();
116     pSamsungFeaturePhone->ProducePhone();
117     CSmartPhone* pSamsungSmartPhone = pSamsungFactory->CreateSmartPhone();
118     pSamsungSmartPhone->ProducePhone();
119 
120     delete pSamsungFeaturePhone;
121     pSamsungFeaturePhone = NULL;
122     delete pSamsungSmartPhone;
123     pSamsungSmartPhone = NULL;
124     delete pSamsungFactory;
125     pSamsungFactory = NULL;
126 
127     return 0;
128 }

 适用场合：

　　　　适用产品簇比较多，并且产品系列比较多的类型。例如某电子公司，光镍电子就有十几个系列，因为每一条镍电池生产线较小，如果每一款镍电池建一个工厂，不现实，所有镍电池生产线共用一个工厂会比较好。另外，公司不仅有镍电池系列，还有不同款式的学习机，电子辞典等许多电子产品。这样的公司就比较适合使用抽象工厂模式。

优缺点：

  1. 优点，同一系列或者相互关联的产品，可以共用工厂，而不必新建工厂，工厂的效率利用率会比较高。
  1. 缺点，如果同一系列或者相互关联的产品里又增加了新的产品，则共同的工厂需要修改来进行生产新产品，这可能会影响到原有的产品的正常生产。

 

参考资料：

  1. 《设计模式——可复用面向对象软件基础》
  1. 《Java与模式》
  2. 《大话设计模式》

 

posted @ 2014-01-08 00:58  飞鹤0755  阅读(270)  评论(0)  编辑  收藏  举报