abstract

Le mot-clé abstract en PHP

Le mot-clé abstract marque une classe ou une méthode comme volontairement incomplète. Une classe abstraite définit une structure commune et un comportement partagé, mais ne peut pas être transformée directement en objet — elle existe pour être étendue. Une méthode abstraite déclare la signature d'une méthode sans corps, forçant chaque sous-classe concrète à fournir l'implémentation réelle.

Cette page explique ce que sont les classes et méthodes abstraites, comment les déclarer, les règles imposées par PHP, et dans quels cas utiliser abstract est le bon choix de conception.

Qu'est-ce qu'une classe abstraite ?

Une classe abstraite est une classe que vous ne pouvez pas instancier directement. Elle est destinée à être étendue par d'autres classes qui complètent les parties manquantes. Une classe abstraite peut mélanger deux types de membres :

• Méthodes abstraites — déclarées mais non implémentées, laissant le travail aux sous-classes.
• Méthodes et propriétés concrètes — entièrement implémentées et héritées telles quelles, ce qui permet de centraliser la logique partagée.

La règle est unidirectionnelle : une classe comportant au moins une méthode abstraite doit être déclarée abstract. L'inverse n'est pas obligatoire — une classe peut être abstraite sans avoir de méthodes abstraites, simplement pour empêcher son instanciation.

<?php

abstract class Animal {
    // Concrete method — inherited by every subclass unchanged
    public function describe(): string {
        return "I am a " . static::class . " and I say " . $this->makeSound();
    }

    // Abstract method — each subclass must implement it
    abstract public function makeSound(): string;
}

Qu'est-ce qu'une méthode abstraite ?

Une méthode abstraite est déclarée avec le mot-clé abstract, n'a pas de corps et se termine par un point-virgule à la place de { ... }. Son rôle est de définir un contrat : toute sous-classe qui souhaite être concrète doit fournir une implémentation compatible.

<?php

abstract public function makeSound(): string; // signature only, no body

Une sous-classe doit garder la méthode compatible avec la déclaration abstraite — les mêmes paramètres (ou des paramètres compatibles) et une visibilité égale ou moins restrictive que l'originale.

Comment définir une classe et une méthode abstraites

Placez abstract avant class pour rendre la classe abstraite, et avant function pour rendre une méthode abstraite. Voici le schéma complet — une classe de base avec une méthode partagée et une méthode abstraite, ainsi que deux sous-classes concrètes :

<?php

abstract class Animal {
    public function describe(): string {
        return static::class . " says " . $this->makeSound();
    }

    abstract public function makeSound(): string;
}

class Dog extends Animal {
    public function makeSound(): string {
        return "Woof!";
    }
}

class Cat extends Animal {
    public function makeSound(): string {
        return "Meow!";
    }
}

echo (new Dog())->describe(), "\n"; // Dog says Woof!
echo (new Cat())->describe(), "\n"; // Cat says Meow!

Chaque sous-classe implémente makeSound() et hérite de describe() gratuitement — cette méthode partagée est précisément ce qui rend une classe de base abstraite plus utile qu'une simple interface dans ce cas.

Que se passe-t-il si vous instanciez une classe abstraite ?

Tenter de créer un objet à partir d'une classe abstraite provoque une erreur fatale, détectée à la compilation :

<?php

abstract class Animal {
    abstract public function makeSound(): string;
}

$a = new Animal();
// Fatal error: Cannot instantiate abstract class Animal

La même erreur se produit si une sous-classe oublie d'implémenter une méthode abstraite héritée — PHP considère alors cette sous-classe comme toujours abstraite.

Règles et pièges à éviter

• Une classe contenant une méthode abstraite doit être déclarée abstract.
• Les méthodes abstraites ne peuvent pas être private — les sous-classes ne pourraient pas les voir pour les redéfinir. Utilisez public ou protected.
• Les méthodes abstraites ne peuvent pas être final (elles sont destinées à être redéfinies) et, depuis PHP 8.0, ne peuvent pas être static de façon vraiment redéfinissable — préférez les méthodes abstraites d'instance.
• Une classe abstraite peut avoir un constructeur ; les sous-classes l'appellent avec parent::__construct().
• Une sous-classe qui n'implémente pas toutes les méthodes abstraites héritées doit elle-même être déclarée abstract.

Classe abstraite vs Interface

Les deux définissent un contrat, mais elles répondent à des questions différentes :

• Une classe abstraite (relation « est-un ») peut contenir des méthodes concrètes, des propriétés et des constructeurs. Une classe ne peut étendre qu'une seule classe abstraite.
• Une interface (relation « peut faire ») ne déclare que des signatures de méthodes (sans implémentation, sans état d'instance) et une classe peut en implémenter plusieurs.

Choisissez une classe abstraite quand les sous-classes partagent une implémentation réelle ; choisissez une interface quand vous avez seulement besoin de garantir une capacité. Consultez PHP Inheritance et PHP Interfaces pour en savoir plus.

Conclusion

Le mot-clé abstract vous permet de définir un modèle partiel : une classe abstraite fournit un comportement partagé tout en déclarant des méthodes abstraites que chaque sous-classe concrète doit implémenter. Vous ne pouvez pas instancier une classe abstraite directement — c'est précisément son intérêt. Utilisez-la lorsque plusieurs classes apparentées partagent de la logique mais que chacune doit personnaliser des étapes spécifiques, et préférez une interface lorsqu'aucune implémentation partagée n'est impliquée.

Pratique