1. 定义

定义算法族，将每一个算法封装到具有共同接口的独立的类中，让他们之间可以互相替换，让算法的变换独立于使用者。

2. 使用

• 场景：通过公共接口的一个引用，在具体的场景下可以使用不同的策略
• 策略：只需要定义公共方法，交给不同的实现类具体实现细节（算法）

（1）场景

package StrategyPattern;
/*
抽象场景
 */
public class Scene {
    Strategy strategy;
    /*
    动态改变策略
     */
    public void setStrategy(Strategy strategy){
        this.strategy = strategy;
    }
    /*
    场景无需关心具体的实现方法，只需要知道有这么个方法,委托给抽象类型来实现
     */
    public void solution(){
        strategy.solution();
    }
}

package StrategyPattern;
/*
具体场景A
 */
public class SceneA extends Scene {
    /*
    委托给A策略
     */
    public SceneA() {
        this.strategy = new StrategyA();
    }
}

package StrategyPattern;
/*
具体场景B
 */
public class SceneB extends Scene {
    /*
    委托给策略B实现
     */
    public SceneB(){
        this.strategy = new StrategyB();
    }
}

（2）策略

package StrategyPattern;
/*
抽象策略
 */
public interface Strategy {
    /*
    不同的解决方法
     */
    public void solution();
}

package StrategyPattern;

public class StrategyA implements Strategy {
    @Override
    public void solution() {
        System.out.println("solutionA");
    }
}

package StrategyPattern;

public class StrategyB implements Strategy {
    @Override
    public void solution() {
        System.out.println("solutionB");
    }
}

（3）在特定场景使用特定策略

public class Test {
    public static void main(String[] args) {
        Scene scene = new SceneA();
        scene.solution();
        scene = new SceneB();
        scene.solution();
    }
}

3. 特点

• 算法的平等性：算法之间可以相互替换，所有的策略算法在实现上也是相互独立的
• 策略的唯一性：运行期间，在每一个时刻只能使用一个具体的策略实现对象

优点：

• 恰当使用继承可以把公共的代码移到父类里面，从而避免代码重复。
• 避免使用多重条件(if-else)语句

缺点：

• 只适用于客户端知道算法或行为的具体实现
• 策略过多会造成冗余