Définition de l'état: différents états, différents comportements; ou en d'autres termes, chaque état a des comportements correspondants.
Quand utiliser le mode d'état
Le mode d'état est plus couramment utilisé dans l'utilisation réelle et convient au "commutateur d'état". Parce que nous utilisons souvent si ElseIf pour changer d'état, si ce jugement d'état est répété, nous devons réfléchir à la question de savoir si nous pouvons adopter le mode d'état.
Non seulement sur la base de l'état, mais aussi sur les attributs. Si les propriétés d'un objet sont différentes, le comportement de l'objet est différent. Propriétés, ces changements (commutation) des propriétés peuvent se produire à tout moment, il est donc possible d'utiliser l'état.
Dans une utilisation réelle, il existe de nombreux commutateurs d'état similaires aux commutateurs, mais parfois ce n'est pas si évident, selon votre expérience et votre profondeur de compréhension du système.
Ce que nous voulons expliquer ici, c'est qu'il existe des différences entre le "Switch Switch State" et le "jugement général de l'état".
La copie de code est la suivante:
if (qui == 1) state = "Bonjour";
else if (qui == 2) state = "hi";
else if (qui == 3) state = "bye";
Il s'agit d'un "jugement d'état général". Si je suis changé en:
La copie de code est la suivante:
if (state.euqals ("bye")) state = "Bonjour";
else if (state.euqals ("bonjour")) state = "hi";
else if (state.euqals ("hi")) state = "bye";
Il s'agit du "Switch Switch State", qui consiste à passer à l'état de l'état de "Hello" à "Hi", puis à "Bye"; L'état peut être modifié le mode d'état est utilisé.
Si vous changez simplement la direction "bonjour" -> "salut" -> "bye" -> "bonjour" dans ce qui précède, vous n'avez pas nécessairement besoin d'utiliser le mode d'état, car le mode d'état en créera beaucoup Sous-classes.
Veuillez consulter l'exemple suivant:
La copie de code est la suivante:
Contexte de classe publique {
État de couleur privée = null;
public void push () {
// Si l'état rouge actuel est passé au bleu
if (state == colore.red) state = color.blue;
// Si l'état bleu actuel est passé au vert
else if (state == colore.blue) state = color.Green;
// Si l'état noir actuel est transféré en rouge
else if (state == colore.black) state = colore.red;
// Si l'état vert actuel est passé au noir
else if (state == Color.Green) State = Color.Black;
Exemple d'échantillon = nouvel échantillon (état);
échantillon.opérate ();
}
public void pull () {
// C'est exactement l'opposé de la commutation de l'état push if (state == Color.Green) State = Color.Blue;
else if (state == colore.black) state = colore.Green;
else if (state == colore.blue) state = colore.red;
else if (state == colore.red) state = colore.black;
Échantillon2 échantillon2 = nouveau échantillon2 (état);
échantillon2.opérate ();
}
}
Dans l'exemple ci-dessus, nous avons deux actions push et pull.
Remarque: mais dans l'exemple ci-dessus, le changement d'état est juste une affectation de couleur simple. Utilisation.
Par exemple: les comptes bancaires basculent souvent entre l'état ouvert et l'état proche.
Par exemple: la TCPConnection classique, l'état de TCP a trois états: la création d'écoute ferme et des conversions répétées.
Par exemple: le compte POP de la boîte aux lettres aura quatre états, start hasuserName autorisé quit, le comportement correspondant de chaque état devrait être relativement important, adapté à l'utilisation de l'état.
Par exemple: la sélection de différents outils dans la boîte à outils peut être considérée comme une commutation entre différents outils, adaptée à l'utilisation de l'état. Par exemple, si vous avez un programme de dessin spécifique, les utilisateurs peuvent choisir différents outils pour dessiner la courbe droite de la boîte.
Comment utiliser le mode d'état
L'État exige que deux types d'entités participent:
1.State Manager Le gestionnaire d'État est un commutateur.
2. La classe parent implémentée par des classes abstraites ou des interfaces, différents états héritent de différentes sous-classes de cette classe parent.
Prenant le contexte ci-dessus comme exemple, nous voulons le modifier et créer deux types d'entités.
La première étape consiste à créer une classe parent:
La copie de code est la suivante:
État de classe abstrait public {
Handlepush abstrait public abstrait (contexte C);
Public abstrait void handlepull (contexte c);
Public Abstract Void getColor ();
}
Les méthodes de la classe parent doivent correspondre au comportement du commutateur dans le gestionnaire d'État. Doit être géré spécifiquement.
Voici les implémentations de sous-classes spécifiques:
La copie de code est la suivante:
classe publique BlueState étend l'état {
handlepush public vide (contexte c) {
// Selon la méthode push "S'il est bleu, passez au vert";
C.SetState (new GreenState ());
}
handlepull public vide (contexte c) {
// Selon la méthode de traction "Si elle est bleue, passez en rouge";
C.SetState (new RedState ());
}
Public Abstract Void getColor () {return (colore.blue)}
}
De même, les sous-classes dans d'autres États sont mises en œuvre en bleu.
La deuxième étape consiste à réécrire le gestionnaire d'État, qui est le contexte de cet exemple:
La copie de code est la suivante:
Contexte de classe ublique {
État de son séjour privé = null;
// SetState est utilisé pour modifier l'état d'état à l'aide de SetState pour réaliser la commutation d'état
Pulic void SetState (État d'état) {
this.state = state;
}
public void push () {
// Les détails de la commutation d'état sont dans ce cas le changement de couleur, qui a été encapsulé dans le mancheau de la sous-classe, et il n'est pas nécessaire de se soucier de State.Handlepush (this);
// Parce que l'échantillon doit utiliser un résultat de commutation à l'état, utilisez getColor ()
Exemple d'échantillon = nouvel échantillon (state.getColor ());
échantillon.opérate ();
}
public void pull () {
state.handlepull (this);
Exemple2 échantillon2 = nouveau échantillon2 (state.getColor ());
échantillon2.opérate ();
}
}
À ce stade, nous avons mis en œuvre le processus de refactorisation de l'État.
Ce qui précède est juste un exemple assez simple.