主目录见：Android高级进阶知识（这是总目录索引）
 策略模式应该说应用也是非常广泛，而且很容易使用。有的人可能用到了但是没有意识到，那么我们今天会让大家意识到而且能在特定的场景中使用到他。我们这里先来看看他的定义：

策略模式定义了一些列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变换。

这里的算法意思不是传统的算法，其实就是一个action，就是一个独立的执行逻辑。策略模式可以独立出来这些逻辑，然后在特定场景选择特定的执行逻辑。接着我们来看看他的UML类图：

策略模式

角色介绍：

• IStrategy:策略接口，定义了各个策略的公共接口
• ConcreteStrategy:具体的策略类，里面实现了策略接口中的策略方法。
• Context:用来操作各个策略的，利用具体的策略类进行各种策略执行。

一.目标

我们今天的目标跟之前讲的设计模式也是一样，我们在明白别人使用的场景的时候自己遇到的时候也能利用起来。所以今天目标也同样是：
1.学会策略模式在什么场景下使用；
2.能在自己编写框架的时候用上这个设计模式。

二.模式解析

首先也是我们这里先假设一个场景：我们大学编程的时候，遇到一个编程题目解不出来，那么这时候有几种情况可以解决。一个是查看答案，一个是求教同学，一个是请教老师。那我们平常写代码可能是这样：

public class StrategyPatternMain {
    
    enum Strategy{
        CHECK_ANSWER,SEARCH_HELP,CONSULT_TEACHER
    }
    
    private Strategy strategy;
    public StrategyPatternMain(Strategy strategy){
        super();
        this.strategy = strategy;
    }
    
    public void doAction(){
        switch (strategy) {
        case CHECK_ANSWER:
            System.out.println("查看答案");
            break;
        case SEARCH_HELP:
            System.out.println("请教同学");
            break;
        case CONSULT_TEACHER:
            System.out.println("请教老师");
            break;
        default:
            break;
        }
    }

    public static void main(String[] args) {
        StrategyPatternMain homeWorkStrategy = new StrategyPatternMain(Strategy.SEARCH_HELP);
        homeWorkStrategy.doAction();
        
        StrategyPatternMain homeWorkStrategy2 = new StrategyPatternMain(Strategy.CHECK_ANSWER);
        homeWorkStrategy2.doAction();
        
        StrategyPatternMain homeWorkStrategy3 = new StrategyPatternMain(Strategy.CONSULT_TEACHER);
        homeWorkStrategy3.doAction();

    }
}

可以看到，完美有没有，你来一个新的方式我这边可以再增加一个case，灵活有没有。然后最后你想到方法越来越多，这个类就被修改了无数遍，代码就是一坨一坨的，这时候你想，不行呀，我应该让他可以组装呀，而且不影响原有的代码。那么策略模式就蹦出来了。

1.策略模式

我们这里解决这个扩展困难问题，我们这里引入策略模式，首先我们先来看看策略接口：

public interface IStrategy {
    void doAction();
}

这个策略接口类很简单，就是一个方法，然后我们来看看几个具体策略类：

public class CheckAnswer implements IStrategy {

    @Override
    public void doAction() {
        System.out.println("查看答案");
    }
}

public class SearchHelp implements IStrategy {

    @Override
    public void doAction() {
        System.out.println("请教同学");
    }
}

public class ConsultTeacher implements IStrategy {

    @Override
    public void doAction() {
        System.out.println("请教老师");
    }
}

我们看到几个策略类也是非常简单的，就是简单地执行各自的打印动作。然后我们看下Context类：

public class Context {
    private IStrategy strategy;
    
    public void setStrategy(IStrategy strategy){
        this.strategy = strategy;
    }
    
    public void doAction(){
        strategy.doAction();
    }
}

我们看到这里面持有了一个策略类的引用，然后在方法里面调用相应的action。我们看下这个怎么使用：

        IStrategy checkAnswer = new CheckAnswer();
        IStrategy searchHelp = new SearchHelp();
        IStrategy consultTeacher = new ConsultTeacher();
        
        Context context = new Context();
        context.setStrategy(checkAnswer);
        context.doAction();
        
        context.setStrategy(searchHelp);
        context.doAction();
        
        context.setStrategy(consultTeacher);
        context.doAction();

我们看到这边如果增加了寻找解决问题的方法，我们只要增加一个具体策略类，然后在使用的时候，设置进去就可以了，这样的话面对扩展就非常地方便。这也是我们为啥要使用这个模式的原因。

2.属性动画中策略模式的使用

属性动画中的插值器(Interpolator)和估值器(Evaluator)的使用就是用的策略模式，我们先来看下插值器。我们先来看下之前写过一篇[属性动画基础用法]中有个属性用法是这样的：

  Point endPoint = new Point(getWidth() - RADIUS,getHeight() - RADIUS);
        ValueAnimator valueAnimator = ValueAnimator.ofObject(new PointEvaluator(),currentPoint,endPoint);
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator valueAnimator) {
                currentPoint = (Point) valueAnimator.getAnimatedValue();
                invalidate();
            }
        });
//这里设置了插值器
        valueAnimator.setInterpolator(new AccelerateDecelerateInterpolator());
        valueAnimator.setDuration(2000);
        valueAnimator.start();

我们看到这里设置了具体的插值器，那么我们来分析下这里面的策略模式的各个 角色，首先就是Context角色，这个很明显就是ValueAnimator，我们看下他的setInterpolator方法：

  @Override
    public void setInterpolator(TimeInterpolator value) {
        if (value != null) {
            mInterpolator = value;
        } else {
            mInterpolator = new LinearInterpolator();
        }
    }

可以看到这个里面设置了具体插值器的引用。然后我们看看具体插值器也就是具体策略类的实现：

@HasNativeInterpolator
public class LinearInterpolator extends BaseInterpolator implements NativeInterpolatorFactory {

    public LinearInterpolator() {
    }

    public LinearInterpolator(Context context, AttributeSet attrs) {
    }

    public float getInterpolation(float input) {
        return input;
    }

    /** @hide */
    @Override
    public long createNativeInterpolator() {
        return NativeInterpolatorFactoryHelper.createLinearInterpolator();
    }
}

我们看到这个具体插值器继承了BaseInterpolator 并且实现了NativeInterpolatorFactory。这里的BaseInterpolator 实际又实现了Interpolator，然后Interpolator又实现了TimeInterpolator：

public interface TimeInterpolator {
    float getInterpolation(float input);
}

所以TimeInterpolator 我们这里可以当做抽象插值器类也就是抽象策略类。看到这里我们已经把每个策略模式的角色都分出来了。其实是非常简单的，但是达到的效果确实符合程序优秀设计的思想。至于估值器其实也是类似的，这里就不举那么多例子了，大家看懂就可以。其实在Glide里面大家设置缓存策略的时候也会用到策略设计模式，大家有兴趣可以自己也看看。
总结：策略模式使用简单，场景也非常多，记住遇到if-else，switch特别多的场景，同时程序后面可能会变化，条件会增加。这时候往往就是策略模式派上用场的时候，所以我们平常用设计模式的时候要多想多用。