Héritage orienté objet en PHP

Objectifs de cet article :

1. Comprendre la définition de l'héritage

2. Maîtriser les bienfaits de l'héritage

(1) Définition

 

Regardons attentivement l'image ci-dessus, puis faisons une chose pour découvrir ce qu'ils ont en commun

Terrain commun :

1. Ils ont tous certains des mêmes attributs et méthodes

2. Ce sont tous des êtres humains

Suivent la définition des classes normales, si nous voulons l'implémenter. les deux classes ci-dessus, nous devons les définir séparément Tous les attributs et méthodes de la classe de joueur NBA, puis lors de la définition de la classe d'ancrage féminine, vous devez écrire des attributs répétés tels que le nom, la taille, le poids et les méthodes d'alimentation s'il y en a. une autre classe appelée étudiant, cela signifie que ces attributs communs et ces méthodes communes doivent être réécrits, et ainsi de suite, le code sera similaire à de nombreux endroits, ce qui augmente la redondance du code, donc afin de résoudre cette redondance, afin de rendre le code plus concis et réutilisable. Élevé, nous pouvons écrire ces attributs et méthodes communs ensemble, puis laisser chaque classe appeler cet attribut et cette méthode communs. Sera-t-il plus pratique à maintenir et le code sera-t-il plus concis ? Cette approche est appelée héritage

Comment le faire spécifiquement, comme indiqué ci-dessous

 

Nous créons d'abord une classe "personne", laissons cette personne avoir toutes deux des attributs et des méthodes communes aux deux classes, et permettre aux joueurs de la NBA et aux présentatrices d'hériter de la classe "personne"

La classe héritée est appelée une classe parent, telle qu'une personne, et la classe héritée est appelée une sous-classe

Résumé : Qu'est-ce que l'héritage ? L'héritage est une méthode pour améliorer la réutilisabilité du code et réduire la redondance du code, comme l'hérédité dans la vraie vie. Les enfants hériteront d'une partie des gènes de leurs parents, ainsi, à votre naissance, vous aurez les attributs et les comportements communs des humains

(2) Avantages de l'héritage

1 Améliorer le code. réutilisabilité et économisez du temps et des coûts de programmation

Les attributs et méthodes définis dans la classe parent ne nécessitent pas de sous-classes. Si la définition est répétée dans une classe, tant que la sous-classe hérite de la classe parent, elle aura tous les attributs et méthodes dans la classe parent

2. Toutes les sous-classes d'une même classe parent peuvent être traitées de la même manière lorsqu'elles sont appelées

Par exemple, qu'il s'agisse d'un joueur de la NBA ou d'une présentatrice féminine, car elles sont tous des êtres humains, lorsque nous les appelons, nous pouvons appeler directement la méthode de la classe parent, comme manger, que la classe soit un joueur de la NBA ou une présentatrice féminine

3. ajuster les membres de la classe définis par la classe parent

a. Nous l'appelons Overwrite

b Une fois la sous-classe modifiée, exécuter selon la méthode définie par la sous-classe

. Cela équivaut à une mutation

Pour apprendre quelque chose, il faut non seulement connaître sa théorie, mais aussi avoir une pratique théorique pertinente. En fait, toutes les théories sont dérivées de la pratique, donc parfois j'ai souligné cela à plusieurs reprises. la théorie est très abstraite, chacun doit également la résumer après avoir acquis une certaine expérience pratique, et résumer une "théorie" concise et facile à comprendre. Une fois cette habitude cultivée, je pense que tout le monde peut comprendre beaucoup de connaissances de manière plus approfondie, et en même temps, il est plus facile de saisir l'essence des choses, de sorte que la capacité d'analyse des problèmes sera également améliorée.

D'accord, puisque nous devons combiner théorie et pratique, alors faisons une démonstration pratique à travers le code pour voir comment l'héritage est implémenté dans le code

( 3) Code spécifique

<?php
/***
 * 案例目标
 * 1.掌握继承的定义
   2.掌握继承的好处
 */
 //定义一个“人”类
class Human{
    public $name = "";//姓名
    public $height = "";//身高
    public $weight = "";//体重

    public function eat($food){
        echo $this->name."在吃".$food."<br/>";
    }
}
//女主播
class Anchors extends Human{
    public $name = "";
    public $stageName = "";
    public function __construct( $name,$stageName ){
        $this->name = $name;
        $this->stageName = $stageName;
    }
    public function singing(){
        echo "我是女主播，我会唱歌<br/>";
    }
    //重写方法eat
    public function  eat($food){
        echo "我是女主播，我是边唱歌边吃{$food}<br/>";
    }
}
//Nba球员类
 class NbaPlayer extends Human{
   //因为父类已经有了，所以就不需要再写了，通过extends来实现
    // public $name  = "";//姓名
    // public $height = "";//身高
    // public $weight = "";//体重

    public $team = "";//团队
    public $playerName = "";//球员号码

    public function __construct( $name,$height,$weight,$team,$playerName ){
        $this->name = $name;
        $this->height=$height;
        $this->weight = $weight;
        $this->team = $team;
        $this->playName = $playerName;
        echo "构造函数执行了,当前对象是{$this->name}<br/>";
    }
    
   
   //跑步
    public function run(){
        echo "跑步中<br/>";
    }
    //跳跃
    public function jump(){
        echo "跳跃<br/>";
    }
    //运球
    public function dribble(){
        echo "运球<br/>";
    } 
    //传球
    public function pass(){
        echo "传球<br/>";
    }
    //投篮
    public function shoot(){
        echo "投篮<br/>";
    }
    //扣篮
    public function dunk(){
        echo "扣篮<br/>";
    }
    //重写方法eat ，只要名称和父类一样就是代表重写了不一定参数也要保持一样
    public function eat($food){
        echo "我是Nba球员，我是站着吃饭，边吃{$food}边看球赛<br/>";
    }
 }
 //测试，NBA球员，没有直接定义name，身高，体重，现在输出一下看结果有没有
 //创建乔丹对象
 $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
 //输出乔丹对象
 echo "名称= ".$jordon->name."<br/>";

 //测试，NBA球员，没有直接定义eat方法，现在输出一下看结果有没有
 echo $jordon->eat("苹果");
 //证明第二个好处，只要是个人就可以调用它的eat方法
 $linda = new Anchors("琳达","LD");
 echo $linda->eat("苹果");
 //测试第三个好处是否真实
 //思路1.为女主播和NBA球员2个类分别重写eat方法
//    2.再次执行2个对象的eat方法
//  会发现一旦子类重写了父类的方法，那么就会调用子类自己的方法了,这里就大家自己写下，因为上面我已经调用了eat方法，一旦重写了，上面的结果会变

?>

Grâce à la démonstration du code ci-dessus, nous résumons :

1. extends est l'héritage Grâce à ce mot-clé, la sous-classe peut hériter de la classe parent, partageant tous les attributs. et méthodes de la classe parent

2. Autres fonctionnalités du code hérité :

● Il est également accessible directement via $this-> dans le constructeur de sous-classe

weight En PHP, une seule classe peut être héritée après l'extension, et ne peut pas être utilisée pour hériter de plusieurs classes, sinon une erreur sera signalée

Résumé :

Cet article dans En fait, il n'y a que deux objectifs. Connaître la définition et les avantages de l'héritage. Enfin, nous pensons avoir une compréhension plus profonde des avantages de l'héritage grâce au code

.

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!