策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。

本文地址：http://www.cnblogs.com/wuyudong/p/5924223.html，转载请注明源地址。

策略模式的结构

　　策略模式是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是：“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。下面就以一个示意性的实现讲解策略模式实例的结构。

这个模式涉及到三个角色：

　　●　环境(Context)角色：持有一个Strategy的引用。

　　●　抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

　　●　具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。

策略模式的使用场景：

1）针对同一种问题的多种处理方式、仅仅是因为具体行为有差别时，

2）需要安全的封装多种同一类型的操作时

3）出现同一抽象类有多个子类，而又需要使用if-else或者switch-case来选择具体子类时。

策略模式的实现

举个例子，计算公交车和地铁运行指定路程后所需的票价

package com.wuyudong.strategy.normal;

public class PriceCalculator {
    // 公交车类型
    private static final int BUS = 1;
    // 地铁类型
    private static final int SUBWAY = 2;

    public static void main(String[] args) {
        PriceCalculator calculator = new PriceCalculator();
        System.out.println("坐10公里的公交车的票价为："
                + calculator.calculatePrice(10, BUS));
        System.out.println("坐10公里的地铁的票价为："
                + calculator.calculatePrice(10, SUBWAY));

    }
    
    //计算公交价格
    private int busPrice(int km) {
        int extraTotal = km - 10;
        int extraFactor = extraTotal / 5;
        int fraction = extraTotal % 5;
        int price = 1 + extraFactor * 1;
        return fraction > 0 ? ++price : price;
    }

    //计算地铁价格
    private int subwayPrice(int km) {
        if (km <= 6) {
            return 3;
        } else if (km > 6 && km < 12) {
            return 4;
        } else if (km < 22 && km > 12) {
            return 5;
        } else if (km < 32 && km > 22) {
            return 6;
        }
        return 7;
    }

    //根据类型来计算相应的价格
    private int calculatePrice(int km, int type) {
        if (type == BUS) {
            return busPrice(km);
        } else {
            return subwayPrice(km);
        }
    }
}

如果再添加一种出租车的价格计算，添加相应的代码：

public class PriceCalculator {
    // 公交车类型
    private static final int BUS = 1;
    // 地铁类型
    private static final int SUBWAY = 2;

    // 出租车类型
    private static final int TAXI = 3;

    public static void main(String[] args) {
        PriceCalculator calculator = new PriceCalculator();
        System.out.println("坐10公里的公交车的票价为："
                + calculator.calculatePrice(10, BUS));
        System.out.println("坐10公里的地铁的票价为："
                + calculator.calculatePrice(10, SUBWAY));

    }

    // 计算出租车价格
    private int taxiprice(int km) {
        return km * 2;
    }

    // 根据类型来计算相应的价格
    private int calculatePrice(int km, int type) {
        if (type == BUS) {
            return busPrice(km);
        } else if (type == SUBWAY) {
            return subwayPrice(km);
        } else {
            return taxiprice(km);
        }
    }
}

可见上面的代码耦合性较高，每当增加新的交通工具类型的时候，需要不断的修改大量的代码，这里使用策略模式重构：

首先定义一个抽象的价格计算接口：

//计算接口
public interface CalculateStrategy {
    int calculatePrice(int km);
}

每一种出行方式都定义一个独立的计算策略类：

公交车计算策略

public class BusStrategy implements CalculateStrategy {
    public int calculatePrice(int km) {
        int extraTotal = km - 10;
        int extraFactor = extraTotal / 5;
        int fraction = extraTotal % 5;
        int price = 1 + extraFactor * 1;
        return fraction > 0 ? ++price : price;
    }

}

地铁计算策略

public class SubwayStrategy implements CalculateStrategy {

    public int calculatePrice(int km) {
        if (km <= 6) {
            return 3;
        } else if (km > 6 && km < 12) {
            return 4;
        } else if (km < 22 && km > 12) {
            return 5;
        } else if (km < 32 && km > 22) {
            return 6;
        }
        return 7;
    }
}

再创建一个扮演Context的角色，代码如下：

public class TranficCalculator {
    CalculateStrategy mStrategy;
    
    public static void main(String[] args) {
        TranficCalculator calculator = new TranficCalculator();
        //设置计算策略
        calculator.setStrategy(new BusStrategy());
        //计算价格
        System.out.println("公交车乘10公里的价格：" + calculator.calculatePrice(10));
        
    }
    
    public void setStrategy(CalculateStrategy mStrategy) {
        this.mStrategy = mStrategy;
    }
    public int calculatePrice(int km) {
        return mStrategy.calculatePrice(km);
    }
}

这样即使需要添加出租车的价格计算，只需要简单的新建一个类，让其继承自CalculateStrategy接口并实现其中的方法即可

优点

1）结构清晰明了、使用简单直观

2）耦合度相对较低，扩展方便

3）操作封装因为更为测地、数据更为安全

缺点

子类增多