Interfaces & polymorphisme

Une interface, c'est un contrat

Une interface liste des méthodes sans les implémenter : c'est une promesse. Une classe qui implements une interface s'engage à fournir toutes ces méthodes. Le reste du code peut alors lui faire confiance sans connaître son type exact : c'est le polymorphisme vu dans le cours POO, en PHP.

interface MoyenPaiement {
    public function payer(float $montant): string;   // signature, pas de corps
}

class CarteBancaire implements MoyenPaiement {
    public function payer(float $montant): string {
        return "Payé $montant € par carte";
    }
}
class Paypal implements MoyenPaiement {
    public function payer(float $montant): string {
        return "Payé $montant € via PayPal";
    }
}

Une classe peut implémenter plusieurs interfaces (séparées par des virgules), contrairement à extends qui n'autorise qu'un seul parent.

Dépendre de l'interface, pas de l'implémentation

La règle d'or : une fonction doit dépendre du contrat (l'interface), pas d'une classe précise. Ainsi elle accepte n'importe quel moyen de paiement, présent ou futur.

// On type avec l'INTERFACE : accepte carte, PayPal, ou tout futur moyen
function encaisser(MoyenPaiement $moyen, float $montant): void {
    echo $moyen->payer($montant) . "\n";
}

encaisser(new CarteBancaire(), 50);
encaisser(new Paypal(), 30);
// Demain : une classe ApplePay implements MoyenPaiement → marche sans rien changer ici

Polymorphisme : exécute

Une seule boucle, plusieurs types : chaque objet répond à sa façon au même appel payer().

<?php
interface MoyenPaiement {
    public function payer(float $montant): string;
}
class CarteBancaire implements MoyenPaiement {
    public function payer(float $m): string { return "💳 $m € par carte"; }
}
class Paypal implements MoyenPaiement {
    public function payer(float $m): string { return "🅿  $m € via PayPal"; }
}
class Especes implements MoyenPaiement {
    public function payer(float $m): string { return "💶 $m € en espèces"; }
}

$moyens = [new CarteBancaire(), new Paypal(), new Especes()];
foreach ($moyens as $moyen) {            // ignore le type exact
    echo $moyen->payer(20) . "\n";
}
?>

Les enum : un type aux valeurs fixes

Comment représenter un ensemble fermé de valeurs ? Un statut de compte (actif, suspendu, supprimé), un rôle utilisateur, un jour de la semaine. Avant PHP 8.1, on utilisait des chaînes magiques ('actif') ou des constantes de classe. Le problème : une faute de frappe ('actfi') passe inaperçue, et rien n'empêche d'affecter une valeur arbitraire à une variable censée contenir un statut.

PHP 8.1 introduit enum : un type dont les seules valeurs possibles sont les case déclarés. On accède à un cas par Statut::Actif. On peut typer un paramètre function definir(Statut $s) : passer autre chose provoque une erreur. C'est sûr et auto-documenté.

<?php
// Enum "adossé" (backed) : chaque case a une valeur scalaire associée (string ou int)
enum Statut: string {
    case Actif    = 'actif';
    case Suspendu = 'suspendu';
    case Supprime = 'supprime';

    public function label(): string {
        return match($this) {
            Statut::Actif    => 'Compte actif',
            Statut::Suspendu => 'Compte suspendu',
            Statut::Supprime => 'Compte supprimé',
        };
    }
}

$s = Statut::Actif;
echo $s->value . "\n";       // actif  (valeur scalaire)
echo $s->label() . "\n";    // Compte actif

// Reconstruire depuis une valeur : from() (erreur si invalide) ou tryFrom() (renvoie null)
$t = Statut::tryFrom('suspendu');
echo ($t !== null ? $t->label() : 'invalide') . "\n"; // Compte suspendu

$u = Statut::tryFrom('inconnu');
echo ($u !== null ? $u->label() : 'valeur invalide') . "\n"; // valeur invalide
?>

Le lien avec cette leçon : un enum peut avoir des méthodes et implémenter une interface. Il reste un objet à part entière, et PHP garantit qu'il respecte le contrat.

<?php
interface Affichable {
    public function label(): string;
}

enum Statut: string implements Affichable {
    case Actif    = 'actif';
    case Suspendu = 'suspendu';
    case Supprime = 'supprime';

    public function label(): string {
        return match($this) {
            Statut::Actif    => 'Compte actif',
            Statut::Suspendu => 'Compte suspendu',
            Statut::Supprime => 'Compte supprimé',
        };
    }
}

// Une fonction typée sur l'interface accepte n'importe quel Affichable,
// y compris un cas d'enum : polymorphisme sans classe concrète
function afficher(Affichable $item): void {
    echo $item->label() . "\n";
}

foreach (Statut::cases() as $cas) {   // cases() liste tous les cas
    afficher($cas);
}
?>