策略模式

一、策略模式的定义

—— 定义了一组算法，将每个算法包装起来，并且使它们之间可以互换

—— 策略模式使这些算法在客户端调用它们的时候能够相互不影响的变化，改变不同算法的实现方式不影响客户端的使用，即策略模式让算法独立于使用它的客户端而独立变化。

策略模式在Java中处处可以体现，TreeSet和TreeMap中均存在这样的构造方法：TreeSet(Comparator<? super E> comparator)和TreeMap(Comparator<? superK> comparator)，对它的描述为：构造一个空的TreeSet，它根据指定比较器进行排序。这里的指定比较器就是我们根据需要自己写的“算法”，这就是策略模式最基本的使用方式。

    策略模式体现了两个非常基本的面向对象设计的原则：

             1. 封装变化的概念。

             2. 编程中使用接口，而不是对接口的实现

2 总结：在客户端做一个槽（接口），可实现可拔插式 ， 实现接口

二、策略模式的角色组成

抽象策略角色：策略类，通常由一个接口或者抽象类实现

具体策略角色：包装了相关的算法和行为

环境角色：持有一个策略类的引用，最终给客户端调用的

三、编写策略模式的一般步骤：

1. 对策略对象定义一个公共接口

2. 编写具体策略类，该类实现了上面的接口

3. 在使用策略对象的类（即：环境角色）中保存一个对策略对象的引用

4. 在使用策略对象的类中，实现对策略对象的set和get方法(注入)或者使用构造方法完成赋值

5. 客户端进行调用

五、Java实现代码

被比较者

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

抽象策略角色

public interface Comparator<T> {
    int compare(T o1,T o2);
}

具体策略角色
1

public class IncreSort implements Comparator<Person>{


    @Override
    public int compare(Person o1, Person o2) {

        if (o1.getAge() < o2.getAge()){
            return  -1 ;
        }else if (o1.getAge() > o2.getAge()){
            return 1;
        }else {
            return 0;
        }

    }
}

2

public class DecreSort implements Comparator<Person>{
    @Override
    public int compare(Person o1, Person o2) {
        if (o1.getAge() < o2.getAge()){
            return  1 ;
        }else if (o1.getAge() > o2.getAge()){
            return -1;
        }else {
            return 0;
        }
    }
}

环境角色

public class Sort {
    private Comparator comparator;

    public Sort(Comparator comparator) {
        this.comparator = comparator;
    }

    public Person[] sort(Person[] p) {
        Person temp;
        for (int j = 0 ; j < p.length-1 ; j++) {
            for (int i = j+1 ; i < p.length ; i++){
                int compare = comparator.compare(p[i], p[j]);
                if (compare > 0){
                    temp =  p[i];
                    p[i] = p[j];
                    p[j] = temp;
                }
            }

        }

        return p;
    }

}

客户端

public class TestSort {
    public static void main(String[] args) {
         Person[] p = {new Person("1",1),new Person("7",7),new Person("5",5), new Person("4", 4)};
        IncreSort comparetor = new IncreSort();
        DecreSort decreSort = new DecreSort();
        //Sort sort = new Sort(comparetor);
        Sort sort = new Sort(decreSort);
        Person[] sort1 = sort.sort(p);

        for (int i=0 ;i < sort1.length ; i++){
            System.out.println(sort1[i].toString());
        }

    }

}