策略模式理解

一 、 概述

策略模式是 处理算法的不同变体的一种成熟模式，策略模式通过接口或抽象类封装算法的标识，即在 接口中定义一个抽象方法，实现该接口的类将实现接口中的抽象方法。
在策略模式中， 封装算法标识的接口称作策略，实现该接口的类称作具体策略。

【ps:处理算法的不同变体指的就是针对一个算法有不同的变体，即对一个行为有多个具体行为】 

   比如一个行为是飞，具有飞这个行为的对象，飞的方式多种多样，飞就是接口为策略，具体怎么飞就是实现该接口的类具体策略 

二、策略模式的结构与使用 

策略模式的结构中包括三种角色

 1. 策略（Strategy）

 2.具体策略（ConcreteStrategy）

 
 3.上下文（Context）                        

      

分析一下uml类图

ConcreteStrategyA与B泛化了Strategy这个接口

Context使用Strategy这个接口【PS:关联关系】持有Strategy这个接口的一个引用，利用多态，可以调用A与B其中一个类的方法

而且自己的成员方法也进行了一下再封装，内部调用这个引用的方法，更安全。

1．策略（Strategy） : Computable.java 

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

2．具体策略（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; 
    }
}

2．具体策略（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; 
    }
}

2．具体策略（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; 
    }
}

3．上下文： 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;
     }
}

4．应用： Application.java_1

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接口类的实例，但不需要知道具体是哪一个类。
  策略模式满足“开-闭原则”。当增加新的具体策略时，不需要修改上下文类的代码，上下文就可以引用新的具体策略的实例。

四.我们身边的设计模式

java.util.Comparator接口【比较器】

public interface Comparator<T> {
  
    int compare(T o1, T o2);

   
    boolean equals(Object obj);
}

我们使用的时候针对不同的对象有不同的比较方法，这个接口是策略，我们的实现则是具体策略，上下文持有策略的引用，方便调用

有问题，请指导促进互相学习！