设计模式~策略模式-02

唐曌

已于 2022-04-26 20:09:34 修改

阅读量414

点赞数 1

分类专栏：设计模式 python 策略模式文章标签： java 策略模式后端

于 2022-04-20 20:30:43 首次发布

本文链接：https://blog.csdn.net/jeremy321321/article/details/124306464

版权

设计模式同时被 3 个专栏收录

21 篇文章 0 订阅

订阅专栏

python

6 篇文章 0 订阅

订阅专栏

策略模式

1 篇文章 0 订阅

订阅专栏

策略模式

优点

缺点

使用场景

策略模式针对一组算法。定义一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们之间可以相互替换。

策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。

【解释：跟不同类型的"美女"约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去海边浪漫最合适，单目的都是为了得到"美女"的芳心，我的追"美女"锦囊中有好多Strategy哦。】


public interface Comparable<T> {
    int compareTo(T o);
}
/**
* 实体类
*/
public class Cat implements Comparable<Cat> {
    int weight, height;
    public Cat(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    public int compareTo(Cat c) {
        if(this.weight < c.weight) return -1;
        else if(this.weight > c.weight) return 1;
        else return 0;
    }
    @Override
    public String toString() {
        return "Cat{" +
                "weight=" + weight +
                ", height=" + height +
                '}';
    }
}
//比较器
@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    default void m() {
        System.out.println("m");
    }
}
/**
* 比较身高
*/
public class CatHeightComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        if(o1.height > o2.height) return -1;
        else if (o1.height < o2.height) return 1;
        else return 0;
    }
}
/**
* 比较重量
*/
public class CatWeightComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        if(o1.weight < o2.weight) return -1;
        else if (o1.weight > o2.weight) return 1;
        else return 0;
    }
}

/**
* 选择排序
*/
public class Sorter<T> {
    public void sort(T[] arr, Comparator<T> comparator) {
        for(int i=0; i<arr.length - 1; i++) {
            int minPos = i;
            for(int j=i+1; j<arr.length; j++) {
                minPos = comparator.compare(arr[j],arr[minPos])==-1 ? j : minPos;
            }
            swap(arr, i, minPos);
        }
    }
    //sort(int)
    void swap(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

public class CatMain {
    public static void main(String[] args) {
        //int[] a = {9, 2, 3, 5, 7, 1, 4};
        Cat[] a = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};
        //Dog[] a = {new Dog(3), new Dog(5), new Dog(1)};
        Sorter<Cat> sorter = new Sorter<>();//排序方法
        sorter.sort(a, (o1, o2)->{
            if(o1.weight < o2.weight) return -1;
            else if (o1.weight>o2.weight) return 1;
            else return 0;
        });
        System.out.println(Arrays.toString(a));
    }
}