php设计模式－策略模式－例题学习
本文改自《设计模式－java语言中的应用》中的策略模式章节。作者：结城 浩(日本)
简单的说，策略模式就是算法替换，用不同的类实现不同的算法。
难点：需要根据算法设计出不同的方法，参数等。
程序示例
这里的程序是计算机游戏“剪刀石头布”。
猜拳时的策略有两种方法。第一种方法有点笨，“猜赢之后继续出同样的招式”(WinningStrategy)，第2种方法则是“从上一次出的招式，以概率分配方式求出下一个招式的几率”(ProbStrategy)。
类一览表。
Hand:表示猜拳手势的类
HandStrategyInterface:表示猜拳战略的接口
Player:表示玩猜拳的游戏者的类
WinningStratrgy:策略1，表示猜赢之后继续出同样招式的战略的类
ProbStratrgy:策略2，表示根据上一次出的招式以概率计算出下一个招式的类。
Main:执行主类
代码在附件。
Hand.php
HandStrategyInterface.php
Player.php
WinningStrategy.php
ProbStrategy.php
Main.php
运行结果示例：
代码在附件。
简单的说，策略模式就是算法替换，用不同的类实现不同的算法。
难点：需要根据算法设计出不同的方法，参数等。
程序示例
这里的程序是计算机游戏“剪刀石头布”。
猜拳时的策略有两种方法。第一种方法有点笨，“猜赢之后继续出同样的招式”(WinningStrategy)，第2种方法则是“从上一次出的招式，以概率分配方式求出下一个招式的几率”(ProbStrategy)。
类一览表。
Hand:表示猜拳手势的类
HandStrategyInterface:表示猜拳战略的接口
Player:表示玩猜拳的游戏者的类
WinningStratrgy:策略1，表示猜赢之后继续出同样招式的战略的类
ProbStratrgy:策略2，表示根据上一次出的招式以概率计算出下一个招式的类。
Main:执行主类
代码在附件。
Hand.php
<?php
/**
* 手势类
*
* @author 结城 浩
*/
class Hand
{
public static $HANDVALUE_GUU = 0; //表示石头的值
public static $HANDVALUE_CHO = 1; //表示剪刀的值
public static $HANDVALUE_PAA = 2; //表示布的值
private static $name_arr = array('石头', '剪刀', '布');
/**
* 手势的值
*
* @var int
*/
private $handValue;
/**
* 私有构造方法
*
* @param int $handvalue 手势的值
*/
private function __construct($handvalue)
{
$this->handValue = $handvalue;
}
/**
* 该方法实现单例数组，里面存放3个对象
*
* @return array 对象数组
*/
public static function getHandArr()
{
static $hand_arr = array();
if (!$hand_arr) {
$hand_arr = array(
new Hand(self::$HANDVALUE_GUU),
new Hand(self::$HANDVALUE_CHO),
new Hand(self::$HANDVALUE_PAA),
);
}
return $hand_arr;
}
/**
* 外部调用，获取一个手势对象
*
* @param int $handvalue 手势的值
* @return Hand 一个手势对象
*/
public static function getHand($handvalue)
{
$hand = self::getHandArr();
return $hand[$handvalue];
}
/**
* 判断是否战胜另一个手势
*
* @param Hand $h 另一个手势对象
* @param boolean
*/
public function isStrongerThan(Hand $h)
{
return $this->fight($h) == 1;
}
/**
* 判断是否输给另一个手势
*
* @param Hand $h 另一个手势对象
* @param boolean
*/
public function isWeakerThan(Hand $h)
{
return $this->fight($n) == -1;
}
/**
* 与另一个手势判断输赢
*
* @param Hand $h 另一个手势对象
* @return int 胜为1 ，负为-1，平局为0
*/
private function fight(Hand $h)
{
if ($this->handValue == $h->handValue) {
return 0;
} elseif (($this->handValue + 1) % 3 == $h->handValue) {
return 1;
} else {
return -1;
}
}
/**
* 字符串显示
*/
function __toString()
{
return self::$name_arr[$this->handValue];
}
}
HandStrategyInterface.php
<?php
/**
* 手势策略接口
*/
interface HandStrategyInterface
{
/**
* 得到下一个手势
*/
public function nextHand();
/**
* 策略的智能学习
*/
public function study($win);
}
Player.php
<?php
require_once 'HandStrategyInterface.php';
/**
* 游戏者类
*
* @author 结城 浩
*/
class Player
{
/**
* 游戏者名称
*
* @var string
*/
private $name;
/**
* 私有策略对象
*
* @var HandStrategyInterface
*/
private $strategy;
/**
* 总胜利次数
*
* @var int
*/
private $wincount;
/**
* 总失败次数
*
* @var int
*/
private $losecount;
/**
* 总游戏次数
*
* @var int
*/
private $gamecount;
/**
* 构造方法
*
* @param string $name 游戏者名称
* @param HandStrategyInterface $strategy 策略对象
*/
function __construct($name, HandStrategyInterface $strategy)
{
$this->name = $name;
$this->strategy = $strategy;
$this->wincount = $this->losecount = $this->gamecount = 0;
}
/**
* 根据策略返回游戏者的下一个手势
*
* @return Hand 游戏者的下一个手势
*/
public function nextHand()
{
$hand = $this->strategy->nextHand();
echo $this->name . ":" . $hand ."<br>";
return $hand;
}
/**
* 胜利后的处理
*/
public function win()
{
$this->strategy->study(true);
$this->wincount++;
$this->gamecount++;
}
/**
* 失败后的处理
*/
public function lose()
{
$this->strategy->study(false);
$this->losecount++;
$this->gamecount++;
}
/**
* 平局后的处理
*/
public function even()
{
$this->gamecount++;
}
/**
* 魔术方法显示游戏者信息
*
* @return string
*/
function __toString()
{
return '[' . $this->name . ':' . $this->gamecount . ' games, ' .
$this->wincount . ' win, ' . $this->losecount . ' lose]';
}
}
WinningStrategy.php
<?php
require_once 'Hand.php';
require_once 'HandStrategyInterface.php';
/**
* 简单策略类
*
* 这是第一个策略，非常简单，如果赢了，就继续同一个手势，如果输了，随机出手势。
*
* @author 结城 浩
*/
class WinningStrategy implements HandStrategyInterface
{
/**
* 与该策略算法有关的变量
*
* @var boolean
*/
private $won = false;
/**
* 上一个手势
*
* @var Hand
*/
private $prevhand;
public function __construct()
{
}
/**
* 策略的算法核心。
*
* 如果赢，就继续相同的手势，输则随机产生一个。
*
* @return Hand
*/
public function nextHand()
{
if (!$this->won) {
$this->prevhand = Hand::getHand(mt_rand(0, 2));
}
return $this->prevhand;
}
/**
* 学习方法，只记住当前的输赢结果
*
* @param boolean 输赢结果
*/
public function study($win)
{
$this->won = $win;
}
}
ProbStrategy.php
<?php
require_once 'Hand.php';
require_once 'HandStrategyInterface.php';
/**
* 复杂策略类
*
* 这是第二个策略，虽然下一次的手势都是由随机数决定，不过它会参考之前的输赢记录，机动性的更改手势的出现几率。
* history字段是一份列出过去输赢记录的表格，用来计算几率。history是一个int类型的2维数组，各下标的含义是
* history[上一次的手势][下一次的手势]
* 这个表达式的值越大，则代表之前获胜的几率越高。用实际的数据可能会更清楚一点。
* 这个作战策略的前提是对手的出拳方式也有另一种Pattern。
*
* @author 结城 浩
*/
class ProbStrategy implements HandStrategyInterface
{
/**
* 前面手势的值，统计用
*
* @var int
*/
private $prevHandValue = 0;
/**
* 后面手势的值，统计用
*
* @var int
*/
private $currentHandValue = 0;
/**
* 存放历史数据的数组
*
* history[0][0] 石头之后出石头的不败（获胜或平手）次数。
* history[0][1] 石头之后出剪刀的不败（获胜或平手）次数。
* history[0][2] 石头之后出布的不败（获胜或平手）次数。
* history[1][0] 剪刀之后出石头的不败（获胜或平手）次数。
* history[1][1] 剪刀之后出剪刀的不败（获胜或平手）次数。
* history[1][2] 剪刀之后出布的不败（获胜或平手）次数。
* history[2][0] 布之后出石头的不败（获胜或平手）次数。
* history[2][1] 布之后出剪刀的不败（获胜或平手）次数。
* history[2][2] 布之后出布的不败（获胜或平手）次数。
*
* @var array 二维数组
*/
private $history = array(
array(1, 1, 1),
array(1, 1, 1),
array(1, 1, 1),
);
public function __construct()
{
}
/**
* 算法核心
*
* 根据历史数据，计算出某一个手势的下一个手势的3个概率（比如6:4:13），然后
* 也不一定就是那个最大概率的手势，而是依然根据概率得到下一个手势。
*/
public function nextHand()
{
$bet = mt_rand(0, $this->getSum($this->currentHandValue) - 1);
$handvalue = 0;
if ($bet < $this->history[$this->currentHandValue][0]) {
$handvalue = 0;
} elseif ($bet < ($this->history[$this->currentHandValue][0] +
$this->history[$this->currentHandValue][1]) ) {
$handvalue = 1;
} else {
$handvalue = 2;
}
$this->prevHandValue = $this->currentHandValue;
$this->currentHandValue = $handvalue;
$hand = Hand::getHand($handvalue);
return $hand;
}
/**
* 从历史数据中得到某一个手势的次数之和，算概率用的
*
* @param int $hv
* @return int
*/
private function getSum($hv)
{
$sum = 0;
for ($i = 0; $i < 3; $i++) {
$sum += $this->history[$hv][$i];
}
return $sum;
}
/**
* 该策略的学习就是把结果记入统计数据里。
*
* @param boolean $win 本次的输赢结果
*/
public function study($win)
{
if ($win) {
$this->history[$this->prevHandValue][$this->currentHandValue]++;
} else {
$this->history[$this->prevHandValue][($this->currentHandValue + 1) % 3]++;
$this->history[$this->prevHandValue][($this->currentHandValue + 2) % 3]++;
}
}
}
Main.php
<?php
require_once 'Hand.php';
require_once 'WinningStrategy.php';
require_once 'ProbStrategy.php';
require_once 'Player.php';
/**
* 执行主类
*
* 使用方法，把这几个类一起拷贝到web服务器的docment_root路径下，然后
* http://localhost/Main.php
*
* @author 结城 浩
*/
class Main
{
public static function run()
{
//得到两个游戏者，策略不同
$player1 = new Player('张三', new WinningStrategy());
$player2 = new Player('李四', new ProbStrategy());
//1000次运算，得到结果,并不停的输出。
for ($i = 0; $i < 1000; $i++) {
$nextHand1 = $player1->nextHand();
$nextHand2 = $player2->nextHand();
if ($nextHand1->isStrongerThan($nextHand2)) {
$player1->win();
$player2->lose();
self::echoinfo('胜利者: ' . $player1);
} elseif ($nextHand2->isStrongerThan($nextHand1)) {
$player1->lose();
$player2->win();
self::echoinfo('胜利者: ' . $player2);
} else {
$player1->even();
$player2->even();
self::echoinfo('平手。 ');
}
self::echoinfo(' ');
}
//统计
self::echoinfo('======================= 低调滴分割线 =======================');
self::echoinfo($player1);
self::echoinfo($player2);
}
/**
* 只是一个便利的输出换行
*
* @param string $s 待输出信息
* @return string 加了换行后的输出
*/
public static function echoinfo($s)
{
echo $s . "<br />\n";
}
}
//执行
Main::run();
运行结果示例：
代码在附件。