Patron État

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy. Leçon 98 sur 110.

Le pattern State permet à un objet de modifier son comportement lorsque son état interne change, donnant l’impression que l’objet a changé de classe. Au lieu d’utiliser des conditions complexes pour gérer différents états, vous encapsulez chaque état dans sa propre classe et déléguez le comportement à l’objet représentant l’état actuel.

Le patron consiste en un Contexte qui maintient une référence à l'état actuel, et des classes d'État qui définissent le comportement pour chaque état possible. Lorsque l'état du contexte change, son comportement change automatiquement :

abstract class DocumentState {
  void publish(Document doc);
  String getStatus();
}

class DraftState implements DocumentState {
  @override
  void publish(Document doc) {
    print('Moving to review...');
    doc.setState(ReviewState());
  }

  @override
  String getStatus() => 'Draft';
}

class ReviewState implements DocumentState {
  @override
  void publish(Document doc) {
    print('Document published!');
    doc.setState(PublishedState());
  }

  @override
  String getStatus() => 'Under Review';
}

class PublishedState implements DocumentState {
  @override
  void publish(Document doc) {
    print('Already published.');
  }

  @override
  String getStatus() => 'Published';
}

class Document {
  DocumentState _state = DraftState();

  void setState(DocumentState state) => _state = state;
  void publish() => _state.publish(this);
  String getStatus() => _state.getStatus();
}

void main() {
  var doc = Document();
  print(doc.getStatus());  // Brouillon
  doc.publish();           // Passage en révision...
  print(doc.getStatus());  // En cours de révision
  doc.publish();           // Document publié !
  print(doc.getStatus());  // Publié
}

Chaque classe d'état gère l'action publish() différemment et peut faire passer le document à l'état suivant. La classe Document n'a pas besoin de structures conditionnelles pour vérifier son état actuel — elle délègue simplement à l'objet d'état qui est actuellement actif. Ce patron est idéal pour les objets ayant des modes de comportement distincts, comme le traitement des commandes, les lecteurs multimédias ou les systèmes de flux de travail.

Défi

Facile

Construisons un système de feu de signalisation à l'aide du patron State ! Vous allez créer un feu de signalisation qui parcourt différents états, chaque état déterminant la couleur du feu et la manière dont il passe à l'état suivant.

Vous allez organiser votre code en deux fichiers :

traffic_light.dart : ce fichier contient vos classes d'état et le contexte du feu de signalisation. Créez une classe abstraite TrafficLightState avec deux méthodes : String getColor(), qui renvoie la couleur actuelle du feu, et void next(TrafficLight light), qui fait passer le feu à son état suivant. Implémentez trois classes d'état concrètes :
- RedState - renvoie RED comme couleur et affiche Stop! Light is red. lorsque next() est appelée, puis passe à GreenState
- GreenState - renvoie GREEN comme couleur et affiche Go! Light is green. lorsque next() est appelée, puis passe à YellowState
- YellowState - renvoie YELLOW comme couleur et affiche Caution! Light is yellow. lorsque next() est appelée, puis passe à RedState
Créez ensuite une classe TrafficLight (le contexte) qui commence dans l'état RedState. Elle doit disposer d'une méthode setState() pour modifier l'état actuel, d'une méthode getColor() qui délègue à l'état actuel, et d'une méthode change() qui appelle next() sur l'état actuel.
main.dart : importez votre fichier du feu de signalisation et présentez le fonctionnement du patron State. Créez un TrafficLight et affichez sa couleur initiale. Appelez ensuite change() trois fois, en affichant la couleur après chaque changement. Cela montrera le feu parcourant tous les états avant de revenir au début.

Remarquez que la classe TrafficLight n'a besoin d'aucune instruction conditionnelle pour déterminer son comportement : chaque état connaît sa propre couleur et l'état qui vient ensuite. Le feu de signalisation délègue simplement le comportement à l'état actuellement actif !

Sortie attendue :

RED
Stop! Light is red.
GREEN
Go! Light is green.
YELLOW
Caution! Light is yellow.
RED

Essayez vous-même

import 'traffic_light.dart';

void main() {
  // TODO: Créer une instance de TrafficLight
  
  // TODO: Afficher la couleur initiale
  
  // TODO: Appeler change() et afficher la couleur (3 fois pour parcourir tous les états)
  // Premier changement : RED -> GREEN
  
  // Deuxième changement : GREEN -> YELLOW
  
  // Troisième changement : YELLOW -> RED
}