设计模式策略模式

策略模式

　　定义算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。(虽然能理解意思，但真心记不住= =)

　　策略模式其实不难，顾名思义就是更改策略（策略接口下的子类）。首先是需要一个策略接口：Strategy，可以有n个子类实现此接口；其次是

拥有此接口对象（注意是接口对象，而不是任意的子类）的客户端，那么客户端可以在运行时根据需要选择策略（子类）。

　　这样做的好处：

　　　　1. 维护方便：若策略经常改变，则更换策略便是；若出现新策略，那么实现一个继承策略接口的子类便可。其实这都可以归结为针对接口编程带来的好处。

　　　　2. 强大的组合：想象一下，若有n个策略接口，每个策略接口都有m个子类。客户端只要维护n个策略接口对象，在运行时更改具体子类，那么其组合效应　　　　　　　　　　　　 是非常惊人的，可以很方便的根据实际需要组装出各种接口组合。

　　

　　说了这么多，写一个例子：

　　有这样一个场景：有3种鸭子（为毛是鸭子呢- -）：小鸭、会飞的老鸭（这个更囧吧）、玩具鸭。它们具有两类行为：叫和飞。具体行为分配如下列表：

　　　　　　quack 　　fly
   小鸭：　　不会叫 　  不会飞
   老鸭： 　  嘎嘎叫      会飞
   橡皮鸭：　吱吱叫　   不会飞

　　一种常见的做法是：写一个Duck的抽象类，包括quack()和fly()方法（应当是抽象的，因为每种鸭子的行为不同），然后这三种鸭子继承Duck抽象类。这样做的问题：1. 代码无法复用。当两种鸭子的某一行为相同时，你只能去copy代码；当增加一种新鸭子时，也只能重写其行为。 2. 当鸭子的行为改变时，很显然只能修改源代码！这样不好嘛？好是好，可有没有想过运行时修改，而不用修改源代码呢！

　　现在就用策略模式来改变这一现状吧：）

　　1. FlyBehaviour接口及其两个子类CanFly和CantFly，分别代表“会飞”和“不会飞”。

package StrategyPattern;
/*
 * 飞行接口
 */
public interface FlyBehaviour {
    public void fly();
}



package StrategyPattern;

public class CanFly implements FlyBehaviour {

    @Override
    public void fly() {
        // TODO Auto-generated method stub
        System.out.print("会飞");
    }

}



package StrategyPattern;

public class CantFly implements FlyBehaviour {

    @Override
    public void fly() {
        // TODO Auto-generated method stub
        System.out.print("不会飞");
    }

}

　　2. QuackBehaviour接口及其三个子类NoQuack，GagaQuack和ZhizhiQuack，分别代表“不会叫”、“嘎嘎叫”、“吱吱叫”。

package StrategyPattern;
/**
 * 叫行为。
 * @author Administrator
 *
 */
public interface QuackBehaviour {
    public void quack();
}


package StrategyPattern;

public class NoQuack implements QuackBehaviour {

    @Override
    public void quack() {
        // TODO Auto-generated method stub
        System.out.print("不会叫");
    }

}

package StrategyPattern;

public class GagaQuack implements QuackBehaviour {

    @Override
    public void quack() {
        // TODO Auto-generated method stub
        System.out.print("嘎嘎叫");
    }

}


package StrategyPattern;

public class ZhizhiQuack implements QuackBehaviour {

    @Override
    public void quack() {
        // TODO Auto-generated method stub
        System.out.print("吱吱叫");
    }

}

　　3. Duck抽象类，含有FlyBehaviour和QuackBehaviour的两个接口对象。及其三个子类，LittleDuck、OldDuck和RubbDuck。

package StrategyPattern;

import java.awt.DisplayMode;

/**
 * duck的抽象父类。
 * @author Administrator
 *
 */
public abstract class Duck {
    
    FlyBehaviour flyBh;
    QuackBehaviour quackBh;
    
    public Duck(FlyBehaviour fly, QuackBehaviour quack) {
        this.flyBh = fly;
        this.quackBh = quack;
    }
    
    public void setFlyBehaviour(FlyBehaviour fly) {
        this.flyBh = fly;
    }
    
    public void setQuackBehaviour(QuackBehaviour quack) {
        this.quackBh = quack;
    }
    
    public void performFly() {
        flyBh.fly();
    }
    
    public void peformQuack() {
        quackBh.quack();
    }
    
    public abstract void display();
    
}



package StrategyPattern;

public class LittleDuck extends Duck {

    public LittleDuck(FlyBehaviour fly, QuackBehaviour quack) {
        super(fly, quack);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println();
        System.out.print("小鸭");
        peformQuack();
        performFly();
    }

}



package StrategyPattern;

public class OldDuck extends Duck {

    public OldDuck(FlyBehaviour fly, QuackBehaviour quack) {
        super(fly, quack);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println();
        System.out.print("老鸭");
        peformQuack();
        performFly();
    }

}




package StrategyPattern;

public class RubbDuck extends Duck {

    public RubbDuck(FlyBehaviour fly, QuackBehaviour quack) {
        super(fly, quack);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println();
        System.out.print("橡皮鸭");
        peformQuack();
        performFly();
    }

}

　　最后，看看效果吧：

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Duck littleDuck = new LittleDuck(new CantFly(), new NoQuack());
        Duck oldDuck = new OldDuck(new CanFly(), new GagaQuack());
        Duck rubbDuck = new RubbDuck(new CantFly(), new ZhizhiQuack());
        littleDuck.display();
        oldDuck.display();
        rubbDuck.display();
    }

运行结果：

小鸭不会叫不会飞
老鸭嘎嘎叫会飞
橡皮鸭吱吱叫不会飞