PHP Academy · Leçon

Étendre des classes par héritage

Utiliser extends pour créer des hiérarchies de classes et redéfinir des méthodes.

Étendre des classes par héritage est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Introduction : héritage en PHP

L'héritage permet à une classe (enfant) de réutiliser et d'étendre le code d'une autre classe (parent) à l'aide du mot-clé extends. PHP prend en charge l'héritage simple.

Concepts clés

Concepts clés :

L'enfant hérite de tous les membres publics et protégés
Remplacez les méthodes parentes pour modifier le comportement
Appelez une méthode parente avec parent::
Utilisez final pour empêcher le remplacement

extends de base

Exemple :

<?php
class Shape {
    public function __construct(protected string $color) {}
    public function describe(): string { return "A {$this->color} shape"; }
}

class Circle extends Shape {
    public function __construct(string $color, private float $radius) {
        parent::__construct($color);
    }
    public function area(): float { return M_PI * $this->radius ** 2; }
}

$c = new Circle('red', 5);
echo $c->describe();   // A red shape
echo round($c->area()); // 79

Remplacement de méthodes

Suite :

<?php
class Logger {
    public function log(string $msg): void {
        echo "[LOG] $msg" . PHP_EOL;
    }
}

class DatabaseLogger extends Logger {
    public function log(string $msg): void {
        // Extend parent behavior
        parent::log($msg);
        // Also save to DB
        echo "[DB] Saved: $msg" . PHP_EOL;
    }
}

$l = new DatabaseLogger();
$l->log('User login');

Mot-clé final

Pour aller plus loin :

<?php
class PaymentProcessor {
    final public function processPayment(float $amount): void {
        // Critical logic — cannot be overridden
        $this->validate($amount);
        $this->charge($amount);
        $this->log($amount);
    }

    protected function validate(float $amount): void { /* ... */ }
    protected function charge(float $amount): void   { /* ... */ }
    protected function log(float $amount): void      { /* ... */ }
}

Vérification avec instanceof

Utilisation pratique :

<?php
class Vehicle {}
class Car extends Vehicle {}
class ElectricCar extends Car {}

$ev = new ElectricCar();

var_dump($ev instanceof ElectricCar); // true
var_dump($ev instanceof Car);         // true
var_dump($ev instanceof Vehicle);     // true

// Also works with interfaces
var_dump($ev instanceof Countable);   // false

Classe de base abstraite

Utilisation avancée :

<?php
abstract class Notification {
    abstract public function send(string $message): bool;

    public function sendBatch(array $messages): void {
        foreach ($messages as $msg) {
            $this->send($msg);
        }
    }
}

class EmailNotification extends Notification {
    public function send(string $message): bool {
        echo "Email: $message" . PHP_EOL;
        return true;
    }
}

Modèle

Les modèles courants d'héritage en PHP servent à résoudre proprement des problèmes de conception récurrents. Appliquez-les de manière cohérente pour obtenir un code lisible et facile à maintenir.

Quand l'utiliser

Savoir quand appliquer l'héritage en PHP est aussi important que de savoir comment le faire. Une utilisation excessive entraîne de la complexité ; une utilisation insuffisante entraîne des duplications.

Exemple concret

Dans les applications réelles, l'héritage en PHP apparaît fréquemment dans les frameworks, les ORM et les couches de services. Le comprendre vous prépare à contribuer à des projets PHP professionnels.

Pièges courants

Évitez ces erreurs avec l'héritage en PHP :

Appelez toujours parent::__construct() pour initialiser l'état de la classe parente
Ne remplacez pas une méthode uniquement pour appeler la méthode parente sans modification
Utilisez final pour les méthodes essentielles à la sécurité
Préférez la composition aux hiérarchies d'héritage profondes

Vérification rapide

Quel mot-clé empêche le remplacement d'une méthode dans une sous-classe ?

Récapitulatif : héritage en PHP

Résumé :

Appelez toujours parent::__construct() pour initialiser l'état de la classe parente
Ne remplacez pas une méthode uniquement pour appeler la méthode parente sans modification
Utilisez final pour les méthodes essentielles à la sécurité
Préférez la composition aux hiérarchies d'héritage profondes

Questions Fréquemment Posées

La leçon « Étendre des classes par héritage » est-elle gratuite ?

Oui — le texte complet de « Étendre des classes par héritage » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Étendre des classes par héritage » ?

Utiliser extends pour créer des hiérarchies de classes et redéfinir des méthodes. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Étendre des classes par héritage » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à PHP Academy