工厂模式学习笔记

工厂模式：
工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的
1。简单的工厂模式：
 我们以IBM的电脑为示例，我们需要得到IBM的不同类型的电脑，如笔记本电脑，台式机，服务器等，并在屏幕上显示其产品的类型名。
抽象产品：IComputer（由具体产品实现）
具体产品：IBM_TablePC（台式机），IBM_NoteBookPC（笔记本）
产品工厂：IBM_PCFactory（用来创建不同类型的计算机）

代码实例：

     public   abstract   class  IComputer
    {
         public   void  PrintType()
        {
            Console.WriteLine(GetName());
        }
         public   abstract   string  GetName();
    }
     public   class  IBM_TablePC : IComputer
    {
         public   override   string  GetName()
        {
             return   " IBM-台式电脑 " ;
        }
    }
     public   class  IBM_NoteBookPC : IComputer
    {
         public   override   string  GetName()
        {
             return   " IBM-笔记本电脑 " ;
        }
    }
     public   class  IBM_PCFactory
    {
         public   static  IComputer CreatePC( string  PCName)
        {

             if  (PCName  ==   " TablePC " )
            {
                 return   new  IBM_TablePC();
            }
             else   if  (PCName  ==   " NoteBookPC " )
            {
                 return   new  IBM_NoteBookPC();
            }
             else
            {
                 return   null ;
            }
        }
    }

调用方法：

            IComputer TablePC  =  IBM_PCFactory.CreatePC( " TablePC " );
            TablePC.PrintType();
            IComputer NoteBookPC  =  IBM_PCFactory.CreatePC( " NoteBookPC " );
            NoteBookPC.PrintType();
            Console.ReadLine();

 
优点：
1。可以将创建对象的具体过程封装起来。
2。在增加一种产品类型的时候，如服务器机，我们只需实现IComputer，然后将工厂类IBM_PCFactory的逻辑部分增加条件判断语句即可，而不用修改其它的部分。
缺点：
1。随着产品的增加，工厂类的逻辑部分会越来越大，不利于维护。
2。每增加一种产品，就得修改工厂类IBM_PCFactory的逻辑部分，没有起到很好的封装作用，当用户没有工厂类IBM_PCFactory的源代码而只有工厂类IBM_PCFactory的无可奈何。
针对简单工厂模式的缺点，并针对性的进行弥补，于是又提出一种叫做工厂方法的模式。

2。工厂方法模式
重新实现上面的例子：

抽象产品：IComputer（由具体产品实现）
具体产品：IBM_TablePC（台式机），IBM_NoteBookPC（笔记本）
抽象工厂：IBM_PCFactory（由具体类型计算机工厂实现）
具体工厂：IBM_TablePCFactory（实现IBM_PCFactory），IBM_NoteBookPCFactory（实现IBM_PCFactory）

代码实例：

public   abstract   class  IComputer
    {
         public   void  PrintType()
        {
            Console.WriteLine(GetName());
        }
         public   abstract   string  GetName();
    }
     public   class  IBM_TablePC : IComputer
    {
         public   override   string  GetName()
        {
             return   " IBM-台式电脑 " ;
        }
    }
     public   class  IBM_NoteBookPC : IComputer
    {
         public   override   string  GetName()
        {
             return   " IBM-笔记本电脑 " ;
        }
    }
     public   abstract    class  IBM_PCFactory
    {        
         public   abstract    IComputer CreatePC();         
    }
     public   class  IBM_TablePCFactory : IBM_PCFactory
    {
         public    override  IComputer CreatePC()
        {
             return   new  IBM_TablePC();
        }  
    }
     public   class  IBM_NoteBookPCFactory : IBM_PCFactory
    {
         public    override  IComputer CreatePC()
        {
             return   new  IBM_NoteBookPC();
        }
    }

调用方法：

IBM_PCFactory TablePCFactory  =   new  IBM_TablePCFactory();
            IComputer TablePC  =  TablePCFactory.CreatePC();
            TablePC.PrintType();
            IBM_PCFactory NoteBookPCFactory  =   new  IBM_NoteBookPCFactory();
            IComputer NoteBookPC  =  NoteBookPCFactory.CreatePC();
            Console.ReadLine();

 

优点：
1。每增加一种产品类型的时候，只需添加只需实现IComputer的子类，然后添加实现IBM_PCFactory的子工厂，而不用修改其他的部分
缺点：
1。不支持产品族，比如现在如果是2种电脑品牌IBM和HP，那么每种品牌都会有其各自的类型计算机，那么用这种工厂方法模式会力不从心，于是又引出一种支持多产品的模式－－抽象工厂模式（Abstract Factory Pattern）

3.抽象工厂模式
接着上面的例子，假如我们把现在要得到IBM和HP的不同类型的电脑。

抽象产品：IIBMComputer（由具体产品实现）,IHPComputer（由具体产品实现）
具体产品：IBM_TablePC（台式机），IBM_NoteBookPC（笔记本）,HP_TablePC（台式机），HP_NoteBookPC（笔记本）
抽象工厂：PCFactory（由具体类型计算机工厂实现）
具体工厂：TablePCFactory ，NoteBookPCFactory（实现PCFactory）

代码实例：

   ///   <summary>
     ///  IBM的抽象产品
     ///   </summary>
     public   abstract   class  IIBMComputer
    {
         public   void  PrintType()
        {
            Console.WriteLine(GetName());
        }
         public   abstract   string  GetName();
    }    
     ///   <summary>
     ///  IBM的台式机
     ///   </summary>
     public   class  IBM_TablePC : IIBMComputer
    {
         public   override   string  GetName()
        {
             return   " IBM-台式电脑 " ;
        }
    }
     ///   <summary>
     ///  IBM的笔记本
     ///   </summary>
     public   class  IBM_NoteBookPC : IIBMComputer
    {
         public   override   string  GetName()
        {
             return   " IBM-笔记本电脑 " ;
        }
    }
     ///   <summary>
     ///  HP的抽象产品
     ///   </summary>
     public   abstract   class  IHPComputer
    {
         public   void  PrintType()
        {
            Console.WriteLine(GetName());
        }
         public   abstract   string  GetName(); 
    }
     ///   <summary>
     ///  HP的台式机
     ///   </summary>
     public   class  HP_TablePC : IHPComputer
    {
         public   override   string  GetName()
        {
             return   " HP-台式电脑 " ;
        }
    }
     ///   <summary>
     ///  HP的笔记本
     ///   </summary>
     public   class  HP_NoteBookPC : IHPComputer
    {
         public   override   string  GetName()
        {
             return   " HP-笔记本电脑 " ;
        }
    }
     ///   <summary>
     ///  抽象工厂
     ///   </summary>
     public   abstract    class  PCFactory
    {
         public   abstract  IIBMComputer CreateIBMPC();
         public   abstract  IHPComputer CreateHPPC();         
    }
     ///   <summary>
     ///  台式机系列的具体工厂
     ///   </summary>
     public   class  TablePCFactory : PCFactory
    {
         public   override  IHPComputer CreateHPPC()
        {
             return   new  HP_TablePC();
        }
         public   override  IIBMComputer CreateIBMPC()
        {
             return   new  IBM_TablePC();
        }
    }
     ///   <summary>
     ///  笔记本系列的具体工厂
     ///   </summary>
     public   class  NoteBookPCFactory : PCFactory
    {
         public   override  IHPComputer CreateHPPC()
        {
             return   new  HP_NoteBookPC();
        }
         public   override  IIBMComputer CreateIBMPC()
        {
             return   new  IBM_NoteBookPC();
        }
    }

调用方法：

PCFactory tablePCFactory  =   new  TablePCFactory(); // 创建台式机系列工厂
            IIBMComputer ibmTablePC  =  tablePCFactory.CreateIBMPC(); // 创建IBM的台式机
            ibmTablePC.PrintType();
            IHPComputer hpTablePC  =  tablePCFactory.CreateHPPC(); // 创建HP的台式机
            hpTablePC.PrintType();
            PCFactory notebookPCFactory  =   new  NoteBookPCFactory(); // 创建笔记本系列工厂
            IIBMComputer ibmnotebookPC  =  notebookPCFactory.CreateIBMPC(); // 创建IBM的笔记本
            ibmnotebookPC.PrintType();
            IHPComputer hpnotebookPC  =  notebookPCFactory.CreateHPPC(); // 创建HP的笔记本
            hpnotebookPC.PrintType();
            Console.ReadLine();

 

优点：
1。每增加一种系列的产品时，如服务器机，只需增加实现PCFactory的一个具体工厂ServerFactory即可，不用动用其他部分。
缺点：
得和其他模式结合弥补。