extends

Le mot-clé PHP extends

extends permet à une classe de déclarer l'héritage en PHP : une classe enfant (ou sous-classe) construite avec extends acquiert automatiquement les propriétés et méthodes non privées de sa classe parente (ou superclasse). Plutôt que de copier du code partagé dans chaque classe concernée, vous l'écrivez une seule fois dans la classe parente et laissez les sous-classes le spécialiser.

Cette page couvre la syntaxe, la façon d'appeler le code parent avec parent::, le fonctionnement de la surcharge de méthodes, les règles des modificateurs d'accès qui déterminent ce qu'une classe enfant hérite, ainsi que les erreurs courantes. PHP ne supporte que l'héritage simple — une classe ne peut extends qu'un seul parent (utilisez les interfaces lorsqu'un type doit jouer plusieurs rôles).

Syntaxe

class ChildClass extends ParentClass {
  // additional or overriding members
}

La classe enfant peut faire trois choses :

1. Hériter des membres du parent sans modification.
2. Ajouter de nouvelles propriétés et méthodes qui lui sont propres.
3. Surcharger une méthode héritée en la redéclarant avec le même nom.

Un premier exemple

<?php

class Fruit {
  public $name;
  public $color;

  public function __construct($name, $color) {
    $this->name = $name;
    $this->color = $color;
  }

  public function getInfo() {
    echo "This fruit is a {$this->name} and it is {$this->color}.";
  }
}

// Apple inherits everything from Fruit and overrides getInfo().
class Apple extends Fruit {
  public function getInfo() {
    echo "This fruit is an {$this->name} and it is {$this->color}.";
  }
}

$apple = new Apple("apple", "red");
$apple->getInfo();
// Output: This fruit is an apple and it is red.

Apple ne déclare jamais $name, $color ni de constructeur — elle les hérite de Fruit. Elle redéfinit uniquement getInfo(), ce qui surcharge la version de la classe parente.

Appeler le parent avec parent::

Une classe enfant souhaite souvent étendre le comportement du parent plutôt que le remplacer. Lorsqu'une classe enfant définit son propre constructeur, PHP n'appelle pas automatiquement le constructeur parent — vous devez l'appeler explicitement avec parent::__construct(). La même syntaxe parent:: fonctionne pour n'importe quelle méthode surchargée.

<?php

class Car {
  public $model;
  public $year;

  public function __construct($model, $year) {
    $this->model = $model;
    $this->year = $year;
  }

  public function getInfo() {
    echo "This car is a {$this->model} from {$this->year}.";
  }
}

class Toyota extends Car {
  public function __construct($year) {
    // Fill in the model, defer the rest to the parent.
    parent::__construct("Toyota", $year);
  }

  public function getInfo() {
    parent::getInfo();            // reuse the parent's output...
    echo " (built by Toyota)";    // ...then add to it.
  }
}

$toyota = new Toyota(2021);
$toyota->getInfo();
// Output: This car is a Toyota from 2021. (built by Toyota)

Si Toyota n'avait aucun constructeur, elle hériterait du constructeur de Car et vous la créeriez avec new Toyota("Corolla", 2021).

Ce qu'une classe enfant peut — et ne peut pas — hériter

Les modificateurs d'accès déterminent la visibilité à travers la frontière d'héritage :

• Les membres public sont hérités et utilisables partout.
• Les membres protected sont hérités et accessibles à l'intérieur de la classe enfant, mais pas depuis l'extérieur de la classe.
• Les membres private ne sont pas accessibles dans la classe enfant. Ils existent toujours sur l'objet, mais la classe enfant ne peut pas les voir par leur nom.

<?php

class Account {
  public $owner = "Ann";
  protected $balance = 100;   // visible to children
  private $pin = "1234";      // hidden from children

  public function reveal() {
    return "$this->owner, balance $this->balance, pin $this->pin";
  }
}

class SavingsAccount extends Account {
  public function summary() {
    // $this->balance works (protected); $this->pin would be null/undefined.
    return "{$this->owner} has {$this->balance}";
  }
}

$s = new SavingsAccount();
echo $s->summary();
// Output: Ann has 100

Consultez les modificateurs d'accès PHP pour les règles complètes sur public / protected / private.

Sceller une classe ou une méthode avec final

Utilisez le mot-clé final pour empêcher toute extension ultérieure. Une final class ne peut pas être une classe parente ; une méthode final ne peut pas être surchargée par une sous-classe. Ceci est utile lorsque la surcharge briserait une invariante dont votre classe dépend.

class PaymentGateway {
  final public function charge() { /* must not be altered */ }
}

Erreurs courantes

• Oublier parent::__construct(). Définir un constructeur dans la classe enfant masque celui du parent. Si vous oubliez de l'appeler, les propriétés du parent restent non initialisées.
• Héritage simple. class A extends B, C est une erreur de syntaxe. Composez des comportements avec des interfaces ou des traits à la place.
• Les membres privés ne sont pas partagés. Une propriété private sur la classe parente est invisible pour la classe enfant ; rendez-la protected si les sous-classes en ont besoin.
• Les signatures de surcharge doivent rester compatibles. Une méthode qui surcharge doit accepter les mêmes arguments (ou des arguments plus larges), sinon PHP émet un avertissement.

Sujets connexes

• Héritage PHP — le concept plus large qu'extends implémente.
• Classes et objets PHP — les briques de base.
• Classes abstraites — des parents qui doivent être étendus.
• Interfaces — des contrats pour des classes sans lien entre elles.

Pratique