策略模式

策略模式- 2020-11-14 20:59- 设计模式: 设计模式,策略模式

定义

策略模式(Strategy Pattern)：定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化，也称为政策模式(Policy)。

名词解析

算法

乍一看 算法 这个说法有点让人难以理解，其实可以将算法看作是一系列的策略，在使用策略模式时，指定具体想要的策略模式。

DOME

通过给动物排序，可以按照重量排序，也可以按照高度排序，可以给猫狗排序，也可以给其他动物排序

实体类 ：Dog Cat

import lombok.Data;
/**
 * 猫类
 *
 * @Author Bai
 * @Date 2020-11-14 18:33
 */
@Data
public class Cat {
    /**
     * 猫的重量
     */
    private Integer weight;
    /**
     * 猫的长度
     */
    private Integer high;
    public Cat(Integer weight, Integer high) {
        this.weight = weight;
        this.high = high;
    }
    @Override
    public String toString() {
        return "Cat{" +
                "weight=" + weight +
                ", high=" + high +
                '}';
    }
}

import lombok.Data;
/**
 * 狗类
 *
 * @author Bai
 * @date 2020/11/14 18:47
 */
@Data
public class Dog {
    /**
     * 重量
     */
    private Integer weight;
    public Dog(Integer weight) {
        this.weight = weight;
    }
}

比较器：Comparator

/**
 * 比较器
 * @Author Bai
 * @Date 2020-11-14 18:33
 */
public interface Comparator<T> {
    /**
     * 比较两者大小
     *
     * @param o1
     * @param o2
     * @return
     */
    int compare(T o1, T o2);
}

具体比较器（也可以理解为算法）:

CatWeightComparator
CatHighComparator
DogWeightComparator

package com.xy.blog.test.designpatterns.strategy;
/**
 * 猫重量比较器
 *
 * @Author Bai
 * @Date 2020-11-14 18:33
 */
public class CatWeightComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        if (o1.getWeight() < o2.getWeight()) {
            return -1;
        }
        if (o1.getWeight() > o2.getWeight()) {
            return 1;
        }
        return 0;
    }
}

/**
 * 猫高度比较器
 *
 * @author Bai
 * @date 2020-11-14 18:33
 */
public class CatHighComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        if (o1.getHigh() < o2.getHigh()) {
            return -1;
        }
        if (o1.getHigh() > o2.getHigh()) {
            return 1;
        }
        return 0;
    }
}

/**
 * 猫重量比较器
 *
 * @Author Bai
 * @Date 2020-11-14 18:33
 */
public class DogWeightComparator implements Comparator<Dog> {
    @Override
    public int compare(Dog o1, Dog o2) {
        if (o1.getWeight() < o2.getWeight()) {
            return -1;
        }
        if (o1.getWeight() > o2.getWeight()) {
            return 1;
        }
        return 0;
    }
}

排序：Sort

package com.xy.blog.test.designpatterns.strategy;
import com.google.common.collect.Lists;
import java.util.List;
/**
 * 排序
 *
 * @Author Bai
 * @Date 2020-11-14 18:33
 */
public class Sort<T> {
    public void sort(List<T> os, Comparator<T> comparator) {
        // 对 arr 进行拷贝，不改变参数内容
        for (int i = 1; i < os.size(); i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;
            for (int j = 0; j < os.size() - i; j++) {
                if (comparator.compare(os.get(j), os.get(j + 1)) > 0) {
                    T tmp = os.get(j);
                    os.set(j, os.get(j + 1));
                    os.set(j + 1, tmp);
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
    }
    public static void main(String[] args) {
        List<Cat> cats = Lists.newArrayList(new Cat(16, 10), new Cat(2, 2), new Cat(14, 20));
        Sort<Cat> sort = new Sort<>();
        sort.sort(cats, new CatWeightComparator());
        System.out.println(cats);
        sort.sort(cats, new CatHighComparator());
        System.out.println(cats);
        List<Dog> dogs = Lists.newArrayList(new Dog(16), new Dog(2), new Dog(14));
        Sort<Dog> dogSort = new Sort<>();
        dogSort.sort(dogs, new DogWeightComparator());
        System.out.println(dogs);
    }
}

好处TODO

开闭原则

坏处TODO

使用者需要了解每种算法，并且找到适合自己的算法。

spring中使用或是项目中使用TODO**