(转载)简单工厂模式和工厂方法模式

一：简单工厂模式

 

1，概念

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。顾名思义工厂就是生产东西的，有原料（参数），模子（对象）就能生产出很多个具有相同功能的对象啦。

2，uml图

 

 

3，代码示例

[csharp] view plaincopyprint?
 
  1. <span style="font-size:18px;">    class Program  
  2.     {  
  3.         static void Main(string[] args)  
  4.         {  
  5.             Operate oper;  //创建Operate类的oper类  
  6.             oper = OperationFactoty.createOperate("+"); //运用简单工厂判断实力化的对象  
  7.             oper.NumberA = 1;  //赋值  
  8.             oper.NumberB = 2;  
  9.             double result = oper.GetResult();  
  10.             Console.WriteLine(result);  //显示运算结果  
  11.         }  
  12.     }  
  13.       
  14.     //简单工厂，通过判断参数，实例化相应的对象  
  15.     public class OperationFactoty    
  16.     {  
  17.         public static Operate createOperate(string operate)  
  18.         {  
  19.             Operate oper = null;  
  20.             switch (operate){  }  
  21.             return oper;  
  22.         }  
  23.     }  
  24.   
  25.     //定义一个运算基类，包含GetResult虚方法  
  26.     public class Operate //定义一个运算类  
  27.     {  
  28.         private double numberA=0;    //运算前的数  
  29.         private double numberB=0;    //运算后的数  
  30.         public double NumberA{  }  
  31.         public double NumberB{  }  
  32.         
  33.         public virtual double GetResult()//返回运算后结果的方法  
  34.         {  
  35.             return result;      //返回结果  
  36.         }  
  37.     }  
  38.   
  39.    // 运算类的四个继承类，分别实现加减乘除四个运算  
  40.     public class NumberAdd : Operate    //加运算  
  41.     {  
  42.         public override double GetResult()//实现基类中的虚方法   
  43.         {  
  44.             double result = NumberA + NumberB;  
  45.             return result;  
  46.         }  
  47.     }  
  48.     public class NumberSub:Operate    //减运算  
  49.     {  
  50.         public override double  GetResult(){   }  
  51.     }  
  52.     public class NumberMul:Operate   //乘运算  
  53.     {  
  54.         public override double  GetResult(){   }  
  55.     }  
  56.     public class NumberDiv:Operate    //除运算  
  57.     {  
  58.         public override double GetResult(){   }  
  59.     }</span>  

 

4，总结

简单工厂模式，我把它理解为一个模子，根据外界给定的原料，在加上自身封装好的判断，生产出不同类型的相应的产品、对象。

简单工厂模式使用场景：工厂类负责创建的对象比较少；客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；简单工厂很容易违反高内聚低耦合原则，因此一般只在很简单的情况下应用。

 

 

二：工厂方法模式

 

1，概念

是定义一个创建产品对象的工厂接口，让子类决定实例化哪一个类，将实际创建工作推迟到子类当中。

 

2，uml图

 

 

3，代码实例

 

（1）工厂方法实现

[csharp] view plaincopyprint?
 
  1. <span style="font-size:18px;">    class Program  
  2.     {  
  3.         static void Main(string[] args)  
  4.         {  
  5.             IFactory factory = new UndergraduateFactory();   //由接口创建新的学雷锋大学生  
  6.             LeiFeng student = factory.CreateLeifeng();   //实例化  
  7.   
  8.             student.BuyRice();  
  9.             student.Sweep();  
  10.             student.Wash();  
  11.         }  
  12.     }  
  13.     //雷锋类，定义了一些功能  
  14.     class LeiFeng    
  15.     {  
  16.         public void Sweep(){ } //擦桌子  
  17.         public void Wash(){ }  //洗衣服  
  18.         public void BuyRice(){ }  //买米  
  19.     }  
  20.   
  21.   
  22.     //学雷锋的大学生  
  23.     class UnderGraduate : LeiFeng{ }  
  24.     //社区志愿者  
  25.     class Volunteer : LeiFeng{ }  
  26.   
  27.     //雷锋工厂  
  28.     interface IFactory //定义一个接口，实现创建雷锋类的功能  
  29.     {  
  30.         LeiFeng CreateLeifeng();  
  31.     }  
  32.       
  33.     class UndergraduateFactory : IFactory//学雷锋大学生工厂  
  34.     {  
  35.         public LeiFeng CreateLeiFeng()  
  36.         {  
  37.             return new UnderGraduate();  
  38.         }  
  39.     }  
  40.     class VolunteerFactory : IFactory//社区志愿者工厂  
  41.     {  
  42.         public LeiFeng CreateLeiFeng()  
  43.         {  
  44.             return new Volunteer();  
  45.         }  
  46.     }</span>  

 

 （2）简单工厂实现

[csharp] view plaincopyprint?
 
  1. <span style="font-size:18px;">    class Program  
  2.     {  
  3.         static void Main(string[] args)  
  4.         {  
  5.             LeiFeng studentA = SimpleFactory.CreateLeiFeng("学雷锋的大学生");//用简单工厂创建并实例化学雷锋的大学生  
  6.             studentA.BuyRice();  
  7.             LeiFeng studentB = SimpleFactory.CreateLeiFeng("社区志愿者");//用简单工厂创建实例化社区志愿者  
  8.             studentB.BuyRice();  
  9.         }  
  10.     }  
  11.     //雷锋类，定义了一些功能  
  12.     class LeiFeng    
  13.     {  
  14.         public void Sweep(){ } //擦桌子  
  15.         public void Wash(){ }  //洗衣服  
  16.         public void BuyRice(){ }  //买米  
  17.     }  
  18.   
  19.   
  20.     //简单工厂类  
  21.     class SimpleFactory  
  22.     {  
  23.        public static LeiFeng CreateLeiFeng(string type)  
  24.        {  
  25.             LeiFeng result = null;  
  26.             switch (type) //判断选择要创建对象的类型  
  27.             {   
  28.                 case "学雷锋的大学生":  
  29.                     result = new UnderGraduate();  
  30.                     break;  
  31.                 case "社区志愿者":  
  32.                    result = new UnderGraduate();  
  33.                    break;  
  34.             }  
  35.             return result;  
  36.         }  
  37.   
  38.     }</span>  


4，总结

 

    工厂方法模型中，“工厂”创建的是还没有分化好的对象，其中没有逻辑判断相比于简单工厂模式，基类工厂去实现接口，子工厂去实现判断并能生产出相应功能的对象。

 

三：简单工厂和工厂方法模式的比较

 

1，简单工厂模式

     专门定义一个工厂类负责创建其他类的实例，最大的优点在于工厂类中包含了必要的逻辑，根据客户需要的条件动态实例化相关的类

 

2，工厂方法模式

     创建对象的接口，让子类去决定具体实例化的对象，把简单的内部逻辑判断移到了客户端代码。工厂方法克服了简单工厂违背开放-封闭原则的缺点，又保持了封装对象创建过程的优点。

 

 

原文地址:http://blog.csdn.net/lishuangzhe7047/article/details/8491269

posted @ 2015-11-03 08:07  lydit  阅读(133)  评论(0)  编辑  收藏  举报