Les patrons de conception

Ce chapitre prolonge les séquences 10 et 12.

Un patron de conception décrit un problème de conception qui revient souvent, les contraintes qui s'y opposent, une solution générique et ses inconvénients. Il ne s'agit donc pas d'un morceau de code à recopier.

Le vocabulaire vient de la Bande des Quatre (Gamma, Helm, Johnson, Vlissides, 1994), qui range les patrons en trois familles : création, structure, comportement.

Les trois patrons certifiés

Stratégie : un algorithme interchangeable

Le problème. Un comportement a plusieurs variantes, et l'on veut pouvoir en changer sans modifier le code qui l'utilise, parfois pendant l'exécution.

C'est le cas de VolStrategy, déjà vu aux chapitres 4 et 5.

interface VolStrategy { void voler(); }

class VolerAvecAiles implements VolStrategy {
    public void voler() { System.out.println("je vole"); }
}

class NePasVoler implements VolStrategy {
    public void voler() { System.out.println("je ne vole pas"); }
}

class Canard {
    private VolStrategy vol;
    Canard(VolStrategy vol) { this.vol = vol; }
    void effectuerVol()  { vol.voler(); }
    void equiper(VolStrategy v) { this.vol = v; }    // changement à chaud
}

Quand y penser. Un switch ou une suite de if sur un type ou un mode, répété à plusieurs endroits.

Fabrique : déporter la décision du type concret

Le problème. La classe à instancier dépend d'une donnée, et l'on ne veut pas que chaque appelant connaisse toutes les classes concrètes.

interface Paiement { void debiter(int centimes); }

class PaiementCarte  implements Paiement { public void debiter(int c) { } }
class PaiementPaypal implements Paiement { public void debiter(int c) { } }

class FabriquePaiement {
    static Paiement pour(String mode) {
        if ("carte".equals(mode))  return new PaiementCarte();
        if ("paypal".equals(mode)) return new PaiementPaypal();
        throw new IllegalArgumentException("mode inconnu : " + mode);
    }
}

Le switch existe toujours, mais il est regroupé en un seul endroit. Pour ajouter un moyen de paiement, il suffit de modifier la fabrique au lieu de reprendre chaque appelant.

Quand y penser. Le même new conditionnel recopié dans plusieurs classes.

Décorateur : ajouter une responsabilité à l'exécution

Le problème. On veut ajouter des fonctionnalités à un objet sans créer de sous-classe, et pouvoir combiner ces ajouts dans l'ordre voulu.

interface Document { byte[] octets(); }

class DocumentSimple implements Document {
    public byte[] octets() { return "coin".getBytes(); }
}

class DocumentCompresse implements Document {
    private final Document interne;
    DocumentCompresse(Document d) { this.interne = d; }
    public byte[] octets() { return compresser(interne.octets()); }
}

class DocumentChiffre implements Document {
    private final Document interne;
    DocumentChiffre(Document d) { this.interne = d; }
    public byte[] octets() { return chiffrer(interne.octets()); }
}

// L'ordre compte : on compresse, puis on chiffre.
Document d = new DocumentChiffre(new DocumentCompresse(new DocumentSimple()));

Avec l'héritage, il aurait fallu écrire DocumentCompresseEtChiffre, DocumentChiffreEtCompresse, et une nouvelle classe pour chaque combinaison. On retrouve l'argument des deux axes du chapitre 4, appliqué ici à l'ajout de fonctionnalités.

Quand y penser. Des sous-classes dont le nom contient un « et ».

Les autres patrons, pour référence

Ces patrons ne sont pas certifiés. Ils sont présentés pour que vous les reconnaissiez si vous les rencontrez, par exemple lors d'une revue de code.

public final class Ressources {
    private Ressources() {}
    private static class Porteur { static final Ressources I = new Ressources(); }
    public static Ressources get() { return Porteur.I; }
}

Rapport r = new Rapport.Monteur()
        .titre("Bilan T3").auteur("Équipe BI").filigrane(true).monter();

interface VitesseKmH { double kmh(); }
class VoitureTierce { double mph() { return 120.0; } }

class AdaptateurVitesse implements VitesseKmH {
    private final VoitureTierce v;
    AdaptateurVitesse(VoitureTierce v) { this.v = v; }
    public double kmh() { return v.mph() * 1.60934; }
}

class BusEvenements {
    private final List<Abonne> abonnes = new ArrayList<>();
    void abonner(Abonne a) { abonnes.add(a); }
    void publier(Commande c) { for (Abonne a : abonnes) a.surCommande(c); }
}

Choisir un patron