设计模式（二）——策略模式(Strategy)

设计模式（二）——策略模式

应用场景

假设现在有一个People类，有两个属性身高height，体重weight，现在要求将一个People数组按照身高排序，应该怎么做？

可以在其中定义一个CompareTo方法，定义两者的排序方式为身高的比较。

在排序的时候，可以参考整数的排序，但是将两者比较大小的语句改为调用comPareTo方法。

public int comPareTo(People p){
    if(this.hight>p.hight) {
        return 1;
    }
    else if(p.hight>this.hight){
        return -1;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9

如果按照上面的方式写，可以实现想要的效果，但是现在我需要按照体重排序，就需要修改很多的代码，假如我想要新建一个猫的类，要按照猫的体重来排序，那还需要写一个猫的排序类，这样就非常的不合理，这时候就需要用到策略模式。

排序将会用到几种策略：

1. 按照身高排序。
2. 按照体重排序。
3. 先按身高排序，再按体重排序。
4. …

策略模式的使用

People.java

package strategy.pojo;

/**
 * @title: People
 * @Author 张宜强
 * @Date: 2022/4/6 15:26
 * @Effect:
 */
public class People {
    private int hight;
    private int weight;

   //set、get、toString、全参构造
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

定义一个接口，里面有一个比较方法，实现这个比较方法的类在其中写比较的逻辑。

package strategy.pojo;

import java.util.List;

/**
 * @title: Comparable
 * @Author 张宜强
 * @Date: 2022/4/6 15:43
 * @Effect:
 */
public interface Comparable<T> {
    public int compareTo(T o1, T o2);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

假如我现在需要按照身高来排序，那么我就新建一个PeopleSortByHeight类，在compareTo方法中按照身高来比较。

package strategy.pojo;

import java.util.List;

/**
 * @title: PeopleSortByHeight
 * @Author 张宜强
 * @Date: 2022/4/6 15:45
 * @Effect:
 */
public class PeopleSortByHeight implements Comparable<People>{
    public int compareTo(People p1,People p2) {
        if(p1.getHight()>p2.getHight()){
            return 1;
        }
        else if (p1.getHight()<p2.getHight()) {
            return -1;
        }
        return 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

修改Sort类，sort方法传如一个Comparable对象，按照对象中的compareTo方法来排序，

public class Sort<T> {

    public void sort(T[] arr, Comparable<T> comparable) {
        for(int i=0; i<arr.length;i++) {
            for(int j=i+1;j<arr.length;j++){
                if(comparable.compareTo(arr[i],arr[j])==1){
                    T temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

最后写一个Main方法，创建一个People数组，按照身高排序，就传入一个PeopleSortByHeight对象

public class Main {
    public static void main(String[] args) {
        People [] peopleArr={new People(188,140),new People(176,160),new People(170,120)};
        Sort sorter = new Sort<People>();
        sorter.sort(peopleArr,new PeopleSortByHeight());
        System.out.println(Arrays.toString(peopleArr));
    }
}
1
2
3
4
5
6
7
8

排序结果：

需求改动后，想要根据体重排序

那现在只需要创建一个新类PeopleSortByWeight 实现Comparable接口，对People的体重进行比较。

package strategy.pojo;

/**
 * @title: PeopleSortByWeight
 * @Author 张宜强
 * @Date: 2022/4/6 16:16
 * @Effect:
 */
public class PeopleSortByWeight implements Comparable<People> {
    public int compareTo(People p1, People p2) {
        if(p1.getWeight()>p2.getWeight()){
            return 1;
        }
        else if (p2.getWeight()>p1.getWeight()) {
            return -1;
        }
        return 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在排序时传入PeopleSortByWeight对象

public class Main {
    public static void main(String[] args) {
        People [] peopleArr={new People(188,140),new People(176,160),new People(170,120)};
        Sort sorter = new Sort<People>();
        sorter.sort(peopleArr,new PeopleSortByWeight());
        System.out.println(Arrays.toString(peopleArr));

    }
}
1
2
3
4
5
6
7
8
9

排序结果：

后面如果想想按照身高排序，如果身高相同再按照体重排序，那么久可以再新建类实现Comparable接口，

如果想给猫按照体重排序，也只需要新建类即可，这样，一个Sort类就可以实现所有的排序，只是不同的排序采取不同的策略。再有新的排序策略的时候不会去改动原有的策略，代码的扩展性变强，耦合性降低。