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

1-简单工厂模式

不熟悉面向对象的朋友，建议先看看用星际快速入门PHP面向对象编程
上次用星际争霸讨论了面向对象的基础知识，似乎面向对象能解决很多问题。
但是还会有很多问题，简单的靠类和对象解决不得太好。
比如如何根据玩家输入的内容（尽管可以转化为其他字符串），来确定要制造的兵种，玩家不会输入代码：new Marine()。
和星际一样，PHP也没有终极兵种，如果类和接口是兵种的话，那么设计模式就是你的战术和控制，它可以让你靠各种兵种的搭配获胜。
待解决的问题：在人族的兵营，我们靠相应玩家的输入来动态确定要造的兵种，假设是机枪兵和火焰兵。

思路：动态的根据传递的数据，新建相应的类的对象。
简单工厂模式示例：
我们把机枪兵类的代码放入一个文件，Marine.php，它的代码如下：

<?php
class Marine {
//机枪兵攻击的方法
public function attack()
{
echo 'Marine attack';
}
}
?>

我们把火焰兵类的代码放入一个文件，Firebat.php，它的代码如下：

<?php
class Firebat {
//火焰兵攻击的方法
public function attack()
{
echo 'Firebat attack';
}
}
?>

主文件中的内容如下：

<?php
//兵种制造器的类
class BarracksCreator {
//制造兵种的方法
public create($createWhat)
{
//根据输入的参数，动态的把需要的类的定义文件载入
require_once($createWhat.'.php');
//根据输入的参数，动态的返回需要的类的对象
return new $createWhat;
}
}

//新建一个兵种制造器对象
$creator = new BarracksCreator()；

//靠接收参数制造一个火焰兵对象
$troop1 = $creator->create('Marine');
$troop1->attack();

//靠接收参数制造一个机枪兵对象
$troop2 = $creator->create('Firebat');
$troop2->attack();
?>

用途总结：简单工厂模式可以将新建对象的任务进行封装，一旦需要增加新的返回类，只要修改负责新建对象的那部分代码。
实现总结：需要一个自动根据参数返回新建对象的工厂，比如上面兵种制造器BarracksCreator，使用的时候只需要将参数传递给他的生产方法create()，无需考虑具体的生产细节。

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

2-工厂方法模式

PHP手册上提到的工厂模式，其实是简单工厂模式。这里来讨论简单工厂模式的扩展：工厂方法模式。
待解决的问题：虽然简单工厂解决了动态返回不同类型对象的问题，但是实际情况当中，往往在新建一个对象的时候，需要做一些额外处理，比如制造机枪兵的时候需要判断水晶矿是否大于50，而制造火焰兵的时候需要同时判断水晶矿是否大于50和气矿大于25，还有是否建造了研究院。如果把这些代码全部放到工厂制造类里面，会使得制造类很臃肿，而且随着工厂生产的对象的种类越来越多，工厂制造类的代码会越来越难以维护。

思路：简单工厂模式中的工厂类（兵种制造器的类）保持不变，增加一个制造接口，定义一个实际制造对象的方法，然后定义各个具体制造不同对象的工厂，同时要求这些工厂执行这个制造接口，让这些工厂去实现实际制造对象的方法。

工厂方法模式示例：
我们把机枪兵类和制造机枪兵的类的代码放入一个文件，Marine.php，它的代码如下：
<?php
//机枪兵类
class Marine {
//机枪兵攻击的方法
public function attack()
{
echo 'Marine attack';
}
}
//制造机枪兵的类，执行接口abstractCreator
class MarineCreator implements abstractCreator {
//实际制造机枪兵的方法
public function realCreate()
{
//如果水晶矿大于50，这里只是作为说明，因为并不存在ore这个变量，也不考虑水晶少于50的处理
if($ore>50)
{
return new Marine();
}
}
}
?>
我们把火焰兵类和制造火焰兵的类的代码放入一个文件，Firebat.php，它的代码如下：
<?php
//火焰兵类
class Firebat {
//火焰兵攻击的方法
public function attack()
{
echo 'Firebat attack';
}
}
//制造火焰兵的类，执行接口abstractCreator
class FirebatCreator implements abstractCreator
//实际制造火焰兵的方法
public function realCreate()
{
//如果水晶矿大于50同时气矿大于25，并且研究院已经存在。这里只是作为说明，因为并不存在ore和gas和Academy变量，也不考虑资源不够时的处理
if($ore>50 && $gas>25 && Academy>1)
{
return new Firebat();
}
}
}
?>

主文件中的内容如下：
<?php
//各个具体工厂必须执行的接口
interface abstractCreator {
//规定各个具体工厂要实现的方法
public function realCreate();
}
//兵种制造器的类，也就是主工厂
class BarracksCreator {
//制造兵种的方法
public create($createWhat)
{
//根据输入的参数，动态的把需要的类的定义文件载入
require_once($createWhat.'.php');
//根据输入的参数，动态的获取相应的具体工厂的类的名字
$creatorClassName = $createWhat.'Creator';
//新建具体工厂对象
$creator = new $creatorClassName;
//用具体工厂来实际生产，然后返回需要的类的对象。因为它们都执行了接口abstractCreator，所以肯定实现了方法realCreate()
return $creator->realCreate();
}
}
//新建一个兵种制造器对象
$creator = new BarracksCreator()；
//靠接收参数制造一个火焰兵对象
$troop1 = $creator->create('Marine');
$troop1->attack();

//靠接收参数制造一个机枪兵对象
$troop2 = $creator->create('Firebat');
$troop2->attack();
?>

用途总结：工厂方法模式将新建对象的任务将给对应的具体工厂类，不必因为某些生产的对象需要进行额外处理而修改对外的主工厂。
实现总结：需要接收参数的主工厂类，比如上面兵种制造器BarracksCreator，还需要声明具体制造方法的一个接口，比如上面abstractCreator，然后定义具体生产各个产品的具体工厂类，每个具体工厂类必须执行接口abstractCreator，这样他们就必须实现制造对象的方法，比如上面的realCreate()。使用的时候只需要将参数传递给主工厂类工厂的生产方法create()，然后由create()根据参数生成具体工厂类的对象，并调用具体工厂类realCreate()获取制造的产品对象并返回，对外界使用来说，只需调用主工厂类工厂进行生产。

说明：其实这篇文章内的工厂方法模式和有些文章写的不同，标准的工厂模式往往是用一个抽象类来代替上面的接口abstractCreator，然后让所有的具体工厂类来继承它，但使用的时候，由于抽象类不能实例化（新建它的对象），所以经常是代码中直接new FirebatCreator()，但是简单工厂模式可以解决直接new的问题，所以我这里将简单工厂模式和工厂方法模式一起使用，使这里的示例更加实用。同时由于PHP是单继承，而执行接口的数量是没有限制的，所以使用接口abstractCreator更加灵活。

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

3-抽象工厂模式

星际争霸是战略游戏，所以同样的兵种，敌我显示是不同的。
典型的就是鼠标的颜色，点中自己的物体的时候，鼠标颜色变成绿色，点中敌人的物体的时候，鼠标颜色变成红色。
还有就是每个物体的状态，点中自己的物体的时候，状态区显示完整的状态，点中敌人的物体的时候，状态区显示一部分信息。
我们假设只考虑鼠标和人族的运输船，玩家自己的运输船点中后状态区会显示里面装载的部队，而点中敌人的则不会显示里面是否装载部队。

这样我们就有四种对象：点中自己的鼠标，点中敌人的鼠标，自己的运输船状态，敌人的运输船状态。
如果用工厂方法模式，就要建立四个具体工厂（或者子工厂），这样的代码不便于维护和修改，因为我们以后要增加另一种情况：盟友。
待解决的问题：我们希望将这些对象联系起来，使得工厂的操作更加有逻辑性。
思路：既然我们通过自己和敌人来区分对象，那么统一归属的对象放入相同的具体工厂，每个具体工厂负责制造多种对象。
抽象工厂模式示例：
<?php
//四个产品类
//点中自己的物体时的鼠标
class mineMouse {
//鼠标的颜色
$color = 'green';
}
//点中敌人的物体时的鼠标
class enemyMouse {
//鼠标的颜色
$color = 'red';
}
//自己的运输船状态
class mineDropship {
//显示装载的情况，假设2辆坦克
$loading = '2 tanks';
}
//敌人的运输船状态
class enemyDropship {
//不显示装载的情况
$loading = '';
}
//主工厂类，也叫抽象工厂类
class abstractCreator {
//根据参数分配工作到具体的工厂，并返回具体工厂对象
public function getCreator($belong)
{
//获取具体工厂的类名
$creatorClassName = $belong.'Creator';
//返回具体工厂对象
return new $creatorClassName();
}
}
//具体工厂必须执行的接口
interface productCreator {
//制造方法,或者说根据参数返回产品(鼠标,运输船)的方法
public function creatProduct($productName);
}
//制造属于自己的物体的具体工厂,执行接口
class mineCreator implements productCreator {
//根据参数生产并返回属于自己的产品
public function creatProduct($productName)
{
//获取产品的类名
$productClassName = 'mine'.$productName;
//返回产品对象
return new $productClassName;
}
}
//制造属于敌人的物体的具体工厂,执行接口
class enemyCreator implements productCreator {
//根据参数生产并返回属于敌人的产品
public function creatProduct($productName)
{
//获取产品的类名
$productClassName = 'enemy'.$productName;
//返回产品对象
return new $productClassName;
}
}
//开始操作
//新建抽象工厂对象
$abstractCreator = new abstractCreator();
//根据归属,得到具体工厂对象,这里先演示敌人的
$realCreator1 = $abstractCreator->getCreator('enemy');
//让具体工厂对象生产鼠标对象
$product1 = $realCreator1->creatProduct('Mouse');
//让鼠标对象显示颜色,显示结果red
echo $product1->color;

//根据归属,得到另一个具体工厂对象,这里演示自己的
$realCreator2 = $abstractCreator->getCreator('mine');
//让具体工厂对象生产运输船
$product2 = $realCreator2->creatProduct('Dropship');
//让运输船对象显示装载对象,显示结果2 tanks，两辆坦克
echo $product2->loading;
?>
用途总结：抽象工厂模式将拥有相同属性的产品归类到同一个具体工厂，减少具体工厂的数量，操作的时候，可以理清职责。
实现总结：需要一个根据属性返回具体工厂对象的抽象工厂，比如上面abstractCreator，同时需要将各个产品的属性（自己的，敌人的）进行归类，根据属性建立各个具体工厂，每个具体工厂制造多个具有相同属性的不同产品（鼠标和运输船）。

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

4-单件和单态模式

星际争霸允许玩家作弊，当然这是在人和电脑对战的时候。而且作弊有个特点，比如快速建造，能量无限是对所有的玩家（包括电脑）都生效，如果关闭了作弊，对所有的玩家的作用都同时消失。
这也就是说如果我们把作弊状态作为一个类，他只能有一个对象。
待解决的问题：确保某个类只能有一个对象。
思路：把对外新建对象的权利都收回，包括new，clone。为了防止通过子类来覆盖父类的方法和成员，将类设置为final。用static成员来保存唯一的对象
单件模式示例：
<?php
//将类设置为final，禁止其他类继承它
final class cheat {
//快速建造的生效状态，用private保护
private $fastBuild = false;
//用static成员来保存唯一的对象
private static $instance;
//设置快速建造的生效状态的方法，用public为了能够公开调用
public function setStatus($input)
{
//如果输入的秘籍正确，operation cwal是快速建造的秘籍
if($input === 'operation cwal')
{
//像开关一样，逆反状态
$this->fastBuild = !$this->fastBuild ;
}
}
//读取快速建造的生效状态的方法，用public为了能够公开调用
public function getStatus()
{
return $this->fastBuild ;
}
//获取唯一对象的唯一方法
public function getInstance()
{
//如果对象没有被新建，则新建它
if(!isset(self::$instance))
{
self::$instance = new cheat() ;
}
return self::$instance ;
}
//用private来禁止在本类以外new对象
private function __construct(){}
//用private来禁止在本类以外clone对象
private function __clone(){}
}
//获取作弊对象的唯一办法
$cheatInstance = cheat::getInstance();
//现在输出为0（这和操作系统有关，有些可能输出false，最好用var_dump来代替echo）
echo $cheatInstance->getInstance();
//输入秘籍
$cheatInstance->setInstance('operation cwal');
//现在输出为1（这和操作系统有关，有些可能输出true，最好用var_dump来代替echo）
echo $cheatInstance->getInstance();
//再次输入秘籍，取消作弊
$cheatInstance->setInstance('operation cwal');
//现在输出为又变成0（这和操作系统有关，有些可能输出false，最好用var_dump来代替echo）
echo $cheatInstance->getInstance();
?>

星际里面有些特殊的秘籍，比如无敌和增加矿，这是仅仅对于人玩家产生作用，对电脑玩家没有作用（大家都无敌还怎么玩）。我们希望有个人类作弊的类来继承作弊类，而子类中新增一些秘籍，比如无敌。单件模式不允许继承，我们可以采用单态模式。
单态模式不是通过唯一对象来保持一致，它将相关的成员设置为static，这样即使存在很多个它的对象，但它们共享成员，保持状态的一致。同时也允许继承。
<?php
//不使用final，允许继承
class cheat {
//快速建造的生效状态，用private保护，同时设置static让所有的作弊对象共享
private static $fastBuild = false;
//设置快速建造的生效状态的方法，用public为了能够公开调用
public function setStatus($input)
{
//如果输入的秘籍正确，operation cwal是快速建造的秘籍
if($input === 'operation cwal')
{
//像开关一样，逆反状态
self::$fastBuild = !self::$fastBuild ;
}
}
//读取快速建造的生效状态的方法，用public为了能够公开调用
public function getStatus()
{
return self::$fastBuild ;
}
}

//新增一个作弊对象
$cheatInstance1 = new cheat();
//现在输出为0（这和操作系统有关，有些可能输出false，最好用var_dump来代替echo）
echo $cheatInstance1->getInstance();
//输入秘籍
$cheatInstance1->setInstance('operation cwal');
//现在输出为1（这和操作系统有关，有些可能输出true，最好用var_dump来代替echo）
echo $cheatInstance1->getInstance();
//新增一个作弊对象
$cheatInstance2 = new cheat();
//现在也是输出为1，因为它们共享$fastBuild
echo $cheatInstance2->getInstance();
?>
作弊的子类可以新增一些成员，这里不再详述。
单件模式用途总结：确保某个类的对象的唯一性，常用来节省系统的资源，比如防止重复的数据库连接。
单件模式实现总结：收回所有新建对象的权利，把对象放入类的一个private成员中，仅提供一个对外的新建对象的方法，调用的时候判断对象是否已经新建

单态模式用途总结：确保某个类所有的对象的成员都一致，同时允许灵活的继承这各类。但相对单件模式而言，系统资源开销要大一些。
单态模式实现总结：把所有相关的成员设置为static。

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

5-模板模式

星际中的虫族部队有个特别的进化兵种，就是飞龙，飞龙可以变成空中卫士（天蟹）或者吞噬者（对空的）。另外还有口水兵可以进化变成地刺。
这三个变化过程都是类似的：变化的原部队消失，产生一个蛋或茧，孵化一会儿，蛋消失，新的部队产生。

如果我们把这三个进化独立开，就会产生重复的代码，冗余度增大了，所以我们要设法减少多余的代码。
待解决的问题：要经历同样的几个步骤，只是每个步骤的细节会有不同。

思路：做一个进化工程的框架，我们只要控制细节就可以了。
模板模式模式示例：
<?php
//进化的框架类，它是个抽象类
abstract class evolution {
//框架方法，由它来实施各个步骤，用final禁止子类覆盖
final public function process($troop)
{
生成一个蛋，参数为进化的部队
$egg = $this->becomeEgg($troop);
等待蛋孵化，参数为蛋
$this->waitEgg($egg);
孵化后产生新部队
return $this->becomeNew($egg);
}
下面三个抽象方法，由具体子类来实现
abstract public function becomeEgg($troop);
abstract public function waitEgg($egg);
abstract public function becomeNew($egg);
}
为了简单说明，这里用空中卫士（天蟹）的进化类来演示，地刺等的处理方法类似
//天蟹的进化类继承抽象进化类
class GuardianEvolution extends evolution {
//实现生成一个蛋
public function becomeEgg($troop)
{
//销毁飞龙，返回一个蛋的对象的代码
}
//等待蛋孵化
public function waitEgg($troop)
{
//等待几十秒钟的代码
}
//孵化后产生新部队
public function becomeNew(($troop)
{
//销毁蛋，返回一个天蟹
}
}
//新建一个天蟹进化的对象
$e1 = new GuardianEvolution();
//让它调用父类的进化框架函数，自动完成三个步骤
$e1->process($sds);
?>

用途总结：模板模式可以将一系列的步骤自动化，同时又可以满足不同的细节变化。
实现总结：需要一个抽象类来包含框架函数，让具体的子类继承它，并实现所有的步骤。使用的时候只要调用框架函数就自动完成了。

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

6-正面模式

星际里面的战斗都是在地图上进行的，只要我们可以编辑地图，就可以创造一些新的战役。可是，星际里面的地图绘制相关的代码如果开放出来，估计大多数万家都看不懂，更不要说自己编辑地图了。

待解决的问题：在不了解地图代码的结构下，我们要让玩家自己编辑地图。

思路：对于玩家而言，他熟悉的是水晶矿，高地这些形状，他和系统通过鼠标交互。我们可以设计一个地图编辑器让玩家使用，而无需让他研究绘制地图的
细节代码。（实际上暴雪公司就是这样做的，很多玩家甚至暴雪内部人员都是用星际中的地图编辑器制作地图）

正面模式（Facade）示例：
<?php
//玩家的鼠标对象，记录鼠标在编辑其中的状态
class mouse {
//鼠标所处的X轴坐标
public static $X;
//鼠标当前能绘制的对象，比如水晶矿，河流等
public static $object;
//鼠标所处的Y轴坐标
public static $Y;
}
//地图编辑器
class mapEdit {
//绘制方法
public static function draw()
{
//根据鼠标对象的状态在地图上绘制各种东西
//如果是水晶矿
if(mouse::$object == "ore")
{
//调用水晶矿类的绘制方法，这个类定义在下面，这是真正的绘制，但玩家不必学习他的细节
ore::draw();
//如果是河流
}elseif(mouse::$object == "river"){
//调用河流类的绘制方法，这个类定义在下面，这是真正的绘制，但玩家不必学习他的细节
river::draw();
}
}
}
//水晶矿类
class ore {
//剩余的矿，以及其他属性，这里略过
public $remain;
//绘制水晶矿
public static function draw()
{
//实际的绘制水晶矿的底层细节代码
}
}
//河流类
class river {
//绘制河流
public static function draw()
{
//实际的绘制河流的底层细节代码
}
}

//玩家在地图编辑器上点击绘制对象列表上的水晶矿对象
mouse::$object = "ore";
//玩家移动鼠标
mouse::$X = 311;
mouse::$Y = 126;
//在地图上点击，表示绘制当前对象，也就是一个水晶矿
mapEdit::draw();
?>

用途总结：正面模式让使用者集中于他所要进行的工作，而不必知道全部细节，或者说提供了一个容易使用的工具，同时屏蔽了底层细节，不必让使用者重新学习。
实现总结：需要一个类似上面地图编辑器的代码类，帮助玩家方便的进行操作。

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

7-观察者模式

当我们在星际中开地图和几家电脑作战的时候，电脑的几个玩家相当于结盟，一旦我们出兵进攻某一家电脑，其余的电脑会出兵救援。
那么如何让各家电脑知道自己的盟友被攻击了呢？并且自动做出反应？
待解决的问题：一旦某个电脑被我们进攻，其他电脑就获知，并且自动出兵救援。
思路：为电脑设置一些额外的观察系统，由他们去通知其他电脑。

观察者（Observer）模式示例：
<?php
//抽象的结盟类
abstract class abstractAlly {
//放置观察者的集合，这里以简单的数组来直观演示
public $oberserverCollection;
//增加观察者的方法，参数为观察者（也是玩家）的名称
public function addOberserver($oberserverName)
{
以元素的方式将观察者对象放入观察者的集合
$this->oberserverCollection[] = new oberserver($oberserverName);
}
//将被攻击的电脑的名字通知各个观察者
public function notify($beAttackedPlayerName)
{
//把观察者的集合循环
foreach ($this->oberserverCollection as $oberserver)
{
//调用各个观察者的救援函数，参数为被攻击的电脑的名字，if用来排除被攻击的电脑的观察者
if($oberserver->name != $beAttackedPlayerName) $oberserver->help($beAttackedPlayerName);
}
}
abstract public function beAttacked($beAttackedPlayer);
}
//具体的结盟类
class Ally extends abstractAlly {
//构造函数，将所有电脑玩家的名称的数组作为参数
public function __construct($allPlayerName)
{
//把所有电脑玩家的数组循环
foreach ($allPlayerName as $playerName)
{
//增加观察者，参数为各个电脑玩家的名称
$this->addOberserver($playerName);
}
}
//将被攻击的电脑的名字通知各个观察者
public function beAttacked($beAttackedPlayerName)
{
//调用各个观察者的救援函数，参数为被攻击的电脑的名字，if用来排除被攻击的电脑的观察者
$this->notify($beAttackedPlayerName);
}
}
//观察者的接口
interface Ioberserver {
//定义规范救援方法
function help($beAttackedPlayer);
}
//具体的观察者类
class oberserver implements Ioberserver {
//观察者（也是玩家）对象的名字
public $name;
//构造函数，参数为观察者（也是玩家）的名称
public function __construct($name)
{
$this->name = $name;
}
//观察者进行救援的方法
public help($beAttackedPlayerName)
{
//这里简单的输出，谁去救谁，最后加一个换行，便于显示
echo $this->name." help ".$beAttackedPlayerName."<br>";
}
abstract public function beAttacked($beAttackedPlayer);
}
//假设我一对三，两家虫族，一家神族
$allComputePlayer = array('Zerg1', 'Protoss2', 'Zerg2');
//新建电脑结盟
$Ally = new Ally($allComputePlayer);
//假设我进攻了第二个虫族
$Ally->beAttacked('Zerg2');
?>

用途总结：观察者模式可以将某个状态的变化立即通知所有相关的对象，并调用对方的处理方法。
实现总结：需要一个观察者类来处理变化，被观察的对象需要实现通知所有观察者的方法。

8-职责链模式
星际的兵种属性随着对平衡性的调节，会进行修改。如果这样的话，我们就要考虑减少一个事件和具体处理的关联性。
比如一颗原子弹投下的瞬间，在杀伤范围内的部队或者建筑都会减少血，但是随着距离中心点的远近，受损程度是不同的，而且不同的兵种和建筑受损情况是不同的。
待解决的问题：原子弹投下的瞬间，将杀伤的处理分别交给杀伤范围内的部队或者建筑自己的方法处理。
思路：建立一个接口，让所有的部队或者建筑实现。
职责链模式(Chain of Responsibility)示例：
<?php
//被原子弹攻击的接口
interface NuclearAttacked {
//处理被原子弹攻击的方法，参数为投放点的x和y坐标
public function NuclearAttacked($x, $y);
}
//人族的基地，实现被原子弹攻击的接口，其他的内容暂时不考虑
class CommandCenter implements NuclearAttacked {
//处理被原子弹攻击的方法，参数为投放点的x和y坐标
public function NuclearAttacked($x, $y)
{
//根据离原子弹中心的距离，定义减少的血，如果超出了剩余的血，就炸掉
}
}
//巡洋舰（俗称大和），实现被原子弹攻击的接口，其他的内容暂时不考虑
class Battlecruiser implements NuclearAttacked {
//处理被原子弹攻击的方法，参数为投放点的x和y坐标
public function NuclearAttacked($x, $y)
{
//根据离原子弹中心的距离，定义减少的血，如果超出了剩余的血，就炸掉
}
}
//原子弹类
class Nuclear {
//被原子弹攻击的对象
public $attackedThings;
//添加被原子弹攻击的对象
public function addAttackedThings($thing)
{
//添加被原子弹攻击的对象
$this->attackedThings[] = $thing;
}
//原子弹爆炸的方法，参数为投放点的x和y坐标
public function blast($x, $y)
{
//把爆炸的事情交给所有涉及的对象，让他们自己处理
foreach ($this->attackedThings as $thing)
{
//把爆炸的事情交给所有涉及的对象，让他们自己处理
$thing->NuclearAttacked($x, $y);
}
}
}

//新建一个基地对象
$CommandCenter = new CommandCenter();
//新建一个巡洋舰对象
$Battlecruiser = new Battlecruiser();
//造了一颗原子弹
$Nuclear2 = new Nuclear();
//假设投放成功，那个瞬间一个基地对象和一个巡洋舰对象在杀伤范围内
$Nuclear2->addAttackedThings($CommandCenter);
$Nuclear2->addAttackedThings($Battlecruiser);
//原子弹爆炸，这样就把这个事件交给那些涉及的对象的处理方法，假设投放点的x和y坐标是2353, 368
$Nuclear2->blast(2353, 368);
?>

用途总结：职责链模式可以将一个涉及到多个对象的事件的处理交给对象自己处理，减少关联性。
实现总结：需要一个处理事件的接口，然后让所有的对象实现。

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

9-策略模式

星际开地图对战，等5秒钟进入地图后，每个玩家都会拥有一个基地，几个农民等，还会有初始的人口供给。但这些是根据种族的不同而不同。
待解决的问题：我们需要根据种族的不同，而对玩家进行不同的初始化，最好将这些不同的处理方式封装。
思路：定义初始化的接口，然后制作不同种族的初始化类。
策略模式（Strategy）示例：
为了使代码不至于过长，一部分类的定义不在此写出，如果要调试，请用字符串等方式替代new。
<?php
//玩家的类
class player {
//所属种族
public $race;
//部队
public $army;
//建筑
public $building;
//人口供给
public $supply;
//构造函数，设定所属种族
public function __construct($race)
{
$this->race = $race;
}
}
//初始化的接口
interface initialPlayer {
//制造初始化的部队
public function giveArmy($player);
//制造初始化的建筑
public function giveBuilding($player);
//初始化人口供给
public function giveSupply($player);
}

//虫族的初始化算法
class zergInitial implements initialPlayer {
//制造初始化的部队
public function giveArmy($player)
{
//一个Overlord
$player->army[] = new Overlord();
//四个虫族农民
for($i=0; $i<5;$i++)
{
$player->army[] = new Drone();
}
}
//制造初始化的建筑
public function giveBuilding($player)
{
//一个基地
$player->building[] = new Hatchery();
}
//初始化人口供给
public function giveSupply($player)
{
//虫族初始人口供给为9
$player->supply = 9;
}
}
//人族的初始化算法
class terranInitial implements initialPlayer {
//制造初始化的部队
public function giveArmy($player)
{
//四个人族农民
for($i=0; $i<5;$i++)
{
$player->army[] = new SVC();
}
}
//制造初始化的建筑
public function giveBuilding($player)
{
//一个基地
$player->building[] = new Hatchery();
}
//初始化人口供给
public function giveSupply($player)
{
//人族初始人口供给为10
$player->supply = 10;
}
}

//初始化的控制类
class initialController {
//构造函数，参数为玩家的数组
public function __construct($playerArray)
{
foreach ($playerArray as $player)
{
switch ($player->race)
{
case 'zerg':
$initialController = new zergInitial();
break;
case 'terran':
$initialController = new terranInitial();
break;
}
$initialController->giveArmy($player);
$initialController->giveBuilding($player);
$initialController->giveSupply($player);
}
}
}

//假设两个虫族，一个人族
$playerArray = array(new player('zerg'), new player('zerg'), new player('terran'));
//进行初始化工作
$initialController = new initialController($playerArray);
?>

用途总结：策略模式可以将不同情况下的算法封装,根据具体的情况调用。
实现总结：需要一个接口，规定算法规范，使用者（比如初始化来）只要调用对应的算法就可以了。

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

10-代理模式

星际争霸如果是多人对战模式，就会遇到一个问题：如何降低网络延时和负担。
为了确保数据的一致性，我们应该将每个玩家的发生变化的数据不停的传送到开地图的主机进行保存，一旦任何某个玩家的客户机读取数据，就必须向主机请求数据。
尽管大多数数据是交互性的，即使某个玩家的人口也是这样的，如果某个敌人的部队杀死了这个玩家的一个部队，立即影响了他的人口数量。
不过水晶矿和气矿有所不同，除了玩家自己的建造操作和农民采集，别的玩家影响不了这个数据。
所以我们考虑在客户机也放一个数据存储，玩家改变或者读取他的资源的时候，先操作本机数据，再通知主机。
代理（Proxy）模式示例：
为了方便，假设客户机已经通过远程包含或其他方法获取了主机上的php代码，它的代码如下：
<?php
//客户机和主机操作数据时共同要实现的借口
interface iDataProcess
{
//获取数据的方法，$ID表示玩家的ID，$dataName表示获取的数据的名称
public function getData($ID, $dataName);
//改变数据的方法，$ID表示玩家的ID，$dataName表示要改变的数据的名称，$dataValue表示改变后的数据的值
public function updateData($ID, $dataName, $dataValue);
}

//主机操作数据的类
class DataProcess implements iDataProcess
{
// 获取数据的方法，$ID表示玩家的ID，$dataName表示获取的数据的名称
public function getData($ID, $dataName)
{
//操作数据库之类的代码
}
//改变数据的方法，$ID表示玩家的ID，$dataName表示要改变的数据的名称，$dataValue表示改变后的数据的值
public function updateData($ID, $dataName, $dataValue)
{
//操作数据库之类的代码
}
}

//客户机操作数据的类，也就是代理类
class ProxyDataProcess implements iDataProcess
{
//主机操作数据的对象
private $dataProcess;
//构造函数
public function __construct()
{
$this->dataProcess = new DataProcess();
}
// 获取数据的方法，$ID表示玩家的ID，$dataName表示获取的数据的名称
public function getData($ID, $dataName)
{
//判断是否直接向主机请求
switch ($dataName)
{
//如果查询水晶矿
case 'ore':
//直接从客户机保存的数据读取，详细代码略过
break;
//如果查询气矿
case 'gas':
//直接从客户机保存的数据读取，详细代码略过
break;
default:
$this->dataProcess->getData($ID, $dataName);
}
}
//改变数据的方法，$ID表示玩家的ID，$dataName表示要改变的数据的名称，$dataValue表示改变后的数据的值
public function updateData($ID, $dataName, $dataValue)
{
//和读取的思路类似，如果是水晶矿或气矿，就先写入客户机的数据存储，再告诉主机修改
}
}

//新建一个客户机处理数据的对象
$proxyDataProcess = new ProxyDataProcess();
//假如显示本玩家自己的气矿剩余数量
$proxyDataProcess->getData(3, 'gas');
?>

用途总结：代理模式可以将让客户操作一个代理的类，进行一些降低资源消耗的工作，也可以完成比如权限验证的工作。
实现总结：需要一个接口来规定实际和代理操作类都必须实现的方法，比如上面iDataProcess，另外就是实际处理的类，比如上面DataProcess，以及让客户使用的代理操作类，比如上面的ProxyDataProcess。其实代理模式可以有多种用法，这里限于篇幅，只讨论了降低数据操作的负荷

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

11-建造器模式

星际里面有不少的任务关，也可以自己编辑地图，画面上有各种地形，建筑和部队。
这存在一个问题，初始化画面的流程很乱。
待解决的问题：完成初始化画面的工作，同时尽量减少各种绘制细节的耦合。
思路：既然星际的画面由几个部分组成：地图（就是地形和矿产），建筑，部队。那么我们把他们看成是零件，组装起来就是最后的产品（整个画面）。

建造器（Builder）模式示例：
<?php
//规范制造各个零件的接口
interface Builder
{
//制造地图零件
public function buildMapPart();

//制造建筑零件
public function buildBuildingPart();

//制造部队零件
public function buildArmyPart();

//组装零件
public function getResult();
}

//实际建造器类，比如初始化某个任务关
class ConcreteBuilder implements Builder
{
//制造地图零件
public function buildMapPart()
{
//根据任务的设定画上地图
echo '地图零件\n';
}
//制造建筑零件
public function buildBuildingPart()
{
//根据任务的设定画上建筑，包括玩家的和敌人的
echo '建筑零件\n';
}
//制造部队零件
public function buildArmyPart()
{
//根据任务的设定画上部队，包括玩家的和敌人的
echo '部队零件\n';
}
//组装零件
public function getResult()
{
//将所有的东西叠加和处理，形成初始化画面
echo '组装零件\n';
}
}
//监督类，也就是控制绘制流程的类
class Director
{
//私有属性，确定使用的建造器
private $builder;
//构造方法，参数为选定的建造器对象
public function __construct($builder)
{
//确定使用的建造器
$this->builder = $builder;
}
//负责建造流程的方法，调用建造器对象的方法，制造所有零件
public function buildeAllPart()
{
//制造地图零件
$this->builder->buildMapPart();
//制造建筑零件
$this->builder->buildBuildingPart();
//制造部队零件
$this->builder->buildArmyPart();
}
}

//假设根据任务关，初始化我们需要的实际建造器对象
$concreteBuilder = new ConcreteBuilder();
//初始化一个监督对象
$director = new Director($concreteBuilder);
//制造所有零件
$director->buildeAllPart();
//最后让建造器组装零件，生成画面
$concreteBuilder->getResult();
?>

用途总结：建造器模式可以将流程和细节分离，各司其职。
实现总结：需要一个建造器接口或者抽象类，负责规范各个方法，比如上面的Builder。然后让实际的建造器类去实现所有的方法，比如上面的ConcreteBuilder。同时需要负责流程管理的监督类，比如上面的Director，负责调用建造器的各个零件制造方法。最后让建造器去组装所有的零件。

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

12-享元模式

星际的战斗达到后面，地图里面的部队很多，如果我们把每个兵的图像动画和属性值作为一个对象的话，系统的内存里会消耗极大。
我们在玩的时候会发现，因为星际里面的种族只有三个，其实兵种只有几十个。
虽然每个独立的士兵剩余的血不同，但是同一兵种的图像动画是一样的，即使不同的玩家，只是不同的颜色。比如每个人族的机枪兵。
而且大多数玩家只用到常用的一些兵种，很多时候不会制造所有的兵种。
待解决的问题：把把兵种的图像动画共享。
思路：我们把每个兵种的图像动画建模作为对象，放入内存共享。一旦有某个画面用到这个兵种，只要把共享的图像动画拿出来，更改颜色就可以了。

享元（Flyweight）模式示例：
<?php
//机枪兵享元
class MarineFlyweight
{
//绘制机枪兵的图像动画，参数为状态，比如属于哪一个玩家
public function drawMarine($state)
{
//绘制机枪兵
}
}

//享元工厂
class FlyweightFactory
{
//享元数组，用于存放多个享元
private $flyweights;
//获取享元的方法
public function getFlyweight($name)
{
if (!isset($flyweights[$name]))
{
$flyweights[$name] = new $name."Flyweight";
}
return $flyweights[$name];
}
}

//初始化享元工厂
$flyweightFactory = new FlyweightFactory();
//当我们需要绘制一个机枪兵的时候，同时传递一个状态数组，里面包含剩余的血等等
$marine = $flyweightFactory->getFlyweight("Marine");
$marine->drawMarine($status);
?>

用途总结：享元模式可以将需要共享的资源集中起来，统一管理，防止重复消耗。
实现总结：需要一个享元工厂管理共享的资源，比如上面的FlyweightFactory。把所有共享的资源的生产全部交给个享元工厂。

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

13-原型模式

我们一般用new来新增对象，不过很多时候新增一个对象需要一些工作。而星际里面往往会新增某些类的大量的对象，比如新增很多机枪兵和龙骑。
待解决的问题：我们能否减少new的使用，同时避免需要新增对象的时候，了解对象的类名。
思路：php5提供了克隆方法，我们可以新增一个对象，然后每次需要新增和她同类的对象，克隆他就可以了。

原型（Prototype）模式示例：
<?php
//机枪兵类
class Marine
{
//所属的用户ID
public $playerID
//构造函数，参数为用户的id
public function __construct($id)
{
$this->playerID = $id;
}
}

//兵种的管理类
class TroopManager
{
//数组，用于存放多个兵种的原型
public $troopPrototype = array();
//增加原型，第一个参数为原型的名字，第二个参数为原型对象
public function addPrototype($name, $prototype)
{
$this->troopPrototype[$name] = $prototype;
}
//获取原型的克隆，也就是替代new的方法，参数为原型的名字
public function getPrototype($name)
{
return clone $this->troopPrototype[$name];
}
}

//初始化兵种的管理类
$manager = new TroopManager();
//初始化两个属于不同玩家的机枪兵的原型
$m1 = new Marine(1);
$m2 = new Marine(2);
//增加原型，同时用比较容易记忆的名字来命名原型
$manager->addPrototype('Marine of 1', $m1);
$manager->addPrototype('Marine of 2', $m2);

//当需要新增对象的时候，我们可以不必知道对象的类名和初始化的工作
$m3 = $manager->getPrototype('Marine of 1');
?>

用途总结：原型模式可以将新增对象的工作细节封装。
实现总结：需要一个原型管理类，实现增加和获取克隆原型的方法。注意这里由于为了简明，省略了一些东西，实际上我们可以在克隆方法上做一些改动，也可以用接口规范每个原型类。

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

14-迭代器模式

星际的任务关一般会有这样的设定：一开始电脑的农民不采矿，如果战斗打响，或者玩家造出第一个兵，电脑的农民开始采矿。
我们自然会想到把电脑的农民放到一个数组，然后一旦玩家造兵，或者战斗打响，把这个数组循环，让里面的农民采矿。
但问题出来了，由于每个任务的设定会有所不同，我们总希望任务的开发比较方便，而且容易修改（一旦发现bug）。
何况有些任务不是农民采矿，而是电脑出兵攻击玩家。
那么过多的固定细节（用数组存放）以及依赖细节（对数组循环），将使得代码的关联性变得很高。
待解决的问题：把循环处理的事务变的抽象。
思路：关键是对农民的循环，用数组处理只是一种方式，我们考虑抽象的数组，而不是具体的数组。

迭代器（Iterator）模式示例：
<?php
//聚集接口，意思是所有电脑的农民都聚集在这个类里面
interface IAggregate
{
//让具体的聚集类实现的，获取使用的迭代器的方法
public function createIterator();
}

//具体的聚集类
class ConcreteAggregate implements IAggregate
{
//存放农民的数组，注意可以不用数组来处理，看完所有的代码就知道了
public $workers;
//增加元素的方法，这里元素就是农民
public function addElement($element)
{
$this->workers[] = $element;
}
//获取元素的方法
public function getAt($index)
{
return $this->workers[$index];
}
//获取元素的数量的方法
public function getLength()
{
return count($this->workers);
}
//获取迭代器的方法
public function createIterator()
{
return new ConcreteIterator($this);
}
}
//迭代器接口，注意php5有个内置的接口叫Iterator，所以这里我们改成IIterator
interface IIterator
{
//是否元素循环完毕
public function hasNext();
//返回下一个元素，并将指针加1
public function next();
}

//具体的迭代器类
class ConcreteIterator implements IIterator
{
//要迭代的集合
public $collection;
//指针
public $index;
//构造函数，确定迭代的集合，并将指针置零
public function __construct($collection)
{
$this->collection = $collection;
$this->index = 0;
}
//是否元素循环完毕
public function hasNext()
{
if($this->index < $this->collection->getLength())
{
return true;
}
else
{
return false;
}
}
//返回下一个元素，并将指针加1
public function next()
{
$element = $this->collection->getAt($this->index);
$this->index++;
return $element;
}
}

//初始化电脑的农民的聚集对象
$farmerAggregate = new ConcreteAggregate();
//添加农民，这里简单的用字符串表示
$farmerAggregate->addElement('SVC1');
$farmerAggregate->addElement('SVC2');

//获取迭代器
$iterator = $farmerAggregate->createIterator();
//将农民聚集对象循环
while ($iterator->hasNext())
{
//获取下一个农民
$element = $iterator->next();
//我们简单的输出
echo $element;
}
?>

用途总结：迭代器模式建立了类似数组的形式，从上面的代码可以看到，如果要修改循环的处理，或者修改被循环的集合，都不必修改其它相关的代码。
实现总结：需要一个管理聚集的类，比如上面的ConcreteAggregate。另外需要迭代器类，比如上面的ConcreteIterator。然后把所有的操作，比如添加元素，获取下一个元素，指针之类的数组方面的操作抽象出来，这样其它的代码只要使用方法，比如getLength()，而不是细节化的count()函数，这样即使不用数组存放农民，也不需要改动聚集类以外的代码。

生命只有一次。

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();
?>

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

生命只有一次。