JAVA设计模式详解（一）----------策略模式
策略模式，顾名思义就是设计一个策略算法，然后与对象拆分开来将其单独封装到一系列策略类中，并且它们之间可以相互替换。首先LZ举一个例子为大家引出这一个模式。
例子：某公司的中秋节奖励制度为每个员工发放200元，现在我们设计一个员工基类，
public class Staff {
public void payOff(){
System.out.println("发工资200");
}
}
然后让公司各个职位继承它。（普通员工GeneralStaff 项目经理ProjectManager,部门经理DivisionManager）
现在，公司高管突然下了一个决定，公司开始实施按职位发放节日奖励，除了每个人发放的200元奖励外，项目经理还将获得糖果，而部门经理讲获得月饼。这时，你可能会想在staff中添加一个发奖励方法，然后子类分别进行重写
//普通员工GeneralStaff 项目经理ProjectManager,部门经理DivisionManager
class GeneralStaff extends Staff{
@Override
public void grantReward() {
System.out.println("什么都不发");
}
}
class ProjectManager extends Staff{
@Override
public void grantReward() {
System.out.println("发糖");
}
}
class DivisionManager extends Staff{
@Override
public void grantReward() {
System.out.println("发月饼");
}
}
但是，这样做会导致重复代码量增多，而且业务逻辑过于耦合。那么我们怎样做可以消除这些问题呢？这时我们应该想到了：接口。我们把凡是各不相同的东西抽出来，封装到一个独立的接口里，然后分别写出一系列的实现类去完成算法，
interface GrantReward{
public void grantReward();
}
class GrantSuger implements GrantReward{
@Override
public void grantReward() {
System.out.println("发糖");
}
}
class GrantMoonCake implements GrantReward{
@Override
public void grantReward() {
System.out.println("发月饼");
}
}
class GrantNone implements GrantReward{
@Override
public void grantReward() {
System.out.println("什么都不发");
}
}
，而在Staff基类中增加此接口的引用，并将发放奖励的算法交由接口的实现类来完成，而对算法的选择则交由子类去做，注意这里我们提供set方法，而不是提供构造器
public abstract class Staff {
private GrantReward grantReward;
public void payOff(){
System.out.println("发工资200");
}
public void grantReward(){
grantReward.grantReward();
}
public void setGrantReward(GrantReward grantReward) {
this.grantReward = grantReward;
}
}
这样我们的子类继承后，只需要选择实现类来实例化grantReward即可
//普通员工GeneralStaff 项目经理ProjectManager,部门经理DivisionManager
class GeneralStaff extends Staff{
public GeneralStaff(){
this.setGrantReward(new GrantNone());
}
}
class ProjectManager extends Staff{
public ProjectManager(){
this.setGrantReward(new GrantSuger());
}
}
class DivisionManager extends Staff{
public DivisionManager(){
this.setGrantReward(new GrantMoonCake());
}
}
我们写一个测试类来看看结果如何：
1 public static void main(String[] args) {
2 GeneralStaff generalStaff = new GeneralStaff();
3 ProjectManager projectManager = new ProjectManager();
4 DivisionManager divisionManager = new DivisionManager();
5 generalStaff.grantReward();//普通员工
6 projectManager.grantReward();//项目经理
7 divisionManager.grantReward();//部门经理
8 generalStaff.setGrantReward(new GrantMoonCake());
9 generalStaff.grantReward();
10 }
第八行中，我们在行为上动态的更改了一下接口的实现类，发现结果也因此而改变，普通员工也是有月饼的！ =。=
那么这样设计有什么好处呢？我们来看，这样的设计可以让发放月饼和糖的动作被其他对象复用，因为这些行为已经与员工类无关了，而我们可以新增一些行为，不会影响到既有的行为类，也不会影响“使用”到发这些奖励的行为的员工类。而上面我们之所以不用构造器却改用set方法，目的是我们不对具体实现编程，而是在运行时可以轻易地改变它。这里我们发现，代码由“是一个”变成了“有一个”，“有一个”即为组合，这里我们可以得到一个设计原则：多用组合，少用继承。如你所见，使用组合建立系统具有很大的弹性，不仅可将算法封装成类，更可以在运行时动态地改变行为，只要组合的行为对象符合正确的接口标准即可。
没错，这就是LZ今天要说的策略模式。现在，我们来详细分析一下策略模式的结构，这个结构相信在有了LZ之前的一个小例子后各位已经很容易能够看懂。：
Strategy模式有下面的一些优点：
1) 相关算法系列 Strategy类层次为Context定义了一系列的可供重用的算法或行为。 继承有助于析取出这些算法中的公共功能。
2) 提供了可以替换继承关系的办法： 继承提供了另一种支持多种算法或行为的方法。你可以直接生成一个Context类的子类，从而给它以不同的行为。但这会将行为硬行编制到 Context中，而将算法的实现与Context的实现混合起来,从而使Context难以理解、难以维护和难以扩展，而且还不能动态地改变算法。最后你得到一堆相关的类 , 它们之间的唯一差别是它们所使用的算法或行为。 将算法封装在独立的Strategy类中使得你可以独立于其Context改变它，使它易于切换、易于理解、易于扩展。
3) 消除了一些if else条件语句 ：Strategy模式提供了用条件语句选择所需的行为以外的另一种选择。当不同的行为堆砌在一个类中时 ,很难避免使用条件语句来选择合适的行为。将行为封装在一个个独立的Strategy类中消除了这些条件语句。含有许多条件语句的代码通常意味着需要使用Strategy模式。
4) 实现的选择 Strategy模式可以提供相同行为的不同实现。客户可以根据不同时间 /空间权衡取舍要求从不同策略中进行选择。
Strategy模式缺点:
1)客户端必须知道所有的策略类，并自行决定使用哪一个策略类: 本模式有一个潜在的缺点，就是一个客户要选择一个合适的Strategy就必须知道这些Strategy到底有何不同。此时可能不得不向客户暴露具体的实现问题。因此仅当这些不同行为变体与客户相关的行为时 , 才需要使用Strategy模式。
2 ) Strategy和Context之间的通信开销 ：无论各个ConcreteStrategy实现的算法是简单还是复杂, 它们都共享Strategy定义的接口。因此很可能某些 ConcreteStrategy不会都用到所有通过这个接口传递给它们的信息；简单的 ConcreteStrategy可能不使用其中的任何信息！这就意味着有时Context会创建和初始化一些永远不会用到的参数。如果存在这样问题 , 那么将需要在Strategy和Context之间更进行紧密的耦合。
3 )策略模式将造成产生很多策略类：可以通过使用享元模式在一定程度上减少对象的数量。 增加了对象的数目 Strategy增加了一个应用中的对象的数目。有时你可以将 Strategy实现为可供各Context共享的无状态的对象来减少这一开销。任何其余的状态都由 Context维护。Context在每一次对Strategy对象的请求中都将这个状态传递过去。共享的 Strategy不应在各次调用之间维护状态。
