PHP-objektorientierter Code-Case-Sharing von Konstruktor- und Destruktormethoden

　Konstruktormethode und Destruktormethode sind zwei spezielle Methoden in Objekt, sie beziehen sich beide auf den Lebenszyklus des Objekts . Die Konstruktormethode ist die erste -Methode, die vom Objekt automatisch aufgerufen wird, nachdem das Objekt erstellt wurde. Aus diesem Grund verwenden wir die Konstruktormethode im Objekt. Die Destruktormethode ist die letzte Methode , die vom Objekt automatisch aufgerufen wird, bevor es zerstört wird. Aus diesem Grund verwenden wir die Destruktormethode im Objekt. Daher werden normalerweise Konstruktionsmethoden verwendet, um die Initialisierungsarbeiten einiger Objekte abzuschließen, und Destruktormethoden werden verwendet, um die Reinigungsarbeiten abzuschließen einiger Objekte vor der Zerstörung. 1. Konstruktor

In jeder deklarierten Klasse gibt es eine spezielle Member-Methode, die als Konstruktor bezeichnet wird explizit wird es in der Klasse standardmäßig einen Konstruktor ohne Parameterliste und leeren Inhalt geben. Wenn Sie es explizit deklarieren, ist der Standardkonstruktor in der Klasse nicht vorhanden. Wenn ein Objekt erstellt wird, wird die Konstruktormethode einmal automatisch aufgerufen. Das heißt, die Konstruktormethode wird jedes Mal automatisch aufgerufen, wenn das Schlüsselwort new zum Instanziieren des Objekts verwendet wird. Die Konstruktormethode kann nicht aktiv über einen Verweis auf das Objekt aufgerufen werden . Daher werden Konstruktoren normalerweise zum Ausführen einiger nützlicher Initialisierungsaufgaben verwendet, z. B. zum Zuweisen von Anfangswerten zu Elementeigenschaften beim Erstellen von Objekten. In früheren Versionen von PHP5 muss der Methodenname des Konstruktors mit dem Klassennamen identisch sein. Diese Methode kann weiterhin in PHP 5 verwendet werden. In PHP ist es jedoch selten, einen Konstruktor mit demselben Namen wie den Klassennamen zu deklarieren. Der Vorteil besteht darin, dass der Konstruktor unabhängig vom Klassennamen erstellt werden kann entsprechender Konstruktorname. Aus Gründen der Abwärtskompatibilität sucht PHP beim Erstellen eines Objekts, wenn es in einer Klasse keinen Konstruktor namens „construct()“ gibt, nach

In PHP kann nur ein Konstruktor in derselben Klasse deklariert werden. Der Grund dafür ist, dass der Name der Konstruktormethode festgelegt ist und zwei Funktionen mit demselben Namen nicht in PHP deklariert werden können, sodass es keine Überladung der Konstruktor--Methode

function construct( [参数列表] ){ //构造方法名称是以两个下划线开始的
    //方法体，通常用来对成员属性进行初始化赋值}

Programmiersprachen zu erreichen. Auf diese Weise werden beim Erstellen eines Objekts Standardparameter zum Initialisieren der Elementeigenschaften verwendet, wenn im Konstruktor keine Parameter übergeben werden. Der Konstruktor kann Parameter akzeptieren und beim Erstellen eines Objekts Objekteigenschaften zugewiesen werden

• Der Konstruktor kann Klassenmethoden oder andere Funktionen aufrufen

• Der Konstruktor kann den Konstruktor anderer Klassen aufrufen

Beispiel für die Verwendung des Konstruktors:

• 
  
  

  Rufen Sie den Konstruktor der übergeordneten Klasse auf , Rufen Sie den Konstruktor nicht verwandter Klassen auf:

<?phpclass Person{
    private $name;    
    private $age;    
    private $gender;    
    public function construct($name,$age,$gender){
        $this->setName($name);   //调用类方法
        $this->age = $age;        
        $this->setGender($gender);
    }    public function setName($name){
        $this->name = $name;
    }    // ... setter 方法}$person = new Person("yeoman",23,&#39;男&#39;);?>

function construct(){
    parent::construct(); // 调用父类的构造函数必须显示的使用parent调用父类构造函数
    classname::construct(); // 调用其他类的构造函数，classname是类名
    //其他操作}

Der Konstruktor einer Unterklasse in PHP ruft die übergeordnete Klasse nicht aktiv auf Der anzuzeigende Konstruktor wird mit parent::construct() aufgerufen: Wenn es sich um eine mehrstufige Vererbung handelt, erfolgt die Suche beim Aufruf von parent::construct() aufwärts entlang der übergeordneten Klasse bis Finden Sie den am besten geeigneten Konstruktor, zum Beispiel:

<?php
class Animal{
    private $name;    
    function construct($name){
        $this->setName($name)        
        echo "动物类被创建！";
    }    // ... 其他方法}class Birds extends Animal{
    private $name;    
    private $leg;    
    function construct($name,$leg){
        parent::construct($name); // 显示调用
        $this->setLeg($leg);       
         echo "鸟类被创建！";
    }    // ... 其他方法}?>

// 接上例class Parrot extends Birds{
    private $name;    
    private $leg;    
    private $wing;    
    function construct($name){
        parent::construct($name); 
        // 此时没有找到父类（Birds类）合适的构造函数，只能向上搜索，搜索到Animal类时，才找到合适的构造函数
        echo "鹦鹉类被创建！";        
        $this->smackTalk();        
        /*
        输出结果：
        "动物类被创建！"
        "鹦鹉说话！"
        */
    }    function smackTalk(){
        echo "鹦鹉说话！";    
    }

}

function construct($name,$leg){
       Animal::construct($name); // 调用Animal构造函数
        Birds::construct($name,$leg); // 调用Birds构造函数}

Die Destruktormethode ermöglicht die Durchführung einiger spezifischer Operationen vor der Zerstörung eines Objekts, z Schließen der Datei, Freigeben des Ergebnissatzes usw. Wenn ein Objekt im Heap-Speichersegment die Referenz für den Zugriff verliert, kann nicht mehr darauf zugegriffen werden und es wird zu einem Müllobjekt. Normalerweise wird dem Verweis auf das Objekt ein anderer Wert zugewiesen oder das Objekt verliert seinen Verweis, wenn die Seite endet. Der Destruktor wird automatisch aufgerufen, wenn das Objekt zerstört wird, und kann nicht explizit aufgerufen werden. Der Destruktor kann keine Parameter annehmen.

Das Deklarationsformat der Destruktormethode ist wie folgt:

function deconstruct(){
    //方法体，通常用来完成一些在对象销毁前的清理任务}

Nachdem die PHP-Seite geladen wurde;

• unset() class;

• Variable
verweist auf ein anderes Objekt oder Wert;

• Der Speicherrecyclingmechanismus von PHP ist dem von JAVA sehr ähnlich. Objekte ohne Referenzen werden mithilfe der Referenzzählertechnologie zerstört und recycelt.

• Beispiel:

  <?php
  class test{
      function destruct(){
          echo "当对象销毁时会调用！！！";
      }
  
  }$a = $b = $c = new test();$a = null;unset($b);echo "<hr />";?>

  Nach dem Login kopieren

  　　此例子，如下图，有三个变量引用$a,$b,$c指向test对象，test对象就有3个引用计数，当$a = null时，$a对test对象的引用丢失，计数-1，变为2，当$b被unset()时，$b对test对象的引用也丢失了，计数再-1，变为1，最后页面加载完毕，$c指向test对象的引用自动被释放，此时计数再-1，变为0，test对象已没有变量引用，就会被销毁，此时就会调用析构函数。
  

  在PHP中析构方法并不是很常用，它属于类中可选的一部分，只有需要时才在类中声明。

  <?phpclass Person{
      var $name;    
      var $sex;    
      var $age;    
      function construct($name, $sex, $age){
          $this->name = $name;        
          $this->sex = $sex;       
           $this->age = $age;  
      }    
      function destruct(){
          echo "再见" . $this->name . "<br />";    
      }
  }
  $person1 = new Person("张三三", "男", 23);
  $person1 = null;   //第一个对象将失去引用
  $person2 = new Person("李四四", "女", 17);
  $person3 = new Person("王五五", "男", 43);
  ?>

  Nach dem Login kopieren

  运行结果：

  再见张三三
  再见王五五
  再见李四四

  Nach dem Login kopieren

  　　第一个对象在声明完成以后，它的引用就被赋予了空值，所以第一个对象最先失去的引用，不能再被访问了，人后自动调用第一个对象中的析构方法输出“再见张三三”。后面声明的两个对象都是在页面执行结束时失去的引用，也都自动调用了析构方法。但因为对象的引用都是放在栈内存中的，由于栈的后进先出特点，最后创建的对象会被最先释放，多以先自动调用第三个对象的析构方法，最后才调用第二个对象的析构方法。

  Das obige ist der detaillierte Inhalt vonPHP-objektorientierter Code-Case-Sharing von Konstruktor- und Destruktormethoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!