`
ttitfly
  • 浏览: 623858 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

策略模式(Strategy模式)

    博客分类:
  • java
阅读更多

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.造成很多的策略类。

分享到:
评论
2 楼 dfjinn 2008-10-28  
不错,学习了。
1 楼 sunqi 2008-07-17  
hao,jian dan ming liao

相关推荐

    【Java设计模式】(2)策略模式Strategy

    策略模式(Strategy)是软件设计模式中的一种行为模式,它使你能在运行时改变对象的行为。在Java中,策略模式通常涉及定义一系列算法,并将每个算法封装起来,使得它们可以相互替换,同时使得算法的变化独立于使用它...

    (行为型模式) Strategy 策略模式

    C#面向对象设计模式 (行为型模式) Strategy 策略模式 视频讲座下载

    策略模式 Strategy Pattern

    ### 策略模式 Strategy Pattern #### 概述 策略模式是一种行为设计模式,它使得算法可以在运行时被更改。这种模式允许一个类的行为或其算法在运行时根据需要进行改变,通过这种方式,我们可以轻松地扩展不同的算法...

    策略(strategy)模式

    策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在策略模式中,一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为模式。 在策略模式中,我们创建表示各种策略的对象和一个行为根据...

    走进设计模式之 策略模式(Strategy)

    策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在软件设计中,有时我们需要根据不同的场景或条件选择不同的算法或行为。策略模式允许我们将这些算法封装成独立的类,每个类代表一种策略,然后在运行...

    设计模式C++学习之策略模式(Strategy)

    在`Demo1_Strategy`这个示例中,可能包含了多个C++源文件,分别实现了策略模式的不同方面,例如定义了策略接口、具体策略类以及上下文类的实现。通过分析这些源代码,我们可以更深入地理解策略模式的用法和优势。 ...

    设计模式之策略模式(Strategy Pattern)

    在策略模式中,有三个主要角色:策略接口(Strategy Interface)、具体策略类(Concrete Strategy Classes)和上下文(Context)。策略接口定义了所有支持的算法的公共接口,这样上下文就可以通过这个接口来调用这些...

    策略模式(strategy)

    策略模式的核心组成部分包括策略(Strategy)、上下文(Context)和具体策略(Concrete Strategies)。策略定义了算法家族,而上下文则使用这些策略,但并不知道具体的实现细节。具体策略是实现了策略接口的具体算法...

    设计模式之策略模式(Strategy Pattern)

    策略模式的主要组成部分包括上下文(Context)、策略接口(Strategy Interface)和具体策略类(Concrete Strategy Classes)。上下文维护一个对策略对象的引用,并使用这个引用来调用策略对象的算法。策略接口定义了...

    Java 设计模式-策略模式(Strategy)Android讲解

    首先,策略模式由三个主要组成部分构成:上下文(Context)、策略(Strategy)接口和具体策略(Concrete Strategy)。上下文是使用策略的对象,它维护一个对策略的引用,并调用策略的接口来执行算法。策略接口定义了一组...

    C#面向对象设计模式纵横谈(23):(行为型模式) Strategy 策略模式

    策略模式的核心组成部分包括上下文(Context)、策略(Strategy)和具体策略(Concrete Strategy)。上下文是使用策略的对象,它定义了客户所期望的接口,并负责调用具体策略对象的算法。策略是所有具体策略的抽象接口,它...

    详解SpringBoot结合策略模式实战套路

    SpringBoot结合策略模式实战套路 策略模式是一种常用的设计模式,它可以使我们的代码更加灵活、可维护和可扩展。在SpringBoot项目中,策略模式可以与依赖注入机制相结合,实现更加灵活的业务逻辑处理。在本文中,...

    设计模式-策略模式(Strategy)

    策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。这种模式允许你使用算法族,而无需在代码中硬编码这些算法。通过将算法封装到具有共同接口的独立对象中,策略模式使得你可以根据需要灵活地切换算法,...

    [行为模式] head first 设计模式之策略模式(strategy)

    在提供的`strategy.h`文件中,可能包含了策略模式的C++实现。文件中可能定义了策略接口和几个具体策略类的声明,以及上下文类的接口。为了进一步了解其内容,我们需要查看源代码。由于实际的代码没有提供,这里只能...

    每天感悟总结-策略模式Strategy

    2009-03-9 策略模式Strategy:当解决一个问题的途径(策略)有很多种的时候,每一种处理方式都可以做为一种处理策略,通过管理类来切换调用不同的策略。

    策略模式(Strategy)

    策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在软件设计中,我们经常遇到需要根据不同的条件或策略来执行不同操作的情况。策略模式提供了一种将算法族封装到各自独立的对象中,使得它们可以在运行...

    strategy策略模式源码

    策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。...在提供的压缩包文件"strategy"中,可能包含了关于策略模式的示例代码或者详细解释,你可以解压后查看,进一步理解和学习策略模式的实现和应用。

    桥接模式和策略模式的区别,内含可运行代码和两者详细区别

    而策略模式(Strategy Pattern)则是定义一系列的算法,并将每一个算法封装起来,使它们可以相互替换。策略模式让算法的变化独立于使用它的客户端。它主要用于处理那些具有多种行为的对象,可以根据具体情境选择不同...

Global site tag (gtag.js) - Google Analytics