设计模式学习笔记——策略(Strategy)模式

@(设计模式)[设计模式, 策略模式, Stategy]

基本介绍

策略模式主要用于整体切换解决方案，算法。一般使用委托来实现。

策略案例

类图

实现代码

Hand类

package com.pc.strategy.example;/** * 猜拳手势类 * Created by Switch on 2017-02-20. */public class Hand {    private static final int HANDVALUE_ST = 0;  // 石头    private static final int HANDVALUE_JD = 1;  // 剪刀    private static final int HANDVALUE_BU = 2;  // 布    private int handValue;  // 手势值    // 手势值对应的手势名    private static final String[] name = {            "石头", "剪刀", "布"    };    // 手势实例    public static final Hand[] hand = {            new Hand(HANDVALUE_ST),            new Hand(HANDVALUE_JD),            new Hand(HANDVALUE_BU)    };    /**     * 构造方法，私有化，不能new出实例，注册表单例模式     *     * @param handValue 手势值     */    private Hand(int handValue) {        this.handValue = handValue;    }    /**     * 根据手势值，获取手势实例     *     * @param handValue 手势值     * @return 手势实例     */    public static Hand getHand(int handValue) {        return hand[handValue];    }    /**     * 赢了返回true     *     * @param hand 手势实例     * @return     */    public boolean isStrongerThan(Hand hand) {        return fight(hand) == 1;    }    /**     * 输了返回true     *     * @param hand 手势实例     * @return     */    public boolean isWeakerThan(Hand hand) {        return fight(hand) == -1;    }    /**     * 比较     *     * @param hand 手势实例     * @return     */    private int fight(Hand hand) {        if (this.handValue == hand.handValue) {            return 0;   // 平        } else if ((this.handValue + 1) % 3 == hand.handValue) {            return 1;   // 胜        } else {            return -1;  // 负        }    }    @Override    public String toString() {        // 手势值对应的手势名        return name[this.handValue];    }}

Strategy接口

package com.pc.strategy.example;/** * 猜拳策略接口 * Created by Switch on 2017-02-20. */public interface Strategy {    /**     * 下一个出拳手势     *     * @return 手势实例     */    Hand nextHand();    /**     * 根据上一次猜拳是否获胜，决定下一次的猜拳手势     *     * @param win 是否获胜     */    void study(boolean win);}

WinningStrategy类

package com.pc.strategy.example;import java.util.Random;/** * Winning策略类 * Created by Switch on 2017-02-20. */public class WinningStrategy implements Strategy {    private Random random; // 随机    private boolean won = false;    // 上一把是否赢了    private Hand prevHand;  // 上一把的手势对象    /**     * 构造方法，传入初始化随机seek     *     * @param seed 随机种子     */    public WinningStrategy(int seed) {        this.random = new Random(seed);    }    @Override    public Hand nextHand() {        if (!this.won) {            this.prevHand = Hand.getHand(this.random.nextInt(3));        }        return this.prevHand;    }    @Override    public void study(boolean win) {        this.won = win;    }}

ProbStrategy类

package com.pc.strategy.example;import java.util.Random;/** * Prob策略类 * Created by Switch on 2017-02-20. */public class ProbStrategy implements Strategy {    private Random random;  // 随机    private int prevHandValue;  // 上一把的手势值    private int currentHandValue; // 这一把的手势值    // 历史出拳概率数组    // history[上一把的手势值][这一把的手势值] 表示赢的次数    private int[][] history = {            {1, 1, 1},            {1, 1, 1},            {1, 1, 1}    };    /**     * 构造方法，传入初始化随机seek     *     * @param seed 随机种子     */    public ProbStrategy(int seed) {        this.random = new Random(seed);    }    @Override    public Hand nextHand() {        int randomValue = this.random.nextInt(this.getSum(this.currentHandValue));        int handValue = 0;        if (randomValue < this.history[this.currentHandValue][0]) {            // 当随机数在0到剪刀赢的次数时，赋值为0            handValue = 0;        } else if (randomValue < this.history[this.currentHandValue][0] + this.history[this.currentHandValue][1]) {            // 当随机数在剪刀赢的次数到石头赢得次数时，赋值为1            handValue = 1;        } else {            // 其他情况，赋值为2            handValue = 2;        }        // 当前值赋值为之前值        this.prevHandValue = this.currentHandValue;        // 计算出来的值赋值为当前值        this.currentHandValue = handValue;        return Hand.getHand(handValue);    }    /**     * 获取history[上一把的手势值][三种手势]赢的总次数     *     * @param hv 上一把的手势值     * @return history[上一把的手势值][三种手势]赢的总次数     */    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[上一把的手势值][这一把的手势]赢的次数加一            this.history[this.prevHandValue][this.currentHandValue]++;        } else {            // history[上一把的手势值][其他手势]赢的次数加一            this.history[this.prevHandValue][(this.currentHandValue + 1) % 3]++;            this.history[this.prevHandValue][(this.currentHandValue + 2) % 3]++;        }    }}

Player类

package com.pc.strategy.example;/** * 玩家类 * Created by Switch on 2017-02-20. */public class Player {    private String name; // 玩家名    private Strategy strategy; // 策略对象    private int wincount;   // 赢的次数    private int losecount;  // 输出次数    private int gamecount;  // 游戏总次数    /**     * 构造方法     *     * @param name     玩家名     * @param strategy 策略对象     */    public Player(String name, Strategy strategy) {        this.name = name;        this.strategy = strategy;    }    /**     * 策略决定下次要出的手势     *     * @return 手势对象     */    public Hand nextHand() {        return this.strategy.nextHand();    }    /**     * 赢     */    public void win() {        this.strategy.study(true);        this.wincount++;        this.gamecount++;    }    /**     * 输     */    public void lose() {        this.strategy.study(false);        this.losecount++;        this.gamecount++;    }    /**     * 平     */    public void even() {        this.gamecount++;    }    @Override    public String toString() {        return "[" + this.name + ":" + this.gamecount + " games, " + this.wincount + " win, " + this.losecount + " lose]";    }}

测试类

package com.pc.strategy.example.test;import com.pc.strategy.example.Hand;import com.pc.strategy.example.Player;import com.pc.strategy.example.ProbStrategy;import com.pc.strategy.example.WinningStrategy;import org.junit.Test;/** * Strategy Tester. * * @author Switch * @version 1.0 */public class StrategyTest {    /**     * 测试策略类     */    @Test    public void testStrategy() {        Player switchvov = new Player("switch", new WinningStrategy(54));        Player kity = new Player("kity", new ProbStrategy(32));        for (int i = 0; i < 10000; i++) {            Hand nextValue1 = switchvov.nextHand();            Hand nextValue2 = kity.nextHand();            if (nextValue1.isStrongerThan(nextValue2)) {                switchvov.win();                kity.lose();                System.out.println("Winner:" + switchvov);            } else if (nextValue1.isWeakerThan(nextValue2)) {                switchvov.lose();                kity.win();                System.out.println("Winner:" + kity);            } else {                System.out.println("Even...");                switchvov.even();                kity.even();            }        }        System.out.println("Total Result:");        System.out.println(switchvov);        System.out.println(kity);    }}

运行结果

Winner:[switch:1 games, 1 win, 0 lose]Winner:[switch:2 games, 2 win, 0 lose]Even...Winner:[kity:4 games, 1 win, 2 lose]Winner:[kity:5 games, 2 win, 2 lose]省略N行。。。Winner:[switch:9998 games, 3136 win, 3642 lose]Winner:[switch:9999 games, 3137 win, 3642 lose]Winner:[kity:10000 games, 3643 win, 3137 lose]Total Result:[switch:10000 games, 3137 win, 3643 lose][kity:10000 games, 3643 win, 3137 lose]

策略模式中的角色

Strategy(策略)

Strategy角色负责决定实现策略所必需的接口(API)。在案例中，由Strategy接口扮演此角色。

ConcreteStrategy(具体的策略)

ConcreteStrategy角色负责实现Strategy角色的接口(API) ，即负责实现具体的策略(战略、方向、方法和算法)。在案例中，由WinningStrategy类和ProbStrategy类扮演此角色。

Context(上下文)

负责使用Strategy角色。Context角色保存了ConcreteStrategy 角色的实例，并使用ConcreteStrategy角色去实现需求(总之，还是要调用Strategy角色的接口(API))。在案例中，由Player类扮演此角色。

类图

GitHub：DesignPatternStudy

——————参考《图解设计模式》