PHP随笔：六大设计模式（2021-4）

简单的一些复习、预习等随笔;

文中部分转载自：https://blog.csdn.net/z15818264727/article/details/52354263

#1.单例设计模式-Singleton

- 所谓单例模式，即在应用程序中最多只有该类的一个实例存在， **一旦创建** ，就会 **一直存在于内存** 中！

- 单例设计模式常应用于数据库类设计，采用单例模式，只连接一次数据库，防止打开多个数据库连接。既： 数据**连接池**

- 一个单例类应具备以下特点：

- - 单例类**不能直接实例化**创建，而是 只能**由类本身实例化** 。因此，要获得这样的限制效果，构造函数必须标记为 private ，从而防止类被实例化。

- - 需要一个 **私有静态成员变量来保存** 类实例和公开一个能访问到实例的 **公开静态方法** 。

- - 在PHP中，为了防止他人对单例类实例克隆，通常还为其提供一个 **空的私有__clone()** 方法。

- ### 例子：

```
<?php

/**
 * Singleton of Database
 */
class Database
{
    // We need a static private variable to store a Database instance.
    private static $instance;

// Mark as private to prevent it from being instanced.
    private function function__construct()
    {
        // Do nothing.
    }

private function function__clone()
    {
        // Do nothing.
    }

public static function getInstance()
    {
        if (!(self::$instance instanceof self)) {
            self::$instance = new self();
        }

return self::$instance;
    }
}

$a = Database::getInstance();
$b = Database::getInstance();

// true
var_dump($a === $b);
```

#2.工厂设计模式-Factory

- 主要是当**操作类的参数变化**时，**只用改相应的工厂类**就可以

- 工厂设计模式常用于根据输入参数的不同或者应用程序配置的不同来创建一种专门用来实例化并返回其对应的类的实例。

- 使用场景：使用方法 new实例化类，每次实例化只需调用工厂类中的方法实例化即可。

- 优点：由于一个类可能会在很多地方被实例化。当类名或参数发生变化时，工厂模式可简单快捷的在工厂类下的方法中 一次性修改，避免了一个个的去修改实例化的对象。

- ### 例子：
- 我们举例子，假设矩形、圆都有同样的一个方法，那么我们用基类提供的API来创建实例时，通过传参数来自动创建对应的类的实例，他们都有获取周长和面积的功能。

```
<?php

interface InterfaceShape
{
    function getArea();

function getCircumference();
}

/**
 * 矩形
 */
class Rectangle implements InterfaceShape
{
    private $width;
    private $height;

public function __construct($width, $height)
    {
        $this->width = $width;
        $this->height = $height;
    }

public function getArea()
    {
        return $this->width * $this->height;
    }

public function getCircumference()
    {
        return 2 * $this->width + 2 * $this->height;
    }
}

/**
 * 圆形
 */
class Circle implements InterfaceShape
{
    private $radius;

function __construct($radius)
    {
        $this->radius = $radius;
    }

public function getArea()
    {
        return M_PI * pow($this->radius, 2);
    }

public function getCircumference()
    {
        return 2 * M_PI * $this->radius;
    }
}

/**
 * 形状工厂类
 */
class FactoryShape
{
    public static function create()
    {
        switch (func_num_args()) {
            case 1:
                return new Circle(func_get_arg(0));
            case 2:
                return new Rectangle(func_get_arg(0), func_get_arg(1));
            default:
                # code...
                break;
        }
    }
}

$rect = FactoryShape::create(5, 5);
// object(Rectangle)#1 (2) { ["width":"Rectangle":private]=> int(5) ["height":"Rectangle":private]=> int(5) }
var_dump($rect);
echo "<br>";

// object(Circle)#2 (1) { ["radius":"Circle":private]=> int(4) }
$circle = FactoryShape::create(4);
var_dump($circle);

```

#3.观察者设计模式

- - 一个对象通过提供方法允许另一个对象即**观察者（注册自己）**使本身变得**可观察**。
- - 当可观察的对象更改时，它会将消息发送到已注册的观察者。
- - 这些观察者使用该信息执行的操作与可观察的对象无关。
- - 结果是对象可以相互对话，而不必了解原因。

- 观察者模式是一种事件系统，意味着这一模式允许某个类观察另一个类的状态，当被观察的类状态发生改变的时候，观察类可以收到通知并且做出相应的动作;观察者模式为您提供了避免组件之间紧密耦。

- 简而言之：你做的事跟我无关，但是我会因为知道了你今天打麻将运气不佳而自己跑去做你对面（开玩笑哈）。

- ### 例子：

```
<?php

/*
观察者接口
*/

interface InterfaceObserver
{
    function onListen($sender, $args);

function getObserverName();
}

// 可被观察者接口
interface InterfaceObservable
{
    function addObserver($observer);

function removeObserver($observer_name);
}

// 观察者抽象类
abstract class Observer implements InterfaceObserver
{
    protected $observer_name;

function getObserverName()
    {
        return $this->observer_name;
    }

function onListen($sender, $args)
    {

}
}

// 可被观察类
abstract class Observable implements InterfaceObservable
{
    protected $observers = array();

public function addObserver($observer)
    {
        if ($observer instanceof InterfaceObserver) {
            $this->observers[] = $observer;
        }
    }

public function removeObserver($observer_name)
    {
        foreach ($this->observers as $index => $observer) {
            if ($observer->getObserverName() === $observer_name) {
                array_splice($this->observers, $index, 1);
                return;
            }
        }
    }
}

// 模拟一个可以被观察的类
class A extends Observable
{
    public function addListener($listener)
    {
        foreach ($this->observers as $observer) {
            $observer->onListen($this, $listener);
        }
    }
}

// 模拟一个观察者类
class B extends Observer
{
    protected $observer_name = 'B';

public function onListen($sender, $args)
    {
        var_dump($sender);
        echo "<br>";
        var_dump($args);
        echo "<br>";
    }
}

// 模拟另外一个观察者类
class C extends Observer
{
    protected $observer_name = 'C';

public function onListen($sender, $args)
    {
        var_dump($sender);
        echo "<br>";
        var_dump($args);
        echo "<br>";
    }
}

$a = new A();
// 注入观察者
$a->addObserver(new B());
$a->addObserver(new C());

// 可以看到观察到的信息
$a->addListener('D');

// 移除观察者
$a->removeObserver('B');

// 打印的信息：
// object(A)#1 (1) { ["observers":protected]=> array(2) { [0]=> object(B)#2 (1) { ["observer_name":protected]=> string(1) "B" } [1]=> object(C)#3 (1) { ["observer_name":protected]=> string(1) "C" } } }
// string(1) "D"
// object(A)#1 (1) { ["observers":protected]=> array(2) { [0]=> object(B)#2 (1) { ["observer_name":protected]=> string(1) "B" } [1]=> object(C)#3 (1) { ["observer_name":protected]=> string(1) "C" } } }
// string(1) "D"

```

# 4.适配器模式
- 将一个类的接口转换成客户希望的另一个接口,适配器模式使得原本的由于接口不兼容而不能一起工作的那些类可以一起工作。

- 应用场景：老代码接口不适应新的接口需求，或者代码很多很乱不便于继续修改，或者使用第三方类库。例如：php连接数据库的方法：mysql,,mysqli,pdo,可以用适配器统一

- ### 例子：

```
<?php
//老的代码

class User
{
    private $name;
    function __construct($name)
    {
        $this->name = $name;
    }

public function getName()
    {
        return $this->name;
    }

}

//新代码，开放平台标准接口

interface UserInterface
{
    function getUserName();
}

class UserInfo implements UserInterface
{
    protected $user;
    function __construct($user)
    {
        $this->user = $user;
    }

public function getUserName()
    {
        return $this->user->getName();
    }

}

$olduser = new User('张三');

echo $olduser->getName() . "n";

$newuser = new UserInfo($olduser);

echo $newuser->getUserName() . "n";

```

#5.策略模式
- 将一组特定的行为和算法封装成类，以适应某些特定的上下文环境。

- ###例子：
- - 一个电商网站系统，针对男性女性用户要各自跳转到不同的商品类目，并且所有广告位展示不同的广告

UserStrategy.php

```
<?php
    namespace IMooc;
    interface UserStrategy {
        function showAd();
        function showCategory();
    }

```

MaleUserStrategy.php

```
<?php

namespace IMooc;
    class MaleUserStrategy implements UserStrategy  {

function showAd()
        {
            echo "IPhone6";
        }

function showCategory()
        {
            echo "电子产品";
        }
    }
```

FemaleUserStrategy.php

```
<?php

namespace IMooc;
    class FemaleUserStrategy implements UserStrategy {
        function showAd()
        {
            echo "2014新款女装";
        }
        function showCategory()
        {
            echo "女装";
        }
    }
```

测试:
```
<?php

interface FlyBehavior{
        public function fly();
    }

class FlyWithWings implements FlyBehavior{
        public function fly(){
            echo "Fly With Wings \n";
        }
    }

class FlyWithNo implements FlyBehavior{
        public function fly(){
            echo "Fly With No Wings \n";
        }
    }
    class Duck{
        private $_flyBehavior;
        public function performFly(){
            $this->_flyBehavior->fly();
        }

public function setFlyBehavior(FlyBehavior $behavior){
            $this->_flyBehavior = $behavior;
        }
    }

class RubberDuck extends Duck{
    }
    // Test Case
    $duck = new RubberDuck();

/*  想让鸭子用翅膀飞行 */
    $duck->setFlyBehavior(new FlyWithWings());
    $duck->performFly();

/*  想让鸭子不用翅膀飞行 */
    $duck->setFlyBehavior(new FlyWithNo());
    $duck->performFly();
```

#6.装饰器模式
- 使用场景：当某一功能或方法draw，要满足不同的功能需求时，可以使用装饰器模式；

- 实现方式：在方法的类中建addDecorator(添加装饰器),beforeDraw,afterDraw 3个新方法， 后2个分别放置在要修改的方法draw首尾.然后创建不同的装器类（其中要包含相同的,beforeDraw,afterDraw方法）能过addDecorator添加进去，然后在beforeDraw,afterDraw中循环处理，与观察者模式使用有点相似

- 1.装饰器模式（Decorator），可以动态地添加修改类的功能

- 2.一个类提供了一项功能，如果要在修改并添加额外的功能，传统的编程模式，需要写一个子类继承它，并重新实现类的方法

- 3.使用装饰器模式，仅需在运行时添加一个装饰器对象即可实现，可以实现最大的灵活性

- ###例子：

DrawDecorator.php
```
<?php

interface DrawDecorator
{
    function beforeDraw();
    function afterDraw();
}

```

Canvas.php
```
<?php

class Canvas
{
    public $data;
    protected $decorators = array();

//Decorator
    function init($width = 20, $height = 10)
    {
        $data = array();
        for ($i = 0; $i < $height; $i++) {
            for ($j = 0; $j < $width; $j++) {
                $data[$i][$j] = '*';
            }
        }
        $this->data = $data;
    }

function addDecorator(DrawDecorator $decorator)
    {
        $this->decorators[] = $decorator;
    }

function beforeDraw()
    {
        foreach ($this->decorators as $decorator) {
            $decorator->beforeDraw();
        }
    }

function afterDraw()
    {
        $decorators = array_reverse($this->decorators);
        foreach ($decorators as $decorator) {
            $decorator->afterDraw();
        }
    }

```

ColorDrawDecorator.php

```
<?php

class ColorDrawDecorator implements DrawDecorator
{
    protected $color;
    function __construct($color = 'red')
    {
        $this->color = $color;
    }
    function beforeDraw()
    {
        echo "<div style='color: {$this->color};'>";
    }
    function afterDraw()
    {
        echo "</div>";
    }
}
```

index.php

```
<?php
define('BASEDIR', __DIR__);
include BASEDIR.'/IMooc/Loader.php';
spl_autoload_register('\\IMooc\\Loader::autoload');

$canvas = new IMooc\Canvas();
$canvas->init();
$canvas->addDecorator(new \IMooc\ColorDrawDecorator('green'));
$canvas->rect(3,6,4,12);
$canvas->draw();

```

<h1 id="h1-1-singleton"><a name="1.单例设计模式-Singleton" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1.单例设计模式-Singleton</h1><ul>
<li><p>所谓单例模式，即在应用程序中最多只有该类的一个实例存在， <strong>一旦创建</strong> ，就会 <strong>一直存在于内存</strong> 中！</p>
</li><li><p>单例设计模式常应用于数据库类设计，采用单例模式，只连接一次数据库，防止打开多个数据库连接。既： 数据<strong>连接池</strong></p>
</li><li><p>一个单例类应具备以下特点：</p>
</li><li><ul>
<li>单例类<strong>不能直接实例化</strong>创建，而是 只能<strong>由类本身实例化</strong> 。因此，要获得这样的限制效果，构造函数必须标记为 private ，从而防止类被实例化。</li></ul>
</li></ul>
<ul>
<li><ul>
<li>需要一个 <strong>私有静态成员变量来保存</strong> 类实例和公开一个能访问到实例的 <strong>公开静态方法</strong> 。</li></ul>
</li></ul>
<ul>
<li><ul>
<li>在PHP中，为了防止他人对单例类实例克隆，通常还为其提供一个 <strong>空的私有__clone()</strong> 方法。</li></ul>
</li><li><h3 id="h3--"><a name="例子：" class="reference-link"></a><span class="header-link octicon octicon-link"></span>例子：</h3></li></ul>
<pre><code>&lt;?php

/**
 * Singleton of Database
 */
class Database
{
    // We need a static private variable to store a Database instance.
    private static $instance;

// Mark as private to prevent it from being instanced.
    private function function__construct()
    {
        // Do nothing.
    }

private function function__clone()
    {
        // Do nothing.
    }

public static function getInstance()
    {
        if (!(self::$instance instanceof self)) {
            self::$instance = new self();
        }

return self::$instance;
    }
}

$a = Database::getInstance();
$b = Database::getInstance();

// true
var_dump($a === $b);
</code></pre><h1 id="h1-2-factory"><a name="2.工厂设计模式-Factory" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2.工厂设计模式-Factory</h1><ul>
<li><p>主要是当<strong>操作类的参数变化</strong>时，<strong>只用改相应的工厂类</strong>就可以</p>
</li><li><p>工厂设计模式常用于根据输入参数的不同或者应用程序配置的不同来创建一种专门用来实例化并返回其对应的类的实例。</p>
</li><li><p>使用场景：使用方法 new实例化类，每次实例化只需调用工厂类中的方法实例化即可。</p>
</li><li><p>优点：由于一个类可能会在很多地方被实例化。当类名或参数发生变化时，工厂模式可简单快捷的在工厂类下的方法中 一次性修改，避免了一个个的去修改实例化的对象。</p>
</li><li><h3 id="h3--"><a name="例子：" class="reference-link"></a><span class="header-link octicon octicon-link"></span>例子：</h3></li><li>我们举例子，假设矩形、圆都有同样的一个方法，那么我们用基类提供的API来创建实例时，通过传参数来自动创建对应的类的实例，他们都有获取周长和面积的功能。</li></ul>
<pre><code>&lt;?php

interface InterfaceShape
{
    function getArea();

function getCircumference();
}

/**
 * 矩形
 */
class Rectangle implements InterfaceShape
{
    private $width;
    private $height;

public function __construct($width, $height)
    {
        $this-&gt;width = $width;
        $this-&gt;height = $height;
    }

public function getArea()
    {
        return $this-&gt;width * $this-&gt;height;
    }

public function getCircumference()
    {
        return 2 * $this-&gt;width + 2 * $this-&gt;height;
    }
}

/**
 * 圆形
 */
class Circle implements InterfaceShape
{
    private $radius;

function __construct($radius)
    {
        $this-&gt;radius = $radius;
    }

public function getArea()
    {
        return M_PI * pow($this-&gt;radius, 2);
    }

public function getCircumference()
    {
        return 2 * M_PI * $this-&gt;radius;
    }
}

$rect = FactoryShape::create(5, 5);
// object(Rectangle)#1 (2) { ["width":"Rectangle":private]=&gt; int(5) ["height":"Rectangle":private]=&gt; int(5) }
var_dump($rect);
echo "&lt;br&gt;";

// object(Circle)#2 (1) { ["radius":"Circle":private]=&gt; int(4) }
$circle = FactoryShape::create(4);
var_dump($circle);
</code></pre><h1 id="h1-3-"><a name="3.观察者设计模式" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3.观察者设计模式</h1><ul>
<li><ul>
<li>一个对象通过提供方法允许另一个对象即<strong>观察者（注册自己）</strong>使本身变得<strong>可观察</strong>。</li></ul>
</li><li><ul>
<li>当可观察的对象更改时，它会将消息发送到已注册的观察者。</li></ul>
</li><li><ul>
<li>这些观察者使用该信息执行的操作与可观察的对象无关。</li></ul>
</li><li><ul>
<li>结果是对象可以相互对话，而不必了解原因。</li></ul>
</li><li><p>观察者模式是一种事件系统，意味着这一模式允许某个类观察另一个类的状态，当被观察的类状态发生改变的时候，观察类可以收到通知并且做出相应的动作;观察者模式为您提供了避免组件之间紧密耦。</p>
</li><li><p>简而言之：你做的事跟我无关，但是我会因为知道了你今天打麻将运气不佳而自己跑去做你对面（开玩笑哈）。</p>
</li><li><h3 id="h3--"><a name="例子：" class="reference-link"></a><span class="header-link octicon octicon-link"></span>例子：</h3></li></ul>
<pre><code>&lt;?php

/*
观察者接口
*/

interface InterfaceObserver
{
    function onListen($sender, $args);

function getObserverName();
}

// 可被观察者接口
interface InterfaceObservable
{
    function addObserver($observer);

function removeObserver($observer_name);
}

// 观察者抽象类
abstract class Observer implements InterfaceObserver
{
    protected $observer_name;

function getObserverName()
    {
        return $this-&gt;observer_name;
    }

function onListen($sender, $args)
    {

}
}

// 可被观察类
abstract class Observable implements InterfaceObservable
{
    protected $observers = array();

public function addObserver($observer)
    {
        if ($observer instanceof InterfaceObserver) {
            $this-&gt;observers[] = $observer;
        }
    }

public function removeObserver($observer_name)
    {
        foreach ($this-&gt;observers as $index =&gt; $observer) {
            if ($observer-&gt;getObserverName() === $observer_name) {
                array_splice($this-&gt;observers, $index, 1);
                return;
            }
        }
    }
}

// 模拟一个可以被观察的类
class A extends Observable
{
    public function addListener($listener)
    {
        foreach ($this-&gt;observers as $observer) {
            $observer-&gt;onListen($this, $listener);
        }
    }
}

// 模拟一个观察者类
class B extends Observer
{
    protected $observer_name = 'B';

public function onListen($sender, $args)
    {
        var_dump($sender);
        echo "&lt;br&gt;";
        var_dump($args);
        echo "&lt;br&gt;";
    }
}

// 模拟另外一个观察者类
class C extends Observer
{
    protected $observer_name = 'C';

public function onListen($sender, $args)
    {
        var_dump($sender);
        echo "&lt;br&gt;";
        var_dump($args);
        echo "&lt;br&gt;";
    }
}

$a = new A();
// 注入观察者
$a-&gt;addObserver(new B());
$a-&gt;addObserver(new C());

// 可以看到观察到的信息
$a-&gt;addListener('D');

// 移除观察者
$a-&gt;removeObserver('B');

// 打印的信息：
// object(A)#1 (1) { ["observers":protected]=&gt; array(2) { [0]=&gt; object(B)#2 (1) { ["observer_name":protected]=&gt; string(1) "B" } [1]=&gt; object(C)#3 (1) { ["observer_name":protected]=&gt; string(1) "C" } } }
// string(1) "D"
// object(A)#1 (1) { ["observers":protected]=&gt; array(2) { [0]=&gt; object(B)#2 (1) { ["observer_name":protected]=&gt; string(1) "B" } [1]=&gt; object(C)#3 (1) { ["observer_name":protected]=&gt; string(1) "C" } } }
// string(1) "D"
</code></pre><h1 id="h1-4-"><a name="4.适配器模式" class="reference-link"></a><span class="header-link octicon octicon-link"></span>4.适配器模式</h1><ul>
<li><p>将一个类的接口转换成客户希望的另一个接口,适配器模式使得原本的由于接口不兼容而不能一起工作的那些类可以一起工作。</p>
</li><li><p>应用场景：老代码接口不适应新的接口需求，或者代码很多很乱不便于继续修改，或者使用第三方类库。例如：php连接数据库的方法：mysql,,mysqli,pdo,可以用适配器统一</p>
</li><li><h3 id="h3--"><a name="例子：" class="reference-link"></a><span class="header-link octicon octicon-link"></span>例子：</h3></li></ul>
<pre><code>&lt;?php
//老的代码

class User
{
    private $name;
    function __construct($name)
    {
        $this-&gt;name = $name;
    }

public function getName()
    {
        return $this-&gt;name;
    }

}

//新代码，开放平台标准接口

interface UserInterface
{
    function getUserName();
}

class UserInfo implements UserInterface
{
    protected $user;
    function __construct($user)
    {
        $this-&gt;user = $user;
    }

public function getUserName()
    {
        return $this-&gt;user-&gt;getName();
    }

}

$olduser = new User('张三');

echo $olduser-&gt;getName() . "n";

$newuser = new UserInfo($olduser);

echo $newuser-&gt;getUserName() . "n";
</code></pre><h1 id="h1-5-"><a name="5.策略模式" class="reference-link"></a><span class="header-link octicon octicon-link"></span>5.策略模式</h1><ul>
<li><p>将一组特定的行为和算法封装成类，以适应某些特定的上下文环境。</p>
</li><li><h3 id="h3--"><a name="例子：" class="reference-link"></a><span class="header-link octicon octicon-link"></span>例子：</h3></li><li><ul>
<li>一个电商网站系统，针对男性女性用户要各自跳转到不同的商品类目，并且所有广告位展示不同的广告</li></ul>
</li></ul>
<p>UserStrategy.php</p>
<pre><code>&lt;?php
    namespace IMooc;
    interface UserStrategy {
        function showAd();
        function showCategory();
    }
</code></pre><p>MaleUserStrategy.php</p>
<pre><code>&lt;?php

namespace IMooc;
    class MaleUserStrategy implements UserStrategy  {

function showAd()
        {
            echo "IPhone6";
        }

function showCategory()
        {
            echo "电子产品";
        }
    }
</code></pre><p>FemaleUserStrategy.php</p>
<pre><code>&lt;?php

namespace IMooc;
    class FemaleUserStrategy implements UserStrategy {
        function showAd()
        {
            echo "2014新款女装";
        }
        function showCategory()
        {
            echo "女装";
        }
    }
</code></pre><p>测试:</p>
<pre><code>&lt;?php

interface FlyBehavior{
        public function fly();
    }

class FlyWithWings implements FlyBehavior{
        public function fly(){
            echo "Fly With Wings \n";
        }
    }

class FlyWithNo implements FlyBehavior{
        public function fly(){
            echo "Fly With No Wings \n";
        }
    }
    class Duck{
        private $_flyBehavior;
        public function performFly(){
            $this-&gt;_flyBehavior-&gt;fly();
        }

public function setFlyBehavior(FlyBehavior $behavior){
            $this-&gt;_flyBehavior = $behavior;
        }
    }

class RubberDuck extends Duck{
    }
    // Test Case
    $duck = new RubberDuck();

/*  想让鸭子用翅膀飞行 */
    $duck-&gt;setFlyBehavior(new FlyWithWings());
    $duck-&gt;performFly();

/*  想让鸭子不用翅膀飞行 */
    $duck-&gt;setFlyBehavior(new FlyWithNo());
    $duck-&gt;performFly();
</code></pre><h1 id="h1-6-"><a name="6.装饰器模式" class="reference-link"></a><span class="header-link octicon octicon-link"></span>6.装饰器模式</h1><ul>
<li><p>使用场景：当某一功能或方法draw，要满足不同的功能需求时，可以使用装饰器模式；</p>
</li><li><p>实现方式：在方法的类中建addDecorator(添加装饰器),beforeDraw,afterDraw 3个新方法， 后2个分别放置在要修改的方法draw首尾.然后创建不同的装器类（其中要包含相同的,beforeDraw,afterDraw方法）能过addDecorator添加进去，然后在beforeDraw,afterDraw中循环处理，与观察者模式使用有点相似</p>
</li><li><p>1.装饰器模式（Decorator），可以动态地添加修改类的功能</p>
</li><li><p>2.一个类提供了一项功能，如果要在修改并添加额外的功能，传统的编程模式，需要写一个子类继承它，并重新实现类的方法</p>
</li><li><p>3.使用装饰器模式，仅需在运行时添加一个装饰器对象即可实现，可以实现最大的灵活性</p>
</li><li><h3 id="h3--"><a name="例子：" class="reference-link"></a><span class="header-link octicon octicon-link"></span>例子：</h3></li></ul>
<p>DrawDecorator.php</p>
<pre><code>&lt;?php

interface DrawDecorator
{
    function beforeDraw();
    function afterDraw();
}
</code></pre><p>Canvas.php</p>
<pre><code>&lt;?php

class Canvas
{
    public $data;
    protected $decorators = array();

//Decorator
    function init($width = 20, $height = 10)
    {
        $data = array();
        for ($i = 0; $i &lt; $height; $i++) {
            for ($j = 0; $j &lt; $width; $j++) {
                $data[$i][$j] = '*';
            }
        }
        $this-&gt;data = $data;
    }

function addDecorator(DrawDecorator $decorator)
    {
        $this-&gt;decorators[] = $decorator;
    }

function beforeDraw()
    {
        foreach ($this-&gt;decorators as $decorator) {
            $decorator-&gt;beforeDraw();
        }
    }

function afterDraw()
    {
        $decorators = array_reverse($this-&gt;decorators);
        foreach ($decorators as $decorator) {
            $decorator-&gt;afterDraw();
        }
    }

class ColorDrawDecorator implements DrawDecorator
{
    protected $color;
    function __construct($color = 'red')
    {
        $this-&gt;color = $color;
    }
    function beforeDraw()
    {
        echo "&lt;div style='color: {$this-&gt;color};'&gt;";
    }
    function afterDraw()
    {
        echo "&lt;/div&gt;";
    }
}
</code></pre><p>index.php</p>
<pre><code>&lt;?php
define('BASEDIR', __DIR__);
include BASEDIR.'/IMooc/Loader.php';
spl_autoload_register('\\IMooc\\Loader::autoload');

$canvas = new IMooc\Canvas();
$canvas-&gt;init();
$canvas-&gt;addDecorator(new \IMooc\ColorDrawDecorator('green'));
$canvas-&gt;rect(3,6,4,12);
$canvas-&gt;draw();
</code></pre>

PHP随笔：六大设计模式（2021-4）

热门文章

置顶推荐

最近访客