Java23种设计模式：策略模式（四）

策略模式：

用一个排序来说一下策略模式：

常用七种：

冒泡排序

选择排序

插入排序

希尔排序

快速排序

归并排序

堆排序

用一个排序的实例来解释策略模式：

/**

* 用数组排序抽出策略模式

* @author 向平

*

*/

public class XPSortedUtil {

/**

* 排序int类型的

*/

public static void sort(int[] arr){

for (int i = 0; i < arr.length; i++) {

for (int j = 0; j < arr.length-1; j++) {

if (arr[j] > arr[j+1]) {

swap(arr,j,j+1);

}

}

}

XPPrint(arr);

}

private static void swap(int[] arr,int i, int j) {

int temp = arr[i];

arr[i] = arr[i+1];

arr[i+1] = temp;

}

public static void XPPrint(int[] arr) {

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

}

}

以上是写了一个int数组的排序。如果要一个double类型的排序，那么我们必须要新增一个double数组排序的方法。

double的排序省略了。。。。

如果要写Car类数组的排序，那我们就是写一个Car数组的排序。

/**

* 用数组排序抽出策略模式

* @author 向平

*

*/

public class XPSortedUtil {

/**

* 排序Car类型的

*/

public static void sort(Car[] arr){

for (int i = 0; i < arr.length; i++) {

for (int j = 0; j < arr.length-1; j++) {

if (arr[j] > arr[j+1]) {

swap(arr,j,j+1);

}

}

}

XPPrint(arr);

}

private static void swap(Car[] arr,int i, int j) {

Car temp = arr[i];

arr[i] = arr[i+1];

arr[i+1] = temp;

}

}

看到这里大家都发现了，这样写下去不得了。。。。。

这样的话有多少类，那就有多少排序方法，那你写的这个排序工具类，简直就没法去维护和兼容

这样的情况我们该怎么办呢？？？？

我们能不能订一套排序的统一规则呢？

当然可以，既然说到了定制统一规则，那我们一下子就会想到接口，没错，就是接口。

好，既然我们想到用接口来定义一个统一排序的规则，那我们就定义个XPComparable接口把：接口中有一个compareTo方法

************重点来了***************

XPComparable定义好了以后，叫要进行排序的类实现它。然后根据不同类排序的规则，随意自定义规则。

然后在排序工具类中调用的时候，用XPComparable的引用去实现多态。用XPComparable的引用去调用compareTo方法，

传入的是什么类的类型数组，就会调用该类中自定义实现的compareTo方法进行比较。

比如：汽车类实现了XPComparable接口，那汽车就可以比较大小了

public class Car implements XPComparable{

private String type;

private int money;

public Car() {

super();

}

public Car(String type, int money) {

super();

this.type = type;

this.money = money;

}

public String getType() {

return type;

}

public void setType(String type) {

this.type = type;

}

public int getMoney() {

return money;

}

public void setMoney(int money) {

this.money = money;

}

@Override

public int compareTo(Object obj) throws Exception {

if (obj instanceof Car) {

Car objCar = (Car) obj;

if (this.getMoney() > objCar.getMoney()) {

return 1;

}else if (this.getMoney()==objCar.getMoney()) {

return 0;

}else{

return -1;

}

}else{

//如果传入的不是Car类说明这个不能进行对比，所以抛异常

throw new Exception();

}

}

}

排序工具类也需要变动一下：

public class XPSortedUtil {

/**

* 排序int类型的

*/

public static void sort(int[] arr){

for (int i = 0; i < arr.length; i++) {

for (int j = 0; j < arr.length-1; j++) {

if (arr[j] > arr[j+1]) {

swap(arr,j,j+1);

}

}

}

XPPrint(arr);

}

private static void swap(int[] arr,int i, int j) {

int temp = arr[i];

arr[i] = arr[i+1];

arr[i+1] = temp;

}

public static void XPPrint(int[] arr) {

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

}

/**

* 这个就是满足所有类型的排序，只要这个类实现了XPComparable接口，也就是说只要自定义类遵循了排序规则，就可以排序

* @param arr

*/

public static void sort(Object[] arr){

for (int i = 0; i < arr.length; i++) {

for (int j = 0; j < arr.length-1; j++) {

//关键部分，多态：用父接口指向子类对象

XPComparable obj1 = (XPComparable) arr[j];

XPComparable obj2 = (XPComparable) arr[j+1];

//等于1：obj1>obj2 等于0：obj1=obj2 等于-1：obj1<obj2

//有可能类型不匹配，所以异常处理一下

try {

if (obj1.compareTo(obj2)== 1) {

swap(arr,j,j+1);

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

private static void swap(Object[] arr, int x, int y) {

Object object = arr[x];

arr[x] = arr[y];

arr[y] = object;

}

}

以上这么多的好处是什么吗？

就是你要怎么排序，就可以在自己类里面定具体规则，我要根据什么方式排序。

比如：我有个学生类，实现了XPComparable接口了，我就可以在compareTo方法中写排序具体的规则了，如果现在我是按照学号排序，

可能下次我的需求变了，你就直接在你的学生类的compareTo方法中修改排序规则即可，不会对其他的有任何影响。

大家慢慢体会一下这种设计的好处。

小结一下：说了这么多有提到了多态，没错多态才是面向对象的核心，多态是你系统或项目后期扩展和维护的重要手段之一。

设计模式是什么？

其实就是把简单的东西复杂化，没错是这样。那为嘛要复杂化呢？是为了适应你后期的项目需求，多态是设计模式中一个非常重要的组成部分。但是在使用设计模式时也不要前期设计的过度复杂，适用就可以了

因为你的设计是随项目的增进而调整。不要为了设计而设计喔。。。。

大家别急，还没到策略设计模式。。。万里长城才第一步。。。。

请大家分析一个问题：

上面虽然解决了为统一比较定义规则，然后也是实现了所有类的排序，但是真没有问题吗？？？？

1.虽然把排序规则可以定在所有排序类的内部，根据自己的排序需求来定制。但是如果某一天我想要修改排序的具体规则。那是不是又得去动我们已经写好的代码。

如：假设我现在有个学生类，学生类里有：学号，年龄，学分，体重，身高

1>.那我当前是按照学号写的排序规则，那下次如果我要以年龄来排序，我是不是要动已经写好的代码。

2>.好，我就当你改好了，但是如果有一天又变了，你是不是又要去改规则，那周而复始，你就见鬼了。。。太麻烦了，

3>.为什么会这样呢？？？ 那是因为你的排序规则和你的学生类之间设计的耦合度太高了。应该解耦。

怎么解耦呢？？？

2.我们可以把排序的具体排序规则把它从具体类中剥离出去。好，没错就是这个思路。我们剥离出来的东西叫 "比较器" 吧

3.具体排序规则也太多了，也就意味着你的比较器也很多，我们也必须要统一下来，使用多态。不然，你又一个噩梦开始了，如果学生类中有 "学号比较器"，"年龄比较器"，"学分比较器"，"体重比较器"，"身高比较器"

如果不要父类，其实和你上面没有太大的优化，只是把代码剥离了而已。你还得不断的修改 比较器对象。所以我们为所有的比较器顶一个统一的规则，比较器接口。

4.我们就定义一个比较器接口把：Comparator接口：接口中有：compare(Object o1,Object o2)接口

写一段代码理一下思路：

比较器接口：

/**

* 比较器接口

* @author 向平

*

*/

public interface XPComparator {

//如果相等就返回0，如果object1>object2 就返回1 ，如果object1<object2 就返回-1

int compare(Object object1,Object object2);

}

比较器实现：

/**

* 学生具体按学分比较的比较器

* @author 向平

*

*/

public class StudentScoreComparator implements XPComparator{

@Override

public int compare(Object object1, Object object2) {

Student student1 = (Student)object1;

Student student2 = (Student)object2;

if (student1.getScroce()>student2.getScroce()) {

return 1;

}else if (student1.getScroce()<student2.getScroce()) {

return -1;

}

return 0;

}

}

使用比较器：

package com.xp.strategy;

/**

* 学生类

* @author 向平

*

*/

public class Student implements XPComparable{

private String name;

private int age;

private double scroce;

//比较器

private XPComparator comparator;

public Student() {

super();

}

public Student(String name, int age, double scroce) {

super();

this.name = name;

this.age = age;

this.scroce = scroce;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public double getScroce() {

return scroce;

}

public void setScroce(double scroce) {

this.scroce = scroce;

}

public XPComparator getComparator() {

return comparator;

}

public void setComparator(XPComparator comparator) {

this.comparator = comparator;

}

/**

* 开始比较

*/

@Override

public int compareTo(Object obj) throws Exception {

//如果我想要切换到其他比较器，我只要外界传入不同比较器对象即可，里面的东西不用在变化

return getComparator().compare(this, obj);

//当然也可以使用内部类,大家自己去实现以下吧

}

}

说了这么多，其实比较器就是使用了策略模式。

也就是说，我要排序的时候，我只要定一个策略就可以了。不同的策略就会有不同的结果。