java设计模式的理解

1.Strategy设计模式主要是对对象行为的选择进行决策

先看一下定义吧

The Strategy Pattern: a famly of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

大概意思就是 有一系列算法，把他们每个算法都分别封装起来，使他们可以互相替换。策略模式可以让算法从客户端独立出来，算法的改变不会影响客户端

在网上很容易就可以古狗到策略模式的类图



每个算法都是一个具体的策略，图中ConcreteStrategyA,ConcreteStrategyB,ConcreteStrategyC为3 个具体的算法，Strategy模式就是把一组具体的算法（策略）分别封装起来，并把这些封装起来的算法实现共同的一个接口 Strategy ，这个接口就是一个抽象的策略，我们的主类中拥有一个抽象策略的引用声明为Strategy接口类型，所有具体算法们都实现了抽接口中的方法AlgorithmInterface (),由于多态，所以我们可在我们的主类里直接调用抽象接口的方法AlgorithmInterface() ，这样做的好处就是我们可以在run time时使用setter方法改变具体的策略而不影响到客户的代码。

测试代码：

package {
import flash.display.Sprite;
import net.nshen.designpatterns.strategy.*;
  public class designpatterns extends Sprite
  {
    public function designpatterns()
    {
      Test_Strategy()
    }
   
   
    public function Test_Strategy():void{
     var context:Context=new Context();
     //设置策略
     context.strategy=new ConcreteStrategyA()
     context.ContextInterface()
     //runtime 更改策略B
     context.strategy=new ConcreteStrategyB()
     context.ContextInterface()
     //runtime 更改策略C
     context.strategy=new ConcreteStrategyC()
     context.ContextInterface()
    }
   
  }
}

Context:

* 需要使用ConcreteStrategy提供的算法。
* 内部维护一个Strategy的实例。
* 负责动态设置运行时Strategy具体的实现算法。
* 负责跟Strategy之间的交互和数据传递。

package net.nshen.designpatterns.strategy
{
  public class Context
  {
    private var _strategy:IStrategy
   
    public function set strategy(p_strategy:IStrategy):void{
     this._strategy=p_strategy;
    }
    public function ContextInterface():void{
     this._strategy.AlgorithmInterface()
    }
  }
}

Strategy(抽象策略类)：

* 定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，Context使用这个接口调用不同的算法，一般使用接口或抽象类实现。

package net.nshen.designpatterns.strategy
{
  /**
   *
   *
   * 抽象策略，可以为接口，也可以为一个抽象类,这里是接口
   *
   */
  public interface IStrategy
  {
    function AlgorithmInterface():void
  }
}

ConcreteStrategy(具体策略类)：

* 实现了Strategy定义的接口，提供具体的算法实现

具体策略A:

package net.nshen.designpatterns.strategy
{
  public class ConcreteStrategyA implements IStrategy
  {
    public function AlgorithmInterface():void
    {
      trace("调用策略A")
    }
   
  }
}

具体策略B:

package net.nshen.designpatterns.strategy
{
  public class ConcreteStrategyB implements IStrategy
  {
    public function AlgorithmInterface():void
    {
      trace("调用策略B")
    }
   
  }
}

具体策略C:

package net.nshen.designpatterns.strategy
{
  public class ConcreteStrategyC implements IStrategy
  {
    public function AlgorithmInterface():void
    {
      trace("调用策略C")
    }
   
  }
}

  完整代码点这里下载

在《head first design patterns》的例子中更把策略描述成行为（Behavior）的抽象，建议去看一下，由于各种各样的鸭子叫的方法和飞的方法各不相同，如下图，把鸭子的多种Fly行为和多种Quack行为独立出来，打包成两个策略包，分别实现两个抽象的接口FlyBehaviors 和 QuackBehaviors ，此时所有鸭子的父类Duck就是上面图中的Context,保存抽象策略的引用 flyBehavior , quackBehavior ，由于策略模式的好处，使得Duck的子类各种各样的鸭子可以run time选择自己相应的行为





=================理论与实践分割线=========================================================