Héritage en PHP : extends, parent:: et redéfinition

En PHP, une classe hérite d'une autre avec extends : class Dog extends Animal donne à Dog toutes les propriétés et méthodes publiques et protégées d'Animal. L'enfant peut ajouter de nouvelles méthodes, redéfinir des méthodes héritées en déclarant une méthode du même nom, et appeler l'original avec parent::method().

<?php
class Animal
{
    public function __construct(protected string $name) {}

    public function speak(): string
    {
        return "{$this->name} makes a sound";
    }

    public function name(): string
    {
        return $this->name;
    }
}

class Dog extends Animal
{
    public function speak(): string
    {
        return "{$this->name} barks";
    }

    public function fetch(): string
    {
        return "{$this->name} brings the ball back";
    }
}

$generic = new Animal('Some animal');
$rex = new Dog('Rex');

echo $generic->speak(), "\n";
echo $rex->speak(), "\n";     // overridden
echo $rex->name(), "\n";      // inherited
echo $rex->fetch(), "\n";     // added

Dog n'a pas de constructeur, il utilise donc celui d'Animal, c'est pourquoi new Dog('Rex') fonctionne. Une classe enfant ne peut étendre qu'un seul parent ; PHP n'a pas d'héritage multiple de classes.

Appeler la méthode parent avec parent::

Redéfinir remplace entièrement la méthode du parent. Pour l'étendre au lieu de la remplacer, appelez parent::method() depuis l'enfant et construisez sur son résultat :

<?php
class Report
{
    public function header(): string
    {
        return "Sales report";
    }

    public function lines(): array
    {
        return ['Q1: 120', 'Q2: 98'];
    }
}

class DetailedReport extends Report
{
    public function header(): string
    {
        return parent::header() . " (detailed)";
    }

    public function lines(): array
    {
        $lines = parent::lines();
        $lines[] = 'Total: 218';
        return $lines;
    }
}

$r = new DetailedReport();
echo $r->header(), "\n";
echo implode("\n", $r->lines()), "\n";

C'est pareil pour les constructeurs avec parent::__construct(...), que présente la page sur le constructeur, y compris ce qui se passe quand on l'oublie.

protected ou private dans les classes enfants

Un membre protected est caché au code extérieur mais visible par toutes les classes de la famille. Un membre private n'est visible que dans la classe qui le déclare, donc une classe enfant ne le voit pas du tout :

<?php
class BankAccount
{
    protected float $balance = 100;
    private string $pin = '1234';

    public function hasPin(): bool
    {
        return $this->pin !== '';
    }
}

class SavingsAccount extends BankAccount
{
    public function addInterest(float $rate): void
    {
        $this->balance *= 1 + $rate;   // protected: allowed
    }

    public function balance(): float
    {
        return $this->balance;
    }

    public function pinKnown(): bool
    {
        return isset($this->pin);      // private in the parent: not visible here
    }
}

$s = new SavingsAccount();
$s->addInterest(0.05);
echo $s->balance(), "\n";
var_dump($s->pinKnown(), $s->hasPin());

isset($this->pin) est faux dans l'enfant, car l'enfant n'a pas accès au $pin privé du parent, alors que la méthode propre du parent hasPin() le lit toujours. Utilisez protected pour ce sur quoi les sous-classes sont censées construire, et private pour les détails que vous voulez pouvoir changer librement.

Polymorphisme et instanceof

Du code écrit pour le type parent fonctionne avec chaque enfant. Chaque objet exécute sa propre version d'une méthode redéfinie, donc une seule boucle les gère tous. instanceof vérifie si un objet appartient à une classe ou à l'un de ses enfants :

<?php
class Shape
{
    public function area(): float
    {
        return 0;
    }
}

class Rectangle extends Shape
{
    public function __construct(private float $w, private float $h) {}

    public function area(): float
    {
        return $this->w * $this->h;
    }
}

class Circle extends Shape
{
    public function __construct(private float $r) {}

    public function area(): float
    {
        return M_PI * $this->r ** 2;
    }
}

function totalArea(Shape ...$shapes): float
{
    return array_sum(array_map(fn (Shape $s) => $s->area(), $shapes));
}

$shapes = [new Rectangle(3, 4), new Circle(1), new Rectangle(2, 2)];
printf("Total area: %.2f\n", totalArea(...$shapes));

foreach ($shapes as $s) {
    echo get_class($s), ': ', $s instanceof Shape ? 'is a Shape' : 'not a Shape';
    echo $s instanceof Circle ? ', is a Circle' : '', "\n";
}
echo get_parent_class(new Circle(2)), "\n";

Quand le parent ne doit jamais être utilisé seul (un simple Shape d'aire 0 n'a guère de sens), faites-en une classe abstraite et déclarez area() abstraite.

Règles de redéfinition : les signatures doivent rester compatibles

Une méthode qui en redéfinit une autre doit accepter au moins ce qu'acceptait le parent et renvoyer quelque chose d'utilisable par les appelants du parent. Vous pouvez ajouter un paramètre facultatif, élargir le type d'un paramètre ou restreindre le type de retour ; vous ne pouvez pas ajouter de paramètre obligatoire ni rendre privée une méthode publique.

<?php
class Exporter
{
    public function export(array $rows): string
    {
        return implode(';', array_map(fn ($r) => implode(',', $r), $rows));
    }
}

class CsvExporter extends Exporter
{
    // Adds an optional parameter: compatible
    public function export(array $rows, string $sep = ','): string
    {
        return implode("\n", array_map(fn ($r) => implode($sep, $r), $rows));
    }
}

$rows = [['id', 'name'], [1, 'Ada'], [2, 'Linus']];
echo (new Exporter())->export($rows), "\n\n";
echo (new CsvExporter())->export($rows), "\n\n";
echo (new CsvExporter())->export($rows, "\t"), "\n";

Remplacez string $sep = ',' par un string $sep obligatoire et PHP refuse de compiler la classe avec une erreur fatale (« Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string »).

Classes et méthodes final

final arrête l'héritage à cet endroit. Une méthode final ne peut pas être redéfinie, et une final class ne peut pas être étendue. Les deux sont vérifiées à la compilation du fichier, donc le script ne démarre pas du tout :

<?php
class Payment
{
    final public function charge(int $cents): string
    {
        return "charged $cents";
    }
}

class FreePayment extends Payment
{
    public function charge(int $cents): string
    {
        return 'free';
    }
}

PHP Fatal error:  Cannot override final method Payment::charge() in /home/index.php on line 12

Pour une classe final, le message est Class B cannot extend final class A. Marquez une méthode final quand le parent compte sur un comportement unique, par exemple une méthode qui vérifie les permissions avant toute autre chose.

Le piège des méthodes privées

Une méthode privée n'est pas héritée, donc une méthode enfant du même nom ne la redéfinit pas. Le code du parent continue d'appeler sa propre version privée, ce qui surprend ceux qui s'attendent à voir s'exécuter la méthode de l'enfant :

<?php
class Greeter
{
    public function greet(): string
    {
        return $this->word() . ', world';
    }

    private function word(): string
    {
        return 'Hello';
    }
}

class FrenchGreeter extends Greeter
{
    public function word(): string
    {
        return 'Bonjour';
    }
}

echo (new FrenchGreeter())->greet(), "\n";
echo (new FrenchGreeter())->word(), "\n";

greet() affiche toujours Hello : le $this->word() du parent se résout vers la méthode privée du parent. Remplacez private par protected dans Greeter et relancez ; la méthode de l'enfant est maintenant une vraie redéfinition et greet() dit Bonjour.