声明一个Test类,我们先来看一下打印的结果
class Test
{
}
test1=newTest();
t
e
s
t
1
=
n
e
w
T
e
s
t
(
)
;
test2=new Test();
test3=newTest();
t
e
s
t
3
=
n
e
w
T
e
s
t
(
)
;
test4=new Test();
var_dump (
test1);vardump(
t
e
s
t
1
)
;
v
a
r
d
u
m
p
(
test2);
var_dump (
test3);vardump(
t
e
s
t
3
)
;
v
a
r
d
u
m
p
(
test4);
打印结果为:
object(Test)#1 (0) { } object(Test)#2 (0) { } object(Test)#3 (0) { } object(Test)#4 (0) { }
我们可以看到Test被实例化了4次,而实例化多次是非常耗费内存的,是很不合理的,而单例模式就能很好的解决这个问题,同一个类只会被实例化一次,进而结束了内存空间,我们来看一下下面的实例
同样声明一个Test类
class Test
{
private static $_instance=null;
private function __construct()
{
}
private function __clone()
{
}
public static function getInstance()
{
if(!(self::
instanceinstanceofself))self::$instance=newself();returnself::
i
n
s
t
a
n
c
e
i
n
s
t
a
n
c
e
o
f
s
e
l
f
)
)
s
e
l
f
::
$
i
n
s
t
a
n
c
e
=
n
e
w
s
e
l
f
(
)
;
r
e
t
u
r
n
s
e
l
f
::
_instance;
}
}
test1=Test::getInstance();
t
e
s
t
1
=
T
e
s
t
::
g
e
t
I
n
s
t
a
n
c
e
(
)
;
test2=Test::getInstance();
test3=Test::getInstance();
t
e
s
t
3
=
T
e
s
t
::
g
e
t
I
n
s
t
a
n
c
e
(
)
;
test4=Test::getInstance();
var_dump(
test1);vardump(
t
e
s
t
1
)
;
v
a
r
d
u
m
p
(
test2);
var_dump(
test3);vardump(
t
e
s
t
3
)
;
v
a
r
d
u
m
p
(
test4);
我们来看一个这个打印的结果
object(Test)#1 (0) { } object(Test)#1 (0) { } object(Test)#1 (0) { } object(Test)#1 (0) { }
我们可以看到打印出的ID是一样的,这就说明只实例化了一次,这样是非常节省空间的,而且单例模式在实际的开发中也是经常用到的。