设计模式 -- 策略模式

Head First 里面对策略模式的描述：

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

 

例子：

我们要制作一堆游戏里面的猫猫形象，里面的猫暂时主要

有2个技能：跑与叫，但不是每一只猫的这两种技能都是好的，有的不会，有的差，有的好；

共同技能：游泳；

当然它们各自有自己的形态；

 

于是乎有了以下的类图：

代码实现如下：

RunBehaviour 抽象出跑的行为接口

package strategy.run;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public interface RunBehaviour
{
    void run();
}

NoRunBehaviour 是 RunBehaviour  的算法族里面的一员

package strategy.run;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public class NoRunBehaviour implements RunBehaviour
{
    @Override
    public void run()
    {
        System.out.println("~~~ no run ~~~");
    }
}

BadRunBehaviour 也是 RunBehaviour  的算法族里面的一员

package strategy.run;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public class BadRunBehaviour implements RunBehaviour
{
    @Override
    public void run()
    {
        System.out.println("~~~ bad run ~~~");
    }
}

GoodRunBehaviour 也是 RunBehaviour  的算法族里面的一员

package strategy.run;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public class GoodRunBehaviour implements RunBehaviour
{
    @Override
    public void run()
    {
        System.out.println("~~~ good run ~~~");
    }
}

好了，上面完成了run的算法族，就该轮到meow了，同样的道理，抽象出meow 接口

package strategy.meow;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public interface MeowBehaviour
{
    void meow();
}

NoMeowBehaviour

package strategy.meow;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public class NoMeowBehaviour implements MeowBehaviour
{
    @Override
    public void meow()
    {
        System.out.println("~~~ no meow ~~~");
    }
}

BadMeowBehaviour

package strategy.meow;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public class BadMeowBehaviour implements MeowBehaviour
{
    @Override
    public void meow()
    {
        System.out.println("~~~ bad meow ~~~");
    }
}

GoodMeowBehaviour

package strategy.meow;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public class GoodMeowBehaviour implements MeowBehaviour
{
    @Override
    public void meow()
    {
        System.out.println("~~~ good meow ~~~");
    }
}

到此阶段，算法族已经封装完毕，是时候来使用它们了。抽象出Cat 的抽象类

package strategy.cat;

import strategy.run.RunBehaviour;
import strategy.meow.MeowBehaviour;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public abstract class AbstractCat
{
    RunBehaviour runBehaviour;
    MeowBehaviour meowBehaviour;

    public void fly()
    {
        runBehaviour.run();
    }

    public void quack()
    {
        meowBehaviour.meow();
    }

    public void swim()
    {
        System.out.println("~~~ swim ~~~");
    }

    public abstract void diplay();
}

肥猫（FatCat），由于太胖了，不会跑，只会叫

package strategy.cat;

import strategy.run.NoRunBehaviour;
import strategy.meow.GoodMeowBehaviour;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public class FatCat extends AbstractCat
{
    public FatCat()
    {
        runBehaviour = new NoRunBehaviour();
        meowBehaviour = new GoodMeowBehaviour();
    }

    @Override
    public void diplay()
    {
        System.out.println("*** fat cat ***");
    }
}

瘦猫（ThinCat）

package strategy.cat;

import strategy.run.GoodRunBehaviour;
import strategy.meow.BadMeowBehaviour;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public class ThinCat extends AbstractCat
{
    public ThinCat()
    {
        runBehaviour = new GoodRunBehaviour();
        meowBehaviour = new BadMeowBehaviour();
    }

    @Override
    public void diplay()
    {
        System.out.println("*** thin cat ***");
    }
}

最后，我们来使用下面的方法来验证一下我们的代码！

package strategy;

import strategy.cat.AbstractCat;
import strategy.cat.FatCat;
import strategy.cat.ThinCat;

/**
 * Created by chenjiayin on 2017/3/17.
 */
public class StrategyMain
{
    public static void main(String[] args)
    {
        AbstractCat fatDuck = new FatCat();
        AbstractCat thinDuck = new ThinCat();

        fatDuck.diplay();
        fatDuck.quack();
        fatDuck.fly();
        fatDuck.swim();

        System.out.println();

        thinDuck.diplay();
        thinDuck.quack();
        thinDuck.fly();
        thinDuck.swim();
    }
}

输出：

*** fat cat ***
~~~ good meow ~~~
~~~ no run ~~~
~~~ swim ~~~

*** thin cat ***
~~~ bad meow ~~~
~~~ good run ~~~
~~~ swim ~~~

总结：

其实策略模式就有点类似于做象限轴。

上面的例子当中就是一个二维的象限轴，RunBehaviour 就是X轴，MeowBehaviour 就是Y轴，而FatCat 与ThinCat 就是一个具体在二维空间上的描点。

所以，随着象限轴的增加，可组合而成的点（具体的类）也会越来越多，但是我们只需要很少量的改动，就可以为我们带来大量的扩展。