php教程分享

  1. php教程首页
  2. php面向对象

php面向对象之析构函数和对象引用

•php面向对象•阅读 284

本文学习目标：

1、了解析构函数的定义

2、了解析构函数的作用

3、了解析构函数的特点

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

（一）、析构函数

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

public function destruct(){}

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

3、特点：

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

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

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

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

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

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

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

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

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

  1. <?php
  2. class NbaPlayer{
  3. public $name = "";//姓名
  4. public $height = "";//身高
  5. public $weight = "";//体重
  6. public $team = "";//团队
  7. public $playerName = "";//球员号码
  8. public function __construct( $name,$height,$weight,$team,$playerName ){
  9. $this->name = $name;
  10. $this->height=$height;
  11. $this->weight = $weight;
  12. $this->team = $team;
  13. $this->playName = $playerName;
  14. echo "构造函数执行了,当前对象是{$this->name}<br/>";
  15. }
  16. //析构函数
  17. public function __destruct(){
  18. echo "销毁对象".$this->name."<br/>";
  19. }
  20. //跑步
  21. public function run(){
  22. echo "跑步中<br/>";
  23. }
  24. //跳跃
  25. public function jump(){
  26. echo "跳跃<br/>";
  27. }
  28. //运球
  29. public function dribble(){
  30. echo "运球<br/>";
  31. }
  32. //传球
  33. public function pass(){
  34. echo "传球<br/>";
  35. }
  36. //投篮
  37. public function shoot(){
  38. echo "投篮<br/>";
  39. }
  40. //扣篮
  41. public function dunk(){
  42. echo "扣篮<br/>";
  43. }
  44. }
  45. //创建乔丹对象
  46. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
  47. //输出乔丹对象
  48. echo "名称= ".$jordon->name."<br/>";
  49. //让乔丹跑步
  50. $jordon->run();
  51. //创建科比对象
  52. $kobe = new NbaPlayer("科比","2米","93公斤","湖人","24");
  53. //创建詹姆斯对象
  54. $james = new NbaPlayer("詹姆斯","2.03米","120公斤","热火","6");
  55. $james1 = new NbaPlayer("詹姆斯1","2.03米","120公斤","热火","6");
  56. $james2 = new NbaPlayer("詹姆斯2","2.03米","120公斤","热火","6");
  57. $jordon = null;//手动的销毁了对象 ,此时乔丹对象的析构函数将会被触发
  58. $kobe = null;//手动的销毁了对象 ,此时科比对象的析构函数将会被触发
  59. echo "<b>程序结束完毕</b><br/>";
  60. ?>

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

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

  1. <?php
  2. //数据库类
  3. class Mysql{
  4. //定义属性
  5. public $conn = "";
  6. //构造函数
  7. public function __construct( ){
  8. //初始化行为 初始化方法
  9. $this->initConn();
  10. }
  11. //析构函数 销毁数据库连接
  12. public function __destruct(){
  13. //销毁连接
  14. if( $this->conn ){
  15. mysqli_close( $this->conn );
  16. echo "销毁了连接<br/>";
  17. }
  18. }
  19. //定义方法
  20. //创建公共的方法 获取数据库连接
  21. public function initConn(){
  22. $config = Array(
  23. "hostname"=>"127.0.0.1",
  24. "database"=>"Nbaplayer",
  25. "username"=>"root",
  26. "password"=>"root"
  27. );
  28. $this->conn = mysqli_connect( $config['hostname'],$config['username'] ,$config['password'],
  29. $config['database']);
  30. }
  31. }
  32. ?>

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

  1. <?php
  2. require_once "Mysql.class.php";
  3. class NbaPlayer{
  4. public $name = "";//姓名
  5. public $height = "";//身高
  6. public $weight = "";//体重
  7. public $team = "";//团队
  8. public $playerName = "";//球员号码
  9. public $conn = "";//添加一个数据库连接属性
  10. public function __construct( $name,$height,$weight,$team,$playerName ){
  11. $this->name = $name;
  12. $this->height=$height;
  13. $this->weight = $weight;
  14. $this->team = $team;
  15. $this->playName = $playerName;
  16. //初始化数据库连接属性
  17. $mysql = new Mysql();
  18. $this->conn = $mysql->conn;
  19. }
  20. //新增获取所有Nba球员的方法
  21. public function getAll(){
  22. //创建数据库连接
  23. $conn = $this->conn;
  24. //写sql
  25. $sql = " select * from ".$this->tableName;
  26. //执行sql
  27. $result = mysqli_query( $conn,$sql );
  28. //获取数据
  29. // mysqli_fetch_all($result)//特点：不会包含字段名
  30. $list = Array();
  31. while( $row = mysqli_fetch_assoc( $result ) ){
  32. $list[] = $row;
  33. }
  34. //返回数据
  35. return $list;
  36. }
  37. }
  38. //创建乔丹对象
  39. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
  40. $list = $jordon->getAll();
  41. echo "<b>程序结束完毕</b><br/>";
  42. ?>

当你运行，你会发现错误，会发现连接已经被销毁，在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. class NbaPlayer{
  3. public $name = "";//姓名
  4. public $height = "";//身高
  5. public $weight = "";//体重
  6. public $team = "";//团队
  7. public $playerName = "";//球员号码
  8. public function __construct( $name,$height,$weight,$team,$playerName ){
  9. $this->name = $name;
  10. $this->height=$height;
  11. $this->weight = $weight;
  12. $this->team = $team;
  13. $this->playName = $playerName;
  14. echo "构造函数执行了,当前对象是{$this->name}<br/>";
  15. }
  16. public function __destruct(){
  17. echo "销毁对象".$this->name."<br/>";
  18. }
  19. //跑步
  20. public function run(){
  21. echo "跑步中<br/>";
  22. }
  23. //跳跃
  24. public function jump(){
  25. echo "跳跃<br/>";
  26. }
  27. //运球
  28. public function dribble(){
  29. echo "运球<br/>";
  30. }
  31. //传球
  32. public function pass(){
  33. echo "传球<br/>";
  34. }
  35. //投篮
  36. public function shoot(){
  37. echo "投篮<br/>";
  38. }
  39. //扣篮
  40. public function dunk(){
  41. echo "扣篮<br/>";
  42. }
  43. }
  44. //创建乔丹对象
  45. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
  46. //输出乔丹对象
  47. echo "名称= ".$jordon->name."<br/>";
  48. //让乔丹跑步
  49. $jordon->run();
  50. //创建科比对象
  51. $kobe = new NbaPlayer("科比","2米","93公斤","湖人","24");
  52. //创建詹姆斯对象
  53. $james = new NbaPlayer("詹姆斯","2.03米","120公斤","热火","6");
  54. $james1 = new NbaPlayer("詹姆斯1","2.03米","120公斤","热火","6");
  55. $james2 = new NbaPlayer("詹姆斯2","2.03米","120公斤","热火","6");
  56. $jordon1 = $jordon;//&符号表示左边对象和右边对象其实就是一个对象
  57. $jordon = null;//手动的销毁了对象
  58. echo "<b>程序结束完毕</b><br/>";
  59. ?>

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

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

为什么会这样：

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

php面向对象之析构函数和对象引用

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

$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. class NbaPlayer{
  3. public $name = "";//姓名
  4. public $height = "";//身高
  5. public $weight = "";//体重
  6. public $team = "";//团队
  7. public $playerName = "";//球员号码
  8. public function __construct( $name,$height,$weight,$team,$playerName ){
  9. $this->name = $name;
  10. $this->height=$height;
  11. $this->weight = $weight;
  12. $this->team = $team;
  13. $this->playName = $playerName;
  14. echo "构造函数执行了,当前对象是{$this->name}<br/>";
  15. }
  16. public function __destruct(){
  17. echo "销毁对象".$this->name."<br/>";
  18. }
  19. //跑步
  20. public function run(){
  21. echo "跑步中<br/>";
  22. }
  23. //跳跃
  24. public function jump(){
  25. echo "跳跃<br/>";
  26. }
  27. //运球
  28. public function dribble(){
  29. echo "运球<br/>";
  30. }
  31. //传球
  32. public function pass(){
  33. echo "传球<br/>";
  34. }
  35. //投篮
  36. public function shoot(){
  37. echo "投篮<br/>";
  38. }
  39. //扣篮
  40. public function dunk(){
  41. echo "扣篮<br/>";
  42. }
  43. }
  44. //创建乔丹对象
  45. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
  46. //输出乔丹对象
  47. echo "名称= ".$jordon->name."<br/>";
  48. //让乔丹跑步
  49. $jordon->run();
  50. //创建科比对象
  51. $kobe = new NbaPlayer("科比","2米","93公斤","湖人","24");
  52. //创建詹姆斯对象
  53. $james = new NbaPlayer("詹姆斯","2.03米","120公斤","热火","6");
  54. $james1 = new NbaPlayer("詹姆斯1","2.03米","120公斤","热火","6");
  55. $james2 = new NbaPlayer("詹姆斯2","2.03米","120公斤","热火","6");
  56. $jordon1 = &$jordon;//&符号表示左边对象和右边对象其实就是一个对象
  57. $jordon = null;//手动的销毁了对象
  58. echo "<b>程序结束完毕</b><br/>";
  59. ?>

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

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

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

php面向对象之析构函数和对象引用

系统所做事情如下：

1、创建变量,jordon1

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

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

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

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

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

接下来我们通过代码演示

  1. <?php
  2. class NbaPlayer{
  3. public $name = "";//姓名
  4. public $height = "";//身高
  5. public $weight = "";//体重
  6. public $team = "";//团队
  7. public $playerName = "";//球员号码
  8. public function __construct( $name,$height,$weight,$team,$playerName ){
  9. $this->name = $name;
  10. $this->height=$height;
  11. $this->weight = $weight;
  12. $this->team = $team;
  13. $this->playName = $playerName;
  14. // echo "构造函数执行了,当前对象是{$this->name}<br/>";
  15. }
  16. public function __destruct(){
  17. echo "销毁了对象".$this->name."<br/>";
  18. }
  19. //跑步
  20. public function run(){
  21. echo "跑步中<br/>";
  22. }
  23. //跳跃
  24. public function jump(){
  25. echo "跳跃<br/>";
  26. }
  27. //运球
  28. public function dribble(){
  29. echo "运球<br/>";
  30. }
  31. //传球
  32. public function pass(){
  33. echo "传球<br/>";
  34. }
  35. //投篮
  36. public function shoot(){
  37. echo "投篮<br/>";
  38. }
  39. //扣篮
  40. public function dunk(){
  41. echo "扣篮<br/>";
  42. }
  43. }
  44. //创建乔丹对象
  45. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
  46. $jordon1 = clone $jordon;
  47. $jordon1 = null;
  48. $jordon = null;
  49. echo "应用程序结束<br/>";
  50. ?>

执行结果如下：

php面向对象之析构函数和对象引用

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

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

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

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

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

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

解决思路：

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

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

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

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

具体代码如下:

  1. <?php
  2. require_once "Mysql.class.php";
  3. class NbaPlayer{
  4. public $name = "";//姓名
  5. public $height = "";//身高
  6. public $weight = "";//体重
  7. public $team = "";//团队
  8. public $playerName = "";//球员号码
  9. public $conn = "";//添加一个数据库连接属性
  10. public $mysql = "";//新增一个mysql属性
  11. public function __construct( $name,$height,$weight,$team,$playerName ){
  12. $this->name = $name;
  13. $this->height=$height;
  14. $this->weight = $weight;
  15. $this->team = $team;
  16. $this->playName = $playerName;
  17. //初始化数据库连接属性
  18. $mysql = new Mysql();
  19. $this->conn = $mysql->conn;
  20. //解决问题的重点代码
  21. $this->mysql = $mysql;//加了这行代码，getAll中的conn 数据库连接就不会销毁
  22. }
  23. //新增获取所有Nba球员的方法
  24. public function getAll(){
  25. //创建数据库连接
  26. $conn = $this->conn;
  27. //写sql
  28. $sql = " select * from ".$this->tableName;
  29. //执行sql
  30. $result = mysqli_query( $conn,$sql );
  31. //获取数据
  32. // mysqli_fetch_all($result)//特点：不会包含字段名
  33. $list = Array();
  34. while( $row = mysqli_fetch_assoc( $result ) ){
  35. $list[] = $row;
  36. }
  37. //返回数据
  38. return $list;
  39. }
  40. }
  41. //创建乔丹对象
  42. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
  43. $list = $jordon->getAll();
  44. echo "<b>程序结束完毕</b><br/>";
  45. ?>

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

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

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

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

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

赞 (8)
上一篇8-26
下一篇 9-30

相关推荐

  • php析构函数的具体用法小结

    php析构函数的具体用法小结本篇文章主要是对php析构函数的具体用法进行了详细的介绍，需要的朋友可以过来参考下，希望对大家有所帮助简单的说,析构函数是用来在对象关闭时完成的特殊工作,比如我写的上例,在实例化同时打开某文件,但是它什么时候关闭…
    •php函数
    2016-05-0513308

  • PHP面向对象程序设计之接口的继承定义与用法详解

    本文实例讲述了PHP面向对象程序设计之接口的继承定义与用法，分享给大家供大家参考，具体如下：在PHP5中，接口是可以继承自另外一个接口的，这样代码的重用更有效了，要注意只有接口和接口之间使用继承关键字extends，类实现接口必须实现其抽象方法，使用实现关键字implements。下面的这个例子定义接口User，User有两个抽象方法getName和setName。又定义了接口VipUser，继承…
    •php面向对象
    2023-06-09388

  • PHP面向对象五大原则之开放-封闭原则(OCP)详解

    这篇文章主要介绍了PHP面向对象五大原则之开放-封闭原则(OCP),简单分析了PHP面向对象开放-封闭原则(OCP)的概念、原理、使用方法及相关注意事项,需要的朋友可以参考下。本文实例讲述了PHP面向对象五大原则之开放-封闭原则(OCP)。分享给大家供大家参考，具体如下：1.什么是“开放-封闭”随着软件系统规模的不断增大，软件系统的维护和修改的复杂性不断提高，这种困境促使法国工程院士Bertran…
    •php面向对象
    2023-06-10496

  • 如何在php中实现construct构造方法

    php面向对象编程之构造方法__construct()php中构造方法是对象创建完成后第一个被对象自动调用的方法。在每个类中都有一个构造方法，如果没有显示地声明它，那么类中都会默认存在一个没有参数且内容为空的构造方法。构造方法的作用通常构造方法被用来执行一些有用的初始化任务，如对成员属性在创建对象时赋予初始值。构造方法的在类中的声明格式function__constrct([参数列表]){方法体/…
    •php应用
    2023-06-15471

  • php面向对象和面向过程有什么区别

    面向过程和面向对象区别有：面向过程效率比面向对象高，面向对象的编程复杂度更高，但是后期面向对象比面向过程好维护。面向对象面向对象是把一些常用的操作进行类封装起来，方便调用，需要用的地方，调用一下即可，这样开发方便，维护也方便！修改这个封装的类，即可达到修改全站的目的！面向对象三大特性（封装，继承，多态）使得在做复杂的事情的时候效率和正确率得到保证。面向过程面向过程就是把代码封装成子过程或函数，在每…
    •php面向对象
    2023-06-18356

  • PHP 构造函数和析构函数原理与用法分析

    本文实例讲述了PHP构造函数和析构函数原理与用法，分享给大家供大家参考，具体如下：构造函数__construct([mixed$args[,$...]]):voidPHP5允行开发者在一个类中定义一个方法作为构造函数。具有构造函数的类会在每次创建新对象时先调用此方法，所以非常适合在使用对象之前做一些初始化工作。Note:如果子类中定义了构造函数则不会隐式调用其父类的构造函数。要执行父类的构造函数，…
    •php函数
    2023-06-28347

  • PHP析构函数destruct与垃圾回收机制的讲解

    今天小编就为大家分享一篇关于PHP析构函数destruct与垃圾回收机制的讲解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧。析构函数当某个对象成为垃圾或者当对象被显式销毁时执行。PHP5中提供的析构函数是__destruct，其与构造方法__construct相对应。垃圾回收——GC(GarbageCollector)在PHP中，没有任何变量指向这个对…
    •php函数
    2023-06-29356

  • php析构函数的简单使用说明

    与构造函数相反，在PHP5中，可以定义一个名为__destruct()的函数，称之为PHP5析构函数，PHP将在对象在内存中被销毁前调用析构函数，使对象在彻底消失之前完成一些工作。对象在销毁一般可以通过赋值为null实现。随着面向对象编程的普遍展开，面向对象展现了其中很多有趣的问题。相信很多初学者学习php面向对象时会接触两个函数，构造函数与析构函数。构造函数似乎用的更多，析构函数用的较少（相对初…
    •php函数
    2023-06-30397