本文学习目标：

1、了解析构函数的定义

2、了解析构函数的作用

3、了解析构函数的特点

4、掌握对象引用赋值的概念和特点

（一）、析构函数

1、定义：它是一个特殊的函数

public function destruct(){}

2、作用：清理对象，释放内存

3、特点：

1、自动执行，而非手动调用

2、类一旦定义了析构函数，程序结束前就会销毁该类下的所有实例对象

3、在应用程序结束前的最后一刻执行，除非一些特殊情况，比如第4点，或者当对象的生命周期结束以后也会自动执行

4、 一旦我们手动的销毁一个对象，系统会自动的触发该对象的析构函数

特别注意一个特殊的情况：就是如果对象还被其他对象引用的情况下，它的析构函数也不会被触发

5、在对象的生命周期结束前执行

6、应用程序结束前的最后一刻，会销毁掉还未销毁的对象，已经销毁的对象不会再次被销毁

进一步得出，一个对象的析构函数只能执行1次，不会执行多次

7、在php中如果我们不为类定义个析构函数，那么php会自动的为类创建一个析构函数，然后在程序结束前调用默认的析构函数，但是一旦定义了析构函数，就会执行我们写的析构函数进一步我们就可以在自己的析构函数里写自己的业务代码，比如如果程序使用了打印机资源，我们可以销毁对象前释放打印机资源，相关的代码如下：

1. <?php 
2.  
3.  class NbaPlayer{ 
4.  
5.     public $name  = "";//姓名 
6.  
7.     public $height = "";//身高 
8.  
9.     public $weight = "";//体重 
10.  
11.     public $team = "";//团队 
12.  
13.     public $playerName = "";//球员号码    
14.  
15.     public function __construct( $name,$height,$weight,$team,$playerName ){ 
16.  
17.         $this->name = $name; 
18.  
19.         $this->height=$height; 
20.  
21.         $this->weight = $weight; 
22.  
23.         $this->team = $team; 
24.  
25.         $this->playName = $playerName; 
26.  
27.         echo "构造函数执行了,当前对象是{$this->name}<br/>"; 
28.  
29.     } 
30.  
31.     //析构函数 
32.  
33.     public function __destruct(){ 
34.  
35.         echo "销毁对象".$this->name."<br/>"; 
36.  
37.     } 
38.  
39.      
40.  
41.    //跑步 
42.  
43.     public function run(){ 
44.  
45.         echo "跑步中<br/>"; 
46.  
47.     } 
48.  
49.     //跳跃 
50.  
51.     public function jump(){ 
52.  
53.         echo "跳跃<br/>"; 
54.  
55.     } 
56.  
57.     //运球 
58.  
59.     public function dribble(){ 
60.  
61.         echo "运球<br/>"; 
62.  
63.     }  
64.  
65.     //传球 
66.  
67.     public function pass(){ 
68.  
69.         echo "传球<br/>"; 
70.  
71.     } 
72.  
73.     //投篮 
74.  
75.     public function shoot(){ 
76.  
77.         echo "投篮<br/>"; 
78.  
79.     } 
80.  
81.     //扣篮 
82.  
83.     public function dunk(){ 
84.  
85.         echo "扣篮<br/>"; 
86.  
87.     } 
88.  
89.  
90.  
91.  } 
92.  
93.  //创建乔丹对象 
94.  
95. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23"); 
96.  
97. //输出乔丹对象 
98.  
99. echo "名称= ".$jordon->name."<br/>"; 
100.  
101. //让乔丹跑步 
102.  
103. $jordon->run(); 
104.  
105. //创建科比对象 
106.  
107. $kobe = new NbaPlayer("科比","2米","93公斤","湖人","24"); 
108.  
109. //创建詹姆斯对象 
110.  
111. $james = new NbaPlayer("詹姆斯","2.03米","120公斤","热火","6"); 
112.  
113. $james1 = new NbaPlayer("詹姆斯1","2.03米","120公斤","热火","6"); 
114.  
115. $james2 = new NbaPlayer("詹姆斯2","2.03米","120公斤","热火","6"); 
116.  
117. $jordon = null;//手动的销毁了对象 ,此时乔丹对象的析构函数将会被触发 
118.  
119. $kobe = null;//手动的销毁了对象 ,此时科比对象的析构函数将会被触发 
120.  
121. echo "<b>程序结束完毕</b><br/>"; 
122.  
123. ?> 

接下来，我代码修改如下，添加一个Mysql数据库连接类，然后在NbaPlayer构造函数里面调用它

这是Mysql.class.php,里面定义了一个析构函数

1. <?php 
2.  
3. //数据库类 
4.  
5. class Mysql{ 
6.  
7.     //定义属性 
8.  
9.     public $conn = ""; 
10.  
11.     //构造函数 
12.  
13.     public function __construct( ){ 
14.  
15.         //初始化行为 初始化方法 
16.  
17.         $this->initConn(); 
18.  
19.     } 
20.  
21.     //析构函数 销毁数据库连接 
22.  
23.     public function __destruct(){ 
24.  
25.         //销毁连接 
26.  
27.         if( $this->conn ){ 
28.  
29.             mysqli_close( $this->conn ); 
30.  
31.             echo "销毁了连接<br/>"; 
32.  
33.         } 
34.  
35.     } 
36.  
37.       
38.  
39.     //定义方法 
40.  
41.     //创建公共的方法 获取数据库连接 
42.  
43.     public function initConn(){ 
44.  
45.         $config = Array( 
46.  
47.             "hostname"=>"127.0.0.1", 
48.  
49.             "database"=>"Nbaplayer", 
50.  
51.             "username"=>"root", 
52.  
53.             "password"=>"root" 
54.  
55.         ); 
56.  
57.         $this->conn = mysqli_connect( $config['hostname'],$config['username'] ,$config['password'], 
58.  
59.                 $config['database']); 
60.  
61.     } 
62.  
63. } 
64.  
65. ?> 

接下来还是定义个NbaPlayer类，但是为了突出重点，所以NbaPlayer类我会简写如下：

1. <?php 
2.  
3.  require_once "Mysql.class.php"; 
4.  
5.  class NbaPlayer{  
6.  
7.     public $name  = "";//姓名 
8.  
9.     public $height = "";//身高 
10.  
11.     public $weight = "";//体重 
12.  
13.     public $team = "";//团队 
14.  
15.     public $playerName = "";//球员号码 
16.  
17.     public $conn = "";//添加一个数据库连接属性 
18.  
19.  
20.  
21.       
22.  
23.     public function __construct( $name,$height,$weight,$team,$playerName ){ 
24.  
25.         $this->name = $name; 
26.  
27.         $this->height=$height; 
28.  
29.         $this->weight = $weight; 
30.  
31.         $this->team = $team; 
32.  
33.         $this->playName = $playerName; 
34.  
35.         //初始化数据库连接属性 
36.  
37.         $mysql = new Mysql(); 
38.  
39.         $this->conn = $mysql->conn; 
40.  
41.           
42.  
43.     } 
44.  
45.     //新增获取所有Nba球员的方法 
46.  
47.      public function getAll(){ 
48.  
49.          //创建数据库连接 
50.  
51.         $conn = $this->conn; 
52.  
53.         //写sql 
54.  
55.         $sql = " select * from ".$this->tableName; 
56.  
57.         //执行sql 
58.  
59.         $result = mysqli_query( $conn,$sql ); 
60.  
61.         //获取数据 
62.  
63.         // mysqli_fetch_all($result)//特点：不会包含字段名 
64.  
65.         $list = Array(); 
66.  
67.         while( $row = mysqli_fetch_assoc(  $result ) ){ 
68.  
69.             $list[] = $row; 
70.  
71.         } 
72.  
73.         //返回数据 
74.  
75.         return $list; 
76.  
77.      } 
78.  
79.  
80.  
81.  } 
82.  
83.  //创建乔丹对象 
84.  
85. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23"); 
86.  
87. $list = $jordon->getAll(); 
88.  
89. echo "<b>程序结束完毕</b><br/>"; 
90.  
91. ?> 

当你运行，你会发现错误，会发现连接已经被销毁，在getAll函数调用之前，也就是说，一旦 实例化了 $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");

数据库连接对象就销毁了，其实如果你去调试，你会发现，构造函数里的mysql对象其实是在NbaPlayer类的构造函数的最后一个}执行完成后，它就会被销毁，为什么呢

这其实就涉及到变量作用域的问题，因为mysql对象是在构造函数里定义的，所以外面是无法访问到它的，所以一旦构造函数执行完成后，系统会认为它将不再有用，所以就会把它清理掉，从而执行它的析构函数，所以最终你去调用getAll方法的时候，数据库连接都早已断开，自然无法再去执行sql，其实想要解决掉这个问题，那么就需要了解对象引用，我们可以结合对象引用来解决这个问题，接下来先来了解对象引用

（二）、对象引用

总结：

1、变量1=变量2=对象 会创建对象的2个独立引用，但是他们指向的还是同一个对象，所以还是会互相影响

2、变量1=&变量2 只会创建对象的一个引用,因为它们使用同一个对象引用

3、一个对象有没有用，就要看它是否完全没有被引用了，如果没有任何变量引用它，它就真的没用了，才会被销毁，进而它的析构函数才会得以执行

4、变量1=clone 变量2=对象，不会创建对象的新引用，而是仿造了一个新的该对象，具有该对象通用的属性和方法

相关代码如下：

1. <?php 
2.  
3.  
4.  
5.  class NbaPlayer{ 
6.  
7.      
8.  
9.     public $name  = "";//姓名 
10.  
11.     public $height = "";//身高 
12.  
13.     public $weight = "";//体重 
14.  
15.     public $team = "";//团队 
16.  
17.     public $playerName = "";//球员号码 
18.  
19.  
20.  
21.       
22.  
23.     public function __construct( $name,$height,$weight,$team,$playerName ){ 
24.  
25.         $this->name = $name; 
26.  
27.         $this->height=$height; 
28.  
29.         $this->weight = $weight; 
30.  
31.         $this->team = $team; 
32.  
33.         $this->playName = $playerName; 
34.  
35.         echo "构造函数执行了,当前对象是{$this->name}<br/>"; 
36.  
37.     } 
38.  
39.     public function __destruct(){ 
40.  
41.         echo "销毁对象".$this->name."<br/>"; 
42.  
43.     } 
44.  
45.      
46.  
47.    //跑步 
48.  
49.     public function run(){ 
50.  
51.         echo "跑步中<br/>"; 
52.  
53.     } 
54.  
55.     //跳跃 
56.  
57.     public function jump(){ 
58.  
59.         echo "跳跃<br/>"; 
60.  
61.     } 
62.  
63.     //运球 
64.  
65.     public function dribble(){ 
66.  
67.         echo "运球<br/>"; 
68.  
69.     }  
70.  
71.     //传球 
72.  
73.     public function pass(){ 
74.  
75.         echo "传球<br/>"; 
76.  
77.     } 
78.  
79.     //投篮 
80.  
81.     public function shoot(){ 
82.  
83.         echo "投篮<br/>"; 
84.  
85.     } 
86.  
87.     //扣篮 
88.  
89.     public function dunk(){ 
90.  
91.         echo "扣篮<br/>"; 
92.  
93.     } 
94.  
95.  
96.  
97.  } 
98.  
99.  //创建乔丹对象 
100.  
101. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23"); 
102.  
103. //输出乔丹对象 
104.  
105. echo "名称= ".$jordon->name."<br/>"; 
106.  
107. //让乔丹跑步 
108.  
109. $jordon->run(); 
110.  
111.  
112.  
113. //创建科比对象 
114.  
115. $kobe = new NbaPlayer("科比","2米","93公斤","湖人","24"); 
116.  
117. //创建詹姆斯对象 
118.  
119. $james = new NbaPlayer("詹姆斯","2.03米","120公斤","热火","6"); 
120.  
121. $james1 = new NbaPlayer("詹姆斯1","2.03米","120公斤","热火","6"); 
122.  
123. $james2 = new NbaPlayer("詹姆斯2","2.03米","120公斤","热火","6"); 
124.  
125.  
126.  
127.  $jordon1 = $jordon;//&符号表示左边对象和右边对象其实就是一个对象 
128.  
129.  $jordon = null;//手动的销毁了对象  
130.  
131.  
132.  
133. echo "<b>程序结束完毕</b><br/>"; 
134.  
135. ?> 

重点解析：本来不加$jordon1 = $jordon;当程序执行到$jordon=null，乔丹对象的析构函数将会被执行，也就是说 “销毁对象乔丹”在“程序结束完毕” 前显示

但是加了这句以后，你会发现执行到$jordon=null的时候，乔丹对象的析构函数并没有马上执行，而是到应用程序结束后才被系统自动执行 ，也就是说“销毁对象乔丹”在“程序结束完毕” 后显示

为什么会这样：

接下来就来具体分析$jordon1 = $jordon 这行代码到底让系统做了什么事情

结合上面的代码，其实我们写的代码顺序是

$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");

$jordon1 = $jordon;

那么$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");

说明就是

1、创建了乔丹对象

2、创建了一个变量，变量名叫jordon

3、创了一个乔丹对象的独立引用，就是上图的箭头

然后$jordon1 = $jordon;

说明就是

1、创建了一个新的变量，名叫jordon1

2、又创建了一个乔丹对象的独立引用，就是上图的第二个箭头

那么说明 乔丹对象此时被两个变量引用，当我们$jordon=null 的时候，乔丹对象还被jordon1变量引用，所以此时乔丹对象还有用，还有用就不能当做垃圾清理掉，所以这就可以解释上面的问题，乔丹对象 在最后 才会被系统销毁，所以要看一个对象是否有用，要看它到底还存不存在变量引用，如果完全不存在变量引用了，那么这个对象才可以被视作完全无用，它的析构函数才会被执行好这是对象引用赋值的一种形式，还有另外一种 就是 =&

代码如下：

1. <?php 
2.  
3.  
4.  
5.  class NbaPlayer{ 
6.  
7.      
8.  
9.     public $name  = "";//姓名 
10.  
11.     public $height = "";//身高 
12.  
13.     public $weight = "";//体重 
14.  
15.     public $team = "";//团队 
16.  
17.     public $playerName = "";//球员号码 
18.  
19.  
20.  
21.       
22.  
23.     public function __construct( $name,$height,$weight,$team,$playerName ){ 
24.  
25.         $this->name = $name; 
26.  
27.         $this->height=$height; 
28.  
29.         $this->weight = $weight; 
30.  
31.         $this->team = $team; 
32.  
33.         $this->playName = $playerName; 
34.  
35.         echo "构造函数执行了,当前对象是{$this->name}<br/>"; 
36.  
37.     } 
38.  
39.     public function __destruct(){ 
40.  
41.         echo "销毁对象".$this->name."<br/>"; 
42.  
43.     } 
44.  
45.      
46.  
47.    //跑步 
48.  
49.     public function run(){ 
50.  
51.         echo "跑步中<br/>"; 
52.  
53.     } 
54.  
55.     //跳跃 
56.  
57.     public function jump(){ 
58.  
59.         echo "跳跃<br/>"; 
60.  
61.     } 
62.  
63.     //运球 
64.  
65.     public function dribble(){ 
66.  
67.         echo "运球<br/>"; 
68.  
69.     }  
70.  
71.     //传球 
72.  
73.     public function pass(){ 
74.  
75.         echo "传球<br/>"; 
76.  
77.     } 
78.  
79.     //投篮 
80.  
81.     public function shoot(){ 
82.  
83.         echo "投篮<br/>"; 
84.  
85.     } 
86.  
87.     //扣篮 
88.  
89.     public function dunk(){ 
90.  
91.         echo "扣篮<br/>"; 
92.  
93.     } 
94.  
95.  
96.  
97.  } 
98.  
99.  //创建乔丹对象 
100.  
101. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23"); 
102.  
103. //输出乔丹对象 
104.  
105. echo "名称= ".$jordon->name."<br/>"; 
106.  
107. //让乔丹跑步 
108.  
109. $jordon->run(); 
110.  
111.  
112.  
113. //创建科比对象 
114.  
115. $kobe = new NbaPlayer("科比","2米","93公斤","湖人","24"); 
116.  
117. //创建詹姆斯对象 
118.  
119. $james = new NbaPlayer("詹姆斯","2.03米","120公斤","热火","6"); 
120.  
121. $james1 = new NbaPlayer("詹姆斯1","2.03米","120公斤","热火","6"); 
122.  
123. $james2 = new NbaPlayer("詹姆斯2","2.03米","120公斤","热火","6"); 
124.  
125.  
126.  
127.  $jordon1 = &$jordon;//&符号表示左边对象和右边对象其实就是一个对象 
128.  
129.  $jordon = null;//手动的销毁了对象  
130.  
131.  
132.  
133.  
134.  
135. echo "<b>程序结束完毕</b><br/>"; 
136.  
137. ?> 

当我们把上面的代码仅仅加上一个 &,也就是把$jordon1 = $jordon 改成 $jordon1 =& $jordon,你会发现结果又变了

变成什么呢，就是当执行$jordon=null的时候，乔丹对象的析构函数还是被执行了，为什么呢

我们再来看下 $jordon1 = & $jordon 做了什么事情

系统所做事情如下：

1、创建变量,jordon1

2、然后不会再次创建乔丹对象引用，$jordon1通过$jordon变量来使用同一个对象引用来访问乔丹对象

所以此时乔丹对象，只有一个对象引用，不是2个，所以当我们$jordon=null的时候，其实就是销毁了那唯一的对象引用，进而导致乔丹对象完全没有了对象引用，所以他的析构函数此时会被触发执行

不管是$jordon1=$jordon 还是 $jordon1=&jordon ，修改任意变量里面的名称，都会导致另外变量的名称被修改掉，因为他们都是引用的同一个乔丹对象

其实对象赋值，除了上面2种方式外，还有第三种，就是 clone（浅复制） ，也就是比如$jordon1 = clone $jordon;

那这样的赋值方式它究竟又是什么意思呢，其实相当于 仿造了 一个乔丹对象

接下来我们通过代码演示

1. <?php 
2.  
3.  
4.  
5.  class NbaPlayer{ 
6.  
7.      
8.  
9.     public $name  = "";//姓名 
10.  
11.     public $height = "";//身高 
12.  
13.     public $weight = "";//体重 
14.  
15.     public $team = "";//团队 
16.  
17.     public $playerName = "";//球员号码 
18.  
19.  
20.  
21.       
22.  
23.     public function __construct( $name,$height,$weight,$team,$playerName ){ 
24.  
25.         $this->name = $name; 
26.  
27.         $this->height=$height; 
28.  
29.         $this->weight = $weight; 
30.  
31.         $this->team = $team; 
32.  
33.         $this->playName = $playerName; 
34.  
35.         // echo "构造函数执行了,当前对象是{$this->name}<br/>"; 
36.  
37.     } 
38.  
39.     public function __destruct(){ 
40.  
41.         echo "销毁了对象".$this->name."<br/>"; 
42.  
43.     } 
44.  
45.      
46.  
47.    //跑步 
48.  
49.     public function run(){ 
50.  
51.         echo "跑步中<br/>"; 
52.  
53.     } 
54.  
55.     //跳跃 
56.  
57.     public function jump(){ 
58.  
59.         echo "跳跃<br/>"; 
60.  
61.     } 
62.  
63.     //运球 
64.  
65.     public function dribble(){ 
66.  
67.         echo "运球<br/>"; 
68.  
69.     }  
70.  
71.     //传球 
72.  
73.     public function pass(){ 
74.  
75.         echo "传球<br/>"; 
76.  
77.     } 
78.  
79.     //投篮 
80.  
81.     public function shoot(){ 
82.  
83.         echo "投篮<br/>"; 
84.  
85.     } 
86.  
87.     //扣篮 
88.  
89.     public function dunk(){ 
90.  
91.         echo "扣篮<br/>"; 
92.  
93.     } 
94.  
95.  
96.  
97.  } 
98.  
99.  //创建乔丹对象 
100.  
101. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23"); 
102.  
103.  
104.  
105. $jordon1 = clone $jordon; 
106.  
107. $jordon1 = null; 
108.  
109. $jordon = null; 
110.  
111.  
112.  
113. echo "应用程序结束<br/>"; 
114.  
115.  
116.  
117.  
118.  
119. ?> 

执行结果如下：

所以$jordon1=clone $jordon;其实就是 仿造了一个乔丹对象，拥有和乔丹对象一样的属性和方法

到目前为止，我们了解了对象引用，那么结合对象引用，我们如何解决最开始的那个问题呢？

大家思考一下再看下面的解决方案

....................................

好，接下来我们来看上面我们遇到的问题

问题是：mysql对象在构造函数执行完毕后，就被销毁了，导致后面getAll函数里的数据库连接无法使用

解决思路：

1.mysql对象在构造函数执行完成后，就被销毁了，说明mysql对象此时没有了对象引用

2.那我们就要让他在构造函数执行完成后，依然存在对象引用，那么mysql对象就还有用，还有用就不会被销毁

3.在构造函数里，创建mysql对象的引用，让它在构造函数执行完成后，这个引用依然存在

4.我们可以定义个类的新属性比如$mysql,然后让$this->mysql = $mysql;这样就创建了一个mysql对象的独立引用，而且当构造函数执行完成后类的mysql属性还有用，所以这个对象引用还有用，进而mysql对象还有用，就不会被销毁

具体代码如下:

1. <?php 
2.  
3.  require_once "Mysql.class.php"; 
4.  
5.  class NbaPlayer{ 
6.  
7.      
8.  
9.     public $name  = "";//姓名 
10.  
11.     public $height = "";//身高 
12.  
13.     public $weight = "";//体重 
14.  
15.     public $team = "";//团队 
16.  
17.     public $playerName = "";//球员号码 
18.  
19.     public $conn = "";//添加一个数据库连接属性 
20.  
21.     public $mysql = "";//新增一个mysql属性 
22.  
23.  
24.  
25.       
26.  
27.     public function __construct( $name,$height,$weight,$team,$playerName ){ 
28.  
29.         $this->name = $name; 
30.  
31.         $this->height=$height; 
32.  
33.         $this->weight = $weight; 
34.  
35.         $this->team = $team; 
36.  
37.         $this->playName = $playerName; 
38.  
39.         //初始化数据库连接属性 
40.  
41.         $mysql = new Mysql(); 
42.  
43.         $this->conn = $mysql->conn; 
44.  
45.         //解决问题的重点代码 
46.  
47.         $this->mysql = $mysql;//加了这行代码，getAll中的conn 数据库连接就不会销毁 
48.  
49.           
50.  
51.     } 
52.  
53.     //新增获取所有Nba球员的方法 
54.  
55.      public function getAll(){ 
56.  
57.          //创建数据库连接 
58.  
59.         $conn = $this->conn; 
60.  
61.         //写sql 
62.  
63.         $sql = " select * from ".$this->tableName; 
64.  
65.         //执行sql 
66.  
67.         $result = mysqli_query( $conn,$sql ); 
68.  
69.         //获取数据 
70.  
71.         // mysqli_fetch_all($result)//特点：不会包含字段名 
72.  
73.         $list = Array(); 
74.  
75.         while( $row = mysqli_fetch_assoc(  $result ) ){ 
76.  
77.             $list[] = $row; 
78.  
79.         } 
80.  
81.         //返回数据 
82.  
83.         return $list; 
84.  
85.      } 
86.  
87.  
88.  
89.  } 
90.  
91.  //创建乔丹对象 
92.  
93. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23"); 
94.  
95.  
96.  
97. $list = $jordon->getAll(); 
98.  
99.  
100.  
101. echo "<b>程序结束完毕</b><br/>"; 
102.  
103. ?> 

好了，最后我们再稍微做下总结：

1、了解了析构函数的定义，它其实就是一个特殊函数

2、了解了析构函数的作用，就是8个字，清理对象，释放内存

3、了解了析构函数的特点，特点有点多，主要7点

4、知道了对象引用的3种赋值方式，一个是=一个是=&,还有一个是clone

Tags: php析构函数

分享到：