Java 策略模式

@author ixenos

定义

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

　　2.分割行为和环境：对用户屏蔽内部实现，使客户端在调用算法的时候能够互不影响地互换

策略模式的实现(面向接口编程)

　　方法：

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

　　2.具体策略提供不同算法，环境负责维持和查询策略，把具体策略和环境分割开来，使得算法可以在不影响客户端和环境的情况下修改

　　角色分工：

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

　　2.具体策略角色：实现或继承抽象角色，封装对应策略的算法和行为

　　3.环境角色：持有一个抽象策略角色的引用

　　4.客户端：通过环境角色执行策略

示例

1 public interface Strategy {
2
3     public void doSomething();
4 }  

　　具体策略角色：

1 public class StrategyA implements Strategy {
2
3     @Override
4     public void doSomething() {
5         System.out.println("Strategy A do something.");
6     }
7
8 }  

1 public class StrategyB implements Strategy {
2
3     @Override
4     public void doSomething() {
5         System.out.println("Strategy B do something.");
6     }
7
8 }  

　　环境角色：

 1 public class Context {
 2
 3     private Strategy strategy;
 4
 5     public Context(Strategy strategy) {  //利用接口多态
 6         this.strategy = strategy;
 7     }
 8
 9     public void execute() {
10         this.strategy.doSomething();
11     }
12 }  

　　客户端：

 1 public class StrategyCaller {
 2
 3     public static void main(String[] args) {
 4         Context c = new Context(new StrategyA());
 5         c.execute();
 6
 7         Context c2 = new Context(new StrategyB());
 8         c2.execute();
 9     }
10 }  

泛型化策略模式

 1 @SuppressWarnings("all")
 2 public class Context<T extends Strategy> {  //相当于传具体策略类型实例！而不是一个接口类型
 3
 4     private Strategy s;
 5   　　//构造器利用反射将传进来的通配符类型转化为对应泛型
 6     public Context(Class<? extends Strategy> c) {  //使用通配符类型扩大具体策略类型，实际上有点接口多态的味道
 7         try {
 8             s = (T) Class.forName(c.getName()).newInstance(); //因为类型擦除，运行时的原始类型为Strategy，利用反射得原始类型新实例，（getName返回什么类型，带不带泛型）
 9         } catch (Exception e) {
10             e.printStackTrace();
11         }
12     }
13
14     public void execute() {
15         s.doSomething();
16     }
17
18 }  

　　客户端：

 1 public class StrategyCaller {
 2
 3     public static void main(String[] args) {
 4         Context<StrategyA> c = new Context<StrategyA>(StrategyA.class);
 5         c.execute();
 6
 7         Context<StrategyB> c2 = new Context<StrategyB>(StrategyB.class);
 8         c2.execute();
 9     }
10 }