Java 策略模式 (Strategy Pattern)

最近在看 《Head First 设计模式 》，很好的一本书。通俗易懂。

策略模式

定义了算法族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。

代码：

package gx.customer;

import gx.behavior.FlyBehavior;
import gx.behavior.QuackBehavior;

/**
 * 
 * Duck 类是所有鸭子的超类，但飞行行为和呱呱叫行为已经被提取(变化的行为)
 * @author always
 *
 */
public abstract class Duck {


    protected FlyBehavior flyBehavior;
    protected QuackBehavior quackBehavior;

    public void swim(){
        System.out.println("是鸭子都回游泳，这个不算什么");
    }

    public void performFly(){
        if(flyBehavior!=null){
            flyBehavior.fly();
        }else{
            System.out.println("没有飞行行为");
        }
    }

    public void performQuack(){

        if(quackBehavior!=null){
            quackBehavior.quack();
        }else{
            System.out.println("没有叫行为");
        }   
    }


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

    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }

    public abstract void display();
}

package gx.behavior;

/**
 * 飞行行为的接口
 * @author always
 *
 */
public interface FlyBehavior {

    void fly();
}

package gx.behavior;

/**
 * 呱呱叫行为的接口
 * @author always
 *
 */
public interface QuackBehavior {

    void quack();
}

行为的实现：算法族

package gx.behavior.impl;

import gx.behavior.FlyBehavior;

public class FlyNoWay implements FlyBehavior{

    public void fly() {
        System.out.println("已经开始学了，还是没有学会啊。好难额");
    }


}

package gx.behavior.impl;

import gx.behavior.FlyBehavior;

public class FlyWithWings implements FlyBehavior{

    public void fly() {
        System.out.println("用翅膀，用力的飞");
    }

}

package gx.behavior.impl;

import gx.behavior.QuackBehavior;

public class MuteQuack implements QuackBehavior {

    public void quack() {
        System.out.println("不会叫");
    }

}

package gx.behavior.impl;

import gx.behavior.QuackBehavior;

public class Quack implements QuackBehavior{

    public void quack() {
        System.out.println("呱呱叫");
    }



}

package gx.behavior.impl;

import gx.behavior.QuackBehavior;

public class Squack implements QuackBehavior {

    public void quack() {
        System.out.println("吱吱叫");
    }

}

package gx.customer;

import gx.behavior.impl.FlyWithWings;
import gx.behavior.impl.Quack;

public class MallardDuck extends Duck{

    public MallardDuck(){

        flyBehavior=new FlyWithWings();
        quackBehavior=new Quack();
    }

    public void display() {
        System.out.println("看起来像绿头鸭");
    }

}

客户使用封装好的飞行和呱呱叫算法族

package gx.customer;

import gx.behavior.impl.FlyNoWay;
import gx.behavior.impl.MuteQuack;

public class RedheadDuck extends Duck{


    public RedheadDuck(){
        flyBehavior=new FlyNoWay();
        quackBehavior=new MuteQuack();
    }


    @Override
    public void display() {
        System.out.println("红头鸡");
    }

}

测试类：

package gx.test;

import org.junit.Test;

import gx.behavior.impl.FlyWithWings;
import gx.customer.Duck;
import gx.customer.MallardDuck;
import gx.customer.RedheadDuck;

public class TestStrategy {

    private Duck duck;

    @Test
    public void testMallardDuck(){

        duck=new MallardDuck();
        duck.display();
        duck.performFly();
        duck.performQuack();
        /*
        结果：
        看起来像绿头鸭
        用翅膀，用力的飞
        呱呱叫
        */
    }

    @Test
    public void testRedheadDuck(){

        duck=new RedheadDuck();
        duck.display();
        duck.performFly();
        duck.performQuack();
        duck.setFlyBehavior(new FlyWithWings());//动态调用新的“算法”
        duck.performFly();
        /*
        结果：
        红头鸡
        已经开始学了，还是没有学会啊。好难额
        不会叫
        用翅膀，用力的飞

        */
    }

}