2.工厂模式

工厂模式（Factory Pattern）是最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

<?php
//工厂模式
abstract class Operation {
    abstract public function getValue($num1, $num2);
}

class OperationAdd extends Operation {
    public function getValue($num1, $num2) {
        return $num1 + $num2;
    }
}

class OperationSub extends Operation {
    public function getValue($num1, $num2) {
        return $num1 - $num2;
    }
}

class Factory {
    public static function createObj($operate) {
        switch ($operate) {
            case '+':
                return new OperationAdd();
                break;

            case '-':
                return new OperationSub();
                break;
        }
    }
}

$test = Factory::createObj('+');

echo $test->getValue(2, 3);

3.注册模式

<?php
//注册模式
//创建单例
class Single{
    public $hash;
    static protected $ins=null;

    final protected function __construct(){
        $this->hash=rand(1,9999);
    }

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

//工厂模式
class RandFactory{
    public static function factory(){
        return Single::getInstance();
    }
}

//注册树
class Register{
    protected static $objects;
    public static function set($alias,$object){
        self::$objects[$alias]=$object;
    }
    public static function get($alias){
        return self::$objects[$alias];
    }
    public static function _unset($alias){
        unset(self::$objects[$alias]);
    }
}

Register::set('rand',RandFactory::factory());
$object=Register::get('rand');
print_r($object);

4.适配器模式

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。

<?php
//适配器模式
//目标角色  
interface Target {  
    public function simpleMethod1();
    public function simpleMethod2();
}

//源角色class Adaptee {
    public function simpleMethod1(){
        echo 'Adapter simpleMethod1'."<br>";
    }
}

//类适配器角色
class Adapter implements Target {
    private $adaptee;

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

    //委派调用Adaptee的sampleMethod1方法
    public function simpleMethod1(){
        echo $this->adaptee->simpleMethod1();
    }

    public function simpleMethod2(){
        echo 'Adapter simpleMethod2'."<br>";
    }   
}

//客户端
class Client {
    public static function main() {
        $adaptee = new Adaptee();
        $adapter = new Adapter($adaptee);
        $adapter->simpleMethod1();
        $adapter->simpleMethod2();
    }
}
Client::main();

5.观察者模式

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

<?php
//观察者模式
// 主题接口
interface Subject{
    public function register(Observer $observer);
    public function notify();
}

// 观察者接口
interface Observer{
    public function watch();
}

// 主题
class Action implements Subject{
    public $_observers=array();

    public function register(Observer $observer){
        $this->_observers[]=$observer;
    }

    public function notify(){
        foreach ($this->_observers as $observer) {
            $observer->watch();
        }

    }
 }

// 观察者
class Cat implements Observer{
    public function watch(){
        echo "Cat watches TV<hr/>";
    }
}

class Dog implements Observer{
    public function watch(){
        echo "Dog watches TV<hr/>";
    }
}

class People implements Observer{
    public function watch(){
        echo "People watches TV<hr/>";
    }
}

// 应用实例
$action=new Action();
$action->register(new Cat());
$action->register(new People());
$action->register(new Dog());
$action->notify();