首先我们考虑一个场景：有一个整型数组，我们希望通过调用工具类的sort方法对数组进行排序。请看下面的代码：

公共类策略{ public static void main(String[] args) { int[] arr={5, 3, 1, 7, 2}; new DataSorter().sort(arr);//调用排序工具类for (int i=0; i arr.length; i++){ System.out.println(arr[i]); } }}class DataSorter{//排序的工具类public void sort(int[] arr){ //调用sort方法进行排序，这里使用冒泡排序for(int i=arr.length - 1; i 0; i --){ for(int j=0; j i; j++){ if(arr[j] arr[j + 1]) 交换(arr, j, j + 1); } } } private void swap(int[] arr, int i, int j){ int temp=arr[i]; arr[i]=arr[j]; arr[j]=温度； }}

Comparable接口

通过上面的代码，我们可以轻松的对整型数组进行排序，那么如果有新的需求，我们需要对浮点型数据进行排序。排序工具类应该怎么做呢？

那么如果我继续问，如果我现在想要对一只猫进行分类，我该怎么办？猫类如下：

class Cat{ private int Age;//猫的年龄private int Weight;//猫的体重//获取/设置方法.} 你可能照原样回答，复制一个排序算法，修改方法参数，然后指定比较地点的比较猫的年龄或体重，对吧？

public void sort(Cat[] arr){//以cat数组为参数for(int i=arr.length - 1; i 0; i--){ for(int j=0; j i; j++){ if( arr[j].getAge() arr[j + 1].getAge())//比较swap(arr, j, j + 1);但仔细想一想，如果要继续比较小狗、鸡、鸭子等各种对象，这个排序工具类的代码量岂不是会变得很大？为了让排序算法的复用性更强，我们希望排序工具中的sort() 方法可以对调用它的任何对象进行排序。

您可能认为要能够对任何对象进行排序，您可以将sort() 方法的参数更改为Object 类型。这个方向是对的，但问题是，当你得到两个Object类型的对象时，你应该按照什么规则进行比较？

这时我们自然希望调用工具类进行排序的对象有自己的比较规则，这样在排序时可以直接调用该对象的排序规则。

我们将比较规则抽象为Comparable接口。所有需要比较的类都必须实现Comparable接口并定义自己的比较规则，这就是CompareTo()方法。

这样，我们在打包工具的时候，就可以直接比较实现了Comparable接口的对象，而不用担心比较的细节。

public class Strategy {public class Strategy { public static void main(String[] args) {//Integer[] arr={5, 3, 1, 7, 2};//注意将int改为Integer，Integer为对象的子类Cat[] arr={new Cat(3, 3), new Cat(1, 1), new Cat(5, 5)}; DataSorter ds=new DataSorter(); ds.sort(arr); for(int i=0; i arr.length; i++){ System.out.println(arr[i]); } } }}}class DataSorter{//排序的工具类public void sort(Object[] arr ){//参数类型为Object for(int i=arr.length - 1; i 0; i--){ for (int j=0; j i; j++){ 可比较c1=(可比较) arr[j]; //先转换为Comparable类型Comparable c2=(Comparable) arr[j + 1]; if(c1.CompareTo(c2)==1)//调用CompareTo()进行比较，不管具体实现如何swap(arr, j, j + 1); } } } private void swap(Object[] arr, int i, int j){ Object temp=arr[i]; arr[i]=arr[j]; arr[j]=温度； }}类Cat 实现Comparable{ private int Age;私有int 权重； @Override public int CompareTo(Object o) { if(o instanceof Cat){//首先判断传入的对象是否是Cat类对象，如果不是则抛出异常Cat c=(Cat) o; if(this.age c.age) 返回1; else if (this.age c.age) 返回-1;否则返回0； } 抛出null==o ？新的ClassCastException（）； } //get/set . //toString() .}interface Comparable{ public int CompareTo(Object o);}

Comparator接口

相信看完上面Comparable接口的由来，你就会明白了设计感觉比较好，但是还是有漏洞。在Cat 类的CompareTo() 方法中，猫的比较策略是硬编码的。现在我们根据猫的年龄来比较它们。如果有一天我们要比较猫根据猫的体重比较大，那么我需要再次修改源代码。有没有扩展性更好的设计？

我们可以允许用户自己定义一个比较器类，并且可以根据用户指定的比较器来比较对象的大小。

整个逻辑就是：如果这个对象需要比较，那么它必须实现Comparable接口，但是具体怎么比较，是通过具体的Comparator比较器来比较的。

当然，这里少不了多态。我们首先要定义一个比较器接口Comparator。用户的比较器需要实现Comparator接口。下面是代码：

公共类策略{ public static void main(String[] args) { Cat[] arr={new Cat(3, 3), new Cat(1, 1), new Cat(5, 5)}; DataSorter ds=new DataSorter(); ds.sort(arr); for(int i=0; i arr.length; i++){ System.out.println(arr[i]); } } }}class DataSorter{//用于排序的工具类public void sort(Object[] arr){//参数类型为Object for(int i=arr.length - 1; i 0; i--){ for( int j=0; j i; j++){ Comparable c1=(Comparable) arr[j];//先转换为Comparable类型Comparable c2=(Comparable) arr[j + 1]; if(c1.CompareTo(c2)==1)//已经转换为在幕后使用Comparator 比较定义的规则swap(arr, j, j + 1); } } } private void swap(Object[] arr, int i, int j){ Object temp=arr[i]; arr[i]=arr[j]; arr[j]=温度； }}类Cat 实现Comparable{ private int Age;私有int 权重； private Comparator comparator=new CatAgeComparator();//默认持有年龄比较器@Override public int CompareTo(Object o) { return comparator.Compare(this, o);//调用比较器进行比较，而不是写比较直接在这里规则} //get/set/toString .}interface Comparable{ public int CompareTo(Object o); }interface Comparator{ public int Compare(Object o1, Object o2);}//用户定义的比较器，根据猫的年龄段进行比较CatAgeComparator 实现Comparator{ @Override public int Compare(Object o1, Object o2) { Cat c1=（猫）o1；猫c2=(猫) o2; if(c1.getAge() c2.getAge()) 返回1;否则if(c1.getAge() c2.getAge()) 返回-1;否则返回0； }}//比较器类CatWeightComparator 实现Comparator{ @Override public int Compare(Object o1, Object o2) { Cat c1=(Cat) o1;猫c2=(猫) o2 ; if(c1.getWeight() c2.getWeight()) 返回1;否则if(c1.getWeight() c2.getWeight()) 返回-1;否则返回0； }}

关于策略模式的思考

在上面的例子中，我们自己定义了Comparable接口和Comparator接口。事实上，这两个接口是Java原生的。通过上面的代码示例，你一定也知道为什么会存在这两个接口了。

事实上，Comparable定义了一种比较策略。你可以把这里的策略理解为一个函数。然而，一旦策略可用，我们仍然需要具体的策略实现，因此我们有Comparator 接口。

我认为在比较对象的Comparable和Comparator中使用策略模式有以下好处：