什么是策略模式？
先看栗子!!!
假设有一个抽象超类Duck ，其代码如下；
<pre>
public abstract class Duck {
public void Quack(){
System.out.println("--Duck speark--");
}
public abstract void display();
public void swim(){
System.out.println("--Duck swim--");
}
}
</pre>
假设其有一个GreenDuck子类，代码如下：
<pre>
public class GreenDuck extends Duck {
public void display() {
System.out.println("****鸭子头发色是绿色****");
}
}
</pre>
实例化对象
<pre>
public static void main(String[] args) {
GreenDuck gd=new GreenDuck();
RedDuck rd=new RedDuck();
//绿头鸭
gd.display();
gd.Quack();
gd.swim();
//红头鸭
rd.display();
rd.Quack();
rd.swim();
}
</pre>
运行结果
<pre>
****鸭子头发色是绿色的****
--Duck speark--
--Duck swim--
****鸭子头发色是红色的****
--Duck speark--
--Duck swim--
</pre>
以上使用了继承的方法，实现了代码的复用性。使得子类中代码更简洁。但是一项新的问题随之而来。
假设超类中扩展了一个新的需求，例如：
<pre>
public abstract class Duck{
...;
public void fly(){
System.out.println("--Duck fly--");
}
}
</pre>
但是超类中的这个fly()方法不一定是其他子类所需要的。
虽然可以使用面向对象(OO)的思维，通过覆盖父类方法解决继承的问题，代码如下：
<pre>
public class GreenHeadDuck extend Duck{
...
public void fly(){
System.out.println("~GreenHeadDuck no fly~");
}
}
</pre>
又假设新出现一个新的子类Toy_Duck（玩具鸭）,这个子类不会父类的fly(),Quack()方法，则在Toy_Duck中又要覆盖相应的方法。因此，子类都要从继承父类中的方法中进行筛选有用的功能（又称覆盖父类相应方法），增加了子类的工作量，可得出复杂度O(N^2)。
为了应对项目的扩展，重新考虑设计方式，避免改动源码，降低复杂度
1）分析项目变化与不变部分，提取变化部分，抽象成接口+实现；
2）鸭子哪些功能是会根据新需求变化的？叫声、飞行..
1、接口：
<pre>
//飞行接口
1） public interface FlyBehavior
{
void fly();
}
//叫声接口
2）public interface QuackBehavior
{
void quack();
}
</pre>
好处：新增行为简单，行为类更好的复用，组合更方便。既有继承带来的复用好处，没有挖坑
上述接口的实现类有GoodFlyBehavior、BadFlyBehavior、NoFlyBehavior和GoodQuackBehavior、 BadQuackBehavior、NoQuackBehavior
飞行行为对象族代码如下：
<pre>
//GoodFlyBehavior行为对象
public class GoodFlyBehavior implements FlyBehavior {
public void fly() {
System.out.println("--GoodFly--");
}
}
//BadFlyBehavior行为对象
public class BadFlyBehavior implements FlyBehavior {
public void fly() {
System.out.println("--BadFly--");
}
}
//NoFlyBehavior行为对象
public class NoFlyBehavior implements FlyBehavior {
public void fly() {
System.out.println("--不会飞--");
}
}
</pre>
叫声行为对象族代码如下：
<pre>
//GoodQuackBehavior行为对象
public class GoodQuackBehavior implements QuackBehavior {
public void quack() {
System.out.println("好听的叫声");
}
}
//BadQuackBehavior行为对象
public class BadQuackBehavior implements QuackBehavior {
public void quack() {
System.out.println("难听的叫声" );
}
}
//NoQuackBehavior行为对象
public class NoQuackBehavior implements QuackBehavior {
public void quack() {
System.out.println(" 不会叫");
}
}
//
</pre>
重新设计模拟鸭子项目:
<pre>public abstract class Duck {
//将飞行、叫声行为方法定义为对象。
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
//空构造方法
public Duck(){
}
public void Fly(){
flyBehavior.fly();
}
public void Quack(){
quackBehavior.quack();
}
abstract void display();
//设置叫声行为对象接口，便于类方法的组合
public void SetQuackBehavoir(QuackBehavior qb) {
quackBehavior = qb;
}
//设置飞行行为对象接口，便于类方法的组合
public void SetFlyBehavoir(FlyBehavior fb) {
flyBehavior = fb;
}
public void swim() {
System.out.println("swimming");
}
}
</pre>
Duck子类GreenHeadDuck代码如下：
<pre>
public class GreenHeadDuck extends Duck {
public GreenHeadDuck(){
flyBehavior = new GoodFlyBehavior();
quackBehavior = new GoodQuackBehavior();
}
void display() {
System.out.println("GreenHead（绿头鸭子）");
}
}
</pre>
Duck子类 RedHeadDuck代码如下：
<pre>
public class RedHeadDuck extends Duck {
public RedHeadDuck() {
flyBehavior = new BadFlyBehavior();
quackBehavior = new BadQuackBehavior();
}
void display() {
System.out.println("RedHead（红头鸭子）");
}
}
</pre>
于是我们创建一个类去检验以上代码的可行性。
<pre>
public class TestDemo {
public static void main(String[] args) {
Duck mGreenHeadDuck = new GreenHeadDuck();
Duck mRedHeadDuck = new RedHeadDuck();
//对象的属性和方法
mGreenHeadDuck.display();
mGreenHeadDuck.Fly();
mGreenHeadDuck.Quack();
mGreenHeadDuck.swim();
System.out.println("---------分割线----------");
mRedHeadDuck.display();
mRedHeadDuck.Fly();
mRedHeadDuck.Quack();
mRedHeadDuck.swim();
mRedHeadDuck.display();
System.out.println("---------分割线----------");
//可以根据子类自身属性设置相应的参数，解决了因继承带来的某些问题。
mRedHeadDuck.SetFlyBehavoir(new NoFlyBehavior());
mRedHeadDuck.display();
mRedHeadDuck.Fly();
mRedHeadDuck.SetQuackBehavoir(new NoQuackBehavior());
mRedHeadDuck.Quack();
System.out.println("---------分割线----------");
mGreenHeadDuck.SetFlyBehavoir(new BadFlyBehavior());
mGreenHeadDuck.display();
mGreenHeadDuck.Fly();
mGreenHeadDuck.SetQuackBehavoir(new NoQuackBehavior());
mGreenHeadDuck.Quack();
}
}
</pre>
运行结果:
<pre>
GreenHead（绿头鸭子）
--GoodFly--
好听的叫声
im swim
---------分割线----------
RedHead（红头鸭子）
--BadFly--
难听的叫声
i m swim
RedHead（红头鸭子）
---------分割线----------
RedHead（红头鸭子）
--不会飞--
不会叫
---------分割线----------
GreenHead（绿头鸭子）
--BadFly--
不会叫
</pre>
总结：
策略模式：将类中的行为抽离成接口，实现相应的算法族，在超类里放置行为接口对象，并提供设置接口，提高行为组合能力，在子类中具体设定行为对象。原则就是：分离变化部分，封装接口，基于接口编程各种功能。此模式让行为算法的变化独立于算法的使用者。
注意点：
策略模式的思想注意点在于：
(1、分析项目中变化部分与不变部分
(2、多用组合少用继承；用行为类组合，而不是行为的继承。更有弹性
(3、设计模式有没有相应的库直接使用？有些库或框架本身就用某种设计模式设计的
(4、如果找不到适用的模式怎么办
附言
作为一个Java程序员，在开发中遇到的问题，多使用面向对象，基本原则，抽象设计超类继承的做法去解决。如果还不能解决？那就自己看着吧！
