设计模式--策略模式

1、模拟鸭子项目

从OO的角度设计这个项目,鸭子超类，扩展超类（Duck ）、两个具体的子类（GreenHeadDuck、RedHeadDuck）、测试类（StimulateDuck）

public abstract class Duck {
    public Duck() {
    }

    /**
     * 鸭子叫
     */
    public void Quack() {
        System.out.println("~~gaga~~");
    }

    /**
     * 鸭子游泳
     */
    public void swim() {
        System.out.println("~~im swim~~");
    }

    /**
     * 抽象显示
     */
    public abstract void display();
}

public class GreenHeadDuck extends Duck {
   @Override
   public void display() {
      System.out.println("**GreenHead**");
   }
}

public class RedHeadDuck extends Duck {
   @Override
   public void display() {
      System.out.println("**RedHead**");
   }
}

public class StimulateDuck {
   public static void main(String[] args) {
      GreenHeadDuck mGreenHeadDuck = new GreenHeadDuck();
      RedHeadDuck mRedHeadDuck = new RedHeadDuck();
      mGreenHeadDuck.display();
      mGreenHeadDuck.Quack();
      mGreenHeadDuck.swim();
      mRedHeadDuck.display();
      mRedHeadDuck.Quack();
      mRedHeadDuck.swim();
   }
}

2、应对新的需求，看看这个设计的可扩展性

    添加会飞的鸭子

OO思维里的继承方式解决方案是：

public abstract class Duck {

  ...;

  public void fly() {

  System.out.println("~~im fly~~");

  } 

}

问题来了,这个fly让所有子类都会飞了，这是不科学的。

继承的问题：对类的局部改动，尤其超类的局部改动，会影响其他部分。影响会有溢出效应。

继续尝试用OO原理来解决，覆盖：

public class GreenHeadDuck extends Duck {

...；

public void fly() {

  System.out.println("~~no fly~~");

  } 

}

又有新需求，石头鸭子，填坑：

public class StoneDuck extends Duck {

....  }；

超类挖的一个坑，每个子类都要来填，增加工作量，复杂度O(N^2)。不是好的设计方式

2、用策略模式来解决新需求

需要新的设计方式，应对项目的扩展性，降低复杂度：

  1）分析项目变化与不变部分，提取变化部分，抽象成接口+实现；

  2）鸭子哪些功能是会根据新需求变化的？飞行...

接口：

  public interface FlyBehavior  {

  void fly();}

 

  好处：新增行为简单，行为类更好的复用，组合更方便。既有继承带来的复用好处，没有挖坑。

绿头鸭、石头鸭：

public class GreenHeadDuck extends Duck {

  public GreenHeadDuck() {

  mFlyBehavior = new GoodFlyBehavior();

  }

  @Override

  public void display() {...}

}

策略模式：分别封装行为接口，实现算法族，超类里放行为接口对象，在子类里具体设定行为对象。原则就是：分离变化部分，封装接口，基于接口编程各种功能。此模式让行为算法的变化独立于算法的使用者。

代码如下：

抽象类：NewDuck

public abstract class NewDuck {
    protected FlyBehavior flyBehavior;

    public NewDuck() {
    }

    public void fly() {
        flyBehavior.fly();
    }

    public void SetFlyBehavoir(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }

    /**
     * 鸭子叫
     */
    public void Quack() {
        System.out.println("~~gaga~~");
    }

    /**
     * 鸭子游泳
     */
    public void swim() {
        System.out.println("~~im swim~~");
    }

    /**
     * 抽象显示
     */
    public abstract void display();
}

行为接口：FlyBehavior 
public interface FlyBehavior {
   void fly();
}

行为接口具体实现类：

GoodFlyBehavior

public class GoodFlyBehavior implements FlyBehavior {
   @Override
   public void fly() {
      System.out.println("--GoodFly--");
   }
}

测试类：StimulateDuck

public class StimulateDuck {
   public static void main(String[] args) {
      GreenHeadDuckNew greenHeadDuckNew = new GreenHeadDuckNew();
      greenHeadDuckNew.SetFlyBehavoir(new GoodFlyBehavior());
      greenHeadDuckNew.display();
       greenHeadDuckNew.Quack();
       greenHeadDuckNew.swim();
      greenHeadDuckNew.fly();
   }
}