Héritage

DéfinitionHéritage

L'héritage permet à une classe (enfant) de "hériter" de toutes les propriétés et méthodes publiques et protégées d'une autre classe (parent). Cela évite la duplication de code. On utilise le mot-clé extends.

Représentation UML de l'Héritage Mere Fille
1
class Mere
2
{
3
  public $attr;
4
  public function __construct($attr){
5
    $this->attr = $attr;
6
  }
7
  public function meth(){
8
    return $this->attr;
9
  }
10
}
11
class Fille extends Mere
12
{
13
}
14
$element1 = new Fille(5);
15
$element2 = new Fille(10);
16
var_dump($element1); // attr = 5
17
var_dump($element2); // attr = 10
18
echo $element1->meth(); // affiche 5

Chaque instance de classe crée ses propres propriétés héritées de la classe mère.

Les instances ont accès aux méthodes de la classe mère.

DéfinitionRedéfinition de méthodes : parent

Une classe enfant peut redéfinir (surcharger) une méthode héritée de son parent pour en modifier le comportement.

Pour appeler la méthode originale du parent (par exemple, pour l'étendre au lieu de la remplacer), on utilise le mot-clé parent::.

Représentation UML de l'Héritage Mere Fille
1
class Mere
2
{
3
  public function meth1(){
4
    return 'meth1 de classe Mere';
5
  }
6
}
7
class Fille extends Mere
8
{
9
  public function meth1(){
10
    return 'meth1 de classe Fille';
11
  }
12
  public function meth2(){
13
    return parent::meth1();
14
  }
15
}
16
$element = new Fille;
17
echo $element->meth1(); // affiche meth1 de classe Fille
18
echo $element->meth2(); // affiche meth1 de classe Mère

Pour redéfinir une méthode parent, vous devez respecter scrupuleusement son "contrat" :

  1. Elle ne doit pas être final.

  2. La visibilité doit être égale ou augmentée (ex: protected -> public).

  3. Le type de retour doit être égal ou plus précis (ex: Animal -> Chien).

  4. Les types des paramètres doivent être égaux ou plus larges (ex: Chien -> Animal).

  5. Le nombre de paramètres doivent être égaux ou optionnel ((a, b) -> (a, b, c=10))

  6. Son état static (ou non-static) ne doit pas changer.

DéfinitionAttributs et méthodes statiques

Par défaut, les attributs et méthodes appartiennent à l'instance. Si on veut qu'ils appartiennent à la classe elle-même (partagés par toutes les instances), on utilise le mot-clé static.

On y accède avec l'opérateur :: (double deux-points) 25, et on utilise self:: à l'intérieur de la classe.

Représentation UML de l'Héritage Mere Fille
1
class Mere
2
{
3
  public static $attr;
4
  public static function setAttr($attr){
5
    self::$attr = $attr;
6
  }
7
  public function getAttr(){
8
    return self::$attr;
9
  }
10
}
11
class Fille extends Mere
12
{
13
}
14
Mere::setAttr(10); // attr = 10 partagé par toutes les instances
15
$element = new Fille;
16
echo $element->getAttr(); // affiche 10

self : représente la classe à l'intérieur d'elle-même.

Mere : à l'extérieur de la classe, on l'appelle par son nom.

:: : permet d'accéder aux éléments statiques.

DéfinitionMéthode __construct

On peut redéfinir la méthode __construct de la classe mère et y faire appel.

Représentation UML de l'Héritage Mere Fille
1
class Mere
2
{
3
  public $attr1;
4
  public function __construct($attr1){
5
    $this->attr1 = $attr1;
6
  }
7
}
8
class Fille extends Mere
9
{
10
  public $attr2;
11
  public function __construct($attr1, $attr2){
12
    parent::__construct($attr1);
13
    $this->attr2 = $attr2;
14
  }
15
}
16
$element = new Fille(10,5);
17
var_dump($element);

Le nombre de paramètres peut être différent.