PHP之星际设计模式下(转自lightsaber)

15-状态模式

星际的一些兵种会有不止一种状态，比如坦克可以架起来，枪兵可以打兴奋剂，甚至还有一些被动的，比如被虫族女王喷洒绿色液体后，敌人的行动变慢。
如果按照一般的思路，每次我们对一个小兵进行操作的时候，比如一辆坦克，我们都要用if判断他的状态，这样代码中会有很多的if，else或者swith。
不过我们可以发现，我们需要的是他在某个状态下的行为，如果把这些行为按照状态封装起来，就可以减少大量的判断。
待解决的问题：封装坦克的状态，让状态自己去控制行为。
思路：把状态作为属性，兵种类本身只控制状态的变化，具体的行为由状态类定义。

状态（State）模式示例：
<?php
//坦克状态的接口
interface TankState
{
//坦克的攻击方法
public function attack();
}

//坦克普通状态
class TankState_Tank implements TankState
{
//坦克的攻击方法
public function attack()
{
//这里简单的输出当前状态
echo "普通状态";
}
}

//坦克架起来的状态
class TankState_Siege implements TankState
{
//坦克的攻击方法
public function attack()
{
//这里简单的输出当前状态
echo "架起来了";
}
}

//坦克类
class Tank
{
//状态
public $state;
//坦克的攻击方法
public function __construct()
{
//新造出来的坦克当然是普通状态
$this->state = new TankState_Tank();
}
//设置状态的方法，假设参数为玩家点击的键盘
public function setState($key)
{
//如果按了s
if($key = 's')
{
$this->state = new TankState_Siege();
}
//如果按了t
elseif($key = 't')
{
$this->state = new TankState_Tank();
}
}
//坦克的攻击方法
public function attack()
{
//由当前状态自己来处理攻击
$this->state->attack();
}
}
//新造一辆坦克
$tank = new Tank();
//假设正好有个敌人路过，坦克就以普通模式攻击了
$tank->attack();
//架起坦克
$tank->setState('s');
//坦克再次攻击，这次是架起模式
$tank->attack();
?>

用途总结：状态模式可以将和状态相关的行为和属性封装，除了切换状态时，其它地方就不需要大量的判断当前状态，只要调用当前状态的方法等。
实现总结：用一个接口规范状态类需要实现的方法，比如上面的TankState规定了attack()。把各个状态封装成类，将不同状态下的不同方法放入各自的状态类，比如上面的攻击方法，同时所有的状态执行接口。原来的事务类，比如上面的Tank类，只负责状态切换，一旦需要某一个方法的调用，只要交给当前状态就可以了。

/***************************************************************/

16-中介者模式

星际的升级系统做得比较平衡，不过由于不少兵种和建筑的制造都需要有相关的科技建筑，所以关系比较复杂。
比如一个科学站造出来后，所有的飞机场都可以建造科技球了，但是一旦一个科学站被摧毁，就要看是否还有科学站，否则就得让所有的飞机场都不能造科技球。
我们可以用上次说的观察者模式解决问题，不过由于星际里面的升级相关比较多，似乎比较麻烦。
其实从实质来讲，任何升级一般只要知道某种建筑是否存在就行了，因此我们不必让他们多对多联系，设置一个中介者就行了。
这就好像我们不管买什么东西，到超市就可以了，而厂家也只要和超市联系，不必和我们每个消费者直接接触。
待解决的问题：不要让各个建筑互相联系，减少复杂程度。
思路：设置中介者，每次遇到制造科技相关的东西，询问中介者。

中介者（Mediator）模式示例：
<?php
//中介者
class Mediator
{
//存放科技建筑的数量，为了简单说明，用静态属性，其实也可以让各个对象来处理
public static $techBuilding;
//根据参数$techBuildingName代表的建筑名称，返回是否存在相应的科技建筑，为了简单说明，用静态属性
public static function isTechAllow ($techBuildingName)
{
//如果科技建筑数量大于零，就返回true，否则返回false
return self::$techBuilding[$techBuildingName]>0;
}
//一旦科技建筑造好了或者被摧毁，调用这个方法，参数$techBuildingName代表建筑名称，$add为布尔值，true表示增加（建造），false代表减少（摧毁）
public static function changeTech ($techBuildingName, $add)
{
//建造
if ($add)
{
//增加数量
self::$techBuilding[$techBuildingName]++;
}
else
{
//减少数量
self::$techBuilding[$techBuildingName]--;
}
}
}

//科技站类
class ScienceFacility
{
//构造方法
public function __construct()
{
Mediator::changeTech('ScienceFacility', true);
}
//析构方法
public function __destruct()
{
Mediator::changeTech('ScienceFacility', false);
}
}

//飞机场类
class Starport
{
//制造科技球的方法
public function createScienceVessel ()
{
//询问中介者，决定是否能制造科技球
echo Mediator::isTechAllow('ScienceFacility')?'可以制造科技球':'不能制造科技球';
}
}

//造一个科技站
$scienceFacility1 = new ScienceFacility();
//再造一个科技站
$scienceFacility2 = new ScienceFacility();
//造一个飞机场
$starport = new Starport();
//建造科技球，结果是能够
$starport->createScienceVessel();
//一个科技站被摧毁
unset($scienceFacility1);
//这时建造科技球，结果是能够，因为还有一个科技站
$starport->createScienceVessel();
//另一个科技站被摧毁
unset($scienceFacility2);
//这时建造科技球，结果是不行
$starport->createScienceVessel();
?>

用途总结：中介者模式可以减少各个对象的通讯，避免代码相互关联。
实现总结：中介者模式比较灵活，一般只要有中介者类和需要被协调的类，具体设计看遇到的问题。

/***************************************************************/

17-适配器模式

星际的很多兵种，都有至少一项特殊技能。而且有些兵种的技能是相同的，比如虫族部队都会恢复血。
如果按照一般的思路，把技能的操作和控制作为方法，放在每个兵种的定义类来实现，代码会重复，也不容易修改。
那我们就会考虑用继承的办法，比如我们可以设计一个虫族的基类，里面有受伤后血恢复的方法。
在设计刺蛇(Hydralisk，口水兵)的时候，我们可以让刺蛇类继承虫族基类。
但是刺蛇是可以研发钻地的，而钻地不是刺蛇独有的功能，是虫族地面部队都有的特点，我们也要把钻地作为公共基类。
问题出来了，我们不能同时让刺蛇类继承两个类，这是php不允许的。

待解决的问题：如何混合重用两个类，
思路：继承一个类，把新建其中一个类的对象作为属性，然后通过这个属性来调用第二个类的方法。

适配器（Adapter）模式示例：
<?php
//虫族基类
class Zerg
{
//血
public $blood;
//恢复血的方法
public function restoreBlood()
{
//自动逐渐恢复兵种的血
}
}

//钻地的类
class Burrow
{
//钻地的方法
public function burrowOperation()
{
//钻地的动作，隐形等等
echo '我钻地了';
}
}

//刺蛇的类
class Hydralisk extends Zerg
{
//把一个属性来存放钻地对象
public $burrow;
//构造方法，因为php不允许默认值采用对象，所以通过初始化赋值给$burrow
public function __construct()
{
$this->burrow=new Burrow();
}
//钻地的方法
public function burrowOperation()
{
//调用钻地属性存放的对象，使用钻地类的方法
$this->burrow->burrowOperation();
}
}
//制造一个刺蛇
$h1 = new Hydralisk();
//让他钻地
$h1->burrowOperation();
?>

用途总结：适配器模式使得一个类可以同时使用两个基础类的功能，跳出了单纯继承的限制。有效的重用多各类。
实现总结：让新的类去继承一个基础类，然后通过新类的属性来存放其他类的对象，通过这些对象来调用其他类的方法。

/***************************************************************/

18-备忘模式

我们在玩星际任务版或者单机与电脑对战的时候，有时候会突然要离开游戏，或者在出兵前面，需要存储一下游戏。
那么我们通过什么办法来保存目前的信息呢？而且在任何时候，可以恢复保存的游戏呢？

待解决的问题：保存游戏的一切信息，如果恢复的时候完全还原。
思路：建立一个专门保存信息的类，让他来处理这些事情，就像一本备忘录。
为了简单，我们这里用恢复一个玩家的信息来演示。

备忘（Memento）模式示例：
<?php
//备忘类
class Memento
{
//水晶矿
public $ore;
//气矿
public $gas;
//玩家所有的部队对象
public $troop;
//玩家所有的建筑对象
public $building;
//构造方法，参数为要保存的玩家的对象，这里强制参数的类型为Player类
public function __construct(Player $player)
{
//保存这个玩家的水晶矿
$this->ore = $player->ore;
//保存这个玩家的气矿
$this->gas = $player->gas;
//保存这个玩家所有的部队对象
$this->troop = $player->troop;
//保存这个玩家所有的建筑对象
$this->building = $player->building;
}
}

//玩家的类
class Player
{
//水晶矿
public $ore;
//气矿
public $gas;
//玩家所有的部队对象
public $troop;
//玩家所有的建筑对象
public $building;
//获取这个玩家的备忘对象
public function getMemento()
{
return new Memento($this);
}
//用这个玩家的备忘对象来恢复这个玩家，这里强制参数的类型为Memento类
public function restore(Memento $m)
{
//水晶矿
$this->ore = $m->ore;
//气矿
$this->gas = $m->gas;
//玩家所有的部队对象
$this->troop = $m->troop;
//玩家所有的建筑对象
$this->building = $m->building;
}
}
//制造一个玩家
$p1 = new Player();
//假设他现在采了100水晶矿
$p1->ore = 100;
//我们先保存游戏，然后继续玩游戏
$m = $p1->getMemento();
//假设他现在采了200水晶矿
$p1->ore = 200;
//我们现在载入原来保存的游戏
$p1->restore($m);
//输出水晶矿，可以看到已经变成原来保存的状态了
echo $p1->ore;
?>

用途总结：备忘模式使得我们可以保存某一时刻为止的信息，然后在需要的时候，将需要的信息恢复，就像游戏的保存和载入归档一样。
实现总结：需要一个备忘类来保存信息，被保存的类需要实现生成备忘对象的方法，以及调用备忘对象来恢复自己状态的方法。

/***************************************************************/

19-组合模式

星际里面我们可以下载别人制作的地图，或者自己做地图玩。
我们在选择玩哪张地图的时候，可以看到游戏列出当前地图包里面的地图或地图包的名字。
虽然地图和地图包是通过文件和文件夹区分的，但是我们开发的时候，总希望能使用对象来进行抽象。
那么对于地图和地图包这两个相关的对象，我们能不能简化他们之间的区别呢？

待解决的问题：尽量是调用这两种对象的代码一致，也就是说很多场合不必区分到底是地图还是地图包。
思路：我们做一个抽象类，让地图类和地图包类继承它，这样类的很多方法的名称一样。

组合（Composite）模式示例：
<?php
//抽象地图类
abstract class abstractMap
{
//地图或地图包的名称
public $name;
//构造方法
public function __construct($name)
{
$this->name = $name;
}
//地图或地图包的名称，地图对象没有子对象，所以用空函数，直接继承
public function getChildren(){}
//添加子对象，地图对象没有子对象，所以用空函数，直接继承
public function addChild(abstractMap $child){}
//显示地图或地图包的名称
public function showMapName()
{
echo $this->name."<br>";
}
//显示子对象，地图对象没有子对象，所以用空函数，直接继承
public function showChildren(){}
}

//地图类，继承抽象地图，这里面我们暂且使用抽象地图的方法
class Map extends abstractMap
{

}
//地图包类，继承抽象地图，这里面我们就需要重载抽象地图的方法
class MapBag extends abstractMap
{
//子对象的集合
public $childern;
//添加子对象，强制用abstractMap对象，当然地图和地图包由于继承了abstractMap，所以也是abstractMap对象
public function addChild(abstractMap $child)
{
$this->childern[] = $child;
}
//添加子对象
public function function showChildren()
{
if (count($this->childern)>0)
{
foreach ($this->childern as $child)
{
//调用地图或包的名称
$child->showMapName();
}
}
}
}

//新建一个地图包对象，假设文件夹名字为Allied，这个大家可以看看星际的地图目录，真实存在的
$map1 = new MapBag('Allied');
//新建一个地图对象，假设文件名字为(2)Fire Walker（也是真实的）
$map2 = new Map('(2)Fire Walker');

//接下去可以看到组合模式的特点和用处。
//假设后面的代码需要操作两个对象，而我们假设并不清楚这两个对象谁是地图，谁是地图包
//给$map1添加一个它的子对象，是个地图，(4)The Gardens
$map1->addChild(new Map('(4)The Gardens'));
//展示它的子对象
$map1->showChildren();

//给$map2添加一个它的子对象，是个地图，(2)Fire Walker，这里不会报错，因为地图继承了一个空的添加方法
$map2->addChild(new Map('(2)Fire Walker'));
//展示它的子对象，也不会出错，因为地图继承了一个空的展示方法
$map2->showChildren();
?>

用途总结：组合模式可以对容器和物体（这里的地图包和地图）统一处理，其他代码处理这些对象的时候，不必过于追究谁是容器，谁是物体。这里为了简化说明，没有深入探讨，其实组合模式常常用于和迭代模式结合，比如我们可以用统一的方法（就像这里的showChildren方法），获取地图包下所有的地图名（包括子目录）
实现总结：用一个基类实现一些容器和物体共用的方法，比如上面的abstractMap，然后让容器和物体类继承基类。由于各自的特性不同，在容器和物体类中重载相应的方法，比如addChild方法。这样对外就可以用统一的方法操作这两种对象。

/***************************************************************/

20-桥接模式

在面向对象设计的时候，我们一般会根据需要，设计不同的类。但是如果两个类需要类似的功能的时候，我们就会遇到问题，到底重用还是重写。
更复杂的是，如果一些功能需要临时转换就麻烦了，比如星际里面的虫族，地面部队可以钻到地下，然后隐形。
但是小狗在地下不能动，而地刺可以攻击。尽管可以设计不同的类，但问题是玩家可以看到自己的部队埋在地下（一个洞），而敌人看不到。
这涉及功能的切换，而且星际里面有很多探测隐形的东西，这样就更频繁了。

待解决的问题：我们要临时切换一些功能的实现方式，而且在此基础上不同的调用类又有所不同。
思路：将钻地区分两种实现，不同的部队类在它的基础上进一步扩展。

桥接（Bridge）模式示例：
<?php
//虫族的基础类
class Zerg
{
//实现钻地的基本对象
public $imp;
//负责切换钻地基本对象的方法
public function setImp($imp)
{
$this->imp = $imp;
}
//部队的钻地方法，可以扩展基本对象的钻地
public function underground()
{
$this->imp->underground();
}
}

//小狗的类
class Zergling extends Zerg
{
//调用基本的钻地方法，然后实现扩展，这里简单的echo
public function underground()
{
parent::underground();
echo '小狗不能动<br>';
}
}

//地刺的类
class Lurker extends Zerg
{
//调用基本的钻地方法，然后实现扩展，这里简单的echo
public function underground()
{
parent::underground();
echo '地刺能够进行攻击<br>';
}
}

//钻地的基本接口
interface Implementor
{
//基本的钻地方法
public function underground();
}

//隐形钻地的基本类
class InvisibleImp implements Implementor
{
//基本的钻地方法
public function underground()
{
echo '隐形了，什么也看不到<br>';
}
}

//不隐形钻地的基本类，比如玩家自己看到的或被探测到的
class VisibleImp implements Implementor
{
//基本的钻地方法
public function underground()
{
echo '地上一个洞<br>';
}
}
//造一个小狗
$z1 = new Zergling();
//玩家把它埋入前沿阵地，假设此时有敌人经过，代码进行切换
$z1->setImp(new InvisibleImp());
//敌人看不到小狗，但是小狗也不能进攻
$z1->underground();

//造一个地刺
$l1 = new Lurker();
//玩家把它埋入前沿阵地，假设此时有敌人经过，代码进行切换
$l1->setImp(new InvisibleImp());
//敌人看不到地刺，但是地刺能攻击敌人
$l1->underground();

//敌人急了，马上飞过来一个科技球，代码进行切换
$l1->setImp(new VisibleImp());
//敌人看到地刺了，地刺继续攻击敌人
$l1->underground();
?>

用途总结：桥接模式可以将基本的实现和具体的调用类分开，调用类可以扩展更复杂的实现。
实现总结：需要一些基本执行类，实现基本的方法，比如上面的两个钻地类。同时我们可以设计多个不同的扩展调用类，将基本的功能扩展，比如地刺和小狗就进一步实现了不同的在地下的行为。