二十三种设计模式的自我了解--策略模式（1）

策略模式属于三大类中的行为模式（多个类与对象之间通过协作共同完成单个对象无法独立完成的任务）：策略模式。定义一系列算法，并进行封账，使其可以相互替换，切换算法、替换算法，不会影响到客户端

一，引入

这里以各种比较方式来说明

说到比较，就得说一下java封装的两个类Comparable和Compareor

毫无疑问是用来比较的，但是这里自定义这两个方法来进行比较

一。这里用选择排序算法

定义一个sorter

public class Sorter1{
    public static void sot(Cat[] a) {
//      选择排序
        for (int i = 0; i <a.length-1 ; i++) {
            int minPos=i;

            for (int j = i+1; j <a.length ; j++) {
                minPos=a[j].compareTo(a[minPos])== -1? j:minPos;
            }
            swap(a,i,minPos);
        }
    }


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

使用猫的体重来进行比较。写一个类Cat，

public class Cat {
    int weight, height;

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

    }

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

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

public class Main {
    
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,19,1};
     
        Sorter<Cat> sorter = new Sorter<>();
        sorter.sot(a);
        System.out.println(Arrays.toString(a));
   
    }
}

 1.这个是属于调用了一个自定义的算法，但是，程序吗，解决业务为目标，若有要求了：

多个对象进行比较了？多个对象之间的不同比较了？

2.这是对于业务进行分析，若针对代码进性假设了，这里是int类型，做改成double了？

这些问题，提出来之后，就得面临一个面向对象设计原则问题，必须遵循一个"开放封闭原则"：对扩展开放，对更改封闭。

 二。深究

对于类型如果是double，解决方法有两个。第一个就是，写一个double类型的类，重新创建对象封装一个方法，按照这个思路，如果有其他类型，那就得再创建对象，再封装，周而复始！显示，不可取，因为代码复用性基本为零，怎么办了

对于新对象进行比较这个问题，java自带一个接口Comparable ，接口里有一个方compareTo（Objecct object）这里面直接放对象就行，就可以进行比较，但是这里最好使用泛型，可以直接指定对象了，除了这个方法还有一接口Compareto,比较器，区别没有研究透，后续说明，上代码，定义一个比较类，写一个方法sorter，实现算法，并加入compareto（）指定类型

public class Sorter<T>{

    public  void soter(T[] a, Comparator<T> comparator) {
//      选择排序
        for (int i = 0; i <a.length-1 ; i++) {
            int minPos=i;

            for (int j = i+1; j <a.length ; j++) {
                minPos=comparator.compare(a[j],a[minPos])==-1?j:minPos;
            }
                swap(a,i,minPos);
        }
    }

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

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

无论定义多少个对象，比较方法，只要创建这个类，实现Compareto。将比较方式写入

一切都调用简单了。

整个流程,把策略模式核心思想表达出来了