Strategy模式

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

java 代码

 

package  org.common;    
   
public   class  Calculate  ... {    
        
    public String getResult(float a,float b,char c)...{    
            
        float add = a+b;    
        float sub = a-b;    
        float mult = a*b;    
        float division = a/b;    
            
        switch(c)...{    
            case '+':    
                return "相加结果为:" + add;    
            case '-':    
                return "相减结果为:" + sub;    
            case '*':    
                return "相乘结果为:" + mult;    
            case '/':    
                return "相除结果为:" + division;    
            default:    
                return "出错";    
        }    
    }    
   
}    

 

java 代码

 

package  org.common;    
   
public   class  Test  ... {    
        
    public static void main(String[] args)...{    
        float a = 200;    
        float b = 50;    
        Calculate cal = new Calculate();    
        System.out.println(cal.getResult(a, b, '+'));    
        System.out.println(cal.getResult(a, b, '-'));    
        System.out.println(cal.getResult(a, b, '*'));    
        System.out.println(cal.getResult(a, b, '/'));    
        System.out.println(cal.getResult(a, b, '('));    
    }    
   
}     

 

 

运行结果为：

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

2. 用策略模式来实现：

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

策略模式：

由三部分组成

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

一个抽象策略角色：

java 代码

 

package  org.strategy;    
/** */ /**   
 * 抽象策略角色   
 */    
public   abstract   class  AbstractStrategy  ... {    
   
    public abstract String calculate(float a,float b);    
}     

 

几个具体策略角色：

java 代码

 

package  org.strategy;    
/** */ /**   
 * 具体策略角色   
 */    
public   class  SubStrategy  extends  AbstractStrategy ... {    
   
    public  String calculate(float a,float b)...{    
        float result = a-b;    
        return "相减结果为:" + result;    
    }    
}    

 

java 代码

 

package  org.strategy;    
/** */ /**   
 * 具体策略角色   
 */    
public   class  AddStrategy  extends  AbstractStrategy ... {    
   
    public  String calculate(float a,float b)...{    
        float result = a+b;    
        return "相加结果为:" + result;    
    }    
}     

 

java 代码

 

package  org.strategy;    
/** */ /**   
 * 具体策略角色   
 */    
public   class  MultStrategy  extends  AbstractStrategy ... {    
   
    public  String calculate(float a,float b)...{    
        float result = a*b;    
        return "相乘结果为:" + result;    
    }    
}    

 

 

java 代码

 

package  org.strategy;    
/** */ /**   
 * 具体策略角色   
 */    
public   class  DivisionStrategy  extends  AbstractStrategy ... {    
   
    public  String calculate(float a,float b)...{    
        float result = a/b;    
        return "相除结果为:" + result;    
    }    
}     

 

环境角色：

java 代码

 

package  org.strategy;    
/** */ /**   
 * 环境角色，最终给客户端调用的   
 */    
public   class  ContextRole  ... {    
   
    /** *//**   
     * 拥有一个策略类的引用   
     */   
    private AbstractStrategy abstactStrategy;    
        
    public ContextRole(AbstractStrategy abstactStrategy)...{    
        this.abstactStrategy = abstactStrategy;    
    }    
        
    public String calculate(float a,float b) ...{    
        String result = abstactStrategy.calculate(a, b);    
        return result;    
    }    
}    

 

客户端调用：

java 代码

 

package  org.strategy;    
/** */ /**   
 * 客户端   
 */    
public   class  Test  ... {    
        
    public static void main(String[] args)...{    
        float a = 200;    
        float b = 25;    
            
        ContextRole contextRole1 = new ContextRole(new AddStrategy());    
        System.out.println(contextRole1.calculate(a, b));    
            
        ContextRole contextRole2 = new ContextRole(new SubStrategy());    
        System.out.println(contextRole2.calculate(a, b));    
            
        ContextRole contextRole3 = new ContextRole(new MultStrategy());    
        System.out.println(contextRole3.calculate(a, b));    
            
        ContextRole contextRole4 = new ContextRole(new DivisionStrategy());    
        System.out.println(contextRole4.calculate(a, b));    
            
    }    
   
}     

 

输出结果为：

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

总结：

策略模式优点:

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

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

策略模式缺点:

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