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

如下，游戏初期只有两种僵尸，除了外观，其它的都一样

abstract class AbstractZombie{
    public abstract void display();
    public void attack(){
        System.out.println("咬.");
    }
    public void move(){
        System.out.println("一步一步走.");
    }
}
class NormalZombie extends AbstractZombie{
    public void display(){
        System.out.println("我是普通僵尸.");
    }
}
class FlagZombie extends AbstractZombie{
    public void display(){
        System.out.println("我是旗手僵尸.");
    }
}
public class StrategyTest {
    public static void main(String[] args) {
        NormalZombie normalZombie = new NormalZombie();
        normalZombie.display();
        normalZombie.move();
        normalZombie.attack();
        FlagZombie flagZombie = new FlagZombie();
        flagZombie.display();
        flagZombie.move();
        flagZombie.attack();
    }
}

随着游戏的升级，引入了更多的僵尸，也就是移动方式和攻击方式都更加多了，未来变化也不可知，而且相互之间的攻击方式也有可能随着等级的变化而发生变化，对于移动方式和攻击方式就都需要进行抽象了，让子类去实现不同的移动方式和攻击方式。

interface MoveAble{
    void move();
}
interface AttackAble{
    void attack();
}
class StepByStep 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{
    public MoveAble moveAble;
    public AttackAble attackAble;
    public Zombie(MoveAble moveAble, AttackAble attackAble) {
        this.moveAble = moveAble;
        this.attackAble = attackAble;
    }
    abstract public void display();
    abstract void move();
    abstract void attack();
}
class NormalZombie extends Zombie{
    public NormalZombie() {
        super(new StepByStep(),new BiteAttack());
    }
    @Override
    public void display() {
        System.out.println("我是普通僵尸.");
    }
    @Override
    void move() {
        moveAble.move();
    }
    @Override
    void attack() {
        attackAble.attack();
    }
}
class FlagZombie extends Zombie{
    public FlagZombie() {
        super(new StepByStep(), new BiteAttack());
    }
    @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) {
        NormalZombie normalZombie = new NormalZombie();
        normalZombie.display();
        normalZombie.move();
        normalZombie.attack();
        System.out.println("普通僵尸升级了...");
        normalZombie.attackAble = new HitAttack();
        normalZombie.attack();
    }
}

应用场景
1.当你有很多类似的类，但它们执行某些行为的方式不同时，请使用此策略。
2.使用该模式将类的业务逻辑与算法的实现细节隔离开来，这些算法在逻辑上下文中可能不那么重要。
3.当你的类具有大量的条件运算符，并且在同一算法的不同变体之间切换时，请使用此模式。

优点：
1.可以将算法的实现细节与使用它的代码隔离开来。
2.符合开闭原则

Spring&JDK源码中的应用
1java.util.Comparator
2org.springframework.beans.factory.support.InstantiationStrategy