本文实例讲述了PHP面向对象程序设计组合模式与装饰模式。分享给大家供大家参考，具体如下：
组合模式
定义：组合模式定义了一个单根继承体系，使具有截然不同职责的集合可以并肩工作。
一个军队的案例，
<?phpabstract class Unit {
// 个体 abstract function bombardStrength();
}
class Archer extends Unit {
// 弓箭手 function bombardStrength() {
return 4;
}
}
class LaserCannonUnit extends Unit {
// 火炮手 function bombardStrength() {
return 44;
}
}
?>
军队整合成员，输出火力
<?phpabstract class Unit {
abstract function bombardStrength();
}
class Archer extends Unit {
function bombardStrength() {
return 4;
}
}
class LaserCannonUnit extends Unit {
function bombardStrength() {
return 44;
}
}
class Army {
// 军队 private $units = array();
// 定义私有属性 个体集 function addUnit( Unit $unit ) {
// 添加成员 array_push( $this->units, $unit );
}
function bombardStrength() {
// 火力 $ret = 0;
foreach( $this->units as $unit ) {
$ret += $unit->bombardStrength();
}
return $ret;
}
}
$unit1 = new Archer();
$unit2 = new LaserCannonUnit();
$army = new Army();
$army->addUnit( $unit1 );
$army->addUnit( $unit2 );
print $army->bombardStrength();
// 输出火力?>
output:
48
军队进一步整合其他军队
<?phpabstract class Unit {
abstract function bombardStrength();
}
class Archer extends Unit {
function bombardStrength() {
return 4;
}
}
class LaserCannonUnit extends Unit {
function bombardStrength() {
return 44;
}
}
class Army {
private $units = array();
private $armies= array();
function addUnit( Unit $unit ) {
array_push( $this->units, $unit );
}
function addArmy( Army $army ) {
array_push( $this->armies, $army );
}
function bombardStrength() {
$ret = 0;
foreach( $this->units as $unit ) {
$ret += $unit->bombardStrength();
}
foreach( $this->armies as $army ) {
$ret += $army->bombardStrength();
}
return $ret;
}
}
$unit1 = new Archer();
$unit2 = new LaserCannonUnit();
$army = new Army();
$army->addUnit( $unit1 );
$army->addUnit( $unit2 );
print $army->bombardStrength();
print "n";
$army2 = clone $army;
// 克隆军队$army->addArmy( $army2 );
print $army->bombardStrength();
print "n";
?>
output:
48
96
更好的方式，支持新增，移除等等其他功能。
<?phpabstract class Unit {
abstract function addUnit( Unit $unit );
abstract function removeUnit( Unit $unit );
abstract function bombardStrength();
}
class Army extends Unit {
// 军队 private $units = array();
function addUnit( Unit $unit ) {
if ( in_array( $unit, $this->units, true ) ) {
// $this用于调用正常的属性或方法，self调用静态的方法，属性或者常量 return;
}
$this->units[] = $unit;
}
function removeUnit( Unit $unit ) {
// >= php 5.3 $this->units = array_udiff( $this->units, array( $unit ), function( $a, $b ) {
return ($a === $b)?0:1;
}
);
// < php 5.3 // $this->units = array_udiff( $this->units, array( $unit ), // create_function( '$a,$b', 'return ($a === $b)?0:1;
' ) );
// 对象数组，create_function,创建函数 }
function bombardStrength() {
$ret = 0;
foreach( $this->units as $unit ) {
$ret += $unit->bombardStrength();
}
return $ret;
}
}
// quick example classesclass Tank extends Unit {
// 坦克 function addUnit( Unit $unit ) {
}
function removeUnit( Unit $unit ) {
}
function bombardStrength() {
return 4;
}
}
class Soldier extends Unit {
// 士兵 function addUnit( Unit $unit ) {
}
function removeUnit( Unit $unit ) {
}
function bombardStrength() {
return 8;
}
}
$tank = new Tank();
$tank2 = new Tank();
$soldier = new Soldier();
$army = new Army();
$army->addUnit( $soldier );
$army->addUnit( $tank );
$army->addUnit( $tank2 );
print_r( $army );
print $army->bombardStrength()."n";
$army->removeUnit( $soldier );
print_r( $army );
print $army->bombardStrength()."n";
?>
output:
Army Object( [units:Army:private] => Array ( [0] => Soldier Object ( ) [1] => Tank Object ( ) [2] => Tank Object ( ) ))16Army Object( [units:Army:private] => Array ( [1] => Tank Object ( ) [2] => Tank Object ( ) ))8
添加异常处理
<?phpabstract class Unit {
abstract function addUnit( Unit $unit );
abstract function removeUnit( Unit $unit );
abstract function bombardStrength();
}
class Army extends Unit {
private $units = array();
function addUnit( Unit $unit ) {
if ( in_array( $unit, $this->units, true ) ) {
return;
}
$this->units[] = $unit;
}
function removeUnit( Unit $unit ) {
// >= php 5.3 //$this->units = array_udiff( $this->units, array( $unit ), // function( $a, $b ) {
return ($a === $b)?0:1;
}
);
// < php 5.3 $this->units = array_udiff( $this->units, array( $unit ), create_function( '$a,$b', 'return ($a === $b)?0:1;
' ) );
}
function bombardStrength() {
$ret = 0;
foreach( $this->units as $unit ) {
$ret += $unit->bombardStrength();
}
return $ret;
}
}
class UnitException extends Exception {
}
class Archer extends Unit {
function addUnit( Unit $unit ) {
throw new UnitException( get_class($this)." is a leaf" );
}
function removeUnit( Unit $unit ) {
throw new UnitException( get_class($this)." is a leaf" );
}
function bombardStrength() {
return 4;
}
}
$archer = new Archer();
$archer2 = new Archer();
$archer->addUnit( $archer2 );
?>
output:
Fatal error: Uncaught exception 'UnitException' with message 'Archer is a leaf'
点评：组合模式中的一切类都共享同一个父类型，可以轻松地在设计中添加新的组合对象或局部对象，而无需大范围地修改代码。
最终的效果，逐步优化(完美)：
<?phpclass UnitException extends Exception {
}
abstract class Unit {
abstract function bombardStrength();
function addUnit( Unit $unit ) {
throw new UnitException( get_class($this)." is a leaf" );
}
function removeUnit( Unit $unit ) {
throw new UnitException( get_class($this)." is a leaf" );
}
}
class Archer extends Unit {
function bombardStrength() {
return 4;
}
}
class LaserCannonUnit extends Unit {
function bombardStrength() {
return 44;
}
}
class Army extends Unit {
private $units = array();
function addUnit( Unit $unit ) {
if ( in_array( $unit, $this->units, true ) ) {
return;
}
$this->units[] = $unit;
}
function removeUnit( Unit $unit ) {
// >= php 5.3 //$this->units = array_udiff( $this->units, array( $unit ), // function( $a, $b ) {
return ($a === $b)?0:1;
}
);
// < php 5.3 $this->units = array_udiff( $this->units, array( $unit ), create_function( '$a,$b', 'return ($a === $b)?0:1;
' ) );
}
function bombardStrength() {
$ret = 0;
foreach( $this->units as $unit ) {
$ret += $unit->bombardStrength();
}
return $ret;
}
}
// create an army$main_army = new Army();
// add some units$main_army->addUnit( new Archer() );
$main_army->addUnit( new LaserCannonUnit() );
// create a new army$sub_army = new Army();
// add some units$sub_army->addUnit( new Archer() );
$sub_army->addUnit( new Archer() );
$sub_army->addUnit( new Archer() );
// add the second army to the first$main_army->addUnit( $sub_army );
// all the calculations handled behind the scenesprint "attacking with strength: {
$main_army->bombardStrength()}
n";
?>
output:
attacking with strength: 60
更牛逼的组合处理，
<?phpabstract class Unit {
function getComposite() {
return null;
}
abstract function bombardStrength();
}
abstract class CompositeUnit extends Unit {
// 抽象类继承抽象类 private $units = array();
function getComposite() {
return $this;
}
protected function units() {
return $this->units;
}
function removeUnit( Unit $unit ) {
// >= php 5.3 //$this->units = array_udiff( $this->units, array( $unit ), // function( $a, $b ) {
return ($a === $b)?0:1;
}
);
// < php 5.3 $this->units = array_udiff( $this->units, array( $unit ), create_function( '$a,$b', 'return ($a === $b)?0:1;
' ) );
}
function addUnit( Unit $unit ) {
if ( in_array( $unit, $this->units, true ) ) {
return;
}
$this->units[] = $unit;
}
}
class Army extends CompositeUnit {
function bombardStrength() {
$ret = 0;
foreach( $this->units as $unit ) {
$ret += $unit->bombardStrength();
}
return $ret;
}
}
class Archer extends Unit {
function bombardStrength() {
return 4;
}
}
class LaserCannonUnit extends Unit {
function bombardStrength() {
return 44;
}
}
class UnitScript {
static function joinExisting( Unit $newUnit, Unit $occupyingUnit ) {
// 静态方法，直接通过类名来使用 $comp;
if ( ! is_null( $comp = $occupyingUnit->getComposite() ) ) {
// 军队合并处理 $comp->addUnit( $newUnit );
}
else {
// 士兵合并处理 $comp = new Army();
$comp->addUnit( $occupyingUnit );
$comp->addUnit( $newUnit );
}
return $comp;
}
}
$army1 = new Army();
$army1->addUnit( new Archer() );
$army1->addUnit( new Archer() );
$army2 = new Army();
$army2->addUnit( new Archer() );
$army2->addUnit( new Archer() );
$army2->addUnit( new LaserCannonUnit() );
$composite = UnitScript::joinExisting( $army2, $army1 );
print_r( $composite );
?>
output:
Army Object( [units:CompositeUnit:private] => Array ( [0] => Archer Object ( ) [1] => Archer Object ( ) [2] => Army Object ( [units:CompositeUnit:private] => Array ( [0] => Archer Object ( ) [1] => Archer Object ( ) [2] => LaserCannonUnit Object ( ) ) ) ))
点评：Unit 基础，CompositeUnit复合中实现add与remove。军队继承Composite，射手继承Archer。这样射手中就不会有多余的add与remove方法了。
装饰模式
装饰模式帮助我们改变具体组件的功能。
看例子
<?phpabstract class Tile {
// 砖瓦 abstract function getWealthFactor();
// 获取财富}
class Plains extends Tile {
// 平原 private $wealthfactor = 2;
function getWealthFactor() {
return $this->wealthfactor;
}
}
class DiamondPlains extends Plains {
// 钻石地段 function getWealthFactor() {
return parent::getWealthFactor() + 2;
}
}
class PollutedPlains extends Plains {
// 污染地段 function getWealthFactor() {
return parent::getWealthFactor() - 4;
}
}
$tile = new PollutedPlains();
print $tile->getWealthFactor();
?>
output:
-2
点评：不具有灵活性，我们不能同时获得钻石与被污染的土地的资金情况。
装饰模式使用组合和委托而不是只使用继承来解决功能变化的问题。
看例子：
<?phpabstract class Tile {
abstract function getWealthFactor();
}
class Plains extends Tile {
private $wealthfactor = 2;
function getWealthFactor() {
return $this->wealthfactor;
}
}
abstract class TileDecorator extends Tile {
// 装饰 protected $tile;
function __construct( Tile $tile ) {
$this->tile = $tile;
}
}
class DiamondDecorator extends TileDecorator {
// 钻石装饰 function getWealthFactor() {
return $this->tile->getWealthFactor()+2;
}
}
class PollutionDecorator extends TileDecorator {
// 污染装饰 function getWealthFactor() {
return $this->tile->getWealthFactor()-4;
}
}
$tile = new Plains();
print $tile->getWealthFactor();
// 2$tile = new DiamondDecorator( new Plains() );
print $tile->getWealthFactor();
// 4$tile = new PollutionDecorator( new DiamondDecorator( new Plains() ));
print $tile->getWealthFactor();
// 0?>
output:
2
4
0
点评：这个模型具有扩展性。我们不需要创建DiamondPollutionPlains对象就可以构建一个钻石被污染的对象。
一个更逼真的例子
<?phpclass RequestHelper{
}
// 请求助手abstract class ProcessRequest {
// 进程请求 abstract function process( RequestHelper $req );
}
class MainProcess extends ProcessRequest {
// 主进程 function process( RequestHelper $req ) {
print __CLASS__.": doing something useful with requestn";
}
}
abstract class DecorateProcess extends ProcessRequest {
// 装饰进程 protected $processrequest;
function __construct( ProcessRequest $pr ) {
// 引用对象，委托 $this->processrequest = $pr;
}
}
class LogRequest extends DecorateProcess {
// 日志请求 function process( RequestHelper $req ) {
print __CLASS__.": logging requestn";
// 当前类,有点递归的感觉 $this->processrequest->process( $req );
}
}
class AuthenticateRequest extends DecorateProcess {
// 认证请求 function process( RequestHelper $req ) {
print __CLASS__.": authenticating requestn";
$this->processrequest->process( $req );
}
}
class StructureRequest extends DecorateProcess {
// 组织结构请求 function process( RequestHelper $req ) {
print __CLASS__.": structuring requestn";
$this->processrequest->process( $req );
}
}
$process = new AuthenticateRequest( new StructureRequest( new LogRequest ( new MainProcess() )));
// 这样可以很灵活的组合进程的关系，省去很多重复的继承$process->process( new RequestHelper() );
print_r($process);
?>
output:
AuthenticateRequest: authenticating requestStructureRequest: structuring requestLogRequest: logging requestMainProcess: doing something useful with requestAuthenticateRequest Object( [processrequest:protected] => StructureRequest Object ( [processrequest:protected] => LogRequest Object ( [processrequest:protected] => MainProcess Object ( ) ) ))
点评：这里有一种递归的感觉，一层调用一层。模式是牛人总结出来用于灵活的解决一些现实问题的。牛！给开发多一点思路。
更多关于PHP相关内容感兴趣的读者可查看本站专题：《php面向对象程序设计入门教程》、《PHP基本语法入门教程》、《PHP运算与运算符用法总结》、《PHP网络编程技巧总结》、《PHP数组(Array)操作技巧大全》、《php字符串(string)用法总结》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》
希望本文所述对大家PHP程序设计有所帮助。
