mode état

Dans le State Pattern, le comportement d'une classe change en fonction de son état. Ce type de modèle de conception est un modèle comportemental.

Dans le modèle d'état, nous créons des objets qui représentent divers états et un objet de contexte dont le comportement change à mesure que l'objet d'état change.

Introduction

Intention : Permet à un objet de changer de comportement lorsque son état interne change, faisant apparaître l'objet comme si sa classe avait été modifiée.

Solution principale : Le comportement d'un objet dépend de son état (propriétés), et son comportement associé peut être modifié en fonction des changements de son état.

Quand utiliser : Le code contient un grand nombre d'instructions conditionnelles liées à l'état de l'objet.

Comment résoudre : Résumer diverses classes de statut spécifiques.

Code clé : Habituellement, il n'y a qu'une seule méthode dans l'interface du mode commande. L'interface de modèle d'état comporte une ou plusieurs méthodes. De plus, les méthodes de la classe d'implémentation du modèle d'état renvoient généralement une valeur ou modifient la valeur d'une variable d'instance. En d’autres termes, le modèle d’état est généralement lié à l’état de l’objet. Les méthodes de la classe d'implémentation ont des fonctions différentes, remplaçant les méthodes de l'interface. Comme le mode commande, le mode état peut également être utilisé pour éliminer les instructions de sélection conditionnelle telles que if...else.

Exemples d'application : 1. Lorsqu'ils jouent au basket-ball, les athlètes peuvent avoir des états normaux, anormaux et supranormaux. 2. Dans le carillon de Zeng Hou Yi, « la cloche est une interface abstraite », « Zhong A » et ainsi de suite sont des états concrets, et « le carillon de Zeng Hou Yi » est l'environnement spécifique (contexte).

Avantages : 1. Encapsule les règles de conversion. 2. Énumérez les états possibles Avant d'énumérer les états, vous devez déterminer le type d'état. 3. Mettez tous les comportements liés à un certain état dans une classe et vous pourrez facilement ajouter de nouveaux états. Il vous suffit de changer l'état de l'objet pour modifier le comportement de l'objet. 4. Autoriser l'intégration de la logique de transition d'état à l'objet d'état au lieu d'un énorme bloc d'instructions conditionnelles. 5. Plusieurs objets d'environnement peuvent partager un objet d'état, réduisant ainsi le nombre d'objets dans le système.

Inconvénients : 1. L'utilisation du mode état augmentera inévitablement le nombre de classes et d'objets système. 2. La structure et la mise en œuvre du mode état sont relativement complexes. S'il est mal utilisé, cela entraînera une confusion dans la structure et le code du programme. 3. Le mode état ne prend pas très bien en charge le « principe d'ouverture et de fermeture » Pour le mode état qui peut changer d'état, l'ajout d'une nouvelle classe d'état nécessite de modifier le code source responsable de la conversion d'état. état et modification Le comportement d'une certaine classe d'état nécessite également une modification du code source de la classe correspondante.

Scénarios d'utilisation : 1. Scénarios où le comportement change à mesure que l'état change. 2. Remplacement des instructions conditionnelles et de branchement.

Remarque : Utilisez le modèle d'état lorsque le comportement est contraint par des états et qu'il n'y a pas plus de 5 états.

Implémentation

Nous allons créer une interface State et une classe d'état d'entité qui implémente l'interface State. Context est une classe avec un état.

StatePatternDemo, notre classe de démonstration utilise Context et des objets d'état pour démontrer les changements de comportement du Context lorsque l'état change.

Étape 1

Créer une interface.

State.java

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

Étape 2

Créez une classe d'entité qui implémente l'interface.

StartState.java

public class StartState implements State {

   public void doAction(Context context) {
      System.out.println("Player is in start state");
      context.setState(this);	
   }

   public String toString(){
      return "Start State";
   }
}

StopState.java

public class StopState implements State {

   public void doAction(Context context) {
      System.out.println("Player is in stop state");
      context.setState(this);	
   }

   public String toString(){
      return "Stop State";
   }
}

Étape 3

Créer Classe Context.

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

Utilisez Context pour voir quand l'état State change les changements de comportement au fil du temps.

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

Vérifiez la sortie.

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