Héritage et fichiers séparés

Une classe, un fichier

Dans un vrai projet, on ne met pas tout dans index.php. L'habitude est de ranger chaque classe dans son propre fichier, qui porte le même nom qu'elle : la classe Compte va dans Compte.php. Le fichier principal l'inclut avec require_once :

<?php
// Fichier Compte.php : uniquement la classe
class Compte
{
    public function __construct(public string $titulaire, protected float $solde = 0)
    {
    }

    public function decrire(): string
    {
        return "$this->titulaire : $this->solde €";
    }
}

<?php
// Fichier index.php
require_once 'Compte.php';      // copie le contenu de Compte.php ici

$compte = new Compte("Léa", 150);
echo $compte->decrire();

• require inclut un fichier ; s'il n'existe pas, le programme s'arrête avec une erreur fatale ;
• include fait pareil, mais continue avec un simple avertissement si le fichier manque ;
• la version _once (require_once, include_once) n'inclut le fichier qu'une seule fois, même si on le demande plusieurs fois. C'est celle qu'on utilise pour les classes : déclarer deux fois la même classe est une erreur.

Dans les exercices : ils ont plusieurs fichiers, avec des onglets au-dessus de l'éditeur. ▶ Exécuter lance toujours index.php, qui inclut les autres.

L'héritage : extends

Un livret d'épargne est un compte, avec un taux d'intérêt en plus. Plutôt que de tout réécrire, on crée une classe enfant qui hérite de la classe parente avec extends : elle reçoit toutes ses propriétés et méthodes, et peut en ajouter.

<?php
class Livret extends Compte
{
    public function __construct(string $titulaire, float $solde, private float $taux)
    {
        parent::__construct($titulaire, $solde);    // on laisse le parent faire sa part
    }

    public function ajouterInterets(): void
    {
        $this->solde += $this->solde * $this->taux / 100;
    }
}

$livret = new Livret("Tom", 1000, 3);
$livret->ajouterInterets();
echo $livret->decrire();        // Tom : 1030 €  (decrire() vient de Compte)

• parent::__construct(…) appelle le constructeur de la classe parente, pour qu'elle remplisse ses propres propriétés ;
• Livret n'a pas écrit decrire() : elle l'a reçue de Compte.

private ou protected ?

Une propriété private n'est visible que dans sa classe : même une classe enfant ne peut pas la lire. C'est pour ça que $solde est protected dans Compte : protected = visible dans la classe et dans ses classes enfants, mais toujours pas depuis l'extérieur.

Redéfinir une méthode

Une classe enfant peut redéfinir une méthode du parent en écrivant une méthode du même nom. Avec parent::nom(), elle peut quand même réutiliser la version du parent :

<?php
class Livret extends Compte
{
    // … constructeur et ajouterInterets() comme plus haut …

    public function decrire(): string
    {
        return parent::decrire() . " (taux : $this->taux %)";
    }
}

echo $livret->decrire();     // Tom : 1030 € (taux : 3 %)

Signaler une erreur : les exceptions

Quand une méthode reçoit une valeur impossible (un dépôt de -50 €), le plus propre est de lancer une exception avec throw. Le programme s'arrête net… sauf si le code qui a appelé la méthode l'attrape avec try / catch.

<?php
class Compte
{
    // …
    public function deposer(float $montant): void
    {
        if ($montant <= 0) {
            throw new InvalidArgumentException("Montant invalide : $montant");
        }
        $this->solde += $montant;
    }
}

try {
    $compte->deposer(-50);
    echo "Dépôt fait";               // jamais exécuté : l'exception saute directement au catch
} catch (InvalidArgumentException $e) {
    echo "Erreur : " . $e->getMessage();   // Erreur : Montant invalide : -50
}

InvalidArgumentException est une classe d'exception fournie par PHP (« argument invalide »). $e est l'objet exception, et sa méthode getMessage() renvoie le texte donné à new.