Classes abstraites

Objectifs pédagogiques

• Comprendre le rôle et l'intérêt d'une classe abstraite.
• Différencier classe concrète, classe abstraite et interface.
• Implémenter une hiérarchie avec des comportements partagés et spécifiques.

Définition

Une classe abstraite est une classe qui ne peut pas être instanciée directement. Elle sert de modèle de base pour d’autres classes qui vont en hériter.

Elle peut contenir :

• des méthodes concrètes (déjà implémentées),
• des méthodes abstraites (déclarées mais sans corps, à implémenter dans les classes enfants).

Exemple

<?php

abstract class Vehicle {
    protected string $brand;

    public function __construct(string $brand) {
        $this->brand = $brand;
    }

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

    abstract public function move(): string;
}

class Car extends Vehicle {
    public function move(): string {
        return "The car is driving";
    }
}

$car = new Car("Toyota");
echo $car->getBrand(); // Toyota
echo $car->move();     // The car is driving

Explication

• Vehicle est une classe abstraite : elle ne peut pas être instanciée.
• Elle impose à toutes les classes qui en héritent d'implémenter la méthode move().
• Car hérite de Vehicle et fournit une version concrète de move().

Pourquoi utiliser des classes abstraites ?

• Factoriser du code commun à plusieurs classes enfants.
• Obliger les développeurs à implémenter certaines méthodes spécifiques.
• Encadrer la conception en définissant des structures génériques.

Règles à connaître

• Une classe abstraite peut contenir des méthodes concrètes.
• Une classe contenant au moins une méthode abstraite doit être déclarée abstract.
• Une classe enfant doit implémenter toutes les méthodes abstraites du parent, sauf si elle est elle-même abstraite.
• On ne peut pas faire new AbstractClass().

Comparaison avec les interfaces

Caractéristique	Classe abstraite	Interface
Peut contenir du code	✅ Oui	❌ Non
Peut avoir des propriétés	✅ Oui	❌ Non
Peut définir des méthodes abstraites	✅ Oui	✅ Oui
Multiple implémentation	❌ Non	✅ Oui
Peut avoir un constructeur	✅ Oui	❌ Non

Bonnes pratiques

• Préférer les classes abstraites lorsqu’il y a du code commun à partager entre les classes.
• Utiliser une interface lorsque l’on souhaite définir uniquement une signature de comportement.
• Toujours documenter les méthodes abstraites attendues.

Conclusion

Les classes abstraites permettent de poser un cadre fort pour l’architecture logicielle, en décrivant les comportements obligatoires tout en réutilisant du code existant. Elles jouent un rôle clé dans la structuration de vos objets métier.