php 设计模式备忘

1. 单例模式用于：

不重复建立对象，节省内存。（PHP很容易卡死的，比如说递归20，30 层）比如用于数据库连接对象

class Single {
    private $name;//声明一个私有的实例变量
    private function __construct(){//声明私有构造方法为了防止外部代码使用new来创建对象。
    
    }

    static public $instance;//声明一个静态变量（保存在类中唯一的一个实例）
    static public function getinstance(){//声明一个getinstance()静态方法，用于检测是否有实例对象
        if(!self::$instance) self::$instance = new self();
        return self::$instance;
    }

    public function setname($n){ $this->name = $n; }
    public function getname(){ return $this->name; }
}

2.工厂模式用于：

应该TP里面的M方法建立迷行应该就是这样，感觉和单例还是很像的。

工厂模式就是一种类，具有为您创建对象的某些方法，这样就可以使用工厂类创建对象，而不直接使用new。这样如果想更改创建的对象类型，只需更改该工厂即可。

 class Factory {//创建一个基本的工厂类 
     static public function fac($id){//创建一个返回对象实例的静态方法 
         if(1 == $id) return new A(); 
         elseif(2==$id) return new B();
         elseif(3==$id) return new C(); 
         return new D(); 
 } 
 }

3.观察者模式：

针对一个博主，这是一个接口或者对象，里面可以注册观察者（关注者），然后遍历关注者，对每个人执行一个方法。例如这个样子：

<?php
	//主题
	class Paper{
		private $_observers = array();

		//注冊观察者,谁依赖我,谁是我的粉丝，我有动态，依次推送，都在观察关注我
		public function register($sub){
			$this->_observers[] = $sub; 
		}

		//外部统一访问
		public function trigger(){
			if(!empty($this->_observers)){
				foreach($this->_observers as $observer){
					$observer->update();//统一的方法，依次进行各个观察者
				}
			}

		}
	}

	//观察者实现接口

	interface Observerable{
		public function update();
	}

	class Subscriber implements Observerable{
		public function update(){
			echo "Callback\n";
		}
	}

	$paper = new Paper();

	$paper->register(new Subscriber());
	$paper->trigger();

4.策略模式

针对同一个行为，你有不同的方案，就可以写成策略，就是一个大的算法集合。再比如你定价有不同的活动，满200-10，满400-100等，都是一个小算法，集合成策略

<?php
	interface FlyBehavior{
		//策略接口
		public function fly();
	}

	class FlyWithWings implements FlyBehavior{
		//c策略1
		public function fly(){
			echo "Fly with Wings";
		}
	}

	class FlyWithNo implements FlyBehavior{
		//c策略2
		public function fly(){
			echo "Fly with No Wings";
		}
	}

	class Duck{
		private $_flyBehavior;
		public function performFly(){
			$this->_flyBehavior->fly();
		}
		//这里引进来策略，可以切换不同的策略
		public function setFlyBehavior(FlyBehavior $behavior){
			$this->_flyBehavior = $behavior;
		}
	}

	class RubberDuck extends Duck{

	}

	$duck = new RubberDuck();
	$duck->setFlyBehavior(new FlyWithWings());
	$duck->performFly();

	$duck->setFlyBehavior(new FlyWithWings());
	$duck->performFly();

5.装饰者模式

就是给被装饰者增加属性的，之后你就可以取代被装饰者。其实一个明显的例子就是穿衣服的顺序和方案。因为你有很多的方案可以动态加进去。这样的话比生成子类好很多，就不用把每个方案都建立对象，然后执行方法。

不恰当的示例如下：

$a = new a(new person());

$a.show();

$b=new b(new person());

$b.show();

$c = new c(new person());

$c.show();

改进的方案如下：首先把a,b，c 写一个抽象的接口统一起来，然后在面对被装饰者person()

<?php
	//抽象类不能实例化
	abstract class Beverage{
		public $_name;//品类名
		abstract public function Cost();//费用
	}

	//被装饰者,都是给coffee加东西
	class Coffee extends Beverage{
		public function __construct(){
			$this->_name = ‘Coffee‘;//品类名
		}
		public  function Cost(){
			return 1.00;//原味咖啡的底价
		}
	}

	//以下三个类是装饰者相关类
	class CondimentDecorator extends Beverage{
		public function __construct(){
			$this->_name = ‘Condiment‘;
		}
		public function Cost(){
			return 0.1;
		}
	}

	class Milk extends CondimentDecorator{
		public $_beverage;//被装饰者
		public function __construct($beverage){
			$this->_name = ‘Milk‘;//该品种名
			if($beverage instanceof Beverage){
				$this->_beverage = $beverage;
			}else{
				exit(‘Failure‘);
			}
		}

		public function Cost(){
			return $this->_beverage->Cost()+0.2;//底价加上新加的东西
		}
	}

	class Sugar extends CondimentDecorator{
		public $_beverage;//被装饰者
		public function __construct($beverage){
			$this->_name = ‘Sugar‘;//该品种名
			if($beverage instanceof Beverage){
				$this->_beverage = $beverage;
			}else{
				exit(‘Failure‘);
			}
		}

		public function Cost(){
			return $this->_beverage->Cost()+0.2;//底价加上新加的东西
		}
	}

	//拿杯咖啡
	$coffee = new Coffee();
	//加点牛奶
	$coffee = new Milk($coffee);
	//加点糖
	$coffee = new Sugar($coffee);

	echo "Coffee现在的总价格是".$coffee->Cost();

	//总结：
	//1.装饰者和被装饰者必须是同一类型，因为装饰者可以取代它
	//2.当装饰者和组件组合的时候，就是在加入新的行为