php面向对象之析构函数和对象引用
PHP面向对象之析构函数和对象引用
本文学习目标：
1、了解析构函数的定义
2、了解析构函数的作用
3、了解析构函数的特点
4、掌握对象引用赋值的概念和特点
（一）、析构函数
1、定义：它是一个特殊的函数
public function destruct(){
}
2、作用：清理对象，释放内存
3、特点：
1、自动执行，而非手动调用
2、类一旦定义了析构函数，程序结束前就会销毁该类下的所有实例对象
3、在应用程序结束前的最后一刻执行，除非一些特殊情况，比如第4点，或者当对象的生命周期结束以后也会自动执行
4、 一旦我们手动的销毁一个对象，系统会自动的触发该对象的析构函数
特别注意一个特殊的情况：就是如果对象还被其他对象引用的情况下，它的析构函数也不会被触发
5、在对象的生命周期结束前执行
6、应用程序结束前的最后一刻，会销毁掉还未销毁的对象，已经销毁的对象不会再次被销毁
进一步得出，一个对象的析构函数只能执行1次，不会执行多次
7、在Php中如果我们不为类定义个析构函数，那么php会自动的为类创建一个析构函数，然后在
程序结束前调用默认的析构函数，但是一旦定义了析构函数，就会执行我们写的析构函数
进一步我们就可以在自己的析构函数里写自己的业务代码
比如如果程序使用了打印机资源，我们可以销毁对象前释放打印机资源
相关的代码如下：
?php class Nbaplayer{
public $name = "";
//姓名 public $height = "";
//身高 public $weight = "";
//体重 public $team = "";
//团队 public $playerName = "";
//球员号码 public function __construct( $name,$height,$weight,$team,$playerName ){
$this->
name = $name;
$this->
height=$height;
$this->
weight = $weight;
$this->
team = $team;
$this->
playName = $playerName;
echo "构造函数执行了,当前对象是{
$this->
name}
br/>
";
}
//析构函数 public function __destruct(){
echo "销毁对象".$this->
name."br/>
";
}
//跑步 public function run(){
echo "跑步中br/>
";
}
//跳跃 public function jump(){
echo "跳跃br/>
";
}
//运球 public function dribble(){
echo "运球br/>
";
}
//传球 public function pass(){
echo "传球br/>
";
}
//投篮 public function shoot(){
echo "投篮br/>
";
}
//扣篮 public function dunk(){
echo "扣篮br/>
";
}
}
//创建乔丹对象$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
//输出乔丹对象echo "名称= ".$jordon->
name."br/>
";
//让乔丹跑步$jordon->
run();
//创建科比对象$kobe = new NbaPlayer("科比","2米","93公斤","湖人","24");
//创建詹姆斯对象$james = new NbaPlayer("詹姆斯","2.03米","120公斤","热火","6");
$james1 = new NbaPlayer("詹姆斯1","2.03米","120公斤","热火","6");
$james2 = new NbaPlayer("詹姆斯2","2.03米","120公斤","热火","6");
$jordon = null;
//手动的销毁了对象 ,此时乔丹对象的析构函数将会被触发$kobe = null;
//手动的销毁了对象 ,此时科比对象的析构函数将会被触发echo "b>
程序结束完毕/b>
br/>
";
?>
接下来，我代码修改如下，添加一个MySQL数据库连接类，然后在NbaPlayer构造函数里面调用它
这是MySQL.class.php,里面定义了一个析构函数
?php//数据库类class Mysql{
//定义属性 public $conn = "";
//构造函数 public function __construct( ){
//初始化行为 初始化方法 $this->
inITConn();
}
//析构函数 销毁数据库连接 public function __destruct(){
//销毁连接 if( $this->
conn ){
mysqli_close( $this->
conn );
echo "销毁了连接br/>
";
}
}
//定义方法 //创建公共的方法 获取数据库连接 public function initConn(){
$config = Array( "hostname"=>
"127.0.0.1", "database"=>
"Nbaplayer", "username"=>
"root", "password"=>
"root" );
$this->
conn = mysqli_connect( $config['hostname'],$config['username'] ,$config['password'], $config['database']);
}
}
?>
接下来还是定义个NbaPlayer类，但是为了突出重点，所以NbaPlayer类我会简写如下：
?php require_once "mysql.class.php";
class NbaPlayer{
public $name = "";
//姓名 public $height = "";
//身高 public $weight = "";
//体重 public $team = "";
//团队 public $playerName = "";
//球员号码 public $conn = "";
//添加一个数据库连接属性 public function __construct( $name,$height,$weight,$team,$playerName ){
$this->
name = $name;
$this->
height=$height;
$this->
weight = $weight;
$this->
team = $team;
$this->
playName = $playerName;
//初始化数据库连接属性 $mysql = new Mysql();
$this->
conn = $mysql->
conn;
}
//新增获取所有Nba球员的方法 public function getAll(){
//创建数据库连接 $conn = $this->
conn;
//写sql $sql = " select * From ".$this->
tableName;
//执行sql $result = mysqli_query( $conn,$sql );
//获取数据 // mysqli_fetch_all($result)//特点：不会包含字段名 $list = Array();
while( $row = mysqli_fetch_assoc( $result ) ){
$list[] = $row;
}
//返回数据 return $list;
}
}
//创建乔丹对象$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
$list = $jordon->
getAll();
echo "b>
程序结束完毕/b>
br/>
";
?>
当你运行，你会发现错误，会发现连接已经被销毁，在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=对象，不会创建对象的新引用，而是仿造了一个新的该对象，具有该对象通用的属性和方法
相关代码如下：
?php class NbaPlayer{
public $name = "";
//姓名 public $height = "";
//身高 public $weight = "";
//体重 public $team = "";
//团队 public $playerName = "";
//球员号码 public function __construct( $name,$height,$weight,$team,$playerName ){
$this->
name = $name;
$this->
height=$height;
$this->
weight = $weight;
$this->
team = $team;
$this->
playName = $playerName;
echo "构造函数执行了,当前对象是{
$this->
name}
br/>
";
}
public function __destruct(){
echo "销毁对象".$this->
name."br/>
";
}
//跑步 public function run(){
echo "跑步中br/>
";
}
//跳跃 public function jump(){
echo "跳跃br/>
";
}
//运球 public function dribble(){
echo "运球br/>
";
}
//传球 public function pass(){
echo "传球br/>
";
}
//投篮 public function shoot(){
echo "投篮br/>
";
}
//扣篮 public function dunk(){
echo "扣篮br/>
";
}
}
//创建乔丹对象$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
//输出乔丹对象echo "名称= ".$jordon->
name."br/>
";
//让乔丹跑步$jordon->
run();
//创建科比对象$kobe = new NbaPlayer("科比","2米","93公斤","湖人","24");
//创建詹姆斯对象$james = new NbaPlayer("詹姆斯","2.03米","120公斤","热火","6");
$james1 = new NbaPlayer("詹姆斯1","2.03米","120公斤","热火","6");
$james2 = new NbaPlayer("詹姆斯2","2.03米","120公斤","热火","6");
$jordon1 = $jordon;
//&
符号表示左边对象和右边对象其实就是一个对象 $jordon = null;
//手动的销毁了对象 echo "b>
程序结束完毕/b>
br/>
";
?>
重点解析：本来不加$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变量引用，所以此时乔丹对象还有用，还有用就不能当做垃圾清理掉，
所以这就可以解释上面的问题，乔丹对象 在最后 才会被系统销毁，所以要看一个对象是否有用，要看它到底还存不存在变量引用，如果完全不存在变量引用了，那么这个
对象才可以被视作完全无用，它的析构函数才会被执行
好这是对象引用赋值的一种形式，还有另外一种 就是 =&
代码如下：
?php class NbaPlayer{
public $name = "";
//姓名 public $height = "";
//身高 public $weight = "";
//体重 public $team = "";
//团队 public $playerName = "";
//球员号码 public function __construct( $name,$height,$weight,$team,$playerName ){
$this->
name = $name;
$this->
height=$height;
$this->
weight = $weight;
$this->
team = $team;
$this->
playName = $playerName;
echo "构造函数执行了,当前对象是{
$this->
name}
br/>
";
}
public function __destruct(){
echo "销毁对象".$this->
name."br/>
";
}
//跑步 public function run(){
echo "跑步中br/>
";
}
//跳跃 public function jump(){
echo "跳跃br/>
";
}
//运球 public function dribble(){
echo "运球br/>
";
}
//传球 public function pass(){
echo "传球br/>
";
}
//投篮 public function shoot(){
echo "投篮br/>
";
}
//扣篮 public function dunk(){
echo "扣篮br/>
";
}
}
//创建乔丹对象$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
//输出乔丹对象echo "名称= ".$jordon->
name."br/>
";
//让乔丹跑步$jordon->
run();
//创建科比对象$kobe = new NbaPlayer("科比","2米","93公斤","湖人","24");
//创建詹姆斯对象$james = new NbaPlayer("詹姆斯","2.03米","120公斤","热火","6");
$james1 = new NbaPlayer("詹姆斯1","2.03米","120公斤","热火","6");
$james2 = new NbaPlayer("詹姆斯2","2.03米","120公斤","热火","6");
$jordon1 = &
$jordon;
//&
符号表示左边对象和右边对象其实就是一个对象 $jordon = null;
//手动的销毁了对象 echo "b>
程序结束完毕/b>
br/>
";
?>
当我们把上面的代码仅仅加上一个 & ,也就是把$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;
那这样的赋值方式它究竟又是什么意思呢，其实相当于 仿造了 一个乔丹对象
接下来我们通过代码演示
?php class NbaPlayer{
public $name = "";
//姓名 public $height = "";
//身高 public $weight = "";
//体重 public $team = "";
//团队 public $playerName = "";
//球员号码 public function __construct( $name,$height,$weight,$team,$playerName ){
$this->
name = $name;
$this->
height=$height;
$this->
weight = $weight;
$this->
team = $team;
$this->
playName = $playerName;
// echo "构造函数执行了,当前对象是{
$this->
name}
br/>
";
}
public function __destruct(){
echo "销毁了对象".$this->
name."br/>
";
}
//跑步 public function run(){
echo "跑步中br/>
";
}
//跳跃 public function jump(){
echo "跳跃br/>
";
}
//运球 public function dribble(){
echo "运球br/>
";
}
//传球 public function pass(){
echo "传球br/>
";
}
//投篮 public function shoot(){
echo "投篮br/>
";
}
//扣篮 public function dunk(){
echo "扣篮br/>
";
}
}
//创建乔丹对象$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
$jordon1 = clone $jordon;
$jordon1 = null;
$jordon = null;
echo "应用程序结束br/>
";
?>
执行结果如下：
所以$jordon1=clone $jordon; 其实就是 仿造了一个乔丹对象，拥有和乔丹对象一样的属性和方法
到目前为止，我们了解了对象引用，那么结合对象引用，我们如何解决最开始的那个问题呢？
大家思考一下再看下面的解决方案
....................................
好，接下来我们来看上面我们遇到的问题
问题是：mysql对象在构造函数执行完毕后，就被销毁了，导致后面getAll函数里的数据库连接无法使用
解决思路：
1.mysql对象在构造函数执行完成后，就被销毁了，说明mysql对象此时没有了对象引用
2.那我们就要让他在构造函数执行完成后，依然存在对象引用，那么mysql对象就还有用，还有用就不会被销毁
3.在构造函数里，创建mysql对象的引用，让它在构造函数执行完成后，这个引用依然存在
4.我们可以定义个类的新属性比如$mysql,然后让$this-> mysql = $mysql; 这样就创建了一个mysql对象的独立引用，而且当构造函数执行完成后
类的mysql属性还有用，所以这个对象引用还有用，进而mysql对象还有用，就不会被销毁
具体代码如下:
?php require_once "Mysql.class.php";
class NbaPlayer{
public $name = "";
//姓名 public $height = "";
//身高 public $weight = "";
//体重 public $team = "";
//团队 public $playerName = "";
//球员号码 public $conn = "";
//添加一个数据库连接属性 public $mysql = "";
//新增一个mysql属性 public function __construct( $name,$height,$weight,$team,$playerName ){
$this->
name = $name;
$this->
height=$height;
$this->
weight = $weight;
$this->
team = $team;
$this->
playName = $playerName;
//初始化数据库连接属性 $mysql = new Mysql();
$this->
conn = $mysql->
conn;
//解决问题的重点代码 $this->
mysql = $mysql;
//加了这行代码，getAll中的conn 数据库连接就不会销毁 }
//新增获取所有Nba球员的方法 public function getAll(){
//创建数据库连接 $conn = $this->
conn;
//写sql $sql = " select * from ".$this->
tableName;
//执行sql $result = mysqli_query( $conn,$sql );
//获取数据 // mysqli_fetch_all($result)//特点：不会包含字段名 $list = Array();
while( $row = mysqli_fetch_assoc( $result ) ){
$list[] = $row;
}
//返回数据 return $list;
}
}
//创建乔丹对象$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
$list = $jordon->
getAll();
echo "b>
程序结束完毕/b>
br/>
";
?>
好了，最后我们再稍微做下总结：
1、了解了析构函数的定义，它其实就是一个特殊函数
2、了解了析构函数的作用，就是8个字，清理对象，释放内存
3、了解了析构函数的特点，特点有点多，主要7点
4、知道了对象引用的3种赋值方式，一个是=一个是=& ,还有一个是clone
以上就是php面向对象之析构函数和对象引用的详细内容，更多请关注其它相关文章！
声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！
若转载请注明出处： php面向对象之析构函数和对象引用
本文地址： https://pptw.com/jishu/596296.html