L’héritage simple
Il est possible que des classes partagent des attributs et des méthodes. Ce principe est défini par la notion d’héritage qui fait que les classes peuvent être vues comme un ensemble de catégories et de sous catégories.
Pour définir un héritage entre deux classes il faut utiliser le mot-clé extends après le nom de la classe dans sa déclaration.
Exemple:
|
1 2 3 |
class MountainBike extends BiCycle { ... code de la classe ... } |
Le code ci-dessus définit une classe MountainBike qui hérite de la classe BiCycle. La classe MountainBike peut ainsi utiliser tous les attributs et toutes les méthodes de la classe BiCycle.
Il est aussi possible pour la classe MountainBike de redéfinir des attributs ou des méthodes portant les mêmes noms que la classe BiCycles.
Les traits
Les traits sont un mécanisme permettant de réutiliser du code.
Un trait peut être vu comme un ensemble de méthodes qui peuvent être incluses dans d’autres classes. Le contenu du trait est copié dans la classe qui veut l’utiliser. Il n’y a pas besoin d’instancier un trait.
L’avantage des traits est de réduire la duplication de code et de permettre l’utilisation de méthodes de classe sans avoir à passer par la notion d’héritage.
Un trait se définit en utilisant le mot-clé trait.
|
1 2 3 4 5 |
trait monTrait { public function maFonction(){ return "I Love Opentuto.com!"; } } |
Pour inclure un trait dans une classe, il faut utiliser le mot-clé use.
|
1 2 3 4 |
class maClasse { use monTrait; // code de la classe maClasse } |
La méthode maFonction() est maintenant disponible dans chaque instance de la classe maClasse.
|
1 2 |
$maClasse = new maClasse; echo $maClasse->maFonction(); |
Ce code va afficher :
I Love Opentuto.com!
Les classes abstraites
Une classe abstraite est une classe utilisée pour définir un type d’objet très générique, inutilisable directement, qui force les sous-types à avoir certaines particularités.
Une classe abstraite définit des méthodes et des attributs qui seront disponibles dans les classes qui l’étendent.
Pour indiquer qu’une classe est abstraite, il faut la préfixer du mot abstract.
Pour définir une classe abstraite voiture il faut écrire :
|
1 2 3 |
abstract class voiture{ //code de la classe abstraite } |
Il est aussi possible de définir des méthodes abstraites dans une classe. Cela permet d’obliger les classes dérivées à implémenter ces méthodes. Pour déclarer une méthode comme abstraite, il faut la préfixer du mot abstract.
Une classe contenant au moins une méthode abstraite doit obligatoirement être définie comme abstraite.
Par exemple, en définissant une classe abstraite comme suit :
|
1 2 3 4 5 6 7 8 |
abstract class vehicule{ abstract protected function vehiculeVitesse($vitesse); public function afficheVitesse($vitesse) { echo $this->vehiculeVitesse($vitesse); } } |
Il est possible de définir une classe fille comme suit :
|
1 2 3 4 5 6 7 |
class voiture extends vehicule { protected function vehiculeVitesse($vitesse) { return 'Vous roulez à '.$vitesse.' km / h.'; } //code de la classe } |
Ce qui permet d’écrire :
|
1 2 |
$voiture= new voiture; echo $voiture->afficheVitesse(11); |
Les interfaces
Les interfaces sont utilisées pour vérifier que les objets correspondent à certaines spécifications, c’est-à-dire que chaque objet est conforme à certains comportements, qu’il peut gérer certains types d’évènements ou qu’il possède certaines fonctionnalités.
Pour déclarer une interface, il faut utiliser le mot-clé interface. Les méthodes définies dans une interface sont forcément publiques.
|
1 2 3 4 5 |
interface Bicycle{ public function changeCadence(); public function changeGear(); public function speedUp(); } |
Pour indiquer qu’une classe implémente une interface précise, il faut utiliser le mot-clé implements. Une classe peut implémenter plusieurs interfaces. Dans ce cas, les noms des différentes interfaces sont séparés par des virgules.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class ACMEBicycle implements Bicycle{ public function demarrer(){ //Code de la fonction } public function changeCadence(){ //Code de la fonction } public function changeGear(){ //Code de la fonction } public function speedUp(){ //Code de la fonction } } |
- Les interfaces peuvent hériter d’autres interfaces.
- Les classes abstraites peuvent implémenter des interfaces.
