策略模式

定义

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

设计原则

• 将程序中需要变化的部分独立出来，方便以后的扩展、维护，不要和不需要变化的代码混在一起
• 针对接口编程，而不是针对实现编程
• 多用组合，少用继承

使用继承可能会导致的缺点

• 代码在多个子类重复，可能某些子类不需要这些代码
• 不容易动态的改变某一部分的代码
• 改变会牵一发动全身，可能某些子类不需要被改变

而使用组合恰恰就可以解决以上问题，并且它是策略模式中的重要组成部分。接下来通过一个案例来介绍策略模式。

案例

开发一款角色扮演类游戏，有四种角色:战士、剑士、魔法师、刺客，他们都具备攻击的行为，并且每次只能使用一种武器。那么开始编写代码：

分析：四种角色，他们的类型不同，使用的武器也不同，在父类中定义一个抽象的方法display()，用来描述此角色是什么类型，而具体是什么类型交给子类去实现，武器的话，由于在程序运行时可以动态切换武器，在以后的维护中还要添加新的角色，而且新的角色又可能会使用多种武器，这样的话就需要把武器单独从角色父类中提取出来，然后使用组合的方式，给每一个角色配置他所需要的武器，接下来是代码：

• 首先我们需要一个角色超类，代码如下：

  public abstract class Character {
     /**
     * 由子类实现不同的角色类型
     */
  public abstract void display();
  
    /**
     * 攻击的行为
     */
  public abstract void fight();
  
  }
  

上面的display()方法由具体的角色子类去实现，来展示自己是一个什么样的角色，fight也需要被子类实现，以表示该角色具体该如何进行攻击。

• 接下来设计武器类，武器的类型很多，是属于变化的那一部分，所以要把它独立出来，那么就需要一个武器超类接口，代码如下：

    public interface WeaponBehavior {
    //实现此方法，让角色使用不同的武器进行攻击
     void userWeapon();
    }
  

四种角色使用四种不同的武器，那么我们需要定义四个武器实现子类，代码如下：

    /**
     * 刀(战士的武器)
   */
  public class KnifeBehavior implements WeaponBehavior {
  @Override
  public void userWeapon() {
          System.out.println("使用刀来攻击敌人");
      }
  }  

   /**
     * 剑(剑士的武器)
   */
  public class SwordBehavior implements WeaponBehavior{
  @Override
  public void userWeapon() {
          System.out.println("使用剑来攻击敌人");
      }
  }

  /**
    * 魔杖(魔法师的武器)
  */
   public class MagicWandBehavior implements WeaponBehavior{
   @Override
   public void userWeapon() {
           System.out.println("使用魔杖来攻击敌人");
       }
   }

  /**
    * 匕首(刺客的武器)
  */
   public class DaggerBehaviorimplements WeaponBehavior{
   @Override
   public void userWeapon() {
           System.out.println("使用匕首来攻击敌人");
       }
   }

以上定义的这四种武器在这里就代指四种策略，不同的角色使用不同的武器进行攻击

• 最后我们使用组合的方式，将武器和角色嵌入到一起，修改Character类后的代码如下：

  public abstract class Character {
  
  //武器
  protected WeaponBehavior weaponBehavior;
  
  
  public void setWeaponBehavior(WeaponBehavior weaponBehavior){       {
        this.weaponBehavior = weaponBehavior;
  }
     /**
     * 由子类实现不同的角色类型
     */
  public abstract void display();
  
    /**
     * 攻击的行为
     */
  public abstract void fight();
  
  }
  

我们将武器的超类定义在角色超类中，这样子类就可以使用多态的形式去调用武器的userWeapon()方法，并通过setWeaponBehavior(...)方法让角色在程序运行过程中去动态切换武器(以后维护可能要加入其它角色，并且有的角色可以使用多种武器)。接下来我们来写一个战士角色类，代码如下：

public class Warrior extends Character {
public Warrior() {
    weaponBehavior = new KnifeBehavior();
}

@Override
public void display() {
    System.out.println("我是一名战士");
}

@Override
public void fight() {
    weaponBehavior.userWeapon();
}
}

上面代码，我们在构造方法中去创建战士默认使用的武器。

最后来测试一下，中间我们切换了一下武器：

public class Strategy {
public static void main(String[] args){
    Warrior warrior = new Warrior();
    warrior.display();
    warrior.fight();
    System.out.println("切换武器:");
    warrior.setWeaponBehavior(new SwordBehavior());
    warrior.fight();
}
}

打印结果:

我是一名战士
使用刀来攻击敌人
切换武器:
使用剑来攻击敌人

这样就达到了我们的要求，以后不管加入多少武器，只要写一个武器实现类就可以了，并且不会对其它类造成影响，但是策略模式也有缺点，就是当武器种类特别多的时候，那么就需要写很多武器实现类了。