Introduction

Bienvenue dans ce tutoriel consacré à l'héritage et au polymorphisme en PHP orienté objet. Ces concepts sont essentiels pour développer des applications robustes et maintenables. Dans ce guide, nous allons explorer en détail comment utiliser l'héritage pour créer une hiérarchie de classes et comment le polymorphisme permet à ces classes de réagir différemment aux mêmes méthodes.

Objectifs d'apprentissage

• Comprendre le concept d'héritage en PHP
• Savoir utiliser le mot-clé extends pour hériter d'une classe parente
• Maîtriser la surcharge de méthodes pour modifier le comportement des classes dérivées
• Utiliser parent:: pour accéder aux méthodes de la classe parente
• Connaître l'utilisation des classes abstraites
• Comprendre le polymorphisme et son utilité
• Utiliser les modificateurs final et abstract pour les classes et méthodes

L'héritage en PHP

L'héritage est un concept fondamental de la programmation orientée objet. Il permet de définir une classe qui hérite des propriétés et des méthodes d'une autre classe, appelée classe parente. La classe qui hérite est appelée classe dérivée ou classe enfant.

Pour déclarer une classe dérivée, on utilise le mot-clé extends suivi du nom de la classe parente :

class Car extends Vehicle {     // Méthodes et propriétés spécifiques à Car } 

La classe Car hérite maintenant de toutes les méthodes et propriétés de la classe parente Vehicle. Cela signifie que nous pouvons utiliser les méthodes définies dans Vehicle directement dans Car sans avoir à les réécrire.

La surcharge des méthodes

L'une des fonctionnalités les plus puissantes de l'héritage est la surcharge des méthodes. La surcharge permet à une classe dérivée de modifier le comportement d'une méthode héritée de la classe parente.

Pour surcharger une méthode, il suffit de la redéfinir dans la classe dérivée avec le même nom :

class Car extends Vehicle {     public function startEngine()     {         // Comportement spécifique de Car     } } 

Dans cet exemple, nous avons redéfini la méthode startEngine() dans la classe Car. Maintenant, lorsque nous appelons startEngine() sur une instance de Car, le comportement spécifique de Car sera exécuté.

L'utilisation de parent::

Parfois, nous voulons accéder à la version originale d'une méthode dans la classe parente, même si elle a été redéfinie dans la classe dérivée. C'est là que l'opérateur parent:: entre en jeu.

En utilisant parent::, nous pouvons appeler la méthode de la classe parente à partir de la classe dérivée :

class Car extends Vehicle {     public function startEngine()     {         // Comportement spécifique de Car         parent::startEngine();         // Appel de la méthode startEngine() de la classe parente     } } 

Avec cet exemple, lorsque nous appelons startEngine() sur une instance de Car, le comportement spécifique de Car sera exécuté, suivi de l'appel à la méthode startEngine() de la classe parente.

Les classes abstraites

Les classes abstraites sont des classes qui ne peuvent pas être instanciées directement. Elles servent de modèles pour d'autres classes et peuvent contenir des méthodes abstraites, qui doivent être implémentées par les classes dérivées.

Pour déclarer une classe abstraite, on utilise le mot-clé abstract :

abstract class Vehicle {     // Méthodes abstraites et propriétés communes à tous les véhicules } 

Les méthodes abstraites sont déclarées sans implémentation :

abstract class Vehicle {     abstract public function startEngine();     // Méthode abstraite } 

Les classes dérivées qui héritent d'une classe abstraite doivent implémenter toutes les méthodes abstraites de la classe parente, sinon elles seront considérées comme abstraites elles-mêmes.

Le polymorphisme en PHP

Le polymorphisme est un concept clé de la programmation orientée objet. Il permet à différents objets d'avoir des comportements différents lorsqu'ils utilisent les mêmes méthodes.

Par exemple, considérons une classe Animal avec une méthode makeSound(). Différents animaux peuvent implémenter cette méthode de différentes manières :

class Animal {     public function makeSound()     {         // Comportement générique de l'animal     } }  class Cat extends Animal {     public function makeSound()     {         // Comportement spécifique du chat     } }  class Dog extends Animal {     public function makeSound()     {         // Comportement spécifique du chien     } } 

Grâce au polymorphisme, nous pouvons traiter des instances de Cat et de Dog comme des instances de Animal :

$cat = new Cat(); $dog = new Dog();  $animals = [$cat, $dog];  foreach ($animals as $animal) {     $animal->makeSound(); } 

Chaque objet exécutera sa propre implémentation de la méthode makeSound(), produisant ainsi des résultats différents.

Les modificateurs final et abstract

En PHP, il est possible de marquer une classe ou une méthode comme étant final ou abstract.

Une classe marquée comme final ne peut pas être héritée :

final class Vehicle {     // Code de la classe } 

Une méthode marquée comme final ne peut pas être surchargée dans les classes dérivées :

class Vehicle {     final public function startEngine()     {         // Comportement de la méthode     } } 

Une méthode marquée comme abstract doit être implémentée dans les classes dérivées :

abstract class Vehicle {     abstract public function startEngine();     // Méthode abstraite } 

Exercice pratique

Imaginez que vous devez concevoir un système de gestion de produits pour une boutique en ligne. Les produits peuvent être soit des produits physiques, soit des produits numériques. Les produits physiques doivent être expédiés, tandis que les produits numériques peuvent être téléchargés.

Utilisez les concepts d'héritage et de polymorphisme pour concevoir une hiérarchie de classes qui représente ces types de produits. Définissez les méthodes nécessaires pour chaque type de produit (par exemple, ship() pour les produits physiques et download() pour les produits numériques).

Implémentez les méthodes dans les classes dérivées et démontrez le polymorphisme en utilisant une boucle pour appeler les méthodes sur des instances de différents produits.

Conclusion

Dans ce tutoriel, nous avons exploré l'héritage et le polymorphisme en PHP orienté objet. Nous avons appris comment créer une hiérarchie de classes en utilisant l'héritage, comment surcharger des méthodes pour modifier le comportement des classes dérivées, et comment utiliser le polymorphisme pour permettre à différentes classes d'implémenter les mêmes méthodes de façon spécifique.

Nous avons également découvert l'utilisation des classes abstraites pour définir un modèle de classe et les modificateurs final et abstract pour restreindre l'héritage et la surcharge des méthodes.

Enfin, nous avons appliqué ces concepts à la conception d'une hiérarchie de classes pour un système de gestion de produits, en utilisant des méthodes spécifiques pour chaque type de produit et en démontrant le polymorphisme à l'aide d'une boucle.

J'espère que ce tutoriel vous a aidé à approfondir vos connaissances en PHP orienté objet. N'hésitez pas à pratiquer davantage et à explorer d'autres concepts avancés pour devenir un développeur PHP plus compétent.

🌳 Bon codage et à bientôt ! 🌳