每天学习一个设计模式-2.策略模式

策略模式的本质是：分离算法，选择实现。

一、策略模式的定义：

定义一系列的算法，把它们一个个封装起来，并且可以使它们相互替换。本模式使得算法算法可独立于使用它的客户而存在。

策略模式类图

二、应用场景

在以下情况中可以选择策略模式：

1）出现有许多相关的类，仅仅是行为有差别的情况下，可以使用策略模式来使用多个行为中的一个来配置一个类的方法，实现算法动态切换；

2）出现同一个算法，有很多不同实现的情况下，可以使用策略模式来把这些“不同的实现”实现成为一个算法的类层次；

3）需要封装算法中，有与算法相关数据的情况下，可以使用策略模式来避免暴露这些跟算法相关的数据结构；

4）出现抽象一个定义了很多行为的类，并且是通过多个is-else语句来选择这些行为的情况下，可以使用策略模式来代替这些条件语句。

三、策略模式的实现

反恐精英

在精典的射击类游戏反恐精英中，角色可以同时拥有以下武器：1 支大枪（如卡宾枪、AK47、狙击枪等）、1支手枪（沙漠之鹰等）、一把匕首、一颗手雷，角色通过切换不同武器进行攻击。

今天，我们就用JAVA代码来模拟这一场景。

3.1 不使用设计模式

1、角色类：


/**
 * 角色
 */
public class Hero {

    /**
     * 攻击行为
     * @param type 武器类型
     */
    public void attack(int type) {
        
        switch (type) {
            case 1: // AK47
                this.attackWithAk47Gun();
                break;
            case 2: // 炸弹
                this.attackWithBomb();
                break;
            case 3: // 匕首
                this.attackWithKnief();
                break;
            case 4: // 沙漠之鹰手枪
                this.attackWithSMZYHandgun();
                break;
        }
    }

    public void attackWithAk47Gun() {
        System.out.println("使用AK47进行射击...");
    }

    public void attackWithBomb() {
        System.out.println("使用炸弹攻击...");
    }

    public void attackWithKnief() {
        System.out.println("用匕首刺杀...");
    }

    public void attackWithSMZYHandgun() {
        System.out.println("使用沙漠之鹰手枪进行射击...");
    }
}

2、客户端类

public class Client {

    public static void main(String[] args) {

        Hero hero = new Hero();

        // 使用AK47攻击
        hero.attack(1);

        // 使用炸弹攻击
        hero.attack(2);

        // 使用匕首攻击
        hero.attack(3);

        // 使用沙漠之鹰手枪攻击
        hero.attack(4);
    }
}

运行结果：

运行结果

存在的问题：
1）如果增加一种武器类型，则必须要修改Hero类的attack()方法里的switch语句，增加分支，同时要增加对应的武器方法attackWithXXX()，这严重违反了开-闭原则；
2）对客户端暴露了一些实现细节，客户端必须清楚地知道1234代表的武器类别，这违背了迪米特原则。

3.2 使用策略模式

策略模块实现类图

1、角色类：

public class Hero {

    private Weapon weapon;

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }

    /**
     * 攻击
     */
    public void attack() {
        this.weapon.attack();
    }
}

2、武器接口

/**
 * 武器接口
 */
public interface Weapon {

    /**
     * 攻击
     */
    void attack();
}

3、匕首类

public class Knief implements Weapon {

    @Override
    public void attack() {
        System.out.println("用匕首刺杀...");
    }
}

4、炸弹类

/**
 * 炸弹
 */
public class Bomb implements Weapon {
    @Override
    public void attack() {
        System.out.println("使用炸弹攻击...");
    }
}

5、AK枪


/**
 * AK47大枪
 */
public class Ak47Gun implements Weapon{
    @Override
    public void attack() {
        System.out.println("使用AK47进行射击...");
    }
}

6、沙漠之英手枪

/**
 * 手枪：沙漠之鹰
 */
public class SMZYHandgun implements Weapon {
    @Override
    public void attack() {
        System.out.println("使用沙漠之鹰进行射击...");
    }
}

7、客户端类

public class Client {

    public static void main(String[] args) {
        Hero hero = new Hero();

        Weapon weapon = null;

        // 使用AK攻击
        weapon = new Ak47Gun();
        hero.setWeapon(weapon);
        hero.attack();

        // 使用炸弹攻击
        weapon = new Bomb();
        hero.setWeapon(weapon);
        hero.attack();

        // 使用匕首攻击
        weapon = new Knief();
        hero.setWeapon(weapon);
        hero.attack();
        
        weapon = new SMZYHandgun();
        hero.setWeapon(weapon);
        hero.attack();
    }
}

运行结果：

运行结果

三、策略模式的优缺点

优点：

1）避免多重条件语句；
2）更好的扩展性，如上面的实例中，如果增加新式武器，则创建新式武器的类实现Weapon接口，然后给Hero传入新创建的武器的实例就好。

缺点：

增加了对象的数量。