设计模式之策略模式

一. 前言

小熙搜集了些策略模式的资料，策略模式在23种设计模式之中是属于行为类型，对于一件事情有着多种处理方式，可以考虑采用此种模式（还是一种多态的体现）。

二. 过程：

1. 如图：
   

2. 策略模式代码：
   （1）TigerEntity

   /**
    * @author chengxi
    * @date 2020/8/24 18:23
    */
   public class Tiger {
   
       private Integer hight;
   
       private Integer weight;
   
       public Tiger(Integer hight, Integer weight) {
           this.hight = hight;
           this.weight = weight;
       }
   
       public Integer getHight() {
           return hight;
       }
   
       public void setHight(Integer hight) {
           this.hight = hight;
       }
   
       public Integer getWeight() {
           return weight;
       }
   
       public void setWeight(Integer weight) {
           this.weight = weight;
       }
   
       @Override
       public String toString() {
           return "Tiger{" +
                   "hight=" + hight +
                   ", weight=" + weight +
                   '}';
       }
   }
   

   （2） 抽象比较器

   /**
    * 比较器
    *
    * @author chengxi
    * @date 2020/8/24 18:35
    */
   public interface Comparator<T> {
   
       /**
        * 比较方法
        * @param t1
        * @param t2
        * @return
        */
       int compare(T t1, T t2);
   
   }
   

   （3）身高和体重比较器

   /**
    * @author chengxi
    * @date 2020/8/24 18:37
    */
   public class TigerHeightComparator implements Comparator<Tiger> {
       @Override
       public int compare(Tiger t1, Tiger t2) {
           if (t1.getHight() > t2.getHight()) {
               return 1;
           }else if (t1.getHight() < t2.getHight()) {
               return -1;
           }
           return 0;
       }
   }
   
   /**
    * @author chengxi
    * @date 2020/8/24 18:40
    */
   public class TigerWeightComparator implements Comparator<Tiger> {
       @Override
       public int compare(Tiger t1, Tiger t2) {
           if (t1.getWeight() > t2.getHight()) {
               return 1;
           }else if (t1.getWeight() < t2.getWeight()) {
               return -1;
           }
           return 0;
       }
   }
   

   （4）排序方法类

   /**
    * @author chengxi
    * @date 2020/8/24 18:42
    */
   public class ComparatorSorter<T> {
   
       public void sorter(T[] arr, Comparator<T> comparator){
           for (int i = 0; i < arr.length; i++) {
               int maxIndex = i;
   
               for (int j = i + 1; j < arr.length; j++) {
                   maxIndex = comparator.compare(arr[i], arr[j]) == 1 ? i : j;
               }
   
               exchange(arr, i, maxIndex);
           }
       }
   
       void exchange(T[] arr, int i, int j){
           T temp = arr[i];
           arr[i] = arr[j];
           arr[j] = temp;
       }
   
   }
   

   （5）测试类

   /**
    * 在排序中传入不同的比较器
    *
    * @author chengxi
    * @date 2020/8/24 18:54
    */
   public class testMethod {
   
       public static void main(String[] args) {
           Tiger[] tArr = {new Tiger(3,5), new Tiger(1,1), new Tiger(5,3)};
           ComparatorSorter<Tiger> tigerComparatorSorter = new ComparatorSorter<>();
           // 传入身高比较器
           tigerComparatorSorter.sorter(tArr, new TigerHeightComparator());
           // 传入体重比较器
           tigerComparatorSorter.sorter(tArr, new TigerWeightComparator());
   
           System.out.println(Arrays.toString(tArr));
       }
   
   }
   

三. 后语

在这里小熙的测试是，在该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。