php常见设计模式(一)——单例，模版，工厂，注册树

php常见设计模式

1，单例设计模式

1,概要：

要点：一个类最多只能产生一个对象,节省资源。
实现：
    1，自由化构造方法，防止此类被外部实例化
    2，私有化静态属性，保存对象
    3，私有化克隆方法，防止对象被克隆
    4，静态方法公有化，获取对象

2,代码:

<?
class singleton
{ 
    private static $obj = null;
    private function __construct($param)
    { 

    }
    static public function getInstance($param)
    { 
        if(!is_object(self::$obj)){ 
            self::$obj = new Singleton($param);
        }
        return self::$obj;
    }
    private function __clone()
    { 

    }
}

$singletonObj = singleton::getInstance($param);

2，模版模式

1，概要：

模版模式，就是准备一个抽象类或者接口，然后让更多的子类去继承，让子类来实现里边的抽象方法。
具体是使用抽象类，还是使用接口，视情况而定。

复习：抽象类和接口的区别
1，接口是特殊的抽象类，所以抽象类有的特性接口都有
      抽象类不能被实例化，要有抽象方法(至少一个)
   区别：
    抽象类可以有非抽象方法，可以用3p修饰，可以定义成员属性，而接口只能有成员常量，
    所有方法都是public，并且一个类可以继承多个接口。
   抽象类定义：
        abstract class abstractClass{ 
            private $str;
            abstract public function fun();
            public function fun2();
        }
   接口定义：
        interface interfaceClass
        { 
            function fun1();
            function fun2();
            function fun3();
        }

    注意：继承抽象类用extends;
         继承接口用implements;

2,代码

<?php
interface template
{ 
    function fun1();
    function fun2();
    function fun3();
}
class sun1 implements template
{ 
    function fun1()
    { 
        echo "模版模式函数1";
    }
    function fun2()
    { 
        echo "模版模式函数2";
    }

    function fun3()
    { 
        echo "模版模式函数3";
    }

}
class sun2 implements template
{ 
    function fun1()
    { 
        echo "1";
    }
    function fun2()
    { 
        echo "2";
    }

    function fun3()
    { 
        echo "3";
    }

}
$sun2Obj=new sun2();
$sun2Obj->fun1();

3，工厂模式

1，概要

工厂模式，就是生产对象的工厂。也就是说我们把模版下面的实现同功能不同方法的类，需要
实例化的时候写一个工厂类进行实例化，便于后期的维护和管理，提高程序的健壮性

工厂模式一共需要三个角色
    抽象角色
    具体角色
    工厂角色

2,代码

<?php
interface cook
{ 
    function buy();
    function wash();
    function method();
    function eat();
}

class chefA implements cook
{ 
    public function buy()
    { 
        echo "A厨师在菜市场买菜";
    }
    public function wash()
    { 
        echo "A厨师用水洗干净";
    }
    public function method()
    { 
        echo "A厨师喜欢炒菜";
    }
    public function eat()
    { 
        echo "A厨师吃饭用筷子";
    }
}

class chefB implements cook
{ 
    public function buy()
    { 
        echo "B厨师在菜市场买菜";
    }
    public function wash()
    { 
        echo "B厨师用水洗干净";
    }
    public function method()
    { 
        echo "B厨师喜欢炒菜";
    }
    public function eat()
    { 
        echo "B厨师吃饭用筷子";
    }
}

class chefC implements cook
{ 
    public function buy()
    { 
        echo "C厨师在菜市场买菜";
    }
    public function wash()
    { 
        echo "C厨师用水洗干净";
    }
    public function method()
    { 
        echo "C厨师喜欢炒菜";
    }
    public function eat()
    { 
        echo "C厨师吃饭用筷子";
    }
}


class factory
{ 
    public static function getObj($str)
    { 
        $Obj = new $str;
        return $Obj;
    }
}

$Obj = factory::getObj('chefA');
$Obj -> eat();

4，注册树模式

1，概要

所谓注册树模式，就是把对象一一注册到二维数组的键值对中,如果需要某个对象，直接
取出即可。不禁疑问了，既然是实例化之后先注册再取出，还不如用的时候直接实例化啊？
其实小系统的话，无外乎用不用。但是大型系统的话，注册树可以让其更加规整，容易维护。

2，代码

<?php
//本代码实现一个我要学编程到学会编程的过程，结合单例模式，工厂模式，注册树模式
//要学习的基类
namespace base;
abstract class learnPrograming
{ 
    public abstract function planDay();
    public abstract function planReadBook();
    public  function celebrate()
    { 
        echo "I am learned programing";
    }

}
//具体学习的类
namespace learn\language;
use base\learnPrograming;
class PHP extends learnPrograming
{ 
    public static $obj;
    private function __construct()
    { 
        echo "<hr/>learn PHP<hr/>";
    }
    public static function getInstance()
    { 
        if(self::$obj == null){ 
            self::$obj = new PHP;
        }
        return self::$obj;
    }
    public function planDay()
    { 
        echo "I am planing ten days";
    }
    public function planReadBook()
    { 
        echo "I am reading ModernPHP";
    }
}
//具体学习的类
class PYTHON extends learnPrograming
{ 
    public static $obj;
    private function __construct()
    { 
        echo "<hr/>learn PYTHON<hr/>";
    }
    public static function getInstance()
    { 
        if(self::$obj == null){ 
            self::$obj = new PYTHON;
        }
        return self::$obj;
    }
    public function planDay()
    { 
        echo "I am planing TWO days";
    }
    public function planReadBook()
    { 
        echo "I am reading LEARGINGPYTHON";
    }
}
//工厂类
namespace factory;
class factoryClass
{ 
    public static function getObj($lang)
    { 
        $Obj = $lang::getInstance();
        return $Obj;
    }
}
namespace regTree;
class registerTree
{ 
    public  static $Obj_database = array();
    public static function set($name,$obj)
    { 
        self::$Obj_database[$name] = $obj;
    }
    public static function get($name)
    { 
        return self::$Obj_database[$name];
    }

    public static function unsetObj($name)
    { 
        unset(self::$Obj_database[$name]);
    }


}

namespace active;
//将所有对象注册到注册树上
use learn\language\PHP;
use learn\language\PYTHON;
use factory\factoryClass;
use regTree\registerTree;
$class_arr = ['PHP','PYTHON'];
var_dump($class_arr);
$tmpObj = factoryClass::getObj('\learn\language\PHP');

foreach($class_arr as $val){ 
    $tmpObj = factoryClass::getObj('learn\language\\'.$val);
    registerTree::set($val,$tmpObj);
}
$python = registerTree::get('PYTHON');
var_dump($python);