简单工厂模式和策略模式的区别

     看书上的介绍《大话设计模式》，这两很像，都是用一个专门的类来根据客户端的条件产生不同的类，实现不同的功能。两个有什么区别呢，怎么取舍呢，没有自己写过实际的运用，有点晕啊，只能侃侃，耍耍嘴皮子。

      从客户端来看，简单工厂需要至少需要两个类，一个是工厂类Factory，用来产生具体的功能类Function，一个是这个Function类，在这个Function类中定义可以被要被重写的方法。客户端使用的时候首先要使用Factory类根据客户端条件，产生具体的Function类，然后再使用Function类中的方法实现具体的功能；策略类，在客户端也要接触两个类，一个是想要的具体算法类Category，一个是上下文类Context，Context类的构造方法接受一个Category类型对象，然后调用这个对象的具体算法实现具体的功能，Context类和Factory有点类似，和简单工厂模式不同的是Context接受一个对象，用这个对象来实例化自己，然后来调用自己的方法，当然这个方法是用这个对象中的方法。而Factory类接受条件产生一个对象，具体使用这个对象的方法还是要调用这个对象中的方法，而不是Factory中的方法。就是说Factory只负责获得对象，Context要依靠一个具体的对象来实例化自己，并调用具体的功能方法。

     从类的结构来看Factory只要包含一个根据条件创建对象的方法CreateFunction(),Context类需要定义自己的构造函数，和一个实现具体功能的方法。

     简单工厂中包含了必要的逻辑判断，根据客户端选择条件动态实例化相关的类。策略模式中具体的策略类要在客户端判断，然后再上下文类中调用方法。

     简单工厂代码如下：

代码

public   class  Factory
{
   public   static  Function CreateObject( string  condition)
  {
    Function ft  =   null ;
     switch  condition:
     case  conditionA:
    {
      ft  =   new  FunctionA();
       break ;
    }
     case  conditionB:
    {
      ft  =   new  FunctionB();
       break ;
    }

    default:

    break;
  }
}
public  calss Function
{
    public   virtual   void  DoSomething()
   {
     .... ....
   }
}
public   class  FunctionA:Function
{
  public   void   override  DoSomething()
 {
   .... ...
 }
}
public  calss FuctionB:Function
{
   public   void   override  DoSomething()
  {
    .... ....
  }
}
public   static   void  main()
{
   string  condition  =   " asdfasdf " ;
  Function fc  =  Factory.CreateObject(condition);
  fc.DoSomething(); 
}

 

策略模式代码如下：

代码

public   class  Context
{
   private  Strategy st;
   public  Context(Strategy st)
  {
      this .st  =  st;
  }
   public   void  DoStragegyWork()
  {
     st.DoSomeWork();
  }
}
abstract   class  Strategy
{
   public   abstract   void  DoSomeWork();
}
public   class  StrategyA:Strategy
{
   public   override   void  DoSomeWork()
  { A... ... }
}
public   class  StrategyB:Strategy
{
   public   override   void  DoSomeWork()
  { B... ... }
}
public   static   void  main( string  args[])
{
  StrategyB sb  =   new  StrategyB();
  Context ct  =   new  Context(sb);
  ct.DoStragegyWork(); 
}

 

 

可以让策略模式和简单工厂模式结合起来，让new Context(sb);这个构造方法接受一个条件变量，在方法体中根据这个变量产生具体的类来实例化。

 具体方法如下：

 

 

代码

public   class  Context
{
   private  Strategy st;
   public  Context( string  condition)
  {
      switch ( " conditionA " )
      this .st  =   new  StrategyA();
      break ;
      switch ( " conditionB " )
      this .st  =   new  StrategyB();
      break ;
      default :
      break ;
  }
   public   void  DoStragegyWork()
  {
     st.DoSomeWork();
  }
}
abstract   class  Strategy
{
   public   abstract   void  DoSomeWork();
}
public   class  StrategyA:Strategy
{
   public   override   void  DoSomeWork()
  { A... ... }
}
public   class  StrategyB:Strategy
{
   public   override   void  DoSomeWork()
  { B... ... }
}
public   static   void  main( string  args[])
{
  StrategyB sb  =   new  StrategyB();
  Context ct  =   new  Context(sb);
  ct.DoStragegyWork(); 
}

 

     哪位大侠可以举个在项目中的运用，贴点简单的代码看看，先谢谢了。我这些都是从书本里得来的。