Patron État

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 74 sur 87.

Le pattern État est un patron de conception comportemental qui permet à un objet de modifier son comportement lorsque son état interne change. L’objet semble changer de classe, mais en réalité, il délègue son comportement à différents objets d’état. Pensez à un distributeur automatique : sa réponse lorsque vous appuyez sur un bouton dépend du fait qu’il soit en attente, qu’une somme d’argent ait été insérée ou qu’il distribue un produit.

Au lieu d’utiliser des instructions conditionnelles complexes pour gérer différents états, vous encapsulez chaque état dans sa propre classe. Le modèle implique un Contexte qui conserve une référence vers l’état actuel, ainsi que des classes État qui définissent le comportement de chaque état :

interface State {
    void handle(Context context);
}

class Context {
    private State state;
    
    public void setState(State state) {
        this.state = state;
    }
    
    public void request() {
        state.handle(this);
    }
}

Chaque état concret implémente le comportement et peut déclencher des transitions vers d’autres états :

class IdleState implements State {
    public void handle(Context context) {
        System.out.println("Idle: Insert coin to start");
        context.setState(new ActiveState());
    }
}

class ActiveState implements State {
    public void handle(Context context) {
        System.out.println("Active: Processing...");
        context.setState(new IdleState());
    }
}

Le contexte délègue les requêtes à son état actuel, et le comportement change automatiquement lorsque l’état change :

Context context = new Context();
context.setState(new IdleState());

context.request();  // Idle : Insérez une pièce pour commencer
context.request();  // Active : Traitement...

Le patron d’état est idéal lorsque le comportement d’un objet dépend fortement de son état et doit changer lors de l’exécution. Il élimine les grands blocs conditionnels et facilite l’ajout de nouveaux états : il suffit de créer une nouvelle classe implémentant l’interface State.

Défi

Facile

Construisons un système de workflow de documents en utilisant le State Pattern ! Vous allez créer un système qui modélise la façon dont un document passe par différentes étapes, Brouillon, Révision et Publié, chaque état déterminant les actions disponibles et le comportement du document lorsque vous essayez de le modifier ou de l'approuver.

Vous allez organiser votre code sur quatre fichiers :

DocumentState.java : définissez l'interface DocumentState que tous les états implémenteront. Elle doit déclarer deux méthodes : edit(Document doc) pour tenter de modifier le document, et approve(Document doc) pour tenter d'approuver ou de faire passer le document à l'étape suivante.
States.java : créez trois classes d'état concrètes qui implémentent DocumentState :
DraftState - Lorsque edit est appelée, affichez Editing draft.... Lorsque approve est appelée, affichez Draft approved. Moving to review. et faites passer le document à ReviewState.

ReviewState - Lorsque edit est appelée, affichez Cannot edit during review. (aucun changement d'état). Lorsque approve est appelée, affichez Review complete. Publishing document. et faites passer le document à PublishedState.

PublishedState - Lorsque edit est appelée, affichez Cannot edit published document.. Lorsque approve est appelée, affichez Document already published.. Aucune des deux actions ne modifie l'état.
Document.java : créez la classe de contexte qui conserve l'état actuel. Votre Document doit avoir :
Un champ privé contenant le DocumentState actuel, initialisé à DraftState dans le constructeur.

Une méthode setState(DocumentState state) qui modifie l'état actuel.

Une méthode edit() qui délègue l'appel à la méthode edit de l'état actuel.

Une méthode approve() qui délègue l'appel à la méthode approve de l'état actuel.

Une méthode getStatus() qui renvoie le nom simple de la classe de l'état actuel (utilisez getClass().getSimpleName()).
Main.java : faites une démonstration de votre système d'états ! Vous recevrez une entrée : une séquence d'actions sous forme de chaîne séparée par des virgules, où chaque action est soit edit, soit approve (par exemple : edit,approve,edit,approve).
Créez un Document et affichez son état initial au format Status: [state]. Traitez ensuite chaque action dans l'ordre, en appelant la méthode appropriée sur le document. Après chaque action, affichez l'état actuel.

Vous recevrez une entrée : une chaîne d'actions séparées par des virgules.

Par exemple, avec l'entrée edit,approve,approve, votre sortie serait :

Status: DraftState
Editing draft...
Status: DraftState
Draft approved. Moving to review.
Status: ReviewState
Review complete. Publishing document.
Status: PublishedState

Remarquez comment le même appel à approve() produit des résultats différents selon l'état actuel du document. C'est l'essence même du State Pattern ! Le document n'utilise pas de conditions pour vérifier son état ; il délègue plutôt le comportement à l'objet d'état actuel, qui gère l'action de manière appropriée et déclenche les transitions lorsque cela est nécessaire.

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        
        // TODO: Créer un nouveau Document
        
        // TODO: Afficher le statut initial au format "Status: [state]"
        
        // TODO: Diviser l'entrée par une virgule pour obtenir les actions individuelles
        
        // TODO: Parcourir chaque action
        // - Si l'action est "edit", appeler edit() sur document
        // - Si l'action est "approve", appeler approve() sur document
        // - Après chaque action, afficher le statut actuel
    }
}