注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

东东的博客

江南烟雨,同大家一起分享

 
 
 

日志

 
 

设计模式读书笔记之策略模式(Strategy)  

2010-07-13 17:40:37|  分类: 设计模式相关 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化.
(原文:The Strategy Pattern defines a family of algorithms,encapsulates each one,and makes them interchangeable.

Strategy lets the algorithm vary independently from clients that use it.)

策略模式的特点:
1 Context(应用实例或client, 即使用Strategy的类)持有一个Strategy实例;
2 Context可以动态灵活的设置Strategy的具体实例,即切换算法;
3 Context通过调用strategy的方法来执行具体的行为。

示例代码:

  1. class StrategyExample {  
  2.     //test case.  
  3.     public static void main(String[] args) {  
  4.         Context context;  
  5.         // Three contexts following different strategies  
  6.         context = new Context(new FirstStrategy());  
  7.         context.execute();  
  8.           
  9.         context = new Context(new SecondStrategy());  
  10.         context.execute();  
  11.           
  12.         context = new Context(new ThirdStrategy());  
  13.         context.execute();  
  14.     }  
  15.    
  16. }  
  17.    
  18. // Strategy interface  
  19. // The context class uses this to call the concrete strategy  
  20. interface Strategy {  
  21.     void execute();  
  22. }  
  23.    
  24. // Implements the algorithm using the strategy interface  
  25. class FirstStrategy implements Strategy {  
  26.     public void execute() {  
  27.         System.out.println("Called FirstStrategy.execute()");  
  28.     }  
  29. }  
  30.    
  31. class SecondStrategy implements Strategy {  
  32.     public void execute() {  
  33.         System.out.println("Called SecondStrategy.execute()");  
  34.     }  
  35. }  
  36.    
  37. class ThirdStrategy implements Strategy {  
  38.     public void execute() {  
  39.         System.out.println("Called ThirdStrategy.execute()");  
  40.     }  
  41. }  
  42.   
  43. // Configured with a ConcreteStrategy object and maintains a reference to a Strategy object  
  44. class Context {  
  45.     Strategy strategy;  
  46.     // Constructor  
  47.     public Context(Strategy strategy) {  
  48.         this.strategy = strategy;  
  49.     }  
  50.     public void execute() {  
  51.         this.strategy.execute();  
  52.     }  

这个例子很抽象,大多数的设计模式书中都会给出这么个例子,这个例子不具备任何生产价值,于是我想到了一个更好的例子:
笔记本电脑中都有一个电源管理器,提供多种电源管理方案。每个方案都是一种策略,操作系统(或使用电脑的人)应该能灵活切换供电方案。下面用代码模拟:

  1. //策略接口  
  2. package designpattern.strategy;  
  3.   
  4. public interface PowerStrategy {  
  5.     public void apply();  
  6. }  
  7.   
  8. //引用实例,持有策略者  
  9. package designpattern.strategy;  
  10.   
  11. public class Computer {  
  12.     private PowerStrategy ps;  
  13.     public PowerStrategy getPs() {  
  14.         return ps;  
  15.     }  
  16.     public void setPs(PowerStrategy ps) {  
  17.         this.ps = ps;  
  18.     }  
  19.     public void applyPowerStrategy(){  
  20.         ps.apply();  
  21.     }  
  22. }  
  23.   
  24. //策略1 高表现性能策略  
  25. package designpattern.strategy;  
  26.   
  27. public class HighPerformanceStrategy implements PowerStrategy{  
  28.     public void apply() {  
  29.         System.out.println("*** High performance power strategy ***");  
  30.         System.out.println("Turn off monitor: Never;");  
  31.         System.out.println("Turn off hard disk: Never;");  
  32.         System.out.println("System standby: Never;");  
  33.         System.out.println("System hibernates: Never.\n");  
  34.     }  
  35. }  
  36. //策略2 中等策略  
  37. package designpattern.strategy;  
  38.   
  39. public class MediumStragegy implements PowerStrategy{  
  40.     public void apply() {  
  41.         System.out.println("*** Medium power strategy ***");  
  42.         System.out.println("Turn off monitor: 1 hour;");  
  43.         System.out.println("Turn off hard disk: 2 hours;");  
  44.         System.out.println("System standby: 3 hours;");  
  45.         System.out.println("System hibernates: 4 hours.\n");  
  46.     }  
  47. }  
  48.   
  49. //策略3 节能策略  
  50. package designpattern.strategy;  
  51.   
  52. public class EnergySavingStrategy implements PowerStrategy{  
  53.     public void apply() {  
  54.         System.out.println("*** Energy-saving strategy ***");  
  55.         System.out.println("Turn off monitor: 5 minutes;");  
  56.         System.out.println("Turn off hard disk: 15 minutes;");  
  57.         System.out.println("System standby: 30 minutes;");  
  58.         System.out.println("System hibernates: 1 hour.\n");  
  59.     }  
  60. }  
  61.   
  62.   
  63. //测试用例  
  64. package designpattern.strategy;  
  65.   
  66. public class Test {  
  67.     public static void main(String[] args){  
  68.         Computer c = new Computer();  
  69.         c.setPs(new HighPerformanceStrategy());  
  70.         c.applyPowerStrategy();  
  71.           
  72.         c.setPs(new MediumStragegy());  
  73.         c.applyPowerStrategy();  
  74.           
  75.         c.setPs(new EnergySavingStrategy());  
  76.         c.applyPowerStrategy();  
  77.     }  

经典案例:

1 jdk中的类File有一个方法:public String[] list(FilenameFilter filter),列出当前目录下的所有文件,FilenameFilter就是一个策略接口,使用者可以根据自己的需求自由变换文件筛选策略.
2 jdk中工具类Arrays有一个可以对集合排序的方法: public static <T> void sort(T[] a, Comparator<? super T> c),传入一个数组和一个比较器, 这个比较器就是一个策略.(此案有争议,有人认为是template method模式).

应用场景:
1 多个类只区别在表现行为不同,可以使用Strategy模式,在运行时动态选择具体要执行的行为;
2 需要在不同情况下使用不同的策略(算法)。

优点:
把容易发生变化的算法独立出来,易于扩展。

缺点:

类增多了,使系统难度加大。

转自:http://blog.csdn.net/sunxing007/archive/2010/03/15/5381587.aspx

  评论这张
 
阅读(521)| 评论(0)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017