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

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