Detaillierte Erklärung der Unterschiede und Verwendung der Schlüsselwörter this, self und parent in PHP

{一}Einer der Unterschiede zwischen diesem, selbst, übergeordneten PHP in diesem Artikel

Objektorientierte Programmierung (OOP, Object Oriented Programming) ist mittlerweile zu einer grundlegenden Fähigkeit geworden Programmierer. Die Verwendung von OOP-Ideen für die fortgeschrittene Programmierung von PHP ist für die Verbesserung der PHP-Programmierfunktionen und die Planung der Webentwicklungsarchitektur von großer Bedeutung.
Nach der Umschreibung hat PHP5 einen großen Sprung in der Unterstützung von OOP gemacht und ist zu einer Sprache mit den meisten Funktionen einer objektorientierten Sprache geworden. Sie verfügt über viel mehr objektorientierte Funktionen als PHP4. Worüber ich hier hauptsächlich spreche, ist der Unterschied zwischen den drei Schlüsselwörtern this, self und parent. Im wörtlichen Sinne beziehen sie sich auf mich selbst bzw. auf meinen Vater. Lassen Sie mich zunächst eine vorläufige Erklärung geben. Dies ist ein Zeiger auf das aktuelle Objekt (kann in C als Zeiger betrachtet werden), self ist ein Zeiger auf die aktuelle Klasse und parent ist ein Zeiger auf die übergeordnete Klasse. Wir verwenden hier häufig Zeiger zur Beschreibung, da es keine bessere Sprache gibt, um es auszudrücken. Bezüglich des Konzepts der Zeiger können Sie auf die Enzyklopädie verweisen.
Lassen Sie uns anhand konkreter Beispiele darüber sprechen.

Der Code lautet wie folgt:

<?php
  classname          //建立了一个名为name的类
 {
    private$name;         //定义属性，私有
    //定义
构造函数
，用于初始化赋值
    function construct( $name )
    {
         $this->name =$name;         //这里已经使用了this指针语句①
    }
    //
析构函数
    function destruct(){}
    //打印用户名成员函数
    function printname()
    {
         print( $this->name);             //再次使用了this指针语句②，也可以使用echo输出
    }
 }
 $obj1 = new name("PBPHome");   //实例化对象 语句③
 //执行打印
 $obj1->printname(); //输出:PBPHome
 echo"<br>";                                    //输出：回车
 //第二次实例化对象
 $obj2 = new name( "PHP" );
 //执行打印
 $obj2->printname();                         //输出：PHP
 ?>

Erklärung: Die obige Klasse verwendet diesen Zeiger in Anweisung ① und Anweisung ② bzw. Auf wen zeigte das damals? Tatsächlich bestimmt dies, auf wen es bei der Instanziierung zeigt. Wenn das Objekt zum ersten Mal instanziiert wird (Anweisung ③), zeigt dies dann auf das Objekt $obj1, wenn die Ausgabe von Anweisung ② ausgeführt wird , print( $this- >name ), dann wird natürlich „PBPHome“ ausgegeben. Im zweiten Fall wird print($this->name) zu print($obj2->name), sodass „PHP“ ausgegeben wird. Daher ist dies ein Zeiger auf die aktuelle Objektinstanz und zeigt nicht auf ein anderes Objekt oder eine andere Klasse.

{2} Der Unterschied zwischen this, self und parent in PHP Teil 2 self

In diesem Artikel erklären wir die Verwendung von self
Zuerst müssen wir es klarstellen Dieses Selbst bezieht sich auf die Klasse selbst, das heißt, Selbst zeigt nicht auf ein instanziiertes Objekt. Im Allgemeinen wird Selbst verwendet, um auf statische Variablen in der Klasse zu verweisen. Wenn wir statische Mitglieder in der Klasse verwenden (normalerweise mit dem Schlüsselwort static), müssen wir zum Aufrufen auch self verwenden. Beachten Sie außerdem, dass bei Verwendung von self zum Aufrufen statischer Variablen Folgendes verwendet werden muss: (Feld Operator Nummer), siehe Beispiel.

Der Code lautet wie folgt:

<?php
    classcounter     //定义一个counter的类
    {
        //定义属性，包括一个静态变量$firstCount，并赋初值0 语句①  
        private static $firstCount = 0;
        private $lastCount;
        //构造函数
        function construct()
        {
             $this->lastCount =++self::$firstCount;      //使用self来调用静态变量 语句②
        }
        //打印lastCount数值
        function printLastCount()
        {
             print( $this->lastCount );
        }
    }
  //实例化对象
  $obj = new Counter();
 $obj->printLastCount();                             //执行到这里的时候，程序输出1
 ?>

Es gibt zwei Stellen, auf die man achten muss: Aussage ① und Aussage ②. Wir haben in Anweisung ① eine statische Variable $firstCount definiert und dann self verwendet, um diesen Wert in Anweisung ② aufzurufen. Dann rufen wir zu diesem Zeitpunkt die von der Klasse selbst definierte statische Variable $frestCount auf. Unsere statische Variable hat nichts mit der Instanz des folgenden Objekts zu tun, sie bezieht sich nur auf die Klasse. Wenn ich dann die Klasse selbst aufrufe, können wir dies nicht verwenden, um auf sie zu verweisen, da self auf die Klasse selbst verweist hat nichts mit einer Objektinstanz zu tun. Dann ruft das zuvor verwendete this das instanziierte Objekt $obj auf, also lassen Sie sich nicht verwirren.
Das ist es für mich selbst. Mit Beispielen ist es einfacher zu verstehen. Das Ende des zweiten Kapitels.

{3} Der Unterschied zwischen this, self und parent in PHP Teil 3 parent

In diesem Artikel erklären wir die Verwendung von parent.
Zunächst machen wir deutlich, dass parent ein Zeiger auf die übergeordnete Klasse ist. Im Allgemeinen verwenden wir parent, um den Konstruktor der übergeordneten Klasse aufzurufen. Das Beispiel lautet wie folgt:

Der Code lautet wie folgt:

<?php
 //建立基类Animal
 class Animal
 {
    public $name; //基类的属性，名字$name
    //基类的构造函数，初始化赋值
    public function construct( $name )
    {
         $this->name = $name;
    }
 }
 //定义派生类Person 继承自Animal类
 class Person extends Animal
 {
    public$personSex;       //对于派生类，新定义了属性$personSex性别、$personAge年龄
    public $personAge;
    //派生类的构造函数
    function construct( $personSex, $personAge )
    {
         parent::construct( "PBPHome");    //使用parent调用了父类的构造函数 语句①
         $this->personSex = $personSex;
         $this->personAge = $personAge;
    }
    //派生类的成员函数，用于打印，格式：名字 is name,age is 年龄
    function printPerson()
    {
         print( $this->name. " is ".$this->personSex. ",age is ".$this->personAge );
     }
 }
 //实例化Person对象
 $personObject = new Person( "male", "21");
 //执行打印
 $personObject->printPerson();//输出结果：PBPHome is male,age is 21
 ?>

, der auch die Verwendung davon enthält, Sie können ihn selbst analysieren. Wir achten auf dieses Detail: Die Mitgliedsattribute sind alle öffentlich (öffentliche -Attribute und -Methoden , auf die Code innerhalb und außerhalb der Klasse zugreifen kann), insbesondere die der übergeordneten Klasse. Dies ist für den Zugriff durch geerbte Klassen vorgesehen Dies. Der entscheidende Punkt ist Anweisung ①: parent::construct("heiyeluren"). Zu diesem Zeitpunkt verwenden wir parent, um den Konstruktor der übergeordneten Klasse aufzurufen. Auf diese Weise werden die Objekte der geerbten Klasse zugewiesen der Name PBPHome. Wir können es testen, indem wir ein anderes Objekt $personObject1 instanziieren. Nach dem Drucken lautet der Name immer noch PBPHome.
Zusammenfassung: Dies ist ein Zeiger auf eine Objektinstanz, der beim Instanziieren bestimmt wird; self ist ein Verweis auf die Klasse selbst, der im Allgemeinen verwendet wird, um auf statische Variablen in der übergeordneten Klasse zu verweisen , parent wird verwendet, um den Konstruktor der übergeordneten Klasse aufzurufen.

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung der Unterschiede und Verwendung der Schlüsselwörter this, self und parent in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!