策略模式（strategy）对存有person对象的list用升序、降序策略进行排序

从圣思园的教学资料里面看到的，嘿嘿！卖窝窝头，一块钱四个！

策略模式在编程中使用接口，而不是对接口的实现

要求：假设有若干个类Person对象存在一个List中，对他们进行排序，按照年龄排序（正序和倒序两种策略）。假如年龄重复，按照id的正序进行排序。使用策略模式。

1、person类

class Person
{
    private int id;
    private String name;
    private int age;
    private static int num = 1;
    public Person(String name,int age)
    {
        this.id = num++;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

 

2、定义一个排序接口，在定义一个正序的策略类和一个倒序的策略类实现这个排序接口，排序直接用Collections集合工具类里面的sort带比较器的方法，重写compare方法的时候判断一下age是否想等，相等则按照id的正序排序。

interface Strategy
{
    void sort(List list);
}
class SortByAgeAsc implements Strategy
{
    @Override
    public void sort(List list) {
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                int n = o1.getAge() - o2.getAge();
                if (n == 0)
                {
                    return o1.getId() - o2.getId();
                }
                return n;
            }
        });
    }
}
class SortByAgeDesc implements Strategy
{
    @Override
    public void sort(List list) {
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                int n = o2.getAge() - o1.getAge();
                if( n == 0) return o1.getId() - o2.getId();
                return n;
            }
        });
    }
}

3、环境类（到时候直接用strategy接口，我们知道有正序和倒序这两个策略，把strategy设置成这两个策略就可以了）

class Environment
{
    private Strategy strategy;
    public Environment(){}
    public Environment(Strategy strategy){
        this.strategy = strategy;
    }

    public Strategy getStrategy() {
        return strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void sort(List<Person> list)
    {
        strategy.sort(list);
    }
}

4、测试一下，奥利给

public class StrategyApp {
    public static void main(String[] args)
    {
        List<Person> list = new ArrayList<>();
        list.add(new Person("lhh",21));
        list.add(new Person("zq",20));
        list.add(new Person("lyx",20));
        list.add(new Person("xht",22));

        Environment env = new Environment();
        SortByAgeAsc ageAsc = new SortByAgeAsc();
        env.setStrategy(ageAsc);
        env.sort(list);
        System.out.println(list);

        Environment env2 = new Environment(new SortByAgeDesc());
        env2.sort(list);
        System.out.println(list);
    }
}

策略模式的组成

1、抽象策略角色：策略类（也就是上面的strategy接口），通常由一个接口或者抽象类实现

2、具体的策略角色：包装了相关的算法和行为。（如上文的SortByAgeAsc、SortByAgeDesc）

3、环境角色：持有一个策略类的引用，最终给客户端调用。（如上文的Environment）

策略模式的实现

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

2、策略模式使得算法可以在不影响到客户端的情况下发生变化。使用策略模式可以把行为和环境分割开来

3、环境类负责维持和查询行为类，各种算法则在具体策略中提供。由于算法和环境独立开来，算法的修改都不会影响环境和客户

策略模式的意义 

1、策略模式使开发人员能够开发出由许多可替换的部分组成的软件，并且各个部分之间是弱连接的关

2、弱连接的特性使软件具有更强的可扩展性，易于维护；更重要的是，它大大提高了软件的可重用性

策略模式的定义 

1、定义一组算法，将每个算法都封装起来，并且使它们之间可以互换

2、策略模式使这些算法在客户端调用它们的时候能够互不影响地变化

策略模式的缺点

1、客户端必须知道所有策略类，并自行决定使用哪一个策略类。

2、造成很多策略类