Java设计模式--策略模式

策略模式（别名：政策）

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

Strategy Pattern（Another Name: Policy）

Define a family of algorithms, encapsulate each one, and make them inter changeable. Strategy lets the algorithm vary independently from clients that use it.

类图

模式的结构与使用

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

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

简单的例子

Abstract Strategy的接口类ComputableStrategy.java

package Strategy;

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

Strategy的实现类StrategyOne.java

package Strategy;

public class StrategyOne implements ComputableStrategy {

	@Override
	public double computableStrategy(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;
	}
}

Strategy的实现类StrategyTwo.java

package Strategy;

public class StrategyTwo implements ComputableStrategy {

	@Override
	public double computableStrategy(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;
	}
}

Strategy的实现类StrategyThree.java

package Strategy;

import java.util.Arrays;

public class StrategyThree implements ComputableStrategy {

	@Override
	public double computableStrategy(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;
	}
}

Context类GymnasticsGame.java

package Strategy;

public class GymnasticsGame {
	ComputableStrategy strategy;

	public void setStrategy(ComputableStrategy strategy) {
		this.strategy = strategy;
	}

	public double getPersonScore(double a[]) {
		if (strategy != null) {
			return strategy.computableStrategy(a);
		} else
			return 0;
	}
}

测试类Application.java

package Strategy;

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("李四");
		zhang.setScore(game.getPersonScore(a));
		li.setScore(game.getPersonScore(a));
		System.out.println(zhang.getScore());
		System.out.println(li.getScore());
		
		game.setStrategy(new StrategyThree());
		zhang.setScore(game.getPersonScore(a));
		li.setScore(game.getPersonScore(a));
		System.out.println(zhang.getScore());
		System.out.println(li.getScore());
	}
}

class Person {
	String name;
	double score;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}
}

执行效果图

策略模式的优点

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

适用策略模式的情景

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

下载源码请到

MyGitHub