引入

大家先考虑一个场景, 有一个整形数组, 我们希望通过调用一个工具类的排序方法就能对该数组进行排序. 请看下面的代码:

public class strategy {
    public static void main(string[] args) {
        int[] arr = {5, 3, 1, 7, 2};
        new datasorter().sort(arr);//调用工具类进行排序
        for(int i = 0; i < arr.length; i++){
            system.out.println(arr[i]);
        }
    }
}

class datasorter{//用于排序的工具类
    public void sort(int[] arr){//调用sort方法进行排序, 此处使用冒泡排序
        for(int i = arr.length - 1; i > 0; i--){
            for(int j = 0; j < i; j++){
                if(arr[j] > arr[j + 1])
                    swap(arr, j, j  + 1);
            }
        }
    }

    private void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

comparable接口的来龙去脉

通过上面的代码, 我们能够轻易地对整形数组进行排序, 那么如果现在有了新需求, 需要对浮点类型数据进行排序, 排序工具类应该如何做呢?
或许你会想, 不如就新添加一个排序方法, 方法的参数类型为float类型, 把int类型数组的排序算法复制一遍不就可以了吗?
那如果我继续追问, 如果现在要对一只猫进行排序, 那应该怎么做呢? 猫的类如下

class cat{
    private int age;//猫的年龄
    private int weight;//猫的体重

    //get / set 方法...
}

你也许会顺着原来的思路回答, 照样copy一份排序的算法, 修改方法参数, 然后在比较的地方指定比较猫的年龄或体重不就可以了吗?

public void sort(cat[] arr){//以猫数组作为参数
    for(int i = arr.length - 1; i > 0; i--){
        for(int j = 0; j < i; j++){
            if(arr[j].getage() > arr[j + 1].getage())//根据猫的年龄作比较
                swap(arr, j, j  + 1);
        }
    }
}

但仔细想想, 如果还要继续比较小狗, 小鸡, 小鸭等各种对象, 那么这个排序工具类的代码量岂不是变得很大? 为了能让排序算法的可重用性高一点, 我们希望排序工具中的sort()方法可以对任何调用它的对象进行排序.
你可能会想: 到对任何对象都能排序, 把sort()方法的参数改为object类型不久可以了嘛. 这个方向是对的, 但是问题是, 当拿到两个object类型对象, 应该根据什么规则进行比较呢?
这个时候我们自然而然地就希望调用工具类进行排序的对象本身就具备自己的比较法则, 这样在排序的时候就能直接调用对象的排序法则进行排序了.
我们把比较法则抽象为comparable接口, 凡是要进行比较的类都要实现comparable接口, 并且定义自己的比较法则, 也就是compareto()方法.
这样当我们在封装工具时, 就可以直接对实现了comparable接口的对象进行比较, 不用担心比较的细节了.

public class strategy {
public class strategy {
    public static void main(string[] args) {
//      integer[] arr = {5, 3, 1, 7, 2};//注意这里把int改为integer, integer是object的子类
        cat[] arr = {new cat(3, 3), new cat(1, 1), new cat(5, 5)};
        datasorter ds = new datasorter();
        ds.sort(arr);
        for(int i = 0; i < arr.length; i++){
            system.out.println(arr[i]);
        }
    }
}
}

class datasorter{//用于排序的工具类
    public void sort(object[] arr){//参数类型为object
        for(int i = arr.length - 1; i > 0; i--){
            for(int j = 0; j < i; j++){
                comparable c1 = (comparable) arr[j];//先转为comparable类型
                comparable c2 = (comparable) arr[j + 1];
                if(c1.compareto(c2) == 1)//调用compareto()进行比较, 不关心具体的实现
                    swap(arr, j, j  + 1);
            }
        }
    }

    private void swap(object[] arr, int i, int j){
        object temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

class cat implements comparable{
    private int age;
    private int weight;

    @override
    public int compareto(object o) {
        if(o instanceof cat){//先判断传入的是否是cat类对象, 不是则抛异常
            cat c = (cat) o;
            if(this.age > c.age) return 1;
            else if (this.age < c.age) return -1;
            else return 0;
        }
        throw null == o ? new nullpointerexception() : new classcastexception();
    }

    // get / set ...
    //tostring() ...
}

interface comparable{
    public int compareto(object o);
}

引入comparator接口

相信看了上面的comparable接口来由, 大家会感觉整个设计又美好了一些, 但是其中还有漏洞. 我们在cat类的compareto()方法中, 对猫的比较策略是写死的, 现在我们按猫的年龄比较大小, 如果哪天我们想按照猫的体重比较大小, 又要去修改源码了. 有没有扩展性更好的设计?
我们可以让用户自己定义一个比较器类, 对象可以根据用户指定的比较器比较大小.
整个逻辑是: 如果这个对象需要进行比较, 那么它必须实现comparable接口, 但是它具体是怎么比较的, 则通过具体的comparator比较器进行比较.
当然这里少不了多态, 我们首先要定义一个比较器接口comparator, 用户的比较器需要实现comparator接口, 下面上代码:

public class strategy {
    public static void main(string[] args) {
        cat[] arr = {new cat(3, 3), new cat(1, 1), new cat(5, 5)};
        datasorter ds = new datasorter();
        ds.sort(arr);
        for(int i = 0; i < arr.length; i++){
            system.out.println(arr[i]);
        }
    }
}

class datasorter{//用于排序的工具类
    public void sort(object[] arr){//参数类型为object
        for(int i = arr.length - 1; i > 0; i--){
            for(int j = 0; j < i; j++){
                comparable c1 = (comparable) arr[j];//先转为comparable类型
                comparable c2 = (comparable) arr[j + 1];
                if(c1.compareto(c2) == 1)//背后已经转换为使用comparator的定义的规则进行比较
                    swap(arr, j, j  + 1);
            }
        }
    }

    private void swap(object[] arr, int i, int j){
        object temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

class cat implements comparable{
    private int age;
    private int weight;
    private comparator comparator = new catagecomparator();//默认持有年龄比较器

    @override
    public int compareto(object o) {
        return comparator.compare(this, o);//调用比较器比较而不是直接在此写比较法则
    }

    // get / set / tostring ...
}

interface comparable{
    public int compareto(object o);
}

interface comparator{
    public int compare(object o1, object o2);
}

//用户自己定义的, 按照猫的年龄比较大小的比较器
class catagecomparator implements comparator{
    @override
    public int compare(object o1, object o2) {
        cat c1 = (cat) o1;
        cat c2 = (cat) o2;
        if(c1.getage() > c2.getage()) return 1;
        else if(c1.getage() < c2.getage()) return -1;
        else return 0;
    }
}

//按照猫的体重比较大小的比较器
class catweightcomparator implements comparator{
    @override
    public int compare(object o1, object o2) {
        cat c1 = (cat) o1;
        cat c2 = (cat) o2;
        if(c1.getweight() > c2.getweight()) return 1;
        else if(c1.getweight() < c2.getweight()) return -1;
        else return 0;
    }
}

什么是策略模式?

在上面的例子中, 我们自己定义了comparable接口和comparator接口, 其实这两个接口都是java自带的, 通过上面的代码示例, 想必大家也应该知道了为什么会有这两个接口.
其实comparable定义的就是一种比较的策略, 这里的策略你可以理解为一个功能, 然而策略有了, 我们还需要有具体的策略实现, 于是便有了comparator接口.

这里再举一个例子方便大家理解.
现在有一个坦克小游戏, 坦克要能够发射炮弹, 那么我们可以认为发射炮弹就是一种策略, 但是具体到发送什么炮弹, 这可以由具体的策略实现.
到github上看看该坦克游戏
首先定义发射炮弹这种策略

public interface fire {
    public void fire();//发射炮弹的策略
}

为了实现发射炮弹这种策略, 定义策略的具体实现, 也就是定义发射炮弹动作

public interface fireaction {
    public void fireaction(tank tank);
}

坦克想要发送炮弹必须实现fire()接口, 而且坦克拥有发射炮弹的动作, 至于动作的具体实现, 这里默认给出只发射一颗炮弹的动作.

public class tank implements tankhitlistener, fire {
    //省略各种属性方法...
    private fireaction fireaction = new normalfireaction();//默认动作是只发射一颗炮弹
    
    @override
    public void fire() {
        fireaction.fireaction(this);
    }
    
    //...

使用了策略模式有什么好处?

以上面的坦克游戏为例, 当把发射炮弹定义为一种策略后, 能发射炮弹的对象就不只坦克一个了, 如果游戏中有机关, 可以让机关也实现fire()接口, 获得发射炮弹的能力.
而且在定义策略后我们可以根据策略给出不同的实现方式, 比方说坦克发射炮弹的动作是每次只发射一颗炮弹, 而机关是每次向八个方向发射一颗炮弹. 非常灵活.
结束