单例模式又称为职责模式，它用来在程序中创建一个单一功能的访问点，通俗地说就是实例化出来的对象是唯一的。
danli.class <?php class Danli { //保存类的实例的静态成员变量 static private $_instance=null; //私有的构造方法 private function __construct(){ echo "这是一个构造方法<br>"; } //用于访问类的实例的公共的静态方法 static public function getInstance(){ if(!(self::$_instance instanceof Danli)){ echo "实例化<br>"; self::$_instance = new self; } return self::$_instance; } //类的其它方法 public function test(){ echo "调用成功<br>"; } }
index.php <?php //加载类文件 require "Danli.php"; //第一次调用类的实例 $first = Danli::getInstance(); $first->test(); //第二次调用类的实例 $second = Danli::getInstance(); $second->test();
/*单例设计模式 (单态) 定义: 一个类 只能允许有 一个对象存在.
1.不让进: 使类不能被实例化
2.留后门: 设置静态方法
3.给对象: 在静态方法里实例化该类
4.判初夜: 判断是否是 第一次产生该类的对象
5.设静态: 静态方法里 要使用静态属性 *//*//
1.不让进: 使类不能被实例化-----------------
class Test{
// 设置 一个封装的构造方法
private function __construct() {
//占位, 我就是不让你NEW我~~~
}
}
2.留后门: 设置静态方法--------------------
class Test{
// 设置 一个封装的构造方法
private function __construct() {
//占位, 我就是不让你NEW我~~~
}
//后门
public static function getObject() {
echo "啊,我是后门,进吧!<br>";
}
}
3.给对象: 在静态方法里实例化该类------------------
class Test{
// 设置 一个封装的构造方法
private function __construct() {
//占位, 我就是不让你NEW我~~~
}
//后门
public static function getObject() {
echo "啊,我是后门,进吧!<br>";
return new self();//实例化一个对象给你
}
}
4.判初夜: 判断是否是 第一次产生该类的对象------------------
class Test{
private $obj = null;//属性值为对象,默认为null
// 设置 一个封装的构造方法
private function __construct() {
//占位, 我就是不让你NEW我~~~
}
//后门
public static function getObject() {
echo "啊,我是后门,进吧!<br>";
if ($this->obj === null) {
$this->obj = new self();//实例化一个对象
}
//返回的属性 其实就是本对象
return $this->obj;
}
}
5.设静态: 静态方法里 要使用静态属性------------------
class Test{
private static $obj = null;//属性值为对象,默认为null
// 设置 一个封装的构造方法
private function __construct() {
//占位, 我就是不让你NEW我~~~
}
//后门
public static function getObject() {
echo "啊,我是后门,进吧!<br>";
if (self::$obj === null) {
self::$obj = new self();//实例化一个对象
}
//返回的属性 其实就是本对象
return self::$obj;
}
}
Test::getObject();//使用静态方法访问该类里的方法exit;
$t1 = Test::getObject();
$t2 = Test::getObject();
$t3 = Test::getObject();
$t4 = Test::getObject();
$t5 = Test::getObject();
$t6 = Test::getObject();
$t7 = Test::getObject();
$t8 = Test::getObject();
//判断 两个对象 是否是同一个对象
if ($t1 === $t6) {
echo "哦, Yes! 是同一个实例<br>";
} else {
echo "哦, No! 不是同一个实例<br>";
}
最简单的PHP单例模式的类：
使用：
class TestInstance
{
public static $_instance = null;
//为了防止外部new这个类，所以构造方法用protected，这是单例模式的关键之处
protected function __Construct()
{
echo 'Instance,Instance,Instance..........';
}
//用一个静态变量存储类的实例，只有第一次实例化的时候才赋值，以后都直接给出静态实例
public static function getInstance()
{
if(!isset(self::$_instance)){
self::$_instance = new static();
}
return self::$_instance;
}
}
$aa = TestInstance::getInstance();
$aa->xx();
$bb = TestInstance::getInstance();
$bb->xx()从上面的代码可以看出来,PHP的单例模式实现要求：
1、一个private的__construct是必须的，单例类不能在其它类中实例化，只能被自身实例化；2、拥有一个保存类的实例的静态成员变量;
3、一个静态的公共方法用于实例化这个类，并访问这个类的实例;
工厂模式就是一种类，具有为您创建对象的某些方法，这样就可以使用工厂类创建对象，而不直接使用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();
}
}
interface FetchName {//创建一个接口
public function getname();
}
class A implements FetchName{
private $name = "AAAAA";
public function getname(){ return $this->name; }
}
class C implements FetchName{
private $name = "CCCCC";
public function getname(){ return $this->name; }
}
class B implements FetchName{
private $name = "BBBBB";
public function getname(){ return $this->name; }
}
class D implements FetchName{
private $name = "DDDDD";
public function getname(){ return $this->name; }
}
$o = Factory::fac(6);//调用工厂类中的方法
if($o instanceof FetchName){
echo $o->getname();//DDDDD
}
$p=Factory::fac(3);
echo $p->getname();//CCCCC