PHP (POO) -Héritage-

L’héritage est un des principes fondamentaux de la programmation orientée objet, il permet la factorisation du code commun à plusieurs classes au sein d’une seule et unique classe que l’on appel lera classe mère. Chaque classe voulant disposer des fonctionnalités (attributs et méthodes) de la classe mère devra donc l’étendre (on parle alors d’héritage) et sera appelée classe fille. Elle pourra dès lors utiliser les fonctionnalités non privées de la classe mère, les redéfinir pour en modifier le comportement (on parle de polymorphisme) et ajouter ses fonctionnalités propres.

Pour définir un héritage, la classe fille doit indiquer qu’elle étend la classe mère, ceci est possible grâce au mot-clé extends. En PHP, l’héritage multiple est impossible.

<?php 
class Voiture { 
public $couleur = 'noir'; 
} 
class Dacia extends Voiture {} 
$dacia = new Dacia(); 
echo $dacia->couleur; // affiche : noir

Héritage et visibilité 

Une classe fille peut modifier selon les besoins la visibilité des attributs ou des méthodes de la classe mère. Il est possible de redéfinir la visibilité d’une ressource vers une visibilité plus faible mais pas vers une visibilité plus forte

class Voiture {
    protected function abs() {
        echo 'abs déclenché';
    }
}
class Dacia  extends Voiture {
    public function abs() {
        parent::abs();
    }
}

// Ce code affiche fatal error
/*$v1 = new Voiture();
$v1->abs();*/ 

$v2 = new Dacia();
$v2->abs(); // affiche : abs délenché

Héritage et constante

Contrairement aux constantes classiques, les constantes de classe peuvent être redéfinies lors d’un héritage. Une classe fille peut donc modifier selon ses besoins la valeur d’une ou plusiuers constantes de la classe mère.

<?php
        //Enter your code here, enjoy!
class Voiture {
    const MOTEUR_ESSENCE = 1;
}
class Dacia  extends Voiture {
    const MOTEUR_ESSENCE = 2;
}

echo Voiture::MOTEUR_ESSENCE; // Affiche 1
echo Dacia::MOTEUR_ESSENCE; // Affiche 2

Polymorfisme

Une classe fille peut redéfinir les méthodes de classe mère, on parle de polymorphisme. Il existe deux types de polymorphisme :

• La surcharge : Modification de la signature de la méthode
• La redéfinition : Modification du comportement de la méthode

La classe fille pouvant modifier tout ou partie du comportement de la classe mère, elle doit pouvoir s’y référer a tout oment, on utilise pour cela le mot-clé parent. Il représente la classe mère dans un contexte statique.

Exemple :

<?php //Enter your code here, enjoy! 
class Voiture { 
        const MOTEUR_ESSENCE = 1; 
        const MOTEUR_ELECTRIQUE = 2;
        const MOTEUR_HYPRIDE = 3; 
        public $couleur; 
        protected $nPlace;
        private $typeMoteur; 
        public function __construct($couleur, $nPlace, $typeMoteur = self::MOTEUR_ESSENCE){ 
        $this->couleur = (string)$couleur;
        $this->nPlace = (int)$nPlace;
        $this->typeMoteur = (int)$typeMoteur;
    }
}

class Dacia extends Voiture {
    const NB_PLACE = 3;
    private $sport;
    public function __construct($couleur, $sport = false) {
        $this->sport = (bool)$sport;
        parent::__construct($couleur, self::NB_PLACE, self::MOTEUR_HYPRIDE);
    }
}

$v1 =  new Voiture('vert', 10);
var_dump($v1); // Affiche 
object(Voiture)#1 (3) {
  ["couleur"]=>
  string(4) "vert"
  ["nPlace":protected]=>
  int(10)
  ["typeMoteur":"Voiture":private]=>
  int(1)
}


$v2 = new Dacia('noir');
var_dump($v2); // Affiche
object(Dacia)#2 (4) {
  ["sport":"Dacia":private]=>
  bool(false)
  ["couleur"]=>
  string(4) "noir"
  ["nPlace":protected]=>
  int(3)
  ["typeMoteur":"Voiture":private]=>
  int(3)
}

Dans ce code il y a un polymorphisme du constructeur.

Une classe fille hérite par défaut du constructeur et du destructeur de la classe parente, si elle ne les redéfinit pas. dans le cas contraire, les méthodes parentes ne seront pas appelées implicitement par la classe fille. Si vous désirez y faire appel, il est nécessaire de le spécifier explicitement avec parent::__construct() dans le constructeur enfant. les traitements spécifiques à la classe fille peuvent être effectués avant ou après l’appel du constructeur parent.

Le mot-clé final

Afin de pourvoir contrôler au mieux l’utilisation de vos classes, PHP met à disposition le mot-clé final.

Placé devant la signature d’une méthode, il permet d’en empêcher la surcharge par une éventuelle classe fille.