策略模式（Strategy Pattern）使用了算法族，分别封装起来，让它们可以互相替换，此模式让算法的变化独立于使用算法的客户。这种类型的设计模式属于行为型模式。

从上面的概念我们可以看得出来，策略模式主要有两个角色：算法族和使用算法的客户。算法族表示一系列的动作和操作，而使用算法的客户就是执行这些操作的主体。

最近王者荣耀大火，争议不断，突然想到用王者荣耀的例子解析一下正在学习的设计模式，学习和玩乐结合是最好的搭配，现在我就以王者荣耀为情景解释分析策略模式的操作。

1. 创建算法族：英雄技能

王者荣耀中每个英雄都有一套技能，每个英雄所拥有的技能都不一样，比如狄仁杰可以施放令牌技能，项羽有霸王斩技能，鲁班七号有无敌沙嘴炮技能，按照Java的封装、抽象特性，我们可以把技能抽象为一个接口，每一种技能实体都可以调用useSkill()执行技能；

public interface SkillBehavior {
    void useSkill(); //释放技能
}

英雄的技能多种多样，我们把每一种技能都封装为一个技能类，实现统一的接口SkillBehavior，这里举例介绍三种技能：

public class ArrowSkill implements SkillBehavior{
    @Override
    public void useSkill() {
        System.out.println("释放暗箭技能");
    }
}

public class KnifeSkill implements SkillBehavior {
    @Override
    public void useSkill() {
        System.out.println("释放长刀技能");
    }
}

public class GunSkill implements SkillBehavior {
    @Override
    public void useSkill() {
        System.out.println("释放手枪技能");
    }
}

2. 创建使用算法族客户：英雄

技能已经封装好了，还需要有使用技能的客户，那就是英雄了，每个英雄都有一个共性，那就是可以施放技能，我们就抽象封装出一个英雄类，每个英雄都持有一个技能对象，并可以调用performSkill()施放自己拥有的技能：

public abstract class Hero {

    public SkillBehavior mBehavior;

    public Hero(){
        System.out.print("英雄出生 ");
    }
    public void performSkill(){
        if(mBehavior != null){
            mBehavior.useSkill();
        }
    }
    public void setSkillBehavior(SkillBehavior behavior){
        mBehavior = behavior;
    }
}

英雄类封装好了，这时就需要有具体的英雄了，这里我们举例了三位英雄，也是我比较熟悉的英雄：狄仁杰、项羽、鲁班七号，每个英雄都须继承自Hero类：

public class DiRenJie extends Hero {

    public DiRenJie(){
        super();
        System.out.println("狄仁杰：代表法律制裁你...");
        mBehavior = new ArrowSkill();
    }
}

public class XiangYu extends Hero {

    public XiangYu(){
        super();
        System.out.println("项羽：我命由我... ");
        mBehavior = new KnifeSkill();
    }
}

public class LuBanQiHao extends Hero {

    public LuBanQiHao() {
        super();
        System.out.println("鲁班七号：魔法大师，智障250，@￥%*&￥#... ");
        mBehavior = new GunSkill();
    }
}

3. 算法族客户使用算法：英雄施放技能

技能和英雄都准备好了，这时候就要应该开始施放技能了：

public class KingGorgeDemo {

    public static void main(String[] args){
        Hero mDi = new DiRenJie();
        mDi.performSkill();
        Hero mXiang = new XiangYu();
        mXiang.performSkill();
        Hero mLu = new LuBanQiHao();
        mLu.performSkill();
    }
}

我们来看看各位英雄的输出：

英雄出生 狄仁杰：代表法律制裁你...
释放暗箭技能
英雄出生 项羽：我命由我... 
释放长刀技能
英雄出生 鲁班七号：魔法大师，智障250，@￥%*&￥# 
释放手枪技能

4. 让算法族可以互相替换：英雄可以动态更换技能

在最开始策略模式的概念中有一句话：策略模式使用了算法族，分别封装起来，让它们可以互相替换。互相替换是什么概念呢，假设狄仁杰令牌技能使用腻了，想试一下鲁班七号的霸王枪技能，那只需要动态地给狄仁杰这个英雄设置一个GunSkill技能，后面就可以释放鲁班七号的技能了。大家可以发现在Hero里有一个方法setSkillBehavior()。操作如下：

public class KingGorgeDemo {

    public static void main(String[] args){
        Hero mDi = new DiRenJie();
        SkillBehavior gunSkill = new GunSkill();
        mDi.setSkillBehavior(gunSkill);
        mDi.performSkill();
    }
}

这时候的输出就是：

英雄出生 狄仁杰：代表法律制裁你...
释放手枪技能

虽然这个例子有点不恰当，王者荣耀也不可能有这种操作，这只是一个简单的例子方便说明问题而已。可以举例一个实际场景：腾讯要推出狄仁杰的一项叫“神捕”的新技能，那只需要再封装一个执行SkillBehavior接口的技能类SeizeSkill，创建出SeizeSkill对象并设置给狄仁杰英雄对象，这时候释放技能时就是新的神捕技能了。

5. 策略模式的特性

策略模式对于软件开发来说是一种很好的设计模式，即英雄要替换技能时不用去改变英雄的类，技能和英雄互相独立，不耦合，可以用下面的类图表示策略模式的结构：

示例代码戳这里。