设计模式-strategy

策略模式

模式一

主方法只写要比较的参与者和Sort这件事情

public class Main {
    public static void main(String[] args) {
        Sorter sorter = new Sorter();
        Dog[] dogs = {new Dog(1),new Dog(2),new Dog(3)};
        Cat[] cats = {new Cat(1,10),new Cat(12,20),new Cat(3,5)};
        sorter.sort(dogs);
        System.out.println(Arrays.toString(dogs));
        sorter.sort(cats);
        System.out.println(Arrays.toString(cats));
    }
}

比较器

public class Sorter<T> {
    public void sort(Comparable[] arr){
        for(int i=0;i<arr.length;i++){
            int minPos = i;
            for(int j=i+1;j<arr.length;j++){
                minPos = arr[j].compareTo(arr[minPos])==-1 ? j : minPos;
            }
            swap(arr,i,minPos);
        }
    }

    void swap(Comparable[] arr,int i,int minPos){
        Comparable temp = arr[i];
        arr[i] = arr[minPos];
        arr[minPos] = temp;
    }
}

被比较的对象，自带实现比较的具体方法

public interface Comparable {
    int compareTo(Object o1);
}

public class Cat implements Comparable{
    int height;
    int weight;
    @Override
    public int compareTo(Object o) {
        Cat c = (Cat)o;
        if(c.height>this.height){
            return -1;
        }else if(c.height<this.height){
            return 1;
        }else {
            return 0;
        }
    }

public class Dog implements Comparable {
    int food;
    @Override
    public int compareTo(Object o1) {
        Dog d = (Dog)o1;
        if (this.food > d.food) {
            return -1;
        }
        else if(this.food > d.food) {
            return 1;
        }
        else {
            return 0;
        }
    }
}

修改关闭，扩展开放原则：
这个模式的缺点是，比较方式单一，比较固定，不够灵活，如果想比较一个Cat中的多个属性，此时只能修改compareTo接口，或者新增一个新接口，采用下面的模式升级版，可以把比较的方式也多样化

模式二

目标： 要求比较策略灵活处理，增加一个cat类的height的排序

public static void main(String[] args) {
        Sorter sorter = new Sorter();
        Dog[] dogs = {new Dog(10),new Dog(2),new Dog(3)};
        Cat[] cats = {new Cat(1,10),new Cat(12,1),new Cat(3,5)};
        
        Sorter2<Dog> sorter2 = new Sorter2();
        sorter2.sort(dogs,new DogComparator());
        System.out.println(Arrays.toString(dogs));

        Sorter2<Cat> sorter21 = new Sorter2();
        sorter21.sort(cats,new CatHeightComparator());
        System.out.println("height "+Arrays.toString(cats));

        sorter21.sort(cats,new CatWeightComparator());
        System.out.println("weight "+Arrays.toString(cats));
    }

public class Sorter2<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);
        }
    }

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

new一个的比较策略接口

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

每想要实现某个对象的某种维度的排序，就增加一个XXX的比较器的实现，这样就不用修改原有的代码，又有了横向拓展能力

下面是增加Cat的height的sort

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

下面是增加Cat的weight的sort

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;
        }
    }
}

参考
https://www.bilibili.com/video/BV1RC4y1H7ok?p=4