Patron État

Dans le patron État, le comportement d'une classe change en fonction de son état. Ce type de patron de conception appartient aux patrons comportementaux.

Dans le patron État, nous créons des objets représentant divers états et un objet contexte dont le comportement change à mesure que l'objet état change.

Le patron État permet à un objet de changer son comportement lorsque son état interne change, de sorte que l'objet présente des comportements différents dans différents états. En encapsulant chaque état dans une classe indépendante, il évite d'utiliser un grand nombre d'instructions conditionnelles pour implémenter le changement d'état.

Introduction

intention

Il permet à un objet de modifier son comportement lorsque son état interne change, donnant l'impression que l'objet a changé de classe.

Principaux problèmes résolus

  • Le patron État résout le problème du comportement d'un objet dépendant de son état, permettant à l'objet de changer de comportement lorsque l'état change.

Cas d'utilisation

  • Utilisez-le lorsqu'il y a de nombreuses instructions conditionnelles dans le code, et que ces instructions conditionnelles dépendent de l'état de l'objet.

Approche d'implémentation

  • Définir l'interface d'état: Déclare une ou plusieurs méthodes pour encapsuler le comportement d'un état spécifique.
  • Créer des classes d'état concrètes: Implémente l'interface d'état et implémente des comportements spécifiques en fonction des différents états.
  • Définir la classe contexte: Contient une référence à un objet état et met à jour son comportement lorsque l'état change.

Code clé

  • Interface État: Déclare des méthodes de comportement.
  • Classe d'état concrète: Implémente l'interface d'état et encapsule un comportement spécifique.
  • Classe Contexte: Maintient un objet état et fournit des méthodes pour changer son état.

Exemple d'application

  • État d'un joueur de basket-ball: Un athlète peut avoir des états tels que normal, anormal et exceptionnel.
  • Carillons du marquis Yi de Zeng: Les carillons servent de contexte, et différentes cloches (états) produisent différents effets d'interprétation.

Avantages

  • Encapsule les règles de transition d'état: Encapsule la logique de transition d'état dans les objets d'état.
  • Facile à étendre: L'ajout de nouvelles classes d'état n'affecte pas le code existant.
  • Centraliser le comportement lié à l'état: Concentre tout le comportement lié à un état spécifique dans une seule classe.
  • Simplifier les instructions conditionnelles: Évite d'utiliser un grand nombre d'instructions conditionnelles pour changer de comportement.
  • Partage d'état: Permet à plusieurs objets de contexte de partager le même objet d'état.

Inconvénients

  • Augmente le nombre de classes et d'objets: Chaque état nécessite une classe d'état concrète.
  • Implémentation complexe: La structure et l'implémentation du patron sont relativement complexes.
  • Prise en charge insuffisante du principe ouvert-fermé: L'ajout de nouveaux états ou la modification du comportement d'un état peut nécessiter des modifications du code existant.

Suggestions d'utilisation

  • Lorsque le comportement d'un objet change selon son état, envisagez d'utiliser le patron État.
  • Le patron État convient pour remplacer des instructions conditionnelles ou de branchement complexes.

Notes

  • Le patron État est adapté lorsque le nombre d'états est limité (généralement pas plus de 5).
  • À utiliser avec prudence pour éviter de rendre le système trop complexe.

Structure

Le patron État comprend les rôles principaux suivants :

  • Context: Définit l'interface qui intéresse les clients et maintient une référence à l'objet d'état actuel. Le contexte peut déléguer le traitement du comportement lié à l'état à l'objet d'état.

  • State: Définit une interface pour encapsuler le comportement d'un état lié au contexte.

  • État concret: Implémente l'interface d'état et est responsable de la gestion du comportement lié à cet état. Un objet d'état concret maintient généralement une référence à l'objet contexte en interne, afin de pouvoir basculer vers différents états en fonction de différentes conditions.

Implémentation

Nous allons créer uneStateInterface et l'implémentationStateLa classe d'état d'entité de l'interface.ContextUne classe avec un certain état.

StatePatternDemo, notre classe de démonstration utiliseContextet des objets d'état pour démontrer les changements de comportement de Context lorsque son état change.

状态模式的 UML 图

Étape 1

Créer une interface.

State.java

public interface State { public void doAction(Context context); }

Étape 2

Créez des classes d'entités qui implémentent l'interface.

StartState.java

public class StartState implements State { public void doAction(Context context) { System.out.println("Le joueur est dans l'état de démarrage"); context.setState(this); } public String toString(){ return "État de démarrage"; } }

StopState.java

public class StopState implements State { public void doAction(Context context) { System.out.println("Le joueur est dans l'état d'arrêt"); context.setState(this); } public String toString(){ return "État d'arrêt"; } }

Étape 3

CréerContextclasse.

Context.java

public class Context { private State state; public Context(){ state = null; } public void setState(State state){ this.state = state; } public State getState(){ return state; } }

Étape 4

UtilisationContextPour voir quand l'étatStateBehavior change lorsque l'état change.

StatePatternDemo.java

public class StatePatternDemo { public static void main(String[] args) { Context context = new Context(); StartState startState = new StartState(); startState.doAction(context); System.out.println(context.getState().toString()); StopState stopState = new StopState(); stopState.doAction(context); System.out.println(context.getState().toString()); } }

Étape 5

Exécutez le programme, résultat de sortie :

Player is in start state
Start State
Player is in stop state
Stop State

Plus d'articles

autres extensions