Classes anonymes

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy — leçon 58 sur 91.

Parfois, vous avez besoin d'un objet simple et unique sans la lourdeur de définir une classe complète. Les classes anonymes vous permettent de créer des objets à la volée, exactement là où vous en avez besoin. Elles sont particulièrement utiles lorsqu'elles sont combinées avec l'injection de dépendances.

Une classe anonyme est définie en utilisant new class suivi par le corps de la classe :

<?php
$logger = new class {
    public function log(string $message): void {
        echo "Log: $message";
    }
};

$logger->log("Hello!");

Sortie :

Log: Hello!

Les classes anonymes deviennent puissantes lors de l'implémentation d'interfaces. C'est parfait pour les tests ou lorsque vous avez besoin d'une implémentation rapide sans encombrer votre base de code avec des classes à usage unique :

<?php
interface Notifier {
    public function send(string $message): string;
}

function notify(Notifier $notifier, string $msg): string {
    return $notifier->send($msg);
}

$result = notify(new class implements Notifier {
    public function send(string $message): string {
        return "Sent: $message";
    }
}, "Test message");

echo $result;

Sortie :

Sent: Test message

Les classes anonymes peuvent également étendre d'autres classes, utiliser des traits et accepter des arguments de constructeur. Elles ont un accès complet aux fonctionnalités de la POO — elles sont simplement définies en ligne plutôt que dans un fichier séparé. Utilisez-les lorsqu'une définition de classe complète serait excessive, mais que vous avez tout de même besoin d'un comportement orienté objet.

Défi

Facile

Construisons un système de formatage de données qui démontre la puissance des classes anonymes. Au lieu de créer des fichiers de classe séparés pour des implémentations simples et uniques, vous utiliserez des classes anonymes pour créer des implémentations rapides directement là où vous en avez besoin.

Vous organiserez votre code sur deux fichiers :

FormatterInterface.php — Définissez une interface nommée FormatterInterface avec une seule méthode format(string $data): string. Cela établit le contrat que tout formateur doit suivre.
main.php — Incluez le fichier de l'interface et créez une classe DataProcessor qui utilise l'injection de dépendances pour accepter n'importe quel formateur. La classe doit :
- Accepter une FormatterInterface dans son constructeur
- Avoir une méthode process(string $data) qui délègue au formateur injecté et retourne son résultat
Vous recevrez deux entrées : un type de format ("upper" ou "reverse") et une chaîne à formater.

En fonction du type de format, créez une classe anonyme qui implémente FormatterInterface :
- Pour "upper" : la méthode format() doit retourner les données converties en majuscules
- Pour "reverse" : la méthode format() doit retourner les données inversées
Injectez votre classe anonyme dans un DataProcessor, appelez process() avec la chaîne d'entrée, et affichez le résultat.

Cette approche est parfaite lorsque vous avez besoin d'une implémentation rapide sans encombrer votre base de code avec des fichiers de classe à usage unique. La classe anonyme est créée en ligne, implémente l'interface requise et peut être transmise partout où cette interface est attendue.

Aide-mémoire

Les classes anonymes vous permettent de créer des objets à la volée sans définir une classe complète. Elles sont définies en utilisant new class suivi du corps de la classe :

<?php
$logger = new class {
    public function log(string $message): void {
        echo "Log: $message";
    }
};

$logger->log("Hello!");

Les classes anonymes peuvent implémenter des interfaces, ce qui les rend utiles pour l'injection de dépendances et les tests :

<?php
interface Notifier {
    public function send(string $message): string;
}

function notify(Notifier $notifier, string $msg): string {
    return $notifier->send($msg);
}

$result = notify(new class implements Notifier {
    public function send(string $message): string {
        return "Sent: $message";
    }
}, "Test message");

Les classes anonymes supportent toutes les fonctionnalités de la POO : elles peuvent étendre d'autres classes, utiliser des traits et accepter des arguments de constructeur. Utilisez-les lorsqu'une définition de classe complète serait superflue mais que vous avez tout de même besoin d'un comportement orienté objet.

Essayez vous-même

<?php
require_once 'FormatterInterface.php';

// TODO: Créer une classe DataProcessor qui :
// - Accepte une FormatterInterface dans son constructeur
// - Possède une méthode process(string $data) qui délègue au formateur

// Lire l'entrée
$formatType = trim(fgets(STDIN));
$inputString = trim(fgets(STDIN));

// TODO: En fonction de $formatType ("upper" ou "reverse"), créer une classe anonyme
// qui implémente FormatterInterface
// - Pour "upper" : format() doit retourner la version en majuscules des données
// - Pour "reverse" : format() doit retourner la version inversée des données

// TODO: Créer un DataProcessor avec votre formateur de classe anonyme
// Appeler process() avec la chaîne d'entrée et afficher le résultat

?>