Révision de la redéfinition des méthodes

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy. Leçon 33 sur 91.

Vous avez déjà découvert la redéfinition des méthodes dans le chapitre sur l’héritage. Explorons maintenant son lien avec le polymorphisme — l’un des concepts les plus puissants de la programmation orientée objet.

Le polymorphisme signifie « plusieurs formes ». Lorsque tu redéfinis une méthode dans une classe enfant, tu donnes à cette méthode une forme différente tout en conservant le même nom. La magie opère lorsque tu travailles avec des objets via leur type parent :

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

class Dog extends Animal {
    public function speak() {
        return "Woof!";
    }
}

class Cat extends Animal {
    public function speak() {
        return "Meow!";
    }
}

function makeAnimalSpeak(Animal $animal) {
    return $animal->speak();
}

echo makeAnimalSpeak(new Dog()) . "\n";
echo makeAnimalSpeak(new Cat());

Sortie :

Woof!
Meow!

La fonction makeAnimalSpeak() accepte n’importe quel Animal. Elle ne sait pas et ne se soucie pas de recevoir un Dog ou un Cat. PHP appelle automatiquement la méthode redéfinie correcte en fonction du type réel de l’objet lors de l’exécution.

C’est le polymorphisme en action.

Cette approche vous permet d’écrire un code flexible qui fonctionne avec une famille d’objets associés sans connaître leurs types spécifiques. Vous pouvez ajouter de nouvelles classes d’animaux ultérieurement, et la fonction fonctionnera automatiquement avec celles-ci.

Point clé : La redéfinition de méthode permet le polymorphisme en autorisant différentes classes à répondre différemment au même appel de méthode, selon le type réel de l’objet au moment de l’exécution.

Défi

Facile

Construisons un système d'instruments de musique qui démontre le polymorphisme grâce à la redéfinition de méthodes. Vous allez créer une classe de base Instrument et deux classes enfants qui produiront chacune leur propre son unique, puis utiliser une seule fonction pour jouer n'importe quel instrument de manière polymorphe.

Vous organiserez votre code sur quatre fichiers :

Instrument.php : créez une classe Instrument avec une propriété $name protégée, définie par le constructeur. Ajoutez une méthode play() qui renvoie "[name] makes a sound". Cela constitue le comportement de base que les classes enfants redéfiniront.
Guitar.php : créez une classe Guitar qui étend Instrument. Incluez le fichier parent. Le constructeur accepte le nom et le transmet au constructeur parent. Redéfinissez la méthode play() afin qu'elle renvoie "[name] strums a chord".
Drum.php : créez une classe Drum qui étend Instrument. Incluez le fichier parent. Le constructeur accepte le nom et le transmet au constructeur parent. Redéfinissez la méthode play() afin qu'elle renvoie "[name] beats a rhythm".
main.php : incluez les fichiers Guitar et Drum. Créez une fonction appelée performWith qui accepte un paramètre Instrument (avec indication de type) et renvoie le résultat de l'appel de play() sur celui-ci. Cette fonction démontre le polymorphisme. Elle fonctionne avec n'importe quel type d'instrument grâce à l'indication du type de la classe parent.

Vous recevrez deux entrées : un nom pour la guitare et un nom pour le tambour. Créez un Guitar et un Drum avec ces noms. Transmettez chacun à votre fonction performWith() et affichez les résultats : d'abord la guitare, puis le tambour, chacun sur sa propre ligne.

Remarquez comment performWith() accepte n'importe quel Instrument, tandis que PHP appelle automatiquement la méthode play() redéfinie correcte en fonction du type réel de l'objet lors de l'exécution. C'est le polymorphisme en action !

Essayez vous-même

<?php
// Inclure les fichiers d'instruments
require_once 'Guitar.php';
require_once 'Drum.php';

// Lire l'entrée
$guitarName = trim(fgets(STDIN));
$drumName = trim(fgets(STDIN));

// TODO: Créer une fonction appelée performWith qui :
// - Accepte un paramètre Instrument (utiliser le type hint : Instrument $instrument)
// - Retourne le résultat de l'appel à play() sur l'instrument

// TODO: Créer une Guitar avec $guitarName et un Drum avec $drumName
// TODO: Passer chacun à performWith() et afficher les résultats (guitare d'abord, puis batterie)

?>