Héritage et classes abstraites

extends : hériter d'une classe

Un CompteEpargne est un Compte avec un taux en plus. En PHP, on l'écrit avec extends : la classe fille récupère toutes les propriétés et méthodes public/protected du parent.

class Compte {
    protected float $solde = 0;        // protected → accessible aux filles
    public function deposer(float $m): void { if ($m > 0) $this->solde += $m; }
    public function getSolde(): float { return $this->solde; }
}

class CompteEpargne extends Compte {
    public function __construct(private float $taux) {}

    public function ajouterInterets(): void {
        $this->deposer($this->solde * $this->taux);  // réutilise la méthode héritée
    }
}

Remarque : $solde est protected (pas private) pour rester accessible à la classe fille. private resterait invisible même pour les enfants.

parent:: et la redéfinition

Une fille peut redéfinir (override) une méthode du parent, et appeler la version parente avec parent::. Si la fille a son propre constructeur, elle doit appeler parent::__construct(...) pour initialiser la partie héritée.

class CompteCourant extends Compte {
    public function __construct(private float $decouvertAutorise) {
        parent::__construct();   // construit la partie "Compte"
    }
    // on REDÉFINIT retirer pour autoriser un découvert
    public function retirer(float $m): bool {
        if ($m > 0 && $m <= $this->solde + $this->decouvertAutorise) {
            $this->solde -= $m;
            return true;
        }
        return false;
    }
}

Les classes abstraites : un gabarit

Une classe abstraite ne peut pas être instanciée directement : c'est un gabarit pour ses filles. Elle peut imposer des méthodes abstraites (sans corps) que chaque fille doit implémenter.

abstract class Forme {
    abstract public function aire(): float;   // pas de corps : à implémenter

    public function decrire(): string {        // méthode concrète partagée
        return "Aire = " . $this->aire();
    }
}
class Carre extends Forme {
    public function __construct(private float $cote) {}
    public function aire(): float { return $this->cote ** 2; }
}
// new Forme();  // ❌ Error: Cannot instantiate abstract class Forme

Exécute : héritage en action

<?php
class Compte {
    protected float $solde = 0;
    public function deposer(float $m): void { if ($m > 0) $this->solde += $m; }
    public function getSolde(): float { return $this->solde; }
}
class CompteEpargne extends Compte {
    public function __construct(private float $taux) {}
    public function ajouterInterets(): void {
        $this->deposer($this->solde * $this->taux);
    }
}

$e = new CompteEpargne(0.05);
$e->deposer(1000);        // méthode HÉRITÉE de Compte
$e->ajouterInterets();    // méthode PROPRE → +50
echo "Solde : " . $e->getSolde() . " €\n";  // 1050
?>

final : interdire l'héritage ou la redéfinition

L'héritage et la redéfinition sont puissants, mais parfois on veut garantir qu'une classe ou une méthode ne sera pas modifiée par une sous-classe. PHP offre le mot-clé final exactement pour ça.

• final class Paiement { … } : la classe ne peut pas être étendue. Tenter class X extends Paiement provoque une erreur fatale à la compilation (Class X cannot extend final class Paiement).
• final public function valider() { … } dans une classe non-finale : la méthode ne peut pas être redéfinie par une fille. La tenter provoque Cannot override final method.

<?php
// final class : aucune classe ne peut l'étendre
final class Paiement {
    public function __construct(private float $montant) {}

    public function valider(): string {
        return "Paiement de {$this->montant} € validé.";
    }
}

// Utilisation normale : fonctionne parfaitement
$p = new Paiement(49.90);
echo $p->valider() . "\n";

// Ce qui suit provoquerait une erreur fatale à la compilation :
// class PaiementFraude extends Paiement {}
// Fatal error: Class PaiementFraude cannot extend final class Paiement

// final sur une méthode dans une classe non-finale
class Compte {
    protected float $solde = 0;
    public function deposer(float $m): void { if ($m > 0) $this->solde += $m; }

    final public function getSolde(): float { return $this->solde; }
    // getSolde() ne peut PAS être redéfinie par une classe fille
}

class CompteDemo extends Compte {
    // final public function getSolde(): float { return 0; }
    // => Fatal error: Cannot override final method Compte::getSolde()
}

$c = new CompteDemo();
$c->deposer(200);
echo "Solde : " . $c->getSolde() . " €\n";
?>