Java设计模式--策略模式（对象行为型）

1.概述

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

2.涉及到的角色

   策略类（Stratege）：定义所有支持的算法的公共接口。

   具体策略类（Concrete Stratege）：封装了具体的算法或行为，继承于Stratege类。

   上下文类（Context）：用一个ConcreteStratege来配置，维护一个对Stratege对象的引用。

3.适用性

        1）对客户隐藏具体策略(算法)的实现细节，彼此完全独立。

        2）针对同一类型问题的多种处理方式，仅仅是具体行为有差别时。

        3)一个类定义了很多行为，而且这些行为在这个类里的操作以多个条件语句的形式出现。 

           策略模式将相关的条件分支移入它们各自的 Strategy类中以代替这些条件语句。

4.策略模式的优缺点

   优点：

     1)相关算法系列 Strategy类层次为Context定义了一系列的可供重用的算法或行为。 继承有助于析取出这些算法中的公共功能。

     2)消除了一些if else条件语句 ：Strategy模式提供了用条件语句选择所需的行为以外的另一种选择。当不同的行为堆砌在一个类中时

  很难避免使用条件语句来选择合适的行为。将行为封装在一个个独立的Strategy类中消除了这些条件语句。含有许多条件语句的代码

  3)策略模式每个算法都有自己的类，可以通过自己的接口单独测试。因而简化了单元测试。通常意味着需要使用Strategy模式。

   缺点：

     1)客户端必须知道所有的策略类，并自行决定使用哪一个策略类

      2)策略模式将造成产生很多策略类组成

5.结构：

  

6.实例代码：（某项比赛时对选手进行打分）

抽象策略接口：

package com.strategy;

/**
 * @author lxp
 *
 * @TODO
 * 
 */
// 定义抽象策略接口
public interface ComputableStrategy {
	//计算分数
	public abstract double computableScore(double[] a);//数组a中的元素表示被选手打的不同的分数
}

策略一：

package com.strategy;

/**
 * @author lxp
 *
 * @TODO
 * 
 */
// 定义策略一实现策略接口
public class StrategyOne implements ComputableStrategy {

	@Override
	public double computableScore(double[] a) {//计算数组a的元素的代数平均值
		// TODO Auto-generated method stub
		double Score = 0, Sum = 0;
		for (int i = 0; i < a.length; i++) {
			Sum += a[i];
		}
		Score = Sum / a.length;

		return Score;
	}

}

具体策略二：

package com.strategy;

/**
 * @author lxp
 *
 * @TODO
 * 
 */
// 定义策略二实现策略接口
public class StrategyTwo implements ComputableStrategy {

	@Override
	public double computableScore(double[] a) {// 计算数组a的元素的几何平均数
		// TODO Auto-generated method stub
		double Score = 0, Multi = 1;
		for (int i = 0; i < a.length; i++) {
			Multi = Multi * a[i];
		}
		Score = Math.pow(Multi, 1.0 / (a.length));
		return Score;
	}
}

具体策略三：

package com.strategy;

import java.util.Arrays;


/**
 * @author lxp
 *
 * @TODO
 * 
 */
// 定义策略三实现策略接口
public class StrategyThree implements ComputableStrategy {

	@Override
	public double computableScore(double[] a) {// 计算数组a中去除最大值个最小值后的代数平均值
		// TODO Auto-generated method stub

		// 将数组a进行排序
		Arrays.sort(a);

		double Score = 0, Sum = 0;
		if (a.length <= 2) {
			return 0;
		} else {
			for (int i = 1; i < a.length - 1; i++) {
				Sum += a[i];
			}
			Score = Sum / (a.length - 2);
		}
		return Score;
	}

}

上下文类：（此实例中定义为该项比赛）

package com.strategy;

/**
 * @author lxp
 *
 * @TODO
 * 
 */
// 定义上下文的环境类（Context）
public class Game {

	private ComputableStrategy strategy;
	double Score;

	// 定义使用某种策略的方法
	public void setStrategy(ComputableStrategy strategy) {
		this.strategy = strategy;
	}

	// 获得最终的Score
	public double getScore(double[] a) {
		if (strategy == null) {
			return 0;
		} else {
			Score = strategy.computableScore(a);
		}
		return Score;
	}
}

测试类：

package com.strategy;
/**
* @author lxp
*
* @TODO 
* 
*/
//测试类
public class StrategyDemo {
	public static void main(String[] args) {
		double[] a={9,8,10,9,8,9,8,7,10};
		Game game=new Game();
		//使用StrategyOne
		game.setStrategy(new StrategyOne());
		System.out.println("使用策略一得到的分数是："+"\r"+game.getScore(a));
		System.out.println("----------------");
		
		game.setStrategy(new StrategyTwo());
		System.out.println("使用策略二得到的分数是："+"\r"+game.getScore(a));
		System.out.println("----------------");
		
		game.setStrategy(new StrategyThree());
		System.out.println("使用策略三得到的分数是："+"\r"+game.getScore(a));
		System.out.println("----------------");
	}
}

试验结果：