设计套路-策略套路

定义

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

使用场景

针对同一类型问题的多种处理方式，仅仅是具体行为有差别时。

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

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

优点

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

耦合度相对而言较低，扩展方便

操作封装也更为彻底，数据更为安全。

随着策略的增加，子类也会变得繁多。

关键类

策略的顶级接口，策略的具体实现类，策略的上下文环境类

在Android 源码的应用

Android 动画插值器。

好了，又是一对概念，优缺点，场景等官方的话，但是往往定义也是很重要的，下面继续生活场景。

生活实例

我们继续说王二麻子的故事，上次土地登记错误，提交了报告，本身想的会解决掉，但是由于各种原因，还办成这件事，所以王二麻子焦急了，打算去另一个城市找一下自己的朋友寻求帮助，由于距离比较远，王二麻子向的怎么去，有三种办法目前，坐飞机，坐火车，坐汽车，好，我们现在就设计一下代码，送王二麻子去见朋友。

封装出行方式类:

public class Traffic {
    public static void air(){  //飞机
        System.out.print("800");
    }
    public static void train(){  //火车
        System.out.print("300");
    }
    public static void bus(){    //长途汽车
        System.out.print("400");
    }
}

测试类

public class MyClass {
    public static void main(String[] args) {
        Traffic.air();
        Traffic.train();
        Traffic.bus();
    }
}

这里我们很简单的直接调用Traffic类的静态方法就可以让王二麻子选择出行方式，这样看起来很好很正常，但是也明显有弊端，假如王二麻子想要坐私家车出行，这个就得再向traffic类里面加一个静态方法，这样随着出行的方式的增加我们这个类一只在修改，这样违反了开闭原则，而且类变的越来越大，变得难以维护后期。所以我们就得考虑用一个套路-策略套路。
接下来我们用策略套路来给王二麻子设计出行路线：

所有方式的顶级接口

public interface CommonTraffic {
    void getPrice();
}

飞机类

public class Air implements CommonTraffic {
    @Override
    public void getPrice() {
        System.out.print(800);
    }
}

火车类

public class Train implements CommonTraffic {
    @Override
    public void getPrice() {
        System.out.print(300);
    }
}

汽车类

public class Bus implements CommonTraffic {
    @Override
    public void getPrice() {
        System.out.print(400);
    }
}

王二麻子直接调用的交通类

public class Traffic {

    private CommonTraffic traffic;

    public void getPrice() {
        traffic.getPrice();
    }

    public void setTraffic(CommonTraffic traffic) {
        this.traffic = traffic;
    }
}

这个中间类很重要，它是策略模式的关键。

测试类

public class MyClass {
    public static void main(String[] args) {
        Traffic traffic = new Traffic();   //创建交通类
        Air air = new Air();       //选择要出行的方式
        traffic.setTraffic(air);    //设置给交通类
        traffic.getPrice();      //获取出行价格
    }
}

接下来我们再看王二麻子打算私家车出行，那么，只需要创建一个私家车类，然后设置给traffic就可以。这样很好的满足了开闭原则，架构上很清晰，不会因为修改某一种出行方式而可能影响其他类,高度解耦，这就是策略模式的好处。
下面我们再举一个Android开发中遇到的使用策略模式的情况：
比如我们自定义了一个View:

public class CustomView extends View {
    private ICustomView customBean;

    public CustomView(Context context) {
        super(context);
    }

    public CustomView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    public CustomView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        customBean.getViewName();
        customBean.getViewAge();
        customBean.getViewAddress();
        customBean.getViewMotto();
    }

    public void setData(ICustomView bean){
        this.customBean = bean;
    }
}

实体类：

interface ICustomView {
    public String getViewName();

    public int getViewAge();

    public String getViewAddress();

    public String getViewMotto();
    //...
}

上面我们自定义了一个view，数据就是通过public void setData(ICustomView bean)这个方法设置，而ICustomView这个接口里面有很多字段获取方法，那么我们可能会在很多地方都用到这个自定义view,但是服务器给的字段名字不可能一样，那么怎么办?我们用策略套路，让所有的使用自定义view的数据类都继承一个公共的接口，这个接口提供返回统一数据的方法，这样就实现了复用，这其实也是策略模式的一种。

总结

第二篇就这样结束了，都是根据自己的理解和碰到的问题写的，定义优缺点已经总结到上面，看完例子大家再去看一下定义这些东西，可能会理解很多。