<?php

 //单例模式:保证某个类只有一个实例,能自行实例化对象,完成其所有的功能操作.

 //最典型案例:数据库操作(单例模式可以避免大量的new操作.每一次new操作都会消耗系统和内存的资源.)

 header("Content-Type: text/html;charset=utf-8");

 class User{

     //静态的私有属性(保存一个当前类的唯一对象)

     private static $instance;

     //私有的构造方法,防止类外new新对象

     private function __construct(){

     }

     //私有的克隆方法,防止类外克隆新对象

     private function __clone(){

     }

     //静态的公开方法,得到当前类的对象

     public static function getInstance(){

         if(!self::$instance){

             self::$instance = new self();

         }

         return self::$instance;

     }

     private $name;

     public function setName($n){

         $this->name = $n;

     }

     public function getName(){

         echo $this->name;

     }

 }

 $userA = User::getInstance();

 $userB = User::getInstance();

 echo '<pre>'.'单例模式获取唯一实例:'.'<br>';

 var_dump($userA,$userB);

 echo '<hr>'.'单例模式获取当前类私有属性:'.'<br>';

 $userA->setName('admin_a');

 $userB->setName('admin_b');

 $userA->getName();

 echo '<br>';

 $userB->getName();

 <?php

 //工厂模式:实例化对象模式,工厂方法代替new操作的一种设计模式.

 //优点:避免当改变某个类的名字或者方法之后,调用这个类的所有的代码中都修改它的名字或者参数.(为系统结构提供灵活的动态扩展机制,减少了耦合)

 //简单工厂模式生产对象 实例demo

 interface People{

     public function  sex();

 }

 class Man implements People{

     public function sex(){

         echo 'this is Men'.'<br>';

     }

 }

 class Women implements People{

     public function sex(){

         echo 'this is Women'.'<br>';

     }

 }

 class Factoty{

     static function getObject($class_name){

                //可变类,生产新对象

         return new $class_name;

     }

 }

 $man = Factoty::getObject('Man');

 $man->sex();

 $woman = Factoty::getObject('Women');

 $woman->sex();

 <?php

 //观察者模式:某个对象可以被设置为是可观察的,只要通过某种方式允许其他对象注册为观察者.每当被观察的对象改变时,会发送信息给观察者

 //获取类名和发送消息接口

 interface IObserver{

     public function onSendMsg($msg);

     public function getName();

 }

 //添加可观察者接口

 interface IObservable{

     //注意:$observer是个对象,需要保存到数组中

     public function addObserver($observer);

 }

 class UserList implements IObservable{

     private $_observers = array();

     //添加观察者

     public function addObserver($observer){

         $a=$this->_observers[]= $observer;

     }

     //移除观察者 (注意:其实就是移除对应的类)

     public function removeObserver($observer_name) {

         foreach($this->_observers as $index => $observer) {

             if ($observer->getName() === $observer_name) {

                         //从数组中移除选定的元素

                 return array_splice($this->_observers, $index, 1);

             }

         }

     }

     //发送消息

     public function sendMsg($msg){

         foreach($this->_observers as $v){

             $v->onSendMsg($msg);

         }

     }

 }

 class OneObserver implements IObserver{

     public function onSendMsg($args){

         echo($args.'=> send to OneObserver<br>');

     }

     public function getName(){

         return 'OneObserver';

     }

 }

 class TwoObserver implements IObserver{

     public function onSendMsg($args){

         echo($args.'=> send to TwoObserver<br>');

     }

     public function getName(){

         return 'TwoObserver';

     }

 }

 $ul = new UserList();//被观察者

 $ul->addObserver(new OneObserver());//增加观察者

 $ul->addObserver(new TwoObserver());//增加观察者

 $ul->sendMsg('admin');//发送消息到观察者

 $ul->removeObserver('OneObserver');//移除观察者

 $ul->sendMsg("hello world");//发送消息到观察者

 <?php

 interface Strategy { //抽象策略角色,以接口实现

     public function do_method(); //算法接口

 }

 class ConcreteStrategyA implements Strategy { //具体策略角色A

     public function do_method() {

         echo 'do method A';

     }

 }

 class ConcreteStrategyB implements Strategy { //具体策略角色B

     public function do_method() {

         echo 'do method B';

     }

 }

 class ConcreteStrategyC implements Strategy { //具体策略角色C

     public function do_method() {

         echo 'do method C';

     }

 }

 class Question{ //环境角色

     private $_strategy;

     //初始化Strategy接口对应实现类

     public function __construct(Strategy $strategy) {

         $this->_strategy = $strategy;

     }

     public function handle_question() {

         $this->_strategy->do_method();

     }

 }

 $strategyA = new ConcreteStrategyA();

 $question = new Question($strategyA);

 $question->handle_question();//输出do method A

 echo '<br>';

 $strategyB = new ConcreteStrategyB();

 $question = new Question($strategyB);

 $question->handle_question();//输出do method B

 echo '<br>';

 $strategyC = new ConcreteStrategyC();

 $question = new Question($strategyC);

 $question->handle_question();//输出do method C

 <?php

 interface Command { //命令角色

     public function execute(); //执行方法

 }

 class ConcreteCommand implements Command { //具体命令方法

     private $_receiver;

     public function __construct(Receiver $receiver) {

         $this->_receiver = $receiver;

     }

     //Command接口ConcreteCommand类实现对应Receiver类对应方法actionReceiver()

     public function execute() {

         $this->_receiver->actionReceiver();

     }

 }

 class Receiver { //接收者角色

     private $_name;

     public function __construct($name) {

         $this->_name = $name;

     }

     public function actionReceiver() {

         echo 'receive some cmd:'.$this->_name;

     }

 }

 class Invoker { //请求者角色

     private $_command;

     public function __construct(Command $command) {

         $this->_command = $command;

     }

     //Command接口ConcreteCommand类实现方法execute()

     public function actionInvoker() {

         $this->_command->execute();

     }

 }

 $receiver = new Receiver('hello world');

 $command = new ConcreteCommand($receiver);

 $invoker = new Invoker($command);

 $invoker->actionInvoker();//输出：receive some cmd:hello world