Méthode Constructeur et Méthode Destructeur sont deux méthodes spéciales dans Object, elles sont toutes deux liées au cycle de vie de l'objet . La méthode constructeur est la première méthode automatiquement appelée par l'objet après la création de l'objet. C'est la raison pour laquelle nous utilisons la méthode constructeur dans l'objet. La méthode destructeur est la dernière méthode automatiquement appelée par l'objet avant qu'il ne soit détruit. C'est pourquoi nous utilisons la méthode destructeur dans l'objet. Par conséquent, les méthodes de construction sont généralement utilisées pour terminer les travaux d'initialisation de certains objets, et les méthodes de destructeurs sont utilisées pour terminer les travaux de nettoyage de certains objets avant leur destruction. 1. Constructeur
Dans chaque classe déclarée, il existe une méthode membre spéciale appelée constructeur S'il n'y en a pas Si vous le déclarez. explicitement, il y aura un constructeur sans liste de paramètres et avec un contenu vide dans la classe par défaut. Si vous le déclarez explicitement, le constructeur par défaut de la classe n'existera pas. Lorsqu'un objet est créé, la méthode constructeur sera automatiquement appelée une fois, c'est-à-dire que la méthode constructeur sera automatiquement appelée chaque fois que le mot-clé new est utilisé pour instancier l'objet. La méthode constructeur ne peut pas être appelée activement via une référence à l'objet. . Par conséquent, les constructeurs sont généralement utilisés pour effectuer certaines tâches d'initialisation utiles, telles que l'attribution de valeurs initiales aux propriétés des membres lors de la création d'objets. Dans les versions précédentes de PHP5, le nom de la méthode du constructeur doit être le même que le nom de la classe. Cette méthode peut toujours être utilisée en PHP 5. Mais en PHP, il est rare de déclarer un constructeur avec le même nom que le nom de la classe. L'avantage est que le constructeur peut être rendu indépendant du nom de la classe. Lorsque le nom de la classe change, il n'est pas nécessaire de le modifier. nom du constructeur correspondant. Pour des raisons de compatibilité ascendante, lors de la création d'un objet, s'il n'y a pas de constructeur nommé construct() dans une classe, PHP recherchera
un constructeur portant le même nom que le nom de la classe et l'exécutera. Le format pour déclarer un constructeur dans une classe est le suivant :
En PHP, un seul constructeur peut être déclaré dans la même classe. La raison en est que le nom de la méthode constructeur est fixe et que deux fonctions portant le même nom ne peuvent pas être déclarées en PHP, il n'y a donc pas de surcharge de la méthode constructeur
. Cependant, vous pouvez utiliser les paramètres par défaut lors de la déclaration du constructeur pour obtenir la fonction de surcharge du constructeur dans d'autres
function construct( [参数列表] ){ //构造方法名称是以两个下划线开始的
//方法体，通常用来对成员属性进行初始化赋值}Copier après la connexion
orientés objet
langages de programmation . De cette façon, lors de la création d'un objet, si aucun paramètre n'est passé dans le constructeur, les paramètres par défaut sont utilisés pour initialiser les propriétés des membres. Le constructeur peut accepter des paramètres et peut être affecté à des propriétés d'objet lors de la création d'un objet
<?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,'男');?>Copier après la connexion
Héritage
function construct(){
parent::construct(); // 调用父类的构造函数必须显示的使用parent调用父类构造函数
classname::construct(); // 调用其他类的构造函数，classname是类名
//其他操作}Copier après la connexion
et constructeur
Le constructeur d'une sous-classe en PHP n'appellera pas activement la classe parent. le constructeur à afficher est appelé en utilisant parent::construct() : Si l'héritage multi-niveaux est impliqué, lorsque parent::construct() est appelé, la recherche se fera vers le haut le long de la classe parent jusqu'à Trouver le constructeur le plus approprié, par exemple :
<?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 "鸟类被创建！";
} // ... 其他方法}?>Copier après la connexion
Si vous souhaitez appeler les constructeurs de plusieurs classes parents en séquence, vous pouvez utiliser le nom de la classe pour appeler directement le constructeur, par exemple :
// 接上例class Parrot extends Birds{
private $name;
private $leg;
private $wing;
function construct($name){
parent::construct($name);
// 此时没有找到父类（Birds类）合适的构造函数，只能向上搜索，搜索到Animal类时，才找到合适的构造函数
echo "鹦鹉类被创建！";
$this->smackTalk();
/*
输出结果：
"动物类被创建！"
"鹦鹉说话！"
*/
} function smackTalk(){
echo "鹦鹉说话！";
}
}Copier après la connexion
2.
function construct($name,$leg){
Animal::construct($name); // 调用Animal构造函数
Birds::construct($name,$leg); // 调用Birds构造函数}Copier après la connexion
Destructeur
La méthode destructeur permet d'effectuer certaines opérations spécifiques avant de détruire un objet, comme fermer le fichier, libérer l'ensemble de résultats, etc. Lorsqu'un objet dans le segment de mémoire tas perd la référence pour y accéder, il n'est plus accessible et devient un objet poubelle. Habituellement, la référence à un objet se voit attribuer une autre valeur ou l'objet perd sa référence à la fin de la page. Le destructeur est automatiquement appelé lors de la destruction de l'objet et ne peut pas être appelé explicitement. Le destructeur ne peut pas prendre de paramètres.
Le format de déclaration de la méthode destructeur est le suivant :
Le destructeur peut être appelé (mais pas nécessairement) dans les situations suivantes :
function deconstruct(){
//方法体，通常用来完成一些在对象销毁前的清理任务}Copier après la connexion
Une fois la page PHP chargée ;
classe unset()
- Variable
fait référence à un autre objet ; ou valeur ; Le mécanisme de recyclage de la mémoire de PHP est très similaire à celui de JAVA. Les objets sans aucune référence sont détruits et recyclés à l'aide de la technologie du compteur de références.
Exemple :
<?php
class test{
function destruct(){
echo "当对象销毁时会调用！！！";
}
}$a = $b = $c = new test();$a = null;unset($b);echo "<hr />";?>Copier après la connexion
此例子，如下图，有三个变量引用$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);
?>Copier après la connexion
运行结果：
再见张三三
再见王五五
再见李四四
Copier après la connexion
第一个对象在声明完成以后，它的引用就被赋予了空值，所以第一个对象最先失去的引用，不能再被访问了，人后自动调用第一个对象中的析构方法输出“再见张三三”。后面声明的两个对象都是在页面执行结束时失去的引用，也都自动调用了析构方法。但因为对象的引用都是放在栈内存中的，由于栈的后进先出特点，最后创建的对象会被最先释放，多以先自动调用第三个对象的析构方法，最后才调用第二个对象的析构方法。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
