设计模式2——创建型模式之工厂方法模式

定义 ：工厂方法模式 (FactoryMethod Pattern) ，定义一个用于创建对象的接口，让子类决定实例化哪一个类。定义一个抽象工厂类，每一个产品，按照抽象工厂的基本要求新建一个工厂来生产新的产品。

类型：创建型模式。

类图：

参与角色：

1. AbstrctProduct，提供产品生产的标准接口。
2. ConcreteProductA，ConcreteProductB，按接口具体去实现生产的产品。
3. AbstractFactory，提供标准工厂规模的抽象工厂。
4. ConcreteFactoryA，ConcreteFactoryB，按接口标准定制的具体生产产品的在厂。

概述：

         简单工厂模式，在使用时，会违背OCP原则。工厂方法模式就是为了解决这一问题而产生的。每当有一个新的产品要生产时，不用去更改原有的产品线，也不用去修改原有的工厂，一切按规定析添加。这样产品的生产流程一致，新工厂的建造也一致。工厂原有的生产管理方法便可以继续使用，而且人员也不用重新培训，就可以直接上岗。

         因为当增加新的订单时，不需要去更改旧有的产品线以及工厂，这样就可以最大限度的保证原有的产品能够正常运行。这一点，就是工厂方法的核心。下面就以代码来展现这一过程。

代码：

// C++

#include  <iostream>

#include  <afxcom_.h> 

using  namespace  std ;

 

class  CCellPhone

{

public :

     virtual  void  ProducePhone ( )

     {

         cout << "Produce Normal Phone." << endl ;

     }

} ;

 

class  CNokia  :  public  CCellPhone

{

public :

     virtual  void  ProducePhone ( )

     {

         cout << "Produce Nokia Phone." << endl ;

     }

} ;

 

class  CSamsung  :  public  CCellPhone

{

public :

     virtual  void  ProducePhone ( )

     {

         cout << "Produce Samsung Phone." << endl ;

     }

} ;

 

class  CPhoneFactory

{

public :

     virtual  CCellPhone *  CreatePhone ( )  =  0 ;

} ;

 

class  CNokiaFactory  :  public  CPhoneFactory

{

public :

     virtual  CCellPhone *  CreatePhone ( )

     {

         CCellPhone  * pPhone  =  new  CNokia ( ) ;

 

         return  pPhone ;

     }

} ;

 

class  CSamsungFactory  :  public  CPhoneFactory

{

public :

     virtual  CCellPhone *  CreatePhone ( )

     {

         CCellPhone  * pPhone  =  new  CSamsung ( ) ;

 

         return  pPhone ;

     }

} ;

 

int  _tmain ( int  argc ,  _TCHAR *  argv [ ])

{

     // Nokia cellphone production line

     CPhoneFactory *  pNokiaFactory  =  new  CNokiaFactory ( ) ;

     CCellPhone *  pNokiaPhone  =  pNokiaFactory -> CreatePhone ( ) ;

     pNokiaPhone -> ProducePhone ( ) ;

 

     // Samsung cellphone production line

     CPhoneFactory *  pSamsungFactory  =  new  CSamsungFactory ( ) ;

     CCellPhone *  pSamsungPhone  =  pSamsungFactory -> CreatePhone ( ) ;

     pSamsungPhone -> ProducePhone ( ) ;

 

     delete  pNokiaPhone ;

     pNokiaPhone  =  NULL ;

 

     delete  pSamsungPhone ;

     pSamsungPhone  =  NULL ;

 

     return  0 ;

}

 

// C#代码

using  System ;

using  System . Collections . Generic ;

using  System . Text ;

using  System . Diagnostics ;

 

 

namespace  Phone

{

     public  class  CellPhone

     {

         public  virtual  void  ProducePhone ( )

         {

              Console . WriteLine ( " Produce Normal Phone. " ) ;

         }

     }

 

     class  Nokia  :  CellPhone

     {

         public  override  void  ProducePhone ( )

         {

              Console . WriteLine ( " Produce Nokia Phone. " ) ;

         }

     }

 

     class  Samsung  :  CellPhone

     {

         public  override  void  ProducePhone ( )

         {

              Console . WriteLine ( " Produce Samsung Phone. " ) ;

         }

     }

 

     public  interface  IFactory

     {

         CellPhone  CreatePhone ( ) ;

     }

 

     public  class  NokiaFactory  :  IFactory

     {

         public  CellPhone  CreatePhone ( )

         {

              CellPhone  phone  =  new  Nokia ( ) ;

 

              return  phone ;

         }

     }

 

     public  class  SamsungFactory  :  IFactory

     {

         public  CellPhone  CreatePhone ( )

         {

              CellPhone  phone  =  new  Samsung ( ) ;

 

              return  phone ;

         }

     }

 

     class  Program

     {

         static  void  Main ( string [ ]  args )

         {

              IFactory  nokiaFactory  =  new  NokiaFactory ( ) ;

              CellPhone  phone  =  nokiaFactory . CreatePhone ( ) ;

              phone . ProducePhone ( ) ;

 

              IFactory  samsungFactory  =  new  SamsungFactory ( ) ;

              phone  =  samsungFactory . CreatePhone ( ) ;

              phone . ProducePhone ( ) ;

         }

     }

}

 

 

package  CellPhone;

 

public  interface  IFactory {

 

     IPhone  createPhone();

}

 

package  CellPhone;

 

public  interface  IPhone {

 

     void  producePhone();

    

}

 

package  CellPhone;

 

public  class  NokiaFactory  implements  IFactory {

 

     public  IPhone  createPhone()

    {

         IPhone  phone  =  new  NokiaPhone();

        

         return  phone;

    }

}

 

package  CellPhone;

 

public  class  NokiaPhone  implements  IPhone {

 

     public  void  producePhone()

    {

         System. out. println( "Produce nokia phone.");

    }

}

 

package  CellPhone;

 

public  class  SamsungFactory  implements  IFactory {

 

     public  IPhone  createPhone()

    {

         IPhone  phone  =  new  SamsungPhone();

        

         return  phone;

    }

}

 

package  CellPhone;

 

public  class  SamsungPhone  implements  IPhone {

 

     public  void  producePhone()

    {

         System. out. println( "Produce samsung phone.");

    }

}

 

/**

 * CellPhone.java

 */

package  CellPhone;

 

/**

 *  @author  feihe027 @163 .com

 *

 */

 

public  class  CellPhone {

 

     /**

     *  @param  args

     */

     public  static  void  main( String[]  args) {

         // TODO Auto-generated method stub

         IFactory  factory  =  new  NokiaFactory();

         IPhone  phone  =  factory. createPhone();

         phone. producePhone();

        

         factory  =  new  SamsungFactory();

         phone  =  factory. createPhone();

         phone. producePhone();

    }

 

}

 

 

 

优缺点：

1. 优点，能够最大限度地保证对修改关闭，对扩展开放。新的产品，都是通过新添加代码来完成而不是去修改原有代码来完成。

2. 缺点，每添加一个新产品，就新建一个工厂，稍显有点浪费。如果工厂过多，管理工厂也会成为一件麻烦事。抽象工厂模式正好解决这一问题。

 

参考资料：

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

2. 《Java与模式》

3. 《大话设计模式》