Acoplamento sequencial.

Na programação orientada a objetos, o acoplamento sequencial (também conhecido como acoplamento temporal) é uma forma de acoplamento em que uma classe exige que seus métodos sejam chamados em uma sequência específica. Isso pode ser um antipadrão, dependendo do contexto.

Métodos cujo nome começa com Init, Begin, Start, etc. podem indicar a existência de acoplamento sequencial.

Usando um carro como analogia, se o usuário pisar no acelerador sem antes ligar o motor, o carro não trava, não falha nem lança uma exceção - ele simplesmente não acelera.

O acoplamento sequencial pode ser refatorado com o padrão template method para superar os problemas decorrentes do uso desse antipadrão.

Exemplo

Este Parser só funciona se seus métodos forem chamados exatamente na ordem certa. Nada na interface informa isso: basta esquecer tokenize() para que buildTree() falhe em tempo de execução com uma NullPointerException.

class Client {
    Node run(String text) {
        Parser parser = new Parser();
        parser.setInput(text); // deve ser chamado primeiro
        parser.tokenize();     // deve ser chamado em 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 se tokenize() foi esquecido
}

Agora um único método público executa as etapas e entrega a cada uma o resultado da anterior, de modo que a ordem errada simplesmente não pode mais ser escrita:

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

Quando subclasses precisam personalizar etapas específicas, o padrão Template Method dá a mesma garantia: a classe base fixa a ordem e as subclasses sobrescrevem apenas as etapas.

Adaptado do artigo da Wikipédia “Sequential coupling” (revisão 1320717439), disponível sob a licença CC BY-SA 4.0; o texto foi traduzido e editado, e exemplos foram adicionados.