Explication détaillée de la surcharge des nouvelles instances de méthode en PHP orienté objet

Lors de l'apprentissage de PHP, vous constaterez que les méthodes en PHP ne peuvent pas être surchargées La soi-disant surcharge de méthodes consiste à définir le même nom de méthode par " Le nombre de paramètres ou. les types de paramètres sont différents pour accéder à différentes méthodes avec le même nom de méthode.

12. Surcharger de nouvelles méthodes
Lors de l'apprentissage de PHP, vous constaterez que les méthodes en PHP ne peuvent pas être surchargées. Ce qu'on appelle la surcharge de méthode est
Définissez le même nom de méthode. , et accédez à différentes méthodes avec le même
nom en utilisant différents "nombres de paramètres" ou différents "types de paramètres". Cependant, comme PHP est un langage faiblement typé, il peut recevoir différents types de données dans les paramètres de la méthode elle-même. Et comme la méthode PHP peut recevoir un nombre indéfini de paramètres, elle peut être appelée en passant différents nombres de paramètres. 🎜>Différentes méthodes avec des noms de méthode différents ne sont pas non plus valides. Il n’y a donc pas de surcharge de méthode en PHP. Il ne peut pas être surchargé, ce qui signifie que les méthodes portant le même nom de méthode ne peuvent pas être définies dans
votre projet. De plus, comme PHP n'a pas de concept de sous-espace de nom, les méthodes portant le même nom ne peuvent pas être définies sur la même page
et les pages incluses, ni être définies avec le même nom que la méthode fournie par PHP, de course
Les méthodes portant le même nom ne peuvent pas être définies dans la même classe.
Qu'entendons-nous par surcharger de nouvelles méthodes ici ? En fait, ce que nous appelons surcharger une nouvelle méthode, c'est que la sous-classe
remplace la méthode existante de la classe parent, alors pourquoi faisons-nous cela ? Les méthodes de la classe parent ne peuvent-elles pas être héritées et utilisées directement ? Mais
il y a certaines situations que nous devons couvrir. Par exemple, dans l'exemple que nous avons mentionné plus tôt, l'être humain "Person"
a une méthode "speak", et tous ceux qui héritent de la classe "Person" Tous. les sous-classes peuvent « parler ». Notre classe « Student »
est une sous-classe de la classe « Person », donc les instances de « Student » peuvent « parler », mais les humains « parlent
mots » La méthode parle du
mots. 🎜>attributs
dans la classe "Person", et la classe "Student" étend la classe "Person" et étend plusieurs nouveaux attributs Si Si vous utilisez la méthode de parole héritée "say()", vous ne pouvez prononcer que ceux-là. attributs hérités de la classe "Person", alors les attributs nouvellement étendus utilisent ce "say()" hérité Je ne peux pas décrire la méthode, donc certaines personnes ont demandé si je définissais une nouvelle méthode dans le Sous-classe « Étudiant » pour
parler, ne suffirait-il pas de nommer tous les attributs de la sous-classe ? Assurez-vous de ne pas faire cela. D'un point de vue abstrait, un « étudiant » ne peut pas avoir deux manières de « parler ». Même si vous définissez deux méthodes de parole différentes, vous pouvez réaliser ce que vous voulez
Fonction, l'héritage " talk" ne peut plus être utilisée et vous ne pouvez pas la supprimer même si elle est héritée.
Pour le moment, nous utiliserons la superposition.
Bien que les méthodes du même nom ne puissent pas être définies en PHP, dans les deux classes avec une relation parent-enfant, nous pouvons définir des méthodes du même nom que la classe parent dans la sous-classe
, afin que les méthodes héritées de la classe parent La méthode est remplacée.
Extrait de code


Le code est le suivant :

Dans l'exemple ci-dessus, nous remplaçons le "say()" dans la classe parent héritée dans le " Méthode "sous-classe" étudiante, en la recouvrant de

on peut étendre la "méthode".

Cependant, bien que cela résolve le problème que nous avons mentionné ci-dessus, dans le développement réel, une méthode ne peut pas

<?php 
//定义一个“人”类做为父类 
class Person{ 
//下面是人的成员属性 
var $name; //人的名子 
var $sex; //人的性别 
var $age; //人的年龄 
//定义一个
构造方法
参数为属性姓名$name、性别$sex和年龄$age进行赋值 
function construct($name, $sex, $age){ 
$this->name=$name; 
$this->sex=$sex; 
$this->age=$age; 
} 
//这个人可以说话的方法, 说出自己的属性 
function say() { 
echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."<br>"; 
} 
} 
class Student 
extends
 Person 
{ 
var $school; //学生所在学校的属性 
//这个学生学习的方法 
function study() { 
echo "我的名子叫：".$this->name." 我正在”.$this->school.”学习<br>"; 
} 
//这个学性可以说话的方法, 说出自己所有的属性，覆盖了父类的同名方法 
function say() { 
echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."我在 
".$this->school."上学.<br>"; 
} 
} 
?>

consister en un seul code ou plusieurs codes, comme "say(" dans la classe "Person")" a 100 lignes de code dedans. Par exemple

si nous voulons écraser cette méthode et conserver les fonctions d'origine et ajouter un peu de fonctionnalités, nous devons réécrire les 100 lignes de code d'origine
une fois et ajouter les plusieurs. les lignes de code étendues ci-dessus sont plutôt bonnes, mais dans certains cas, les méthodes de la classe parent ne peuvent pas voir le code original
Comment réécrire le code original à ce moment-là ? Nous avons également une solution, c'est-à-dire que dans la méthode de sous-classe, vous pouvez
appeler la méthode surchargée dans la classe parent, c'est-à-dire prendre les fonctions originales de la méthode surchargée et ajouter votre propre
Fonction, vous pouvez utilisez deux méthodes pour appeler la méthode surchargée de la classe parent dans la méthode de la sous-classe :
L'une consiste à utiliser le "nom de classe ::" de la classe parent pour appeler la méthode surchargée de la classe parent
 ; La première consiste à utiliser la méthode "parent::" pour appeler la méthode remplacée dans la classe parent
Extrait de code


Le code est le suivant :

Vous pouvez désormais accéder aux méthodes remplacées dans la classe parent de deux manières. Quelle méthode devrions-nous choisir le mieux ? Les utilisateurs peuvent

class Student extends Person{ 
var $school; //学生所在学校的属性 
//这个学生学习的方法 
function study() { 
echo "我的名子叫：".$this->name." 我正在”.$this->school.”学习<br>"; 
} 
//这个学性可以说话的方法, 说出自己所有的属性，覆盖了父类的同名方法 
function say() { 
//使用父类的“类名：：“来调用父类中被覆盖的方法； 
// Person::say(); 
//或者使用“parent：：”的方试来调用父类中被覆盖的方法； 
parent::say(); 
//加上一点自己的功能 
echo “我的年龄是：".$this->age."我在".$this->school."上学.<br>"; 
} 
}

会发现自己写的代码访问了父类的变量和函数。如果子类非常精炼或者父类非常专业化的时
候尤其是这样。不要用代码中父类文字上的名字，应该用特殊的名字parent，它指的就是子
类在extends 声明中所指的父类的名字。这样做可以避免在多个地方使用父类的名字。如果继
承树在实现的过程中要修改，只要简单地修改类中extends 声明的部分。
同样，构造方法在子类中如果没有声明的话，也可以使用父类中的构造方法，如果子类
中重新定义了一个构造方法也会覆盖掉父类中的构造方法，如果想使用新的构造方法为所有
属性赋值也可以用同样的方式。
代码片段

代码如下:

class Student extends Person{ 
var $school; //学生所在学校的属性 
function construct($name, $sex, $age, $school){ 
//使用父类中的方法为原有的属性赋值 
parent::construct($name, $sex, $age); 
$this->school=$school; 
} 
//这个学生学习的方法 
function study() { 
echo "我的名子叫：".$this->name." 我正在”.$this->school.”学习<br>"; 
} 
//这个人可以说话的方法, 说出自己的属性 
function say() { 
parent::say(); 
//加上一点自己的功能 
echo “我的年龄是：".$this->age."我在".$this->school."上学.<br>";

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!