策略模式

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。那么我们就来点实际的。
比如我们要写一个比较通用的排序，如果是八种基本类型，一个类型写一个排序方法，那么如果我们要对各种各样的对象数组进行排序呢，比如猫、狗、人、车...，不同的对象排序方法不同，以体重给猫排序，以身高给人排序，以速度给车排序等等，每一种不同的排序方式就是一个策略，那么我们要写一个比较通用的排序方法，开始吧：（java当中的Comparator就是一种策略模式，模仿一下）
1、Cat类

package com.mashibing.strategy;
public class Cat implements Comparable<Cat>{
    int weight, height;
    public Cat(int weight, int height){
        this.weight = weight;
        this.height = height;
    }
    @Override
    public String toString() {
        return "Cat{" +
                "weight=" + weight +
                ", height=" + height +
                '}';
    }
}

2、Dog类

package com.mashibing.strategy;
public class Dog implements Comparable<Dog>{
    int food; //饭量
    public Dog(int food) {
        this.food = food;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "food=" + food +
                '}';
    }
}

3、Comparator：自己写一个Comparator接口，不同的策略都实现此接口

package com.mashibing.strategy;
public interface Comparator<T> {
    int compare(T o1, T o2);
}

4、CatWeightComparator：定义一个猫的排序策略，根据猫的体重进行排序

package com.mashibing.strategy;
public class CatWeightComparator implements Comparator<Cat>{
    @Override
    public int compare(Cat o1, Cat o2) {
        if(o1.weight < o2.weight) return -1;
        if(o1.weight > o2.weight) return 1;
        return 0;
    }
}

5、CatHeightComparator：定义一个猫的排序策略，根据猫的身高进行排序

package com.mashibing.strategy;
public class CatHeightComparator implements Comparator<Cat>{
    @Override
    public int compare(Cat o1, Cat o2) {
        if(o1.height > o2.height) return -1;
        if(o1.height < o2.height) return 1;
        return 0;
    }
}

6、DogComparator：定义一个够的排序策略，根据狗的饭量进行排序

package com.mashibing.strategy;
public class DogComparator implements Comparator<Dog>{
    @Override
    public int compare(Dog o1, Dog o2) {
        if(o1.food < o2.food) return -1;
        if(o1.food > o2.food) return 1;
        return 0;
    }
}

7、最后，来实现排序器：

package com.mashibing.strategy;
//此类当中假设8种基本类型的排序算法已写好，懒得写了，哈哈哈，将就看吧
public class Sorter<T> {
    //进行排序的时候需要将被排序数组，以及根据什么排序策略进     //行排序传进来
    public void sort(T[] arr, Comparator<T> comparator){
        for(int i = 0; i < arr.length; i++) {
            int minPos = i;
            for(int j = i+1; j < arr.length; j++){
                minPos = comparator.compare(arr[j], arr[minPos]) == -1 ? j : minPos;
            }
            swap(arr, i, minPos);
        }
    }
    
   public void swap(T[] arr, int i, int j){
        T temp = arr[j];
        arr[j] = arr[i];
        arr[i] = temp;
    }
}

8、测试类 Test

package com.mashibing;
import com.mashibing.strategy.*;
import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
    //  Dog[] a = {new Dog(3), new Dog(5),new Dog(1)};
        Cat[] a = {new Cat(3,3), new Cat(5,5),new Cat(1,1)};
        Sorter<Cat> sorter = new Sorter<>();
        sorter.sort(a, new CatHeightComparator());
        System.out.println(Arrays.toString(a));
    }
}

总结一下：大概就是这个意思了，你要让我一个排序器给你排序，那么你得告诉我，你根据什么东西来排序，那么这个东西就是策略了，如果以后我要对猴子进行排序，那么我只需定义猴子的排序策略，并告诉我的排序器，它便乖乖的有序了