1. 定义

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

2. 案例

植物大战僵尸，僵尸类型有很多种，以后还可能会扩展
第一个版本僵尸：


第二个版本僵尸：


未完待续，第N个版本僵尸：

2.1 第一种实现（不推荐）

定义一个普通僵尸，其他僵尸继承它，重写对应方法，但是有的方法可能时公用的，再去继承另外的僵尸并重写方法，会使得类结构图复杂

2.2 第二种实现：策略模式

分别定义僵尸移动、攻击为算法族，封装起来。
封装移动、攻击：

interface Moveable {
    void move();
}
interface Attackable {
    void attack();
}

实现一个移动

class StepByStepMove implements Moveable {
    @Override
    public void move() {
        System.out.println("一步一步移动.");
    }
}

实现两个攻击

class BiteAttack implements Attackable {
    @Override
    public void attack() {
        System.out.println("咬.");
    }
}
class HitAttack implements Attackable {
    @Override
    public void attack() {
        System.out.println("打.");
    }
}

定义僵尸基类

abstract class Zombie {
    abstract public void display();
    Moveable moveable;
    Attackable attackable;
    public Zombie(Moveable moveable, Attackable attackable) {
        this.moveable = moveable;
        this.attackable = attackable;
    }
    abstract void move();
    abstract void attack();
    public Moveable getMoveable() {
        return moveable;
    }
    public void setMoveable(Moveable moveable) {
        this.moveable = moveable;
    }
    public Attackable getAttackable() {
        return attackable;
    }
    public void setAttackable(Attackable attackable) {
        this.attackable = attackable;
    }
}

定义一个普通僵尸：默认移动为StepByStepMove，默认攻击为BiteAttack

class NormalZombie extends Zombie {
    public NormalZombie() {
        super(new StepByStepMove(), new BiteAttack());
    }
    public NormalZombie(Moveable moveable, Attackable attackable) {
        super(moveable, attackable);
    }
    @Override
    public void display() {
        System.out.println("我是普通僵尸.");
    }
    @Override
    void move() {
        moveable.move();
    }
    @Override
    void attack() {
        attackable.attack();
    }
}

定义一个棋手僵尸：默认移动为StepByStepMove，默认攻击为BiteAttack

class FlagZombie extends Zombie {
    public FlagZombie() {
        super(new StepByStepMove(), new BiteAttack());
    }
    public FlagZombie(Moveable moveable, Attackable attackable) {
        super(moveable, attackable);
    }
    @Override
    public void display() {
        System.out.println("我是旗手僵尸.");
    }
    @Override
    void move() {
        moveable.move();
    }
    @Override
    void attack() {
        attackable.attack();
    }
}

使用：

public class StrategyTest {
    public static void main(String[] args) {
        Zombie zombie = new NormalZombie();
        zombie.display();
        zombie.attack();
        zombie.move();
        //还可以重新设置攻击方式
        zombie.setAttackable(new BiteAttack());
        zombie.attack();
    }
}

3. 应用场景

1. 当你有很多类似的类，但它们执行某些行为的方式不同时，请使用此 策略。

   1. 使用该模式将类的业务逻辑与算法的实现细节隔离开来，这些算法在 逻辑上下文中可能不那么重要。

2. 当你的类具有大量的条件运算符，并且在同一算法的不同变体之间切 换时，请使用此模式。

   4. 优点：

3. 可以将算法的实现细节与使用它的代码隔离开来。

4. 符合开闭原则

   5. Spring &JDK 源码中的应