Couplage séquentiel.

En programmation orientée objet, le couplage séquentiel (également appelé couplage temporel) est une forme de couplage où une classe exige que ses méthodes soient appelées dans un ordre précis. Selon le contexte, il peut s'agir d'un anti-patron.

Les méthodes dont le nom commence par Init, Begin, Start, etc. peuvent signaler l'existence d'un couplage séquentiel.

Pour reprendre l'analogie de la voiture, si l'utilisateur appuie sur l'accélérateur sans avoir d'abord démarré le moteur, la voiture ne plante pas, ne tombe pas en panne et ne lève pas d'exception - elle se contente de ne pas accélérer.

Le couplage séquentiel peut être remanié à l'aide du patron de méthode (template method) afin de surmonter les problèmes posés par l'utilisation de cet anti-patron.

Exemple

Ce Parser ne fonctionne que si ses méthodes sont appelées exactement dans le bon ordre. Rien dans son interface ne l’indique : si l’on oublie tokenize(), buildTree() échoue à l’exécution avec une NullPointerException.

class Client {
    Node run(String text) {
        Parser parser = new Parser();
        parser.setInput(text); // doit être appelée en premier
        parser.tokenize();     // doit être appelée en second
        return parser.buildTree();
    }
}

class Parser {
    private String input;
    private List<String> tokens;

    void setInput(String text) { this.input = text; }
    void tokenize() { tokens = List.of(input.trim().split("\\s+")); }
    Node buildTree() { return new Node(List.copyOf(tokens)); } // NullPointerException si tokenize() a été oubliée
}

Désormais, une seule méthode publique enchaîne les étapes et transmet à chacune le résultat de la précédente : un ordre incorrect ne peut tout simplement plus s’écrire.

class Client {
    Node run(String text) {
        return new Parser().parse(text);
    }
}

final class Parser {
    Node parse(String text) {
        List<String> tokens = tokenize(text);
        return buildTree(tokens);
    }

    private List<String> tokenize(String text) { return List.of(text.trim().split("\\s+")); }
    private Node buildTree(List<String> tokens) { return new Node(List.copyOf(tokens)); }
}

Lorsque des sous-classes doivent personnaliser certaines étapes, le Patron de méthode offre la même garantie : la classe de base fixe l’ordre et les sous-classes ne redéfinissent que les étapes.

Adapté de l’article Wikipédia “Sequential coupling” (révision 1320717439), disponible sous licence CC BY-SA 4.0 ; le texte a été traduit et modifié, et des exemples ont été ajoutés.