策略模式(Strategy Pattern)
策略模式（Strategy Pattern）
策略模式的定义：
策略模式（Strategy Pattern）也叫做政策模式（Policy Pattern）其定义：定义一组算法，将他们封装起来，使它们可以相互替换。
策略模式的优点：
1. 算法直接可以相互替换。这是因为策略都实现策略接口。
2. 可以避免多重条件的情况出现。假设一个策略家族有N个成员，当一会需要策略A，另一会需要策略B，不使用策略模式的话，只能使用ifelse或switch语句实现，但是这样的程序不容易维护，可读性也比较差。使用策略模式后可以由其他模块确定策略。
3. 有良好的扩展性。增加一个策略，只需要实现策略接口，就这么简单。
策略模式的缺点：
1. 子类膨胀，一个策略一个类，策略类的数量比较惊人。
2. 调用者必须知道所有具体策略的存在（调用一个策略还需要自己new出来）。
策略模式的应用场景：
1. 多个类只在算法或行为稍有不同（在抽象概念上是相同的行为）。
2. 算法需要自由切换。
策略模式的通用类图：
Strategy（抽象策略角色）：定义了每个算法必须有的算法和属性。
StrategyA（具体策略角色）：实现了抽象策略定义的接口。
Context（封装角色）：将策略封装起来，屏蔽了调用者直接访问具体策略。
策略模式的通用代码：
抽象策略角色：
public interface Strategy
{
public void operation();
}
具体策略角色：
public class StrategyA implements Strategy
{
@Override
public void operation()
{
System.out.println("strategyA");
}
}
封装角色：
public class Context
{
private Strategy strategy = null;
public Context(Strategy strategy)
{
this.strategy = strategy;
}
/*实现策略可以相互替换*/
public void replaceStrategy(Strategy strategy)
{
this.strategy = strategy;
}
/*封装角色提供接口，让调用使用策略，屏蔽高层模块直接使用策略*/
public void execute()
{
this.strategy.operation();
}
}
场景类：
public class Client
{
public static void main(String[] args)
{
/*这里可以看出策略模式的缺点，调用者必须要知道调用的策略（自己new出来StrategyA的对象）*/
Context context = new Context(new StrategyA());
context.execute();
/*可以实现自由切换策略*/
context.replaceStrategy(new StrategyB());
context.execute();
}
}
举个比较简单的例子理解策略模式
例子："实现一个可以计算两个整数加减乘除计算的功能"。
实现一：不使用策略模式
class Calculator
{
/*代表加减乘除的字符串，用于判断使用什么计算策略*/
private final static String ADD_SYMBOL = "+";
private final static String SUB_SYMBOL = "-";
private final static String MUL_SYMBOL = "*";
private final static String DIV_SYMBOL = "/";
/*策略选择函数，operator字符串参数用于判断，a、b两个参数使用的计算策略*/
public int execute(int a,int b,String operator)
{
int result = 0;
if(ADD_SYMBOL.equals(operator))
{
result = this.add(a, b);
}
else if(SUB_SYMBOL.equals(operator))
{
result = this.sub(a, b);
}
else if(MUL_SYMBOL.equals(operator))
{
result = this.multi(a, b);
}
else if(DIV_SYMBOL.equals(operator))
{
result = this.div(a, b);
}
return result;
}
/*加法功能实现*/
private int add(int a,int b)
{
return a+b;
}
/*减法功能实现*/
private int sub(int a,int b)
{
return a-b;
}
/*乘法功能实现*/
private int multi(int a,int b)
{
return a*b;
}
/*除法功能实现*/
private int div(int a,int b)
{
//只是为了说明问题，除数为0就不考虑了
return a/b;
}
}
这个实现比较容易想到，通过"operator"这个参数决定使用什么计算策略。这样的实现看上去完美的处理了需求，还是有很多需要改进的地方。首先，扩展性很差——若要添加一个求余的需求，除了改源代码旗本没其他办法了，添加一个需求改一次，这样还了得。其次，可读性不行，别看这个程序看上去还比较清晰，要是考虑上异常、"operator"检查，功能变多后等等就不顺眼了。最后，这个类职责不清晰，又要选择策略又要实现策略。
实现二：使用策略模式
抽象策略角色（定义了每个策略都有的接口）：
public interface IStrategy
{
public int doAction(int a, int b);
}
具体策略角色（实现抽象策略）：
/*实现加法策略*/
public class AddStrategy implements IStrategy
{
@Override
public int doAction(int a,int b)
{
return a+b;
}
}
/*实现除法策略*/
public class DivStrategy implements IStrategy
{
@Override
public int doAction(int a, int b)
{
return a/b;
}
}
/*实现乘法策略*/
public class MultiStrategy implements IStrategy
{
@Override
public int doAction(int a, int b)
{
return a*b;
}
}
/*实现减法策略*/
public class SubStrategy implements IStrategy
{
@Override
public int doAction(int a, int b)
{
return a-b;
}
}
封装角色：
public class StrategyContext
{
private IStrategy strategy = null;
public StrategyContext(IStrategy strategy)
{
this.strategy = strategy;
}
public void replaceStrategy(IStrategy strategy)
{
this.strategy = strategy;
}
public int doAction(int a,int b)
{
return strategy.doAction(a, b);
}
}
场景类：
public class Client
{
public static void main(String[] args)
{
/*计算加法，策略模式自身缺点，必须知道具体策略（自己new出来AddStrategy对象）*/
StrategyContext context = new StrategyContext(new AddStrategy());
int result = context.doAction(2, 2);
System.out.println("result : "+result);
}
}
这是按照常规的策略模式实现加减乘除功能的。这样的实现基本上解决了第一种实现方式的缺点。增加一个功能，只需要实现接口 "IStrategy"，扩展非常简单便捷。if判断语句消失了，可读性大大提高。每个类的职责现在更清晰了。尽管如此，这个实现还是有一个非常大缺点，这个缺点是该模式自身的缺点，就是调用者必须知道具体策略（这个缺点可以使用混合模式解决）。
实现三：枚举策略模式
enum EnumStrategy
{
/*加法策略的实现*/
ADD{
@Override
public int execute(int a, int b)
{
return a+b;
}
},
/*减法策略的实现*/
SUB{
@Override
public int execute(int a, int b)
{
return a-b;
}
},
/*乘法策略的实现*/
MUL{
@Override
public int execute(int a, int b)
{
return a*b;
}
},
/*除法策略的实现*/
DIV{
@Override
public int execute(int a, int b)
{
return a/b;
}
};
abstract public int execute(int a,int b);
}
来看看场景类：
public class EnumStrategyClient
{
public static void main(String[] args)
{
System.out.println(EnumStrategy.ADD.execute(2, 2));
}
}
这种变形的策略模式真是太那个了（省略各种赞叹）....太精妙了，不得不佩服那些牛人，这样的实现，让可读性提高到最高点了，一眼就能看明白。连调用都如此简单（你说更看不懂了-_-!!那不是可读性的问题，是你不理解枚举，每一个枚举值其实是这个枚举类型的一个实例，它默认的前缀是public final static的，他其实和类差不多，只不过编译器为我们做了许多事情）。它扩展性没有实现二好，这是受限于enum类型，所以这种变形可以运用在策略不易改变的地方。
