前言

设计模式：主要关注软件系统的设计的设计，与具体语言无关。

策略模式：定义一系类算法，把它们一个个都封装起来，并且它们之间相互切换，从而让算法可以独立于使用它的用户而变化。

单例模式：行为性模式

速记关键字：多方案切换

图例

实现

引入，对int数组使用选择排序从小到大进行排序

// 对int数组进行从小到大的排序
public class Sorter {
    public void sort(int[] arr)  {
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }
        }
    }
}
//执行
public class Main {
    public static void main(String[] args) {
        int[] a = {9,2,3,5,7,1,4};
        Sorter sorter = new Sorter();
        sorter.sort(a);
        System.out.println(Arrays.toString(a));
    }
}
}
//结果
[1, 2, 3, 4, 5, 7, 9]

如果我们想要对double类型进行排序，那就将int类型改成double类型然后排序，如果是float类型，如果是猫类，狗类进行排序我们又将如何处理。

案例：定义一个狗类，狗有体重和身高，通过体重和身高对狗分别进行排序。

// 定义一个 策略接口，使用泛型，可以对输入类型进行效验。有一个比较方法。具体实现在策略方案中实现
public interface Comparator<T> {
    int compare(T o1,T o2);
}

// 方案一：狗的体重比较器，从小到大进行排列
public class DogWeightComparator implements Comparator<Dog>{
    @Override
    public int compare(Dog o1, Dog o2) {
        if(o1.weight<o2.weight) return -1;
        else if(o1.weight>o2.weight) return 1;
        else return 0;
    }
}

// 方案二：狗的身高，从大到小进行排列
public class DogHeightComparator implements Comparator<Dog>{
    @Override
    public int compare(Dog o1, Dog o2) {
        if(o1.height>o2.weight) return -1;
        else if(o1.height<o2.weight) return 1;
        else return 0;
    }
}

// 定义一个选择排序算法，核心两个数比较使用的是comparator.compare(arr[j],arr[min]方法，当传入的方案不同，就会进行不同的计算。
public class SorterGenericity<T> {

    //传入一个T类型的数据，和一个T类型的比较器
    public void sort(T[] arr ,Comparator<T> comparator)  {
        
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;
            
            for (int j = i + 1; j < arr.length; j++) {
                if (comparator.compare(arr[j],arr[min])<0) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }

            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                T tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }

        }

    }
}

//狗类
public class Dog{
    int weight,height;

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public Dog(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "weight=" + weight +
                ", height=" + height +
                '}';
    }
}

执行

public class Main {
    public static void main(String[] args) {

        Dog[] dog = {new Dog(40, 30),new Dog(20, 20),new Dog(10, 10)};
        //体重比较器
        SorterGenericity<Dog> sorterGenericity = new SorterGenericity();
        DogWeightComparator dogComparator = new DogWeightComparator();
        sorterGenericity.sort(dog,dogComparator);
        System.out.println(Arrays.toString(dog));

        //身高比较器，如果以后需要扩展就可以添加新的比较器
        DogHeightComparator dogHeightComparator = new DogHeightComparator();
        sorterGenericity.sort(dog,dogHeightComparator);
        System.out.println(Arrays.toString(dog));
    }
}

输入结果
[Dog{weight=10, height=10}, Dog{weight=20, height=20}, Dog{weight=40, height=30}]
[Dog{weight=40, height=30}, Dog{weight=20, height=20}, Dog{weight=10, height=10}]

结论

如果以后想对狗的年龄进行比较排序，我只需要定义一个年龄比较器。就可以分方便的进行扩展。

在JAVA代码中 Double和Float，Short 都实现了Comparable接口，并且对compare的方法进行了实现。

例如：Short中实现

public static int compare(short x, short y) {
    return x - y;
}

Double中的实现

public static int compare(double d1, double d2) {
    if (d1 < d2)
        return -1;           // Neither val is NaN, thisVal is smaller
    if (d1 > d2)
        return 1;            // Neither val is NaN, thisVal is larger

    // Cannot use doubleToRawLongBits because of possibility of NaNs.
    long thisBits    = Double.doubleToLongBits(d1);
    long anotherBits = Double.doubleToLongBits(d2);

    return (thisBits == anotherBits ?  0 : // Values are equal
            (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
             1));                          // (0.0, -0.0) or (NaN, !NaN)
}