php设计模式三（行为）

责任链模式（Chain of Responsibility）：创建对象的链，沿链条传递请求，直到有一个对象处理它为止。

<?php
abstract class Handler
{
    protected $successor;
    public function setSuccessor($successor)
    {
        $this->successor = $successor;
    }
    abstract public function HandleRequst($request);
}

class A extends Handler{
    public function HandleRequst($request){
        if(is_numeric($request)){
            return 'num：' . $request;
        }else{
            return $this->successor->HandleRequst($request);
        }
    }
}

class B extends Handler{
    public $a = 2;
    public function HandleRequst($request){
        if(is_string($request)){
            return 'string ：' . $request;
        }else{
            return $this->successor->HandleRequst($request);
        }
    }
    public function getName(){
        return $this->a;
    }
    public function setName($str){
        $this->a = $str;
    }
}

class C extends Handler{
    public function HandleRequst($request){
        return '我也不知道请求参数是啥了，你猜猜？' . gettype($request);
    }
}

$a = new A();
$b = new B();
$c = new C();
$b->setSuccessor($c);
$a->setSuccessor($b);
var_dump($a);
echo $b->setName(4);
var_dump($a);

 

命令模式（Command）：请求以命令的形式包裹在对象中，并传给调用对象。

<?php
//命令
interface commond{
    public function execute();
}


class ConcreteCommandOne implements commond{
    //公公
    public $receiver;
    public function __construct($receiver)
    {
        $this->receiver = $receiver;
    }
    public function execute()
    {
        $this->receiver->charge();
    }
}

class ConcreteCommandTwo implements commond{
    //公公
    public $receiver;
    public function __construct($receiver)
    {
        $this->receiver = $receiver;
    }
    public function execute()
    {
        $this->receiver->issue();
    }
}

class Receiver{
    public function charge(){
        echo '收取奏折';
    }
    public function issue(){
        echo '颁布圣旨';
    }
}
//皇帝
class Invoker {
    public $commond;
    public function Invoker($commond){
        $this->commond = $commond;
    }
    public function action(){
        $this->commond->execute();
    }
}
$rece = new Receiver();
$gg1 = new ConcreteCommandOne($rece);
$invo = new Invoker($gg1);
$invo->action();

解释器模式（Interpreter）：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
迭代器模式（Iterator）：提供一种方法顺序访问一个容器对象中各个元素，而又无需暴露该对象的内部细节。
中介者模式（Mediator）：用一个统一的对象来管理不同的对象之间的交互，避免对象之间的紧耦合。
备忘录模式（Memento）：在不破坏封装性的条件下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
观察者模式（Observer）：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。

<?php
//观察者模式
interface Observer{
    public function update($subject);
}


class ConcreteObserver  implements Observer{
    private $observerState;
    public function update($subject){
        $this->observerState = $subject->getState();

    }
}

class Subject{
    //观察者的数组
    public $arr;
    public $stateNow = '';
    public function attach($observer){
        $this->arr = array_push($this->arr,$observer);
    }
    public function detach($observer){
        foreach($this->arr as $key=>$value){
            if($value == $observer){
                unset($this->arr[$key]);
            }
        }
    }
    public function notify(){
        foreach($this->arr as $key=>$value){
            $value->update();
        }
    }
}


class ChildSubject extends Subject{
    public function setState($state){
        $this->stateNow = $state;
    }
    public function getState(){
        return $this->stateNow;
    }
}

状态模式（State）：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。
策略模式（Strategy）：定义一系列的算法，把它们一个个封装起来，并且使它们可以互相替换，本模式使得算法可独立于使用它的客户而变化。
模板方法模式（Template Method）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
访问者模式（Visitor）：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。