【笔记整理】图解设计模式 | 第10章 Strategy模式（整体地替换算法）

【笔记整理】图解设计模式 | 导航

---

定义

• 可以将“策略”理解为“算法”。
• 为了解决问题，我们需要编写特定的算法。使用Strategy模式可以整体地替换算法的实现部分，这能够让我们轻松地以不同的算法去解决同一个问题。

---

Strategy模式中的登场角色

• Strategy（策略）

       Strategy角色负责决定实现策略所必需的接口（API）。

• ConcreteStrategy（具体的策略）

       ConcreteStrategy角色负责实现Strategy角色的接口（API），即负责实现具体的策略（战略、方向、方法和算法）。

• Context（上下文）

       负责使用Strategy角色。Context角色保存了ConcreteStrategy角色的实例，并使用ConcreteStrategy角色去实现需求（总之，还是要调用Strategy角色的接口（API））。

---

Strategy模式的类图

---

拓展思路的要点

• 为什么需要特意编写Strategy角色

       Strategy模式特意将算法与其他部分分离开来，只是定义了与算法相关的接口（API），然后在程序中以委托的方式来使用算法。

       如果使用了Strategy模式，不必修改Stratege角色的接口（API）了，仅仅修改ConcreteStrategy角色即可。而且，使用委托这种弱关联关系可以很方便地整体替换算法。

• 程序运行中也可以切换策略

       在程序运行中可以动态切换ConcreteStrategy角色，根据不同的场景使用不同的策略。

       还可以用某种算法去“验算”另外一种算法是否准确等等。

---

相关的设计模式

• Flyweight模式（第20章）

       有时会使用Flyweight模式让多个地方可以共享ConcreteStrategy角色。

• Abstract Factroy模式（第8章）

       使用Strategy模式可以整体地替换算法。

       使用Abstract Factory模式则可以整体地替换具体工厂、零件和产品。

• State模式（第19章）

       使用Strategy模式和State模式都可以替换被委托对象，而且它们的类之间的关系也很相似。但是两种模式的目的不同。

       在Strategy模式中，ConcreteStrategy角色是表示算法的类。在Strategy模式中，可以替换被委托对象的类。当然如果没有必要，也可以不替换。

       而在State模式中，ConcreteState角色是表示“状态”的类。在State模式中，每次状态变化时，被委托对象的类都必定会被替换。

---

代码

• Hand类（手势）

public class Hand {

	public static final int HANDVALUE_GUU = 0; // 表示石头的值
	public static final int HANDVALUE_CHO = 1; // 表示剪刀的值
	public static final int HANDVALUE_PAA = 2; // 表示布的值
	public static final Hand[] hand = { new Hand(HANDVALUE_GUU), new Hand(HANDVALUE_CHO), new Hand(HANDVALUE_PAA) };

	private static final String[] name = { // 表示猜拳中手势所对应的字符串
			"石头", "剪刀", "布" };

	private int handvalue; // 猜拳中出的手势的值

	public Hand(int handvalue) {
		this.handvalue = handvalue;
	}

	public static Hand getHand(int handvalue) { // 根据手势的值获取其对应的实例
		return hand[handvalue];
	}

	public boolean isStrongerThan(Hand h) { // 如果this胜了h则返回true
		return fight(h) == 1;
	}

	public boolean isWeakerThan(Hand h) { // 如果this输给了h则返回true
		return fight(h) == -1;
	}

	private int fight(Hand h) {
		if (this == h) {
			return 0;
		} else if ((this.handvalue + 1) % 3 == h.handvalue) {
			return 1;
		} else {
			return -1;
		}
	}

	public String toString() { // 转换为手势值所对应的字符串
		return name[handvalue];
	}

}

• Strategy（策略）

public interface Strategy {

	Hand nexthand();

	void study(boolean win);
}

• ConcreteStrategy（具体的策略）

import java.util.Random;

public class WinningStrategy implements Strategy {

	private Random random;
	private boolean won = false; // 上一局猜拳的输赢结果
	private Hand preHand; // 上一局出的手势

	public WinningStrategy(int seed) {
		random = new Random(seed);
	}

	@Override
	public Hand nexthand() {
		if (!won) {
			preHand = Hand.getHand(random.nextInt(3));
		}
		return preHand;
	}

	@Override
	public void study(boolean win) {
		won = win;
	}

}

import java.util.Random;

public class ProbStrategy implements Strategy {

	private Random random;
	private int prevHandValue = 0;
	private int currentHandValue = 0;
	private int[][] history = { { 1, 1, 1, }, { 1, 1, 1, }, { 1, 1, 1, } };

	public ProbStrategy(int seed) {
		random = new Random(seed);
	}

	@Override
	public Hand nexthand() {
		int bet = random.nextInt(getSum(currentHandValue));
		int handvalue = 0;
		if (bet < history[currentHandValue][0]) {
			handvalue = 0;
		} else if (bet < history[currentHandValue][0] + history[currentHandValue][1]) {
			handvalue = 1;
		} else {
			handvalue = 2;
		}
		prevHandValue = currentHandValue;
		currentHandValue = handvalue;
		return Hand.getHand(handvalue);
	}

	private int getSum(int hv) {
		int sum = 0;
		for (int i = 0; i < 3; i++) {
			sum += history[hv][i];
		}
		return sum;
	}

	@Override
	public void study(boolean win) {
		if (win) {
			// 胜，自己概率自增
			history[prevHandValue][currentHandValue]++;
		} else {
			// 负，则另外两个概率自增
			history[prevHandValue][(currentHandValue + 1) % 3]++;
			history[prevHandValue][(currentHandValue + 2) % 3]++;
		}
	}

}

• Context（上下文）

public class Player {

	private String name;
	private Strategy strategy;
	private int wincount;
	private int losecount;
	private int gamecount;

	public Player(String name, Strategy strategy) { // 赋予姓名和策略
		this.name = name;
		this.strategy = strategy;
	}

	public Hand nextHand() {
		return strategy.nexthand();
	}

	public void win() { // 胜
		strategy.study(true);
		wincount++;
		gamecount++;
	}

	public void lose() {
		strategy.study(false);
		losecount++;
		gamecount++;
	}

	public void even() {
		gamecount++;
	}

	@Override
	public String toString() {
		return "Player [name=" + name + ", strategy=" + strategy + ", wincount=" + wincount + ", losecount=" + losecount
				+ ", gamecount=" + gamecount + "]";
	}

}

• Main类

public class Main {

	public static void main(String[] args) {
		int seed1 = 314;
		int seed2 = 15;

		Player player1 = new Player("XiaoMing", new WinningStrategy(seed1));
		Player player2 = new Player("Suych", new ProbStrategy(seed2));

		for (int i = 0; i < 10000; i++) {
			Hand nextHand1 = player1.nextHand();
			Hand nextHand2 = player2.nextHand();
			if (nextHand1.isStrongerThan(nextHand2)) {
				System.out.println("Winner:" + player1);
				player1.win();
				player2.lose();
			} else if (nextHand2.isStrongerThan(nextHand1)) {
				System.out.println("Winner:" + player2);
				player1.lose();
				player2.win();
			} else {
				System.out.println("Even...");
				player1.even();
				player2.even();
			}
		}
		System.out.println("Total result:");
		System.out.println(player1.toString());
		System.out.println(player2.toString());
	}
}

注：博客中的图片来自网上。