一、特性与定义

1. 定义

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

2. 策略模式的解释

我们通过分析一个计算平均数的方法来引出策略模式。我们有下面一个方法，它的作用是计算出传入的double数组各个数的平均值，当然这是用户的需求。如果此时，用户有一个新的需求，想要计算出数组中除去最大最小值后各个数的平均值。那么此时我们可以修改此方法，让其计算出数组中除去最大最小值后各个数的平均值再返回。但是之前的计算所有数的平均数的需求仍然是需要的，不能舍弃，那我们只能在此方法中添加if语句来做判断。但是这也不是一个好方法，因为如果又有新的求，我们就又需要更改这个computeAverage方法来适应新的需求变化，这违背了“开-闭原则”。

所以这时候，我们就可以用策略模式来解决这个问题。策略模式中有一个上下文角色，它里面有计算平均数的方法，这个方法依赖于策略，选用什么样的策略决定使用哪种方式去计算平均数。

public double computeAverage(double[] a) {

    double score = 0, sum = 0;

    for (int i = 0; i < a.length; i++) {

        sum += a[i];

    }

    score = sum / a.length;

    return score;

}

策略模式图解

3. 优点

1). 上下文(Context)和具体策略(ConcreteStrategy)是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例，但不需要知道具体是哪一个类。

2). 策略模式满足“开-闭原则”。当增加新的具体策略时，不需要修改上下文类的代码，上下文就可以引用新的具体策略的实例。

4. 缺点

1). 策略类数量增多，每个策略都是一个类，复用的可能性很小，类数量增多。

2). 所有的策略都需要对外暴露，上层模块必须知道有哪些策略，然后才能知道采用哪种策略。

二、角色与实现

1. 角色

1). 策略(Strategy): 策略是一个接口，该接口定义若干个算法标识，即定义若干个抽象方法。

2). 上下文(Context): 上下文是依赖于策略接口的类，即上下文包含策略声明的变量。上下文中提供一个方法，该方法委托策略变量调用具体策略所实现的策略接口中的方法。

3). 具体策略(ConcreteStrategy): 具体策略是实现策略接口的类。具体策略实现策略接口所定义的抽象方法，即给出算法所标识的具体算法。

2. 实现

假设我们有两个需求：计算一个数组中所有数的平均数；计算一个数组中除去最大最小值后的数的平均数。

1). 策略接口。

public interface Strategy {

public double computeAverage(double[] a);

}

2). A策略，提供了计算平均数的具体方法。

public class StrategyA implements Strategy {

    @Override

    public double computeAverage(double[] a) {

        double score = 0, sum = 0;

        for (int i = 0; i < a.length; i++) {

        sum += a[i];

    }

    score = sum / a.length;

    return score;

    }

}

2). B策略，提供了计算平均数的具体方法。

public class StrategyB implements Strategy {

    @Override

    public double computeAverage(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 += a[i];

        }

        score = sum / (a.length - 2);

return score;

    }

}

3). 上下文，类名为AverageScore，提供了计算平均数的方法。

public class AverageScore {

    Strategy strategy;

    public void setStrategy(Strategy strategy) {

        this.strategy = strategy;

    }

    public double getAverage (double[] a) {

        if (strategy != null) {

            return strategy.computeAverage(a);

        } else {

            System.out.println("没有平均值的算法，得到的-1不代表平均值");

            return -1;

        }

    }

}

4). Person类。

public class Person {

    String name;

    double score;

    public void setScore(double t) {

        score = t;

    }

    public void setName(String s) {

        name = s;

    }

    public double getScore() {

        return score;

    }

    public String getName() {

        return name;

    }

}

5). Application类，封装了main方法，用于启动程序。

public class Application {

    public static void main(String[] args) {

        AverageScore game = new AverageScore(); //上下文对象game

        game.setStrategy(new StrategyA());

        Person zhang = new Person();

        zhang.setName("张三");

        double[] a = {9.12, 9.25, 8.87, 9.99, 6.99, 7.88};

        double aver = game.getAverage(a);

        zhang.setScore(aver);

        System.out.println("算法A:");

        System.out.println(zhang.getName() + "最后得分：" + zhang.getScore());

        game.setStrategy(new StrategyB());

        aver = game.getAverage(a);

        zhang.setScore(aver);

        System.out.println("算法B:");

        System.out.println(zhang.getName() + "最后得分：" + zhang.getScore());

    }

}