Comment fonctionnent l'héritage, les classes abstraites et les interfaces ?

Question

Accepted Answer

PHP supporte l'héritage OOP et l'abstraction à travers trois mécanismes liés : **l'héritage de classe** (`extends`), **les classes abstraites** (classes de base partielles), et **les interfaces** (contrats). Chacun sert un objectif de conception différent.

## Héritage — étendre une classe parent

```php
<?php
class Animal {
    public function __construct(protected string $name) {}
    public function eat(): string { return "{$this->name} eats"; }
}

class Dog extends Animal {              // Dog inherits Animal's members
    public function bark(): string { return "Woof"; }
    public function eat(): string {     // override
        return parent::eat() . " noisily";   // parent:: calls the superclass method
    }
}
```

Une sous-classe `extends` une classe parente, héritan et optionnellement surchargeant ses membres. `parent::` appelle la méthode parent surchargée. PHP supporte **l'héritage unique** (un seul parent).

## Classes abstraites — une base partielle (ne peut pas être instanciée)

```php
abstract class Shape {
    abstract public function area(): float;     // abstract — subclasses MUST implement
    public function describe(): string {         // concrete — shared implementation
        return "Area: " . $this->area();
    }
}
class Circle extends Shape {
    public function __construct(private float $r) {}
    public function area(): float { return 3.14159 * $this->r ** 2; }   // must implement
}
// new Shape();  // ❌ error — abstract classes can't be instantiated
```

Une **classe abstraite** mélange les méthodes abstraites (que les sous-classes doivent implémenter) avec du code concret partagé — une base qui ne peut pas être instanciée directement.

## Interfaces — des contrats purs (plusieurs autorisées)

```php
interface Drawable {
    public function draw(): void;       // only signatures — no implementation
}
interface Serializable {
    public function serialize(): string;
}

class Widget implements Drawable, Serializable {   // implement MULTIPLE interfaces
    public function draw(): void { /* ... */ }
    public function serialize(): string { return "..."; }
}
```

Une **interface** définit un contrat (signatures de méthodes, pas d'implémentation). Une classe peut `implement` **plusieurs** interfaces — la façon de PHP de contourner l'héritage unique pour partager les capacités.

## Quand utiliser laquelle

```text
extends (inheritance) → "is-a" relationship, reuse + override behavior
abstract class → a base with SHARED code + methods subclasses must implement (single)
interface → a CONTRACT/capability multiple unrelated classes can fulfill (multiple)
→ "Program to an interface" — depend on interfaces for flexible, testable designs.
```

## Pourquoi c'est important

L'héritage, les classes abstraites et les interfaces sont des outils OOP fondamentaux, et comprendre les distinctions est important pour concevoir des applications PHP bien structurées (et pour travailler avec les frameworks, qui s'appuient fortement sur ceux-ci). **L'héritage** (`extends`) fournit la réutilisation de code via les relations « is-a », mais PHP n'autorise que l'héritage unique. **Les classes abstraites** fournissent une base partagée avec à la fois du code implémenté et des méthodes que les sous-classes doivent définir — bon pour les classes étroitement liées partageant une logique. **Les interfaces** définissent des contrats/capacités, et de manière cruciale une classe peut implémenter **plusieurs** d'entre elles — ce qui rend les interfaces clés pour des conceptions flexibles et découplées, et la réponse de PHP à la limitation de l'héritage unique.

Savoir quand utiliser laquelle (l'héritage pour la réutilisation is-a, les classes abstraites pour l'implémentation partielle partagée, les interfaces pour les contrats/capacités), et le principe de **programmation vers les interfaces** (dépendre des abstractions pour du code testable, flexible et framework-friendly), est une connaissance importante pour la conception orientée objet en PHP.

Ces mécanismes sous-tendent la façon dont les frameworks comme Laravel et Symfony structurent leur code (interfaces et classes de base abstraites partout), ce qui les rend essentiels à la fois pour concevoir votre propre code correctement et pour comprendre les frameworks sur lesquels vous vous appuyez.