23个java设计模式(四)-- 策略模式

2016年03月09日 原创
关键词: java 设计模式
摘要 策略模式定义一系列算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

一、概述。

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

举个例子,比如有个Arrange类,它可以把一个数组从大到小排列,如果客户需要从小到大的顺序进行排列就只有修改源码,哪怕在编写代码的时候考虑得非常全面,考虑到了从小到大的顺序。但是如果遇到奇怪的需求,比如按奇偶排列,按各位排列,就会造成很大的麻烦。而使用策略模式就可以很好的处理这类问题。

此类问题的症结就是Arrange类的方法体中的代码(具体算法)需要经常地发生变化。面向对象编程有一个很好的设计原则“面向抽象编程”,该原则的核心就是将类中经常需要变化的部分分割出来,并将每种可能的变化对应地交给抽象类的一个子类或者实现接口的一个类去负责,从而让类的设计者不去关心具体实现,避免所涉及的类依赖于具体的实现。

二、策略模式的结构。

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

  • 策略(Strategy):策略是一个接口,该接口定义若干个算法标识,即定义了若干个抽象方法。
  • 具体策略(ConcreteStrategy):具体策略是实现策略接口的类。具体策略实现策略接口所定义的抽象方法,即给出算法标识的具体算法。
  • 上下文(Context):上下文是依赖于策略接口的类,即上下文包含策略声明的变量。上下文中提供一个方法,该方法委托策略变量调用具体策略所实现的策略接口中的方法。

三、示例程序。

下面的程序代码演示了如何使用策略模式对同一个数组进行不同的分析计算。

策略

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

具体策略

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

}

public class StrategyThree implements ComputableStrategy{

	@Override
	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+=a[i];
		}
		score = sum/(a.length-2);
		return score;
	}

}

public class StrategyTwo implements ComputableStrategy{

	@Override
	public double computeScore(double[] a) {
		double score=0,multi=1;
		for(int i = 0; i < a.length;i++) {
			multi*=a[i];
		}
		score=Math.pow(multi, 1./a.length);
		return score;
	}

}

上下文

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);
		return 0;
	}
}

测试类

public class Example1Test {
	@Test
	public void testMain() {
		GymnasticsGame game = new GymnasticsGame();
		ComputableStrategy strategy1 = new StrategyOne();
		ComputableStrategy strategy2 = new StrategyTwo();
		ComputableStrategy strategy3 = new StrategyThree();
		double a[] = {9.12,9.25,8.87,9.99,6.99,7.88};
		double b[] = {9.15,9.26,8.97,9.89,6.97,7.89};
		game.setStrategy(strategy1);
		System.out.println("使用算术平均值方案:");
		System.out.printf("%s 最后得分: %5.3f \n", "张三",game.getPersonScore(a));
		System.out.printf("%s 最后得分: %5.3f \n", "李四",game.getPersonScore(b));
		game.setStrategy(strategy2);
		System.out.println("使用几何平均值方案:");
		System.out.printf("%s 最后得分: %5.3f \n", "张三",game.getPersonScore(a));
		System.out.printf("%s 最后得分: %5.3f \n", "李四",game.getPersonScore(b));
		game.setStrategy(strategy3);
		System.out.println("使用(去掉最高、最低)算术平均值方案:");
		System.out.printf("%s 最后得分: %5.3f \n", "张三",game.getPersonScore(a));
		System.out.printf("%s 最后得分: %5.3f \n", "李四",game.getPersonScore(b));
	}
}

 

更多的例子程序可以查看博主的github  https://github.com/cxylpy/design-patterns.git

四、策略模式的优点。

  1. 上下文(Context)和具体策略(ConcreteStrategy)是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例,但不需要知道具体是哪一个类。
  2. 策略模式满足“开-闭原则”。当增加新的具体策略时,不需要修改上下文类的代码,上下文就可以引用新的具体策略的实例。

五、适合使用策略模式的场景。

  1. 一个类定义了多种行为,并且这些行为在这个类的方法中以多个条件语句的形式出现,那么可以使用策略模式避免在类中使用大量的条件语句。
  2. 程序不希望暴露复杂的、与算法相关的数据结构,那么可以使用策略模式封装算法。
  3. 需要使用一个算法的不同变体。