Redéfinition de méthode

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

Parfois, la méthode héritée d'une classe parente ne correspond pas tout à fait aux besoins de la classe enfant. La redéfinition de méthode (method overriding) permet à une classe enfant de fournir sa propre implémentation d'une méthode qui existe déjà dans la classe parente.

Pour redéfinir une méthode, définissez simplement une méthode dans la classe enfant portant le même nom que la méthode de la classe parente :

<?php
class Animal {
    public $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
    
    public function speak() {
        return "$this->name makes a sound";
    }
}

class Cat extends Animal {
    public function speak() {
        return "$this->name says meow";
    }
}

$cat = new Cat("Whiskers");
echo $cat->speak();

Résultat :

Whiskers says meow

La classe Cat remplace complètement la méthode speak() du parent par sa propre version. Lorsque vous appelez speak() sur un objet chat, PHP utilise l'implémentation de la classe enfant.

Vous pouvez également étendre le comportement du parent en combinant parent:: avec votre propre logique :

<?php
class Dog extends Animal {
    public function speak() {
        return parent::speak() . " - woof woof!";
    }
}

$dog = new Dog("Rex");
echo $dog->speak();

Résultat :

Rex makes a sound - woof woof!

Point clé : La redéfinition de méthode (method overriding) permet aux classes enfants de personnaliser le comportement hérité. Vous pouvez remplacer complètement une méthode ou utiliser parent:: pour enrichir l'implémentation d'origine.

Défi

Facile

Construisons un système de notification qui démontre comment les classes enfants peuvent remplacer complètement ou étendre les méthodes parentes grâce à la redéfinition de méthode (method overriding).

Vous allez créer trois fichiers qui travaillent ensemble pour envoyer différents types de notifications, chacun ayant son propre comportement unique :

Notification.php — Définissez une classe Notification qui sert de base à tous les types de notifications. Elle doit avoir une propriété publique $recipient et un constructeur qui accepte et définit le destinataire. Incluez une méthode send($message) qui retourne "Sending to $this->recipient: $message".
UrgentNotification.php — Définissez une classe UrgentNotification qui étend Notification. Incluez le fichier Notification en haut. Cette classe doit remplacer complètement la méthode send($message) pour retourner "URGENT to $this->recipient: $message!!!" — notez le préfixe "URGENT" et les points d'exclamation à la fin. Cela démontre le remplacement complet du comportement du parent.
LoggedNotification.php — Définissez une classe LoggedNotification qui étend Notification. Incluez le fichier Notification en haut. Cette classe doit redéfinir send($message) mais s'appuyer sur l'implémentation du parent : appelez parent::send($message) et ajoutez " [logged]" au résultat. Cela démontre l'extension plutôt que le remplacement du comportement.

Dans main.php, incluez les trois fichiers de classe de notification. Vous recevrez deux entrées : le nom du destinataire et le message à envoyer. Créez une instance de chaque type de notification (toutes utilisant le même destinataire), puis appelez send() avec le message sur chacune d'elles. Affichez chaque résultat sur sa propre ligne dans cet ordre : notification régulière, notification urgente, puis notification journalisée.

Ce défi montre les deux approches de la redéfinition de méthode — UrgentNotification remplace complètement la logique du parent par son propre formatage, tandis que LoggedNotification utilise parent:: pour conserver le comportement original et y ajouter des éléments.

Aide-mémoire

La redéfinition de méthode (method overriding) permet à une classe enfant de fournir sa propre implémentation d'une méthode héritée d'une classe parente.

Pour redéfinir une méthode, définissez une méthode dans la classe enfant avec le même nom que la méthode de la classe parente :

<?php
class Animal {
    public function speak() {
        return "makes a sound";
    }
}

class Cat extends Animal {
    public function speak() {
        return "says meow";
    }
}

La classe enfant remplace complètement l'implémentation de la méthode de la classe parente. Lorsqu'elle est appelée sur un objet enfant, PHP utilise la version de l'enfant.

Pour étendre le comportement du parent au lieu de le remplacer, utilisez parent:: pour appeler la méthode parente et ajouter votre propre logique :

<?php
class Dog extends Animal {
    public function speak() {
        return parent::speak() . " - woof woof!";
    }
}

Cela combine le comportement original du parent avec des fonctionnalités supplémentaires de la classe enfant.

Essayez vous-même

<?php

require_once 'Notification.php';
require_once 'UrgentNotification.php';
require_once 'LoggedNotification.php';

// Lire l'entrée
$recipient = trim(fgets(STDIN));
$message = trim(fgets(STDIN));

// TODO : Créer une instance de chaque type de notification (toutes utilisant le même destinataire)

// TODO : Appeler send() avec le message sur chaque notification
// Afficher chaque résultat sur sa propre ligne dans cet ordre :
// 1. Notification régulière
// 2. Notification urgente
// 3. Notification journalisée

?>