个人ip打造范文seo排名工具有哪些
参考自马士兵设计模式源码
gitee链接
我的理解是不同对象有不同的处理策略
比如有一个排序工具类Sorter，它的作用就是将传进来的数组进行排序，像这样：
public class Sorter {public static void sort(int[] arr) {for (int i = 0; i < arr.length; i++) {int minPos = i;for (int j = i+1; j < arr.length; j++) {minPos = arr[j] < arr[minPos] == -1 ? j : minPos;}swap(arr, i, minPos);}}private static void swap(int[] arr, int i, int minPos) {int temp = arr[i];arr[i] = arr[minPos];arr[minPos] = temp;}
}
复制代码这个排序工具类有一个问题，就是仅支持int数组，如果需要被处理的是Object对象等类型就不行了，所以让我们来一步一步用策略模式来改造一下。
首先新建两个用于测试的类Cat和Dog：
package com.cc.strategy;public class Cat {int weight, height;public Cat(int weight, int height) {this.weight = weight;this.height = height;}@Overridepublic String toString() {return "Cat{" +"weight=" + weight +", height=" + height +'}';}
}
复制代码package com.cc.strategy;public class Dog {int food;public Dog(int food) {this.food = food;}@Overridepublic String toString() {return "Dog{" +"food=" + food +'}';}
}
复制代码其中Cat有两个属性，重量weight和高度height，Dog有一个饭量food。
首先我们希望Sorter类可以做到，将Cat数组根据weight排序，那么我们可以这样写：
新建一个比较的实现类Comparable（我知道Java已经有这个实现类了，但是为了加深理解，让我们手撸一个吧）：
package com.cc.strategy;public interface Comparable<T> {int compareTo(T o);
}
复制代码其中泛型T可能会有疑惑，后面会提到，
为了支持Sorter排序，Cat需要实现这个Comparable类，修改后如下：
package com.cc.strategy2;// 上面提到的泛型可以在此处指定...
public class Cat implements Comparable<Cat> {int weight, height;public Cat(int weight, int height) {this.weight = weight;this.height = height;}/*** ...然后本来是T o格式，使用了泛型并且在类上指定之后可以在实现函数中直接用Cat c的方式指定* 这样其实是自动做了一层转换：Object o => Cat c* 如果不用泛型，就要这样多写一行：* Cat c = (Cat)o;*/@Overridepublic int compareTo(Cat c) {if (this.weight < c.weight) {return -1;} else if (this.weight > c.weight) {return 1;} else {return 0;}}@Overridepublic String toString() {return "Cat{" +"weight=" + weight +", height=" + height +'}';}
}
复制代码Sorter排序类也要修改，从原来只接受int[]变成Comparable[]，即所有实现了Comparable的对象：
package com.cc.strategy2;public class Sorter {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);}}private void swap(Comparable[] arr, int i, int minPos) {Comparable temp = arr[i];arr[i] = arr[minPos];arr[minPos] = temp;}
}
复制代码测试一下；
package com.cc.strategy;import java.util.Arrays;public class Main {public static void main(String[] args) {Cat[] c = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};Sorter sorter = new Sorter();sorter.sort(c);System.out.println(Arrays.toString(c));}
}
复制代码结果：
[Cat{weight=1, height=1}, Cat{weight=3, height=3}, Cat{weight=5, height=5}]
复制代码Cat类的排序已经完成了，当我们想对Dog也进行排序的话，参照Cat类即可：
package com.cc.strategy;public class Dog implements Comparable<Dog> {int food;public Dog(int food) {this.food = food;}@Overridepublic int compareTo(Dog d) {if (this.food < d.food) {return -1;} else if (this.food > d.food) {return 1;} else {return 0;}}@Overridepublic String toString() {return "Dog{" +"food=" + food +'}';}
}
复制代码现在还有一个问题，Cat的排序，我们是在Cat类的实现函数compareTo()中根据weight来排的，Cat有两个属性weight和height，当我们想让Cat变成按照height排序的话怎么办呢？修改实现函数compareTo()是肯定不行的，这样一点也不灵活，现在终于轮到策略模式出场了，是的，前面的都不是策略模式，只是铺垫。
让我们来新建一个比较实现类Comparator：
package com.cc.strategy;public interface Comparator<T> {int comare(T o1, T o2);
}
复制代码现在可以开始疑惑了，这个Comparator和刚刚的Comparable有什么区别呢？
答：在Java中，Comparable是排序接口，如果一个类实现了Comparable接口，表示该类支持排序，就像我们在Sorter中实现的，实现类Comparable的对象通过compareTo()方法进行排序，返回1，-1或者0；
而Comparator是比较接口，通常是用于一种比较方法的实现，听到这里可能还是不理解，没关系我们接着看。
在刚刚，Cat是通过weight排序的，为了让Cat能够灵活一些，既可以根据weight排序，也可以根据height排序，我们新建两个比较类：
package com.cc.strategy;public class CatHeightComparator implements Comparator<Cat> {@Overridepublic int comare(Cat o1, Cat o2) {if (o1.height < o2.height) {return 1;} else if (o1.height > o2.height) {return -1;} else {return 0;}}
}
复制代码package com.cc.strategy;public class CatWeightComparator implements Comparator<Cat> {@Overridepublic int comare(Cat o1, Cat o2) {if (o1.weight < o2.weight) {return -1;} else if (o1.weight > o2.weight) {return 1;} else {return 0;}}
}
复制代码这两个比较类实现了Comparator的compare()方法，并且分别实现了比较方式，现在改造一下Sorter排序类：
package com.cc.strategy;public class Sorter<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.comare(arr[j], arr[minPos]) == -1 ? j : minPos;}swap(arr, i, minPos);}}private void swap(T[] arr, int i, int minPos) {T temp = arr[i];arr[i] = arr[minPos];arr[minPos] = temp;}
}
复制代码现在，可以将原来Cat关于Comparable实现类的代码删掉，留下一个干净的对象了，因为排序实现我们放在了CatHeightComparator和CatWeightComparator中：
package com.cc.strategy;public class Cat {int weight, height;public Cat(int weight, int height) {this.weight = weight;this.height = height;}@Overridepublic String toString() {return "Cat{" +"weight=" + weight +", height=" + height +'}';}
}
复制代码测试一下：
package com.cc.strategy;import java.util.Arrays;public class Main {public static void main(String[] args) {Cat[] c = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};Sorter<Cat> catSorter = new Sorter<>();catSorter.sort(c, new CatWeightComparator());System.out.println(Arrays.toString(c));catSorter.sort(c, new CatHeightComparator());System.out.println(Arrays.toString(c));}
}
复制代码结果：
[Cat{weight=1, height=1}, Cat{weight=3, height=3}, Cat{weight=5, height=5}]
[Cat{weight=5, height=5}, Cat{weight=3, height=3}, Cat{weight=1, height=1}]
复制代码大功告成，Sorter排序类可以对传入的对象数组，根据不同的排序策略而进行不一样的排序，这就是策略模式的妙用，虽然代码多了一些，但是维护性是很高的，当我们想对Dog类或者更多的类进行排序操作时，只需要为其新建一个排序策略即可。