Composition ou héritage

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy. Leçon 56 sur 91.

Dans le chapitre précédent, tu as appris que les traits fournissent une capacité « has-a », tandis que l’héritage établit une relation « is-a ». La composition approfondit le concept « has-a » en construisant des objets complexes à partir d’objets plus simples, en les stockant comme propriétés plutôt qu’en héritant d’eux.

Avec l’héritage, une Car peut étendre Vehicle. Avec la composition, une Car contient un objet Engine :

<?php
class Engine {
    public function start(): string {
        return "Engine started";
    }
}

class Car {
    private Engine $engine;
    
    public function __construct() {
        $this->engine = new Engine();
    }
    
    public function start(): string {
        return $this->engine->start();
    }
}

$car = new Car();
echo $car->start();

Sortie :

Engine started

La classe Car n’hérite pas de Engine : elle en possède un. Cette approche offre des avantages considérables : tu peux remplacer le moteur par une autre implémentation, les classes restent faiblement couplées et tu évites les hiérarchies rigides que crée l’héritage profond.

Une recommandation courante en POO est de « préférer la composition à l’héritage ». L’héritage fonctionne bien pour les véritables hiérarchies de types (un Dog est réellement un Animal), mais la composition est particulièrement adaptée lorsque vous assemblez des fonctionnalités à partir de parties indépendantes. Vous pouvez combiner plusieurs objets, les remplacer à l’exécution et tester les composants de manière isolée.

La prochaine leçon explore l’injection de dépendances, qui s’appuie directement sur la composition en contrôlant la manière dont les objets reçoivent leurs dépendances.

Défi

Facile

Construisons un système informatique en utilisant la composition, où un Computer est assemblé à partir d’objets composants distincts plutôt que d’en hériter. Cela montre comment la composition vous permet de construire des objets complexes à partir de parties plus simples et indépendantes.

Vous organiserez votre code sur trois fichiers :

Processor.php : créez une classe Processor qui représente un CPU. Utilisez la promotion des propriétés du constructeur pour définir un $model privé (chaîne de caractères) et un $cores privé (entier). Ajoutez une méthode getSpecs() qui renvoie "[model] ([cores] cores)".
Memory.php : créez une classe Memory qui représente la RAM. Utilisez la promotion des propriétés du constructeur pour définir un $size privé (entier représentant des Go). Ajoutez une méthode getCapacity() qui renvoie "[size]GB RAM".
main.php : incluez les deux fichiers de composants et créez une classe Computer qui utilise la composition. La classe Computer doit :
- Stocker un objet Processor et un objet Memory en tant que propriétés privées
- Accepter un modèle de processeur, un nombre de cœurs et une capacité mémoire dans son constructeur
- Créer les objets composants en interne lors de la construction
- Disposer d’une méthode describe() qui renvoie "Computer with [processor specs] and [memory capacity]"
Vous recevrez trois entrées : un modèle de processeur, un nombre de cœurs et une capacité mémoire en Go. Créez un Computer avec ces spécifications et affichez le résultat de l’appel à describe().

Remarquez que Computer n’étend ni Processor ni Memory. Il les contient. Cette relation de type « possède-un », obtenue grâce à la composition, permet à chaque composant de rester indépendant et réutilisable, tout en permettant à Computer de déléguer certaines tâches à ses composants lorsque cela est nécessaire.

Essayez vous-même

<?php
require_once 'Processor.php';
require_once 'Memory.php';

class Computer
{
    // TODO: Définir des propriétés privées pour stocker les objets Processor et Memory

    // TODO: Le constructeur doit accepter le modèle du processeur, le nombre de cœurs et la taille de la mémoire
    // et créer les objets composants en interne
    public function __construct()
    {
        // TODO: Créer les objets Processor et Memory et les stocker
    }

    // TODO: Implémenter la méthode describe() qui retourne
    // "Computer with [processor specs] and [memory capacity]"
    public function describe(): string
    {
        // TODO: Déléguer aux objets composants et retourner la chaîne formatée
    }
}

// Lire l'entrée
$processorModel = trim(fgets(STDIN));
$cores = intval(fgets(STDIN));
$memorySize = intval(fgets(STDIN));

// TODO: Créer un Computer avec les spécifications données et afficher le résultat de describe()

?>