Acoplamiento secuencial.

En la programación orientada a objetos, el acoplamiento secuencial (también conocido como acoplamiento temporal) es una forma de acoplamiento en la que una clase requiere que sus métodos se llamen en una secuencia concreta. Dependiendo del contexto, esto puede ser un antipatrón.

Los métodos cuyo nombre empieza por Init, Begin, Start, etc. pueden indicar la existencia de acoplamiento secuencial.

Usando un coche como analogía, si el usuario pisa el acelerador sin haber arrancado primero el motor, el coche no se bloquea, ni falla, ni lanza una excepción: simplemente no acelera.

El acoplamiento secuencial se puede refactorizar con el patrón método plantilla para superar los problemas que plantea el uso de este antipatrón.

Ejemplo

Este Parser solo funciona si sus métodos se llaman exactamente en el orden correcto. Su interfaz no lo indica en ningún sitio: si se olvida tokenize(), buildTree() falla en tiempo de ejecución con una NullPointerException.

class Client {
    Node run(String text) {
        Parser parser = new Parser();
        parser.setInput(text); // debe llamarse primero
        parser.tokenize();     // debe llamarse en segundo lugar
        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 se omitió tokenize()
}

Ahora un único método público ejecuta los pasos y entrega a cada uno el resultado del anterior, de modo que el orden incorrecto ya no se puede escribir:

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)); }
}

Si las subclases deben personalizar pasos concretos, el patrón Template Method ofrece la misma garantía: la clase base fija el orden y las subclases solo redefinen los pasos.

Adaptado del artículo de Wikipedia “Sequential coupling” (revisión 1320717439), disponible bajo la licencia CC BY-SA 4.0; el texto ha sido traducido y editado, y se han añadido ejemplos.