设计模式学习--策略模式（Strategy Pattern)

本人最近也在学习设计模式，看到也是 HEAD_FIRST设计模式 ，所以，偷个懒，直接转载个笔记。嘿嘿。

设计模式学习–策略模式（Strategy Pattern)
什么是策略模式？
定义算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立使用算法的客户。

怎么使用策略模式设计程序？
分开变化和不会变化的部分，建立一组新的类来代表变化的部分。

三个设计原则：
1. 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
2. 针对接口编程，而不是针对实现编程。
3. 多用组合，少用继承。

策略模式应用例子：
一只鸭Duck，可能是以下几种不同类型的鸭
(MallardDuck) 绿头鸭–会飞会呱呱叫
(RedHeadDuck) 红头鸭–会飞会呱呱叫
(RubberDuck) 橡皮鸭–不会飞会叽叽叫
(DecoyDuck) 诱饵鸭–不会飞也不会叫
(ModelDuck) 模型鸭–不会飞也不会叫

在没有使用策略模式之前可能这样：

1. 利用继承来提供Duck的行为
   ===》导致代码在多个子类中重复
   ===》运行时的行为不容易改变
   ===》很难知道所有鸭子的全部行为
   ===》改变会牵一发动全身，造成其他鸭子不想要的改变。
2. 把会变的行为提取出来设计成一个接口
   ===》导致重复代码变多
   ===》导致代码无法进行复用

使用策略模式会是这样：
1. 采用良好的oo软件设计原则
2. 分开变化和不会变化的部分
3. 针对接口编程

具体实现：
所有类型鸭的抽象：Duck类
[java] view plaincopy
package strategyPattern;

/**
* 所有类型鸭子的超类
* @author wwj
*
*/
public abstract class Duck {
FlyBehavior flyBehavior; //飞行行为
QuackBehavior quackBehavior; //呱呱叫行为

public void performQuack(){  
    quackBehavior.quack();  
}  

public void swim(){  
    System.out.println("All ducks float, even decoys!");  
}  

public abstract void display();  

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

public void setFlyBehavior(FlyBehavior fb) {  
    flyBehavior = fb;  
}  

public void setQuackBehavior(QuackBehavior qb) {  
    quackBehavior = qb;  
}  

}

把会变化的部分取出并“封装”起来，好让其他部分不会受到影响
提供两个接口FlyBehavior和QuackBehavior
[java] view plaincopy
package strategyPattern;

public interface FlyBehavior {
public void fly();
}

[java] view plaincopy
package strategyPattern;

public interface QuackBehavior {
public void quack();
}

实现鸭子的行为（飞行类）
[java] view plaincopy
package strategyPattern;

public class FlyWithWings implements FlyBehavior {

@Override  
public void fly() {  
    //实现鸭子飞行  
    System.out.println("I'm flying!");  
}  

}

[java] view plaincopy
package strategyPattern;

public class FlyNoWay implements FlyBehavior {

@Override  
public void fly() {  
    //什么都不做，不会飞  
    System.out.println("I can't fly");  
}  

}

[java] view plaincopy
public class FlyRocketPowered implements FlyBehavior {

@Override  
public void fly() {  
    System.out.println("I'm flying with a rocket!");  
}  

}

实现鸭子的行为（呱呱叫）
[java] view plaincopy
package strategyPattern;

public class Quack implements QuackBehavior {

@Override  
public void quack() {  
    //实现鸭子呱呱叫  
    System.out.println("Quack");  
}  

}

[java] view plaincopy
package strategyPattern;

public class Squack implements QuackBehavior {

@Override  
public void quack() {  
    //橡皮鸭子叽叽叫  
    System.out.println("Squack");  
}  

}

[java] view plaincopy
package strategyPattern;

public class MuteQuack implements QuackBehavior {

@Override  
public void quack() {  
    // 什么都不做，不会叫  
}  

}

整合鸭子的行为，让不同的鸭子继承鸭类（Duck）
[java] view plaincopy
package strategyPattern;

/**
* 绿头鸭继承鸭类
* @author wwj
*
*/
public class MallardDuck extends Duck{

/** 
 * 因为MallardDuck继承Duck类，所以具有flyBehavior与quackBehavior实例变量 
 */  
public MallardDuck() {  
    quackBehavior = new Quack(); //真正的呱呱叫     
    flyBehavior = new FlyWithWings();   //会用翅膀飞  
}  

public void display() {  
    System.out.println("I'm a real Mallard duck");  //我是一个真正的绿头鸭  
}  

}

[java] view plaincopy
package strategyPattern;

public class RedheadDuck extends Duck{
public RedheadDuck() {
flyBehavior = new FlyWithWings();
quackBehavior = new Quack();
}

@Override  
public void display() {  
    System.out.println("I'm a RedheadDuck!!");  //红头鸭  
}  

}

[java] view plaincopy
package strategyPattern;

public class RubberDuck extends Duck{
public RubberDuck() {
}

@Override  
public void display() {  
    System.out.println("I'm a RubberDuck!!!");  
}  

}

[java] view plaincopy
package strategyPattern;

public class ModelDuck extends Duck {
public ModelDuck() {
flyBehavior = new FlyNoWay(); //不会飞
quackBehavior = new Quack(); //会叽叽叫
}

@Override  
public void display() {  
    System.out.println("I'm a model duck");  
}  

}

[java] view plaincopy
package strategyPattern;

public class DecoyDuck extends Duck{
public DecoyDuck(){
}

@Override  
public void display() {  
    System.out.println("I'm a DecoyDuck!!!");   //我是一只诱饵鸭  
}  

}

测试类：
[java] view plaincopy
package strategyPattern;

public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.performQuack();
mallard.performFly();

    //动态改变模型鸭的行为--通过调用继承来的setter方法  
    Duck model = new ModelDuck();  
    model.performFly();  
    model.setFlyBehavior(new FlyRocketPowered());   //委托  
    model.performFly();  
}  

}

测试结果：
[java] view plaincopy
Quack
I’m flying!
I can’t fly
I’m flying with a rocket!

确实，使用策略模式之后，代码变得可复用了，可以适应更多的变化，而不会互相影响。良好的oo设计必须具备可复用、可扩充、可维护三个特性。模式是前人历经验证的经验，可以用来解决程序设计当中的各种问题。
转载至：http://blog.csdn.net/wwj_748/article/details/8933282