Le polymorphisme est un concept clé dans la programmation orientée objet (POO) qui permet à des objets de différentes classes de répondre à la même interface, c’est-à-dire d’exécuter une méthode portant le même nom. Cela permet une plus grande flexibilité et réutilisation du code. En PHP, le polymorphisme permet de traiter différents objets de manière uniforme grâce à l’héritage et à l’implémentation d’interfaces.
En PHP, il existe principalement deux types de polymorphisme : le polymorphisme par sous-typage et le polymorphisme par interface.
Le polymorphisme par sous-typage repose sur le concept d’héritage. Une classe enfant hérite des propriétés et méthodes de sa classe parente, mais peut aussi redéfinir certaines méthodes. Voici un exemple simple :
```
class Animal {
public function faireDuBruit() {
echo “Some generic animal noise”;
}
}
class Chien extends Animal {
public function faireDuBruit() {
echo “Woof! Woof!”;
}
}
class Chat extends Animal {
public function faireDuBruit() {
echo “Meow! Meow!”;
}
}
function faireFaireBruit(Animal $animal) {
$animal->faireDuBruit();
}
$chien = new Chien();
$chat = new Chat();
faireFaireBruit($chien); // Sortie : Woof! Woof!
faireFaireBruit($chat); // Sortie : Meow! Meow!
```
Dans cet exemple, la classe `Chien` et la classe `Chat` héritent toutes deux de la classe `Animal`. La fonction `faireFaireBruit` peut prendre n’importe quel objet de type `Animal` ou ses sous-classes, démontrant ainsi le polymorphisme par sous-typage.
Le polymorphisme par interface repose sur l’implémentation d’une interface par différentes classes. Voici un exemple :
```
interface Performable {
public function perform();
}
class Acteur implements Performable {
public function perform() {
echo “Acting on stage.”;
}
}
class Musicien implements Performable {
public function perform() {
echo “Playing music.”;
}
}
function startPerformance(Performable $performer) {
$performer->perform();
}
$acteur = new Acteur();
$musicien = new Musicien();
startPerformance($acteur); // Sortie : Acting on stage.
startPerformance($musicien); // Sortie : Playing music.
```
Dans cet exemple, les classes `Acteur` et `Musicien` implémentent toutes deux l’interface `Performable`. La fonction `startPerformance` peut donc accepter et traiter n’importe quel objet qui implémente cette interface, démontrant ainsi le polymorphisme par interface.
1. Réutilisabilité du code : Le polymorphisme permet de créer des fonctions plus génériques et réutilisables.
2. Extensibilité : Ajouter une nouvelle classe qui implémente une interface ou hérite d’une classe existante nécessite rarement de modifier le code existant.
3. Lisibilité et maintenance : Le code devient plus lisible et plus facile à maintenir car il suit des structures communes et prévisibles.
1. [PHP.net documentation officielle](https://www.php.net/manual/en/language.oop5.php)
2. [Programmation Orientée Objet (W3Schools)](https://www.w3schools.com/php/php_oop_accessmodifiers.asp)
3. [Guide de la POO en PHP sur Tutorial Republic](https://www.tutorialrepublic.com/php-tutorial/php-object-oriented-programming.php)
Ces sources fournissent une base solide pour comprendre les principes fondamentaux du polymorphisme en PHP et son application dans des scénarios pratiques.
