基本上所有的编程语言在类中都会有构造函数和析构函数的概念。构造函数是在函数实例创建时可以用来做一些初始化的工作，而析构函数则可以在实例销毁前做一些清理工作。相对来说，构造函数我们使用得非常多，而析构函数则一般会用在释放资源上，比如数据库链接、文件读写的句柄等。

构造函数与析构函数的使用

我们先来看看正常的构造与析构函数的使用：

1. class A 
2.  
3. { 
4.  
5.     public $name; 
6.  
7.     public function __construct($name) 
8.  
9.     { 
10.  
11.         $this->name = $name; 
12.  
13.         echo "A：构造函数被调用，{$this->name}", PHP_EOL; 
14.  
15.     } 
16.  
17.     public function __destruct() 
18.  
19.     { 
20.  
21.         echo "A：析构函数被调用，{$this->name}", PHP_EOL; 
22.  
23.     } 
24.  
25. } 
26.  
27. $a = new A('$a'); 
28.  
29. echo '-----', PHP_EOL; 
30.  
31. class B extends A 
32.  
33. { 
34.  
35.     public function __construct($name) 
36.  
37.     { 
38.  
39.         $this->name = $name; 
40.  
41.         parent::__construct($name); 
42.  
43.         echo "B：构造函数被调用，{$this->name}", PHP_EOL; 
44.  
45.     } 
46.  
47.     public function __destruct() 
48.  
49.     { 
50.  
51.         parent::__destruct(); 
52.  
53.         echo "B：析构函数被调用，{$this->name}", PHP_EOL; 
54.  
55.     } 
56.  
57. } 
58.  
59. class C extends A 
60.  
61. { 
62.  
63.     public function __construct($name) 
64.  
65.     { 
66.  
67.         $this->name = $name; 
68.  
69.         echo "C：构造函数被调用，{$this->name}", PHP_EOL; 
70.  
71.     } 
72.  
73.     public function __destruct() 
74.  
75.     { 
76.  
77.         echo "C：析构函数被调用，{$this->name}", PHP_EOL; 
78.  
79.     } 
80.  
81. } 
82.  
83. class D extends A 
84.  
85. { 
86.  
87. } 
88.  
89. // unset($a); // $a的析构提前 
90.  
91. // $a = null; // $a的析构提前 
92.  
93. $b = new B('$b'); 
94.  
95. $c = new C('$c'); 
96.  
97. $d = new D('$d'); 
98.  
99. echo '-----', PHP_EOL;exit; 
100.  
101. // A：构造函数被调用，$a 
102.  
103. // ----- 
104.  
105. // A：构造函数被调用，$b 
106.  
107. // B：构造函数被调用，$b 
108.  
109. // C：构造函数被调用，$c 
110.  
111. // A：构造函数被调用，$d 
112.  
113. // ----- 
114.  
115. // A：析构函数被调用，$d 
116.  
117. // C：析构函数被调用，$c 
118.  
119. // A：析构函数被调用，$b 
120.  
121. // B：析构函数被调用，$b 
122.  
123. // A：析构函数被调用，$a 

上面的代码是不是有一些内容和我们的预期不太一样？没事，我们一个一个来看：

子类如果重写了父类的构造或析构函数，如果不显式地使用parent::__constuct()调用父类的构造函数，那么父类的构造函数不会执行，如C类子类如果没有重写构造或析构函数，则默认调用父类的析构函数如果没显式地将变量置为NULL或者使用unset()的话，会在脚本执行完成后进行调用，调用顺序在测试代码中是类似于栈的形式先进后出（C->B->A，C先被析构），但在服务器环境中则不一定，也就是说顺序不一定固定

析构函数的引用问题

当对象中包含自身相互的引用时，想要通过设置为NULL或者unset()来调用析构函数可能会出现问题。

1. class E 
2.  
3. { 
4.  
5.     public $name; 
6.  
7.     public $obj; 
8.  
9.     public function __destruct() 
10.  
11.     { 
12.  
13.         echo "E：析构函数被调用，" . $this->name, PHP_EOL; 
14.  
15.         echo '-----', PHP_EOL; 
16.  
17.     } 
18.  
19. } 
20.  
21. $e1 = new E(); 
22.  
23. $e1->name = 'e1'; 
24.  
25. $e2 = new E(); 
26.  
27. $e2->name = 'e2'; 
28.  
29. $e1->obj = $e2; 
30.  
31. $e2->obj = $e1; 

类似于这样的代码，$e1和$e2都是E类的对象，他们又各自持有对方的引用。其实简单点来说的话，自己持有自己的引用都会出现类似的问题。

1. $e1 = new E(); 
2.  
3. $e1->name = 'e1'; 
4.  
5. $e2 = new E(); 
6.  
7. $e2->name = 'e2'; 
8.  
9. $e1->obj = $e2; 
10.  
11. $e2->obj = $e1; 
12.  
13. $e1 = null; 
14.  
15. $e2 = null; 
16.  
17. // gc_collect_cycles(); 
18.  
19. $e3 = new E(); 
20.  
21. $e3->name = 'e3'; 
22.  
23. $e4 = new E(); 
24.  
25. $e4->name = 'e4'; 
26.  
27. $e3->obj = $e4; 
28.  
29. $e4->obj = $e3; 
30.  
31. $e3 = null; 
32.  
33. $e4 = null; 
34.  
35. echo 'E destory', PHP_EOL; 

如果我们不打开gc_collect_cycles()那一行的注释，析构函数执行的顺序是这样的：

1. // 不使用gc回收的结果 
2.  
3. // E destory 
4.  
5. // E：析构函数被调用，e1 
6.  
7. // ----- 
8.  
9. // E：析构函数被调用，e2 
10.  
11. // ----- 
12.  
13. // E：析构函数被调用，e3 
14.  
15. // ----- 
16.  
17. // E：析构函数被调用，e4 
18.  
19. // ----- 

如果我们打开了gc_collect_cycles()的注释，析构函数的执行顺序是：

1. // 使用gc回收后结果 
2.  
3. // E：析构函数被调用，e1 
4.  
5. // ----- 
6.  
7. // E：析构函数被调用，e2 
8.  
9. // ----- 
10.  
11. // E destory 
12.  
13. // E：析构函数被调用，e3 
14.  
15. // ----- 
16.  
17. // E：析构函数被调用，e4 
18.  
19. // ----- 

可以看出，必须要让php使用gc回收一次，确定对象的引用都被释放了之后，类的析构函数才会被执行。引用如果没有释放，析构函数是不会执行的。

构造函数的低版本兼容问题

在PHP5以前，PHP的构造函数是与类名同名的一个方法。也就是说如果我有一个F类，那么function F(){}方法就是它的构造函数。为了向低版本兼容，PHP依然保留了这个特性，在PHP7以后如果有与类名同名的方法，就会报过时警告，但不会影响程序执行。

1. class F 
2.  
3. { 
4.  
5.     public function f()  
6.  
7.     { 
8.  
9.         // Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP; F has a deprecated constructor  
10.  
11.         echo "F：这也是构造函数，与类同名，不区分大小写", PHP_EOL; 
12.  
13.     } 
14.  
15.     // function F(){ 
16.  
17.     //     // Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP; F has a deprecated constructor  
18.  
19.     //     echo "F：这也是构造函数，与类同名", PHP_EOL; 
20.  
21.     // } 
22.  
23.     // function __construct(){ 
24.  
25.     //     echo "F：这是构造函数，__construct()", PHP_EOL; 
26.  
27.     // } 
28.  
29. } 
30.  
31. $f = new F(); 

如果__construc()和类同名方法同时存在的话，会优先走__construct()。另外需要注意的是，函数名不区分大小写，所以F()和f()方法是一样的都会成为构造函数。同理，因为不区分大小写，所以f()和F()是不能同时存在的。当然，我们都不建议使用类同名的函数来做为构造函数，毕竟已经是过时的特性了，说不定哪天就被取消了。

构造函数重载

PHP是不运行方法的重载的，只支持重写，就是子类重写父类方法，但不能定义多个同名方法而参数不同。在Java等语言中，重载方法非常方便，特别是在类实例化时，可以方便地实现多态能力。

$r1 = new R(); // 默认构造函数

$r2 = new R('arg1'); // 默认构造函数 一个参数的构造函数重载，arg1

$r3 = new R('arg1', 'arg2'); // 默认构造函数 两个参数的构造函数重载，arg1，arg2

就像上述代码一样，如果你尝试定义多个__construct()，PHP会很直接地告诉你运行不了，那么有没有别的方法实现上述代码的功能呢？当然有，否则咱也不会写了。

1. class R 
2.  
3. { 
4.  
5.     private $a; 
6.  
7.     private $b; 
8.  
9.     public function __construct() 
10.  
11.     { 
12.  
13.         echo '默认构造函数', PHP_EOL; 
14.  
15.         $argNums = func_num_args(); 
16.  
17.         $args = func_get_args(); 
18.  
19.         if ($argNums == 1) { 
20.  
21.             $this->constructA(...$args); 
22.  
23.         } elseif ($argNums == 2) { 
24.  
25.             $this->constructB(...$args); 
26.  
27.         } 
28.  
29.     } 
30.  
31.     public function constructA($a) 
32.  
33.     { 
34.  
35.         echo '一个参数的构造函数重载，' . $a, PHP_EOL; 
36.  
37.         $this->a = $a; 
38.  
39.     } 
40.  
41.     public function constructB($a, $b) 
42.  
43.     { 
44.  
45.         echo '两个参数的构造函数重载，' . $a . '，' . $b, PHP_EOL; 
46.  
47.         $this->a = $a; 
48.  
49.         $this->b = $b; 
50.  
51.     } 
52.  
53. } 
54.  
55. $r1 = new R(); // 默认构造函数 
56.  
57. $r2 = new R('arg1'); // 默认构造函数 一个参数的构造函数重载，arg1 
58.  
59. $r3 = new R('arg1', 'arg2'); // 默认构造函数 两个参数的构造函数重载，arg1，arg2 

相对来说比Java之类的语言要麻烦一些，但是也确实是实现了相同的功能哦。

构造函数和析构函数的访问限制

构造函数和析构函数默认都是public的，和类中的其他方法默认值一样。当然它们也可以设置成private和protected。如果将构造函数设置成非公共的，那么你将无法实例化这个类。这一点在单例模式被广泛应用，下面我们直接通过一个单例模式的代码看来。

1. class Singleton 
2.  
3. { 
4.  
5.     private static $instance; 
6.  
7.     public static function getInstance() 
8.  
9.     { 
10.  
11.         return self::$instance == null ? self::$instance = new Singleton() : self::$instance; 
12.  
13.     } 
14.  
15.     private function __construct() 
16.  
17.     { 
18.  
19.     } 
20.  
21. } 
22.  
23. $s1 = Singleton::getInstance(); 
24.  
25. $s2 = Singleton::getInstance(); 
26.  
27. echo $s1 === $s2 ? 's1 === s2' : 's1 !== s2', PHP_EOL; 
28.  
29. // $s3 = new Singleton(); // Fatal error: Uncaught Error: Call to private Singleton::__construct() from invalid context 

当$s3想要实例化时，直接就报错了。关于单例模式为什么要让外部无法实例化的问题，我们可以看看之前的设计模式系统文章中的单例模式。

总结：

没想到我们天天用到的构造函数还能玩出这么多花样来吧，日常在开发中比较需要注意的就是子类继承时对构造函数重写时父类构造函数的调用问题以及引用时的析构问题。

Tags: __construct __destory

分享到：