在Java的集合框架中，经常需要通过构造方法传入一个比较器Comparator，或者创建比较器传入Collections的静态方法中作为方法参数，进行比较排序等，使用的是策略模式。
一、策略模式的定义
定义了算法族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。
二、策略模式体现了两个非常基本的面向对象设计原则：
封装变化的概念,找出应用中可能需要变化之处，把它独立出来，不要把那些不需要变化的代码混在一起，系统会变得更有弹性。
编程中使用接口，而不是对接口的实现。
三、策略模式的角色组成
抽象策略角色：策略类，通常由一个接口或者抽象类实现
具体策略角色：包装了相关的算法和行为
环境角色：持有一个策略类的引用，最终给客户端调用的
四、编写策略模式的一般步骤：
1. 对策略对象定义一个公共接口
2. 编写具体策略类，该类实现了上面的接口
3. 在使用策略对象的类（即：环境角色）中保存一个对策略对象的引用
4. 在使用策略对象的类中，实现对策略对象的set和get方法(注入)或者使用构造方法完成赋值
5. 客户端进行调用
五、示例代码
/** * 策略类 * */ public abstract class Strategy { public abstract void algorithmln() ; }
/** *具体策略类 */ public class ConcreateStrategyA extends Strategy{ @Override public void algorithmln() { System.out.println("A"); } } /** *具体策略类 */ public class ConcreateStrategyB extends Strategy{ @Override public void algorithmln() { System.out.println("B"); } } /** *具体策略类 */ public class ConcreateStrategyC extends Strategy{ @Override public void algorithmln() { System.out.println("C"); } }
/** *环境角色 */ public class Context { //定义一个对策略对象的引用 private Strategy strategy; public Context(Strategy strategy) { this.strategy=strategy; } public void contextStrategy() { strategy.algorithmln(); } }
测试代码
public class TestStrategy { public static void main(String[] args) { //测试 Context contextA=new Context(new ConcreateStrategyA()); contextA.contextStrategy(); Context contextB=new Context(new ConcreateStrategyB()); contextB.contextStrategy(); Context contextC=new Context(new ConcreateStrategyC()); contextC.contextStrategy(); } }
输出结果
A
B
C
策略模式在Java中处处可以体现，TreeSet和TreeMap中均存在这样的构造方法：TreeSet(Comparator<? super E> comparator)和TreeMap(Comparator<? superK> comparator)，对它的描述为：构造一个空的TreeSet，它根据指定比较器进行排序。这里的指定比较器就是我们根据需要自己写的“算法”，这就是策略模式最基本的使用方式。
Java实现代码
要求：有这样一个类Class Person，包含id、name、age属性，有若干了Person对象存储在List中，要求对他们进行排序，分别按照名字、年龄、id进行排序（要有正序与倒序两种方式）。如果年龄或者姓名重复，则按照id的正序进行排列。要求使用策略模式进行。
思路分析：可以将若干Person类存放在ArrayList中，然后利用Collections中的 sort(List<T> list,Comparator<? super T> c)方法根据指定比较器产生的顺序对指定列表进行排序，我们要实现具体的比较规则，由于Comparator是一个接口，正好可以作为步骤一中的抽象策略角色。
1. 对策略对象定义一个公共接口
省了一步，直接用接口Comparator即可
2. 编写具体策略类，该类实现了上面的接口
按name进行排序的具体策略类SortByName，其它SortById和SortByAge与之类似：
package com.StrategyJob; import java.util.Comparator; public class SortByName implements Comparator { private int sortType = 0 ; // 定义标记位,默认是采用升序排列 @Override public int compare(Object arg0, Object arg1) { Person p0 = (Person)arg0 ; Person p1 = (Person)arg1 ; String name0 = p0.name ; String name1 = p1.name ; int id0 = p0.id ; int id1 = p1.id ; if(name0.endsWith(name1)){ return id0 - id1 ; } if(this.sortType != 0 ){ return name1.compareTo(name0); }else{ return name0.compareTo(name1); } } // 设置排序类型 public void setSortType(int sign) { this.sortType = sign ; } }
3. 在使用策略对象的类（即：环境角色）中保存一个对策略对象的引用 ； 在使用策略对象的类中，实现对策略对象的set和get方法(注入)或者使用构造方法完成赋值
这里3和4的步骤是在一起
package com.StrategyJob; import java.util.Comparator; public class Environment { private Comparator comparator ; // 私有的抽象策略角色的引用 public Environment(Comparator comp) { this.comparator = comp ; } public void setComparator(Comparator comp){ this.comparator = comp ; } public Comparator getComparator(){ return this.comparator; }
客户端进行调用
public static void main(String[] args){ // 按姓名name进行排序 SortByName sortbyname = new SortByName() ; Environment environment = new Environment(sortbyname); Person p1 = new Person(); Person p2 = new Person(); Person p3 = new Person(); Person p4 = new Person(); ArrayList list = new ArrayList(); p1.setName("zhangsan"); p1.setId(1); p1.setAge(20); p2.setName("lisi"); p2.setId(5); p2.setAge(25); p3.setName("wangwu"); p3.setId(16); p3.setAge(5); p4.setName("zhangsan"); p4.setId(6); p4.setAge(5); list.add(p1); list.add(p2); list.add(p3); list.add(p4); System.out.println("--------------------- 按照name升序排列 -----------------------"); // 按照name进行排序 Collections.sort(list, environment.getComparator()); for(Iterator iter = list.iterator() ; iter.hasNext() ; ){ Person p = (Person)iter.next(); String name = p.name ; int id = p.id ; System.out.println(name + " "+ id); } sortbyname.setSortType(1); System.out.println("--------------------- 按照name降序排列start -----------------------"); // 按照name进行排序 Collections.sort(list, environment.getComparator()); for(Iterator iter = list.iterator() ; iter.hasNext() ; ){ Person p = (Person)iter.next(); String name = p.name ; int id = p.id ; System.out.println(name + " "+ id); } System.out.println("---------------------- 按照id升序排列 ----------------------"); SortById sortbyid = new SortById(); environment.setComparator(sortbyid); Collections.sort(list, environment.getComparator()); for(Iterator iter = list.iterator() ; iter.hasNext() ; ){ Person p = (Person)iter.next(); int id = p.id ; System.out.println(id + ""); } System.out.println("---------------------- 按照id降序排列 ----------------------"); sortbyid.setSortType(1); Collections.sort(list, environment.getComparator()); for(Iterator iter = list.iterator() ; iter.hasNext() ; ){ Person p = (Person)iter.next(); int id = p.id ; System.out.println(id + ""); } System.out.println("---------------------- 按照age升序排列 ----------------------"); SortByAge sortbyage = new SortByAge(); environment.setComparator(sortbyage); Collections.sort(list, environment.getComparator()); for(Iterator iter = list.iterator() ; iter.hasNext() ; ){ Person p = (Person)iter.next(); int age = p.age ; System.out.println(age + " " + p.id); } System.out.println("---------------------- 按照age降序排列 ----------------------"); sortbyage.setSortType(1); Collections.sort(list, environment.getComparator()); for(Iterator iter = list.iterator() ; iter.hasNext() ; ){ Person p = (Person)iter.next(); int age = p.age ; System.out.println(age + " " + p.id); } }
运行结果
应用场景和优缺点
对于Strategy模式来说，主要有这些应用场景：
1、 多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为
2、 需要在不同情况下使用不同的策略(算法)，或者策略还可能在未来用其它方式来实现
3、 对客户隐藏具体策略(算法)的实现细节，彼此完全独立。
对于Strategy模式来说，主要有如下优点：
1、 提供了一种替代继承的方法，而且既保持了继承的优点(代码重用)还比继承更灵活(算法独立，可以任意扩展)。
2、 避免程序中使用多重条件转移语句，使系统更灵活，并易于扩展。
3、 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。
对于Strategy模式来说，主要有如下缺点：
1、 因为每个具体策略类都会产生一个新类，所以会增加系统需要维护的类的数量。
参考资料
《Head First Design Patterns》
http://blog.csdn.net/houqd2012/article/details/12585093?utm_source=tuicool
