java设计模式---策略模式

介绍

定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

结构

策略模式的结构中包括三种角色：
  策略（Strategy）
  具体策略（ConcreteStrategy） 
  上下文（Context） 

UML图

策略模式的结构的描述与使用 

策略（Strategy） : Computable.java 

public interface ComputableStrategy{
  public abstract double computeScore(double [] a);
} 

具体策略（ConcreteStrategy）: StrategyOne.java 

public class StrategyOne implements ComputableStrategy{
    public double computeScore(double [] a){
        double score=0,sum=0;
        for(int i=0;i<a.length;i++){
            sum=sum+a[i];
        }
        score=sum/a.length;
        return score; 
    }
}

具体策略（ConcreteStrategy）: StrategyTwo.java 

public class StrategyTwo implements ComputableStrategy{
    public double computeScore(double [] a){
        double score=0,multi=1;
        int n=a.length;
        for(int i=0;i<a.length;i++){
            multi=multi*a[i];
        }
        score=Math.pow(multi,1.0/n);
        return score; 
    }
}

具体策略（ConcreteStrategy）: StrategyThree.java 

import java.util.Arrays;
public class StrategyThree implements ComputableStrategy{
    public double computeScore(double [] a){
        if(a.length<=2)
            return 0;
        double score=0,sum=0;
        Arrays.sort(a);
        for(int i=1;i<a.length-1;i++){
           sum=sum+a[i]; 
        }
        score=sum/(a.length-2);
        return score; 
    }
}

上下文： GymnasticsGame.java 

public class  GymnasticsGame{
     ComputableStrategy strategy;
     public void setStrategy(ComputableStrategy strategy){
         this.strategy=strategy;
     } 
     public double getPersonScore(double [] a){
        if(strategy!=null)
          return strategy.computeScore(a); 
        else
          return 0;
     }
}

应用

 public class Application{
   public static void main(String args[]){
     GymnasticsGame game=new GymnasticsGame();   
     game.setStrategy(new StrategyOne());        
     Person zhang=new Person();
     zhang.setName("张三");
     double [] a={9.12,9.25,8.87,9.99,6.99,7.88};
     Person li=new Person();
     li.setName("李四");
     double [] b={9.15,9.26,8.97,9.89,6.97,7.89};   
     zhang.setScore(game.getPersonScore(a));
     li.setScore(game.getPersonScore(b));
     System.out.println("使用算术平均值方案:");
     System.out.printf("%s最后得分:%5.3f%n",zhang.getName(),zhang.getScore());
     System.out.printf("%s最后得分:%5.3f%n",li.getName(),li.getScore());
     game.setStrategy(new StrategyTwo());   
     zhang.setScore(game.getPersonScore(a));
     li.setScore(game.getPersonScore(b));
     System.out.println("使用几何平均值方案:");
     System.out.printf("%s最后得分:%5.3f%n",zhang.getName(),zhang.getScore());
     System.out.printf("%s最后得分:%5.3f%n",li.getName(),li.getScore()); 

    game.setStrategy(new StrategyThree());    
     zhang.setScore(game.getPersonScore(a));
     li.setScore(game.getPersonScore(b));
     System.out.println("使用（去掉最高、最底）算术平均值方案:");
     System.out.printf("%s最后得分:%5.3f%n",zhang.getName(),zhang.getScore());
     System.out.printf("%s最后得分:%5.3f%n",li.getName(),li.getScore());            
  }
}
class Person{
   String name;
   double score;
   public void setScore(double t){
      score=t;
   }
   public void setName(String s){
      name=s;
   }
   public double getScore(){
      return score;
   }
   public String getName(){
      return name;
   }

}

策略模式的优点 

  上下文（Context）和具体策略（ConcreteStrategy）是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例，但不需要知道具体是哪一个类。

  策略模式满足“开-闭原则”。当增加新的具体策略时，不需要修改上下文类的代码，上下文就可以引用新的具体策略的实例。