Detaillierte Erläuterung der Instanzverwendung der drei Schlüsselwörter this, self und parent in PHP

Lassen Sie uns zunächst die oben genannten drei Schlüsselwörter verstehen: Dies, Selbst, Eltern, was wörtlich leichter zu verstehen ist, bezieht sich auf Dies, Selbst, Vater, haha, es macht mehr Spaß, lassen Sie uns zunächst ein paar Konzepte festlegen , Wo werden diese drei Schlüsselwörter verwendet? Lassen Sie uns kurz erklären, dass dies ein Zeiger auf das aktuelle Objekt ist (sehen wir uns den Zeiger in C an), self ein Zeiger auf die aktuelle Klasse und parent ein Zeiger auf das übergeordnete Objekt ist . Zeiger auf die Klasse. Wir verwenden hier häufig Hinweise, um es zu beschreiben, weil es keine bessere Sprache gibt, um es auszudrücken. Haha, ich habe Chinesisch nicht gut gelernt. -_-#

Es ist noch nicht ganz klar, also lasst uns anhand konkreter Beispiele darüber sprechen.
(1) Dies

Der Code lautet wie folgt:

<?php  
 class UserName  
 {   
     //定义属性      
     private $name;  
     //定义
构造函数
  
     function construct( $name )  
     {  
          $this->name = $name; //这里已经使用了this指针  
     }  
     //
析构函数
  
     function destruct(){}  
     //打印用户名成员函数  
     function printName()  
     {  
          print( $this->name ); //又使用了this指针  
     }  
 }  
 //实例化对象  
 $nameObject = new UserName( "heiyeluren" );  
 //执行打印  
 $nameObject->printName(); //输出: heiyeluren  
 //第二次实例化对象  
 $nameObject = new UserName( "PHP" );  
 //执行打印  
 $nameObject->printName(); //输出：PHP  
 ?>

Wir sehen, dass die obige Klasse diesen Zeiger dann jeweils in Zeile und Zeile verwendet An wen ist es gerichtet? Tatsächlich bestimmt dies, auf wen es zeigt, wenn es instanziiert wird. Wenn das Objekt beispielsweise zum ersten Mal instanziiert wird (Zeile), zeigt es auf $nameObjektobjekt und dann beim Drucken der Zeile , Ändern Sie print( $this->name ), dann wird natürlich „heiyeluren“ ausgegeben. Im zweiten Fall wird print( $this->name ) zu print( $nameObject->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)self
Zunächst müssen wir klarstellen, dass self auf die Klasse selbst verweist, das heißt, self zeigt nicht auf ein instanziiertes Objekt. Im Allgemeinen wird self verwendet, um auf statische Variablen zu verweisen in der Klasse.

Der Code lautet wie folgt:

<?php  
     class Counter  
     {  
         //定义属性，包括一个静态变量  
         private static $firstCount = ;  
         private $lastCount;  
         //构造函数  
         function construct()  
         {  
              $this->lastCount = ++selft::$firstCount; //使用self来调用静态变量,使用self调用必须使用::(域
运算符
号)  
         }  
         //打印最次数值  
         function printLastCount()  
         {  
              print( $this->lastCount );  
         }   
     }  
 //实例化对象  
 $countObject = new Counter();  
 $countObject->printLastCount(); //输出   
 ?>

Wir müssen hier nur auf zwei Stellen achten, die erste und die zweite Zeile. Wir haben in der zweiten Zeile eine statische Variable $firstCount mit dem Anfangswert „Operator“ definiert. Was wir dann zu diesem Zeitpunkt aufrufen, ist die von der Klasse selbst definierte statische Variable „$frestCount“. Unsere statische Variable hat nichts mit der Instanz von zu tun Das folgende Objekt bezieht sich nur auf die Klasse. Wenn ich dann die Klasse selbst aufrufe, können wir dies nicht als Referenz verwenden. Sie können self als Referenz verwenden, da self auf die Klasse selbst verweist und nichts mit einer Objektinstanz zu tun hat . Mit anderen Worten: Wenn unsere Klasse statische Mitglieder hat, müssen wir sie auch mit self aufrufen.
(3)parent
Wir wissen, dass parent ein Zeiger auf die übergeordnete Klasse ist. Im Allgemeinen verwenden wir parent, um den Konstruktor der übergeordneten Klasse aufzurufen.

Der Code lautet wie folgt:

<?php  
 //基类  
 class Animal  
 {  
     //基类的属性  
     public $name; //名字  
     //基类的构造函数  
     public function construct( $name )  
     {  
          $this->name = $name;  
     }  
 }  
 //派生类  
 class Person extends Animal //Person类继承了Animal类  
 {  
     public $personSex; //性别  
     public $personAge; //年龄  
     //继承类的构造函数  
     function construct( $personSex, $personAge )  
     {  
          parent::construct( "heiyeluren" ); //使用parent调用了父类的构造函数  
          $this->personSex = $personSex;  
          $this->personAge = $personAge;  
     }  
     function printPerson()  
     {  
          print( $this->name. " is " .$this->personSex. ",this year " .$this->personAge );  
      }  
 }  
 //实例化Person对象  
 $personObject = new Person( "male", "");  
 //执行打印  
 $personObject->printPerson(); //输出：heiyeluren is male,this year   
 ?>

Wir achten auf diese Details: Mitgliedsattribute sind alle öffentlich, insbesondere die der übergeordneten Klasse, damit geerbte Klassen darauf zugreifen können Das . Wir achten auf den Schlüsselpunkt: parent::construct( "heiyeluren"). Zu diesem Zeitpunkt verwenden wir parent, um den Konstruktor der übergeordneten Klasse aufzurufen, um die übergeordnete Klasse zu initialisieren, da alle Mitglieder der übergeordneten Klasse vorhanden sind öffentlich, also können wir dies direkt verwenden, um die geerbte Klasse aufzurufen.
Zusammenfassung:
Dies ist ein Zeiger auf eine Objektinstanz, self ist ein Verweis auf die Klasse selbst und parent ist ein Verweis auf die übergeordnete Klasse.

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