Le mot-clé parent::

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy — leçon 22 sur 91.

Lorsqu'une classe enfant hérite d'un parent, vous avez parfois besoin d'accéder directement aux méthodes ou aux propriétés du parent. Le mot-clé parent:: vous permet d'appeler l'implémentation de la classe parente depuis la classe enfant.

Ceci est particulièrement utile dans les constructeurs lorsque l'enfant doit initialiser les propriétés du parent tout en configurant les siennes :

<?php
class Animal {
    public $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
}

class Dog extends Animal {
    public $breed;
    
    public function __construct($name, $breed) {
        parent::__construct($name);
        $this->breed = $breed;
    }
    
    public function describe() {
        return "$this->name is a $this->breed";
    }
}

$dog = new Dog("Max", "Labrador");
echo $dog->describe();

Sortie :

Max is a Labrador

En appelant parent::__construct($name), la classe enfant réutilise la logique d'initialisation du parent au lieu de la dupliquer. Sans cet appel, la propriété $name ne serait jamais définie.

Vous pouvez utiliser parent:: pour appeler n'importe quelle méthode parente, pas seulement les constructeurs. Cela devient particulièrement important lorsque vous souhaitez étendre le comportement d'une méthode plutôt que de la remplacer complètement.

Point clé : Le mot-clé parent:: fournit un moyen d'accéder à l'implémentation de la classe parente. Il est essentiel pour un chaînage correct des constructeurs et pour s'appuyer sur les fonctionnalités héritées plutôt que de les réécrire.

Défi

Facile

Construisons un système de catalogue de produits qui démontre comment les classes enfants peuvent étendre les fonctionnalités parentes en utilisant le mot-clé parent:: pour enchaîner correctement les constructeurs et s'appuyer sur les méthodes héritées.

Vous organiserez votre code sur trois fichiers :

Product.php — Définissez une classe Product qui sert de base à tous les produits. Elle doit avoir des propriétés publiques $name et $price. Le constructeur accepte un nom et un prix, en définissant les deux propriétés. Incluez une méthode getDetails() qui retourne "[name]: $[price]".
ElectronicProduct.php — Définissez une classe ElectronicProduct qui étend Product. Incluez le fichier Product en haut. Cette classe ajoute une propriété $warranty (en mois). Le constructeur doit accepter le nom, le prix et la garantie — utilisez parent::__construct() pour initialiser le nom et le prix via le parent, puis définissez la garantie vous-même. Créez une méthode getDetails() qui s'appuie sur l'implémentation du parent : appelez parent::getDetails() et ajoutez-y " (Warranty: [warranty] months)".
main.php — Incluez le fichier ElectronicProduct. Vous recevrez trois entrées : le nom du produit, le prix (sous forme de chaîne à convertir en flottant) et la période de garantie (sous forme de chaîne à convertir en entier). Créez un ElectronicProduct avec ces valeurs et affichez le résultat de l'appel à getDetails().

Ce défi montre la véritable puissance de parent:: — pas seulement pour l'enchaînement des constructeurs, mais aussi pour étendre le comportement des méthodes. Votre ElectronicProduct réutilise la logique de formatage du parent et ajoute ses propres détails par-dessus, évitant ainsi la duplication de code tout en créant une sortie plus riche.

Aide-mémoire

Le mot-clé parent:: permet à une classe enfant d'accéder aux méthodes et propriétés de sa classe parente.

Utilisez parent::__construct() pour appeler le constructeur du parent depuis la classe enfant :

<?php
class Animal {
    public $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
}

class Dog extends Animal {
    public $breed;
    
    public function __construct($name, $breed) {
        parent::__construct($name);
        $this->breed = $breed;
    }
}

Vous pouvez également utiliser parent:: pour appeler n'importe quelle méthode parente et étendre son comportement :

<?php
class Animal {
    public function describe() {
        return "This is an animal";
    }
}

class Dog extends Animal {
    public function describe() {
        return parent::describe() . " and it's a dog";
    }
}

Cette approche permet aux classes enfants de réutiliser la logique parente au lieu de dupliquer le code, permettant ainsi un chaînage correct des constructeurs et l'extension des méthodes.

Essayez vous-même

<?php
require_once 'ElectronicProduct.php';

// Lire les entrées
$name = trim(fgets(STDIN));
$price = floatval(trim(fgets(STDIN)));
$warranty = intval(trim(fgets(STDIN)));

// TODO: Créer un ElectronicProduct avec les valeurs d'entrée
// et afficher le résultat de l'appel à getDetails()

?>