策略者设计模式 (StrategyPattern)

描述： 策略者解决的是在多种算法相似的情况下，使用if….else…ss等所带来的的复杂代码。解决的思路是，将这些算法的代码封装成一个一个的类，实现统一接口。

核心思想： 策略设计模式就是 实现一种策略 展示不同的结果

使用场景： 有多种动物需要对它们进行排序，但每种动物的排序规则都不一样 此时我们就会写很多的if() 判断语句 此时就可以使用策略者设计模式

策略者设计模式的优点：

  • 算法可以自由的切换
  • 减少多重判断的使用
  • 扩展性好

策略者设计模式的缺点：

  • 策略类都会暴露在外，客户端都要知道每个策略算法的区别
  • 如果系统中的的算法种类很多的话 策略类会爆炸式增长，不便于维护

示例：

  • 猫的对象
1
2
3
4
5
6
7
8
9
public class Cat {
    private Integer age;
    private  String name;

    public  Cat(Integer age,String name){
        this.name=name;
        this.age=age;
    }
}
  • 抽象算法规则
1
2
3
public interface Comparator<T> {
    int compare(T o1, T o2);
}
  • 猫的算法规则实现类
1
2
3
4
5
6
7
8
9
10
11
12
13
public class CatSort implements  Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        if(o1.getName().compareTo(o2.getName())>0)  return  1;
        else  if(o1.getName().compareTo(o2.getName())==0){
             if(o1.getAge().compareTo(o2.getAge())>0) return 1;
             else  if(o1.getAge().compareTo(o2.getAge())<0) return  -1;
            return  0;
        }
        else return -1;

    }
}
  • 统一的算法
1
2
3
4
5
6
7
8
9
10
11
12
13
public void insertSort(T[] arr, Comparator<T> comparator) {
        for (int i = 1; i < arr.length; i++) {
            T temp = arr[i];
            int j = i;
            for (; j > 0 && comparator.compare(arr[j - 1], temp) > 0; ) {
                arr[j] = arr[j - 1];
                j--;
            }
            if (j != i) {
                arr[j] = temp;
            }
        }
    }
  • 客户端的调用
1
2
3
4
5
6
7
public static void main(String[] args) {
    test<Cat> cattest = new test<Cat>();
    Cat[] cat = {new Cat(2, "a"), new Cat(3, "d"), new Cat(4, "b"), new Cat(6, "a"), new Cat(3, "c")};
    cattest.insertSort(cat, new CatSort());
    System.out.println(Arrays.toString(cat));

}

总结：

此处的主要思想就是使用的向上转型的思想，比如我以上的方法想要在加几个猫的排序规则，那么此时我只需要实现排序规则的接口就可以了，不需要改动其他的代码，主要就是我的排序算法insertSort（）使用是父类的Comparator接收的参数，只要实现了它，是它的子类，那么你就可以自由任意切换各种算法。

附图：

策略者设计模式UML