策略模式（别名：政策）

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

Strategy Pattern（Another Name: Policy）

Define a family of algorithms, encapsulate each one, and make them inter changeable. Strategy lets the algorithm vary independently from clients that use it.

类图

模式的结构与使用

策略方法模式的结构中包括三种角色。

+ 策略（Strategy）：策略是一个接口，该接口定义若干个算法标识，即定义了若干个抽象方法。 + 具体策略（Concrete Strategy）：具体策略是实现策略接口的类。具体策略实现策略接口所定义的抽象方法，即给出算法标识的具体算法。 + 上下文（Context）：上下文是依赖于策略接口的类，即上下文包含有策略声明的变量。上下文中提供一个方法，该方法委托策略变量调用具体策略所实现的策略接口中的方法。

简单的例子

Abstract Strategy的接口类ComputableStrategy.java

package Strategy;public interface ComputableStrategy {
         public abstract double computableStrategy(double[] a);}

Strategy的实现类StrategyOne.java

package Strategy;public class StrategyOne implements ComputableStrategy {
         @Override    public double computableStrategy(double[] a) {        double score = 0, sum = 0;        for (int i = 0; i < a.length; i++) {            sum = sum + a[i];        }        score = sum/a.length;        return score;    }}

Strategy的实现类StrategyTwo.java

package Strategy;public class StrategyTwo implements ComputableStrategy {
         @Override    public double computableStrategy(double[] a) {        double score = 0, multi = 1;        int n = a.length;        for (int i = 0; i < a.length; i++) {            multi = multi * a[i];        }        score = Math.pow(multi, 1.0/n);        return score;    }}

Strategy的实现类StrategyThree.java

package Strategy;import java.util.Arrays;public class StrategyThree implements ComputableStrategy {
         @Override    public double computableStrategy(double[] a) {        if (a.length <= 2)            return 0;        double score = 0, sum = 0;        Arrays.sort(a);        for (int i = 1; i < a.length - 1; i++) {            sum = sum + a[i];        }        score = sum/(a.length-2);        return score;    }}

Context类GymnasticsGame.java

package Strategy;public class GymnasticsGame {
         ComputableStrategy strategy;    public void setStrategy(ComputableStrategy strategy) {        this.strategy = strategy;    }    public double getPersonScore(double a[]) {        if (strategy != null) {            return strategy.computableStrategy(a);        } else            return 0;    }}

测试类Application.java

package Strategy;public class Application {
         public static void main(String[] args) {        GymnasticsGame game = new GymnasticsGame();        game.setStrategy(new StrategyOne());        Person zhang = new Person();        zhang.setName("张三");        double[] a = {
    9.12, 9.25, 8.87, 9.99, 6.99, 7.88};        Person li = new Person();        li.setName("李四");        zhang.setScore(game.getPersonScore(a));        li.setScore(game.getPersonScore(a));        System.out.println(zhang.getScore());        System.out.println(li.getScore());        game.setStrategy(new StrategyThree());        zhang.setScore(game.getPersonScore(a));        li.setScore(game.getPersonScore(a));        System.out.println(zhang.getScore());        System.out.println(li.getScore());    }}class Person {    String name;    double score;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public double getScore() {        return score;    }    public void setScore(double score) {        this.score = score;    }}

执行效果图

策略模式的优点

• 上下文（Context）和具体策略（ConcreteStrategy）是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例，但不需要知道具体是哪一个类。
• 策略模式满足“开-闭原则”。当增加新的具体策略时，不需要修改上下文类的代码，上下文就可以引用新的具体策略的实例。

适用策略模式的情景

• 一个类定义了多种行为，并且这些行为在这个类的方法中以多个条件语句的形式出现，那么可以使用策略模式避免在类中使用大量的条件语句。
• 程序不希望暴露复杂的、与算法有关的数据结构，那么可以使用策略模式封装算法。
• 需要使用一个算法的不同变体。

下载源码请到