策略模式(Strategy模式)

1. 以一个算术运算为例，传统做法为：

java 代码
  1. package org.common;   
  2.   
  3. public class Calculate {   
  4.        
  5.     public String getResult(float a,float b,char c){   
  6.            
  7.         float add = a+b;   
  8.         float sub = a-b;   
  9.         float mult = a*b;   
  10.         float division = a/b;   
  11.            
  12.         switch(c){   
  13.             case '+':   
  14.                 return "相加结果为:" + add;   
  15.             case '-':   
  16.                 return "相减结果为:" + sub;   
  17.             case '*':   
  18.                 return "相乘结果为:" + mult;   
  19.             case '/':   
  20.                 return "相除结果为:" + division;   
  21.             default:   
  22.                 return "出错";   
  23.         }   
  24.     }   
  25.   
  26. }  

 

java 代码
  1. package org.common;   
  2.   
  3. public class Test {   
  4.        
  5.     public static void main(String[] args){   
  6.         float a = 200;   
  7.         float b = 50;   
  8.         Calculate cal = new Calculate();   
  9.         System.out.println(cal.getResult(a, b, '+'));   
  10.         System.out.println(cal.getResult(a, b, '-'));   
  11.         System.out.println(cal.getResult(a, b, '*'));   
  12.         System.out.println(cal.getResult(a, b, '/'));   
  13.         System.out.println(cal.getResult(a, b, '('));   
  14.     }   
  15.   
  16. }   

 

运行结果为：

 相加结果为:250.0
相减结果为:150.0
相乘结果为:10000.0
相除结果为:4.0
出错

2. 用策略模式来实现：

策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。
策略模式使得算法可以在不影响到客户端的情况下发生变化。使用策略模式可以把行为和环境分割开来。
环境类负责维持和查询行为类，各种算法则在具体策略中提供。由于算法和环境独立开来，算法的修改都不会影响环境和客户端

策略模式：

由三部分组成

A:  抽象策略角色：策略类，通常由一个接口或者抽象类实现
B:  具体策略角色：包装了相关的算法和行为
C:  环境角色：持有一个策略类的引用，最终给客户端调用的。

一个抽象策略角色：

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 抽象策略角色  
  4.  */  
  5. public abstract class AbstractStrategy {   
  6.   
  7.     public abstract String calculate(float a,float b);   
  8. }   

几个具体策略角色：

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 具体策略角色  
  4.  */  
  5. public class SubStrategy extends AbstractStrategy{   
  6.   
  7.     public  String calculate(float a,float b){   
  8.         float result = a-b;   
  9.         return "相减结果为:" + result;   
  10.     }   
  11. }  

 

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 具体策略角色  
  4.  */  
  5. public class AddStrategy extends AbstractStrategy{   
  6.   
  7.     public  String calculate(float a,float b){   
  8.         float result = a+b;   
  9.         return "相加结果为:" + result;   
  10.     }   
  11. }   

 

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 具体策略角色  
  4.  */  
  5. public class MultStrategy extends AbstractStrategy{   
  6.   
  7.     public  String calculate(float a,float b){   
  8.         float result = a*b;   
  9.         return "相乘结果为:" + result;   
  10.     }   
  11. }  

 

 

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 具体策略角色  
  4.  */  
  5. public class DivisionStrategy extends AbstractStrategy{   
  6.   
  7.     public  String calculate(float a,float b){   
  8.         float result = a/b;   
  9.         return "相除结果为:" + result;   
  10.     }   
  11. }   

环境角色：

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 环境角色，最终给客户端调用的  
  4.  */  
  5. public class ContextRole {   
  6.   
  7.     /**  
  8.      * 拥有一个策略类的引用  
  9.      */  
  10.     private AbstractStrategy abstactStrategy;   
  11.        
  12.     public ContextRole(AbstractStrategy abstactStrategy){   
  13.         this.abstactStrategy = abstactStrategy;   
  14.     }   
  15.        
  16.     public String calculate(float a,float b) {   
  17.         String result = abstactStrategy.calculate(a, b);   
  18.         return result;   
  19.     }   
  20. }  

客户端调用：

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 客户端  
  4.  */  
  5. public class Test {   
  6.        
  7.     public static void main(String[] args){   
  8.         float a = 200;   
  9.         float b = 25;   
  10.            
  11.         ContextRole contextRole1 = new ContextRole(new AddStrategy());   
  12.         System.out.println(contextRole1.calculate(a, b));   
  13.            
  14.         ContextRole contextRole2 = new ContextRole(new SubStrategy());   
  15.         System.out.println(contextRole2.calculate(a, b));   
  16.            
  17.         ContextRole contextRole3 = new ContextRole(new MultStrategy());   
  18.         System.out.println(contextRole3.calculate(a, b));   
  19.            
  20.         ContextRole contextRole4 = new ContextRole(new DivisionStrategy());   
  21.         System.out.println(contextRole4.calculate(a, b));   
  22.            
  23.     }   
  24.   
  25. }   

 

输出结果为：

相加结果为:225.0
相减结果为:175.0
相乘结果为:5000.0
相除结果为:8.0

总结：

策略模式优点:

1.可以很方便的动态改变算法或行为

2.避免使用多重条件转移语句

策略模式缺点:


1.客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
2.造成很多的策略类。

posted on 2008-11-04 09:38 caihaibo 阅读(232) 评论(0)  编辑  收藏 所属分类: java模式

只有注册用户登录后才能发表评论。
网站导航:
 
Powered by: 博客园 模板提供：沪江博客 Copyright ©2024 caihaibo