>  기사  >  백엔드 개발  >  PHP 객체지향 소멸자와 객체 참조

PHP 객체지향 소멸자와 객체 참조

易达
易达원래의
2020-05-23 19:12:291872검색

                          

이 글의 학습 목표:

​​​​​1. 생성자의 정의를 이해합니다
2. 생성자의 역할을 이해합니다

3. 소멸자의 특성을 이해합니다 4. 객체 참조 할당의 개념과 특징을 숙지하세요

(1), 소멸자

1. 정의

:

특수 함수입니다

2. 메모리 해제

3. 기능: public function destruct(){}

1. 수동 호출 대신 자동 실행 2. 클래스가 소멸자를 정의하면 해당 클래스 아래의 모든 인스턴스 개체가 삭제됩니다

          3. 4번 항목과 같은 특별한 상황이 없거나 객체의 생명주기가 끝나는 경우를 제외하고는 애플리케이션이 종료되기 전 마지막 순간에 실행되며 자동으로 실행되기도 합니다           4. 일단 수동으로 객체가 객체가 파괴되면 시스템은 자동으로 객체의 소멸자를 트리거합니다. 특별한 상황에 특별한 주의를 기울이십시오. 객체가 다른 객체에 의해 계속 참조되는 경우 해당 소멸자는 객체의 수명 주기가 끝나기 전에 실행되지 않습니다.

6. 신청 전 마지막 순간까지 파기되지 않은 파기된 개체는 판매되며, 파기된 개체는 다시 파기되지 않습니다.

        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[&#39;hostname&#39;],$config[&#39;username&#39;] ,$config[&#39;password&#39;],
                $config[&#39;database&#39;]);
    }
}
?>

다음으로 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("Jordan","1.98meters", "98kg","Bulls","23");

데이터베이스 연결 개체가 파괴되었습니다. 실제로 디버그로 이동하면 마지막 이후에 생성자의 mysql 개체가 실제로 파괴되는 것을 볼 수 있습니다. NbaPlayer 클래스의 생성자가 실행되는 이유는 무엇입니까?

이것은 실제로 변수 범위 문제와 관련이 있습니다. 왜냐하면 mysql 개체가 생성자에 정의되어 있어 외부에서 접근할 수 없기 때문에 생성자가 실행되면 시스템은 더 이상 유용하지 않다고 생각할 것입니다. 따라서

정리하고 소멸자를 실행하므로 결국 getAll 메서드를 호출하면 데이터베이스 연결이 이미 끊어지고 자연스럽게 더 이상 SQL을 실행할 수 없습니다. 사실 이 문제를 해결하려면 객체 참조를 이해해야 합니다. 이 문제를 해결하려면 객체 참조를 결합해야 합니다. 다음으로 먼저 객체 참조

(2), 객체 참조

를 이해해 보겠습니다. :

        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 这行代码到底让系统做了什么事情

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变量引用,所以此时乔丹对象还有用,还有用就不能当做垃圾清理掉,

所以这就可以解释上面的问题,乔丹对象 在最后 才会被系统销毁,所以要看一个对象是否有用,要看它到底还存不存在变量引用,如果完全不存在变量引用了,那么这个

对象才可以被视作完全无用,它的析构函数才会被执行

好这是对象引用赋值的一种形式,还有另外一种 就是 =& 

代码如下:

<?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 做了什么事情

PHP 객체지향 소멸자와 객체 참조

系统所做事情如下:

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/>";


?>

执行结果如下:

PHP 객체지향 소멸자와 객체 참조

所以$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 객체지향 소멸자와 객체 참조의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명:
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.