策略模式

策略模式是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类的子类。

下面用比较器的实现来解释一下策略模式：

涉及到三个角色：

　　●　　环境(Client)角色：持有一个Strategy的引用。

　　●　　抽象策略(ComparatorStrategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

　　●　　具体策略(Strategy)角色：包装了相关的算法或行为。

 具体的比较方法Sorter:

public class Sorter<T> {

    public void sort(T[] arr, Comparator<T> comparator) {
        for(int i=0; i<arr.length - 1; 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);
        }
    }

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

 比较器的抽象策略接口：

public interface Comparator<T> {
    int compare(T o1, T o2);
}	

具体的策略实现：

public class CatHightComparator implements Comparator<Cat> {
    //用猫的身高去比较
    @Override
    public int compare(Cat o1, Cat o2) {
        if(o1.weight < o2.weight) return -1;
        else if (o1.weight > o2.weight) return 1;
        else return 0;
    }
}

public class CatWeightComparator implements Comparator<Cat> {
    //用猫的体重去比较
    @Override
    public int compare(Cat o1, Cat o2) {
        if(o1.weight < o2.weight) return -1;
        else if (o1.weight > o2.weight) return 1;
        else return 0;
    }	
}

public class DogComparator implements Comparator<Dog> {
    //用狗的食物来比较
    @Override
    public int compare(Dog o1, Dog o2) {
        if(o1.food < o2.food) return -1;
        else if (o1.food > o2.food) return 1;
        else return 0;
    }
}

测试:

public static void main(String[] args) {
        Cat[] a = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};
        //Dog[] a = {new Dog(3), new Dog(5), new Dog(1)};
        Sorter<Cat> sorter = new Sorter<>();
        //使用猫的体重的比较策略
        sorter.sort(a, new CatWeightComparator());
        System.out.println(Arrays.toString(a));
    }