Definición de estado: diferentes estados, diferentes comportamientos;
Cuándo usar el modo de estado
El modo de estado se usa más comúnmente en uso real y es adecuado para "conmutación de estado". Debido a que a menudo usamos si más, más para cambiar los estados, si se repite este juicio de estado, debemos pensar si podemos adoptar el modo de estado.
No solo se basa en el estado, sino también en los atributos. Si las propiedades de un objeto son diferentes, el comportamiento del objeto es diferente. Propiedades, tales cambios (conmutación) de propiedades pueden ocurrir en cualquier momento, por lo que es posible usar el estado.
En uso real, hay muchos cambios de estado similar a los interruptores, pero a veces no es tan obvio, dependiendo de su experiencia y profundidad de comprensión del sistema.
Lo que queremos explicar aquí es que hay algunas diferencias entre el "estado de cambio de cambio" y el "juicio general del estado".
La copia del código es la siguiente:
if (que == 1) state = "hola";
else if (que == 2) state = "HI";
else if (que == 3) state = "adiós";
Este es un "juicio del estado general". Si se cambia a:
La copia del código es la siguiente:
if (state.euqals ("adiós")) state = "hola";
else if (state.euqals ("hola")) state = "HI";
else if (state.euqals ("hi")) state = "adiós";
Este es el "estado de conmutación de interruptor", que es cambiar el estado del estado de "hola" a "hola", y luego a "adiós"; El estado se puede cambiar el modo de estado.
Si simplemente cambia la dirección "Hola"-> "HI"-> "Bye"-> "Hola" En lo anterior, no necesariamente necesita usar el modo de estado, porque el modo de estado creará muchos subclases.
Consulte el siguiente ejemplo:
La copia del código es la siguiente:
contexto de clase pública {
estado de color privado = nulo;
public void push () {
// Si el estado rojo actual se cambia a azul
if (state == color.red) state = color.blue;
// Si el estado azul actual se cambia a verde
else if (state == color.blue) state = color.green;
// Si el estado negro actual se cambia a rojo
else if (state == color.black) state = color.red;
// Si el estado verde actual se cambia a negro
else if (state == color.green) state = color.black;
Muestra muestra = nueva muestra (estado);
muestra.operate ();
}
public void Pull () {
// es exactamente lo opuesto al cambio de estado de empuje if (state == color.green) state = color.blue;
else if (state == color.black) state = color.green;
else if (state == color.blue) state = color.red;
else if (state == color.red) state = color.black;
Sample2 sample2 = nueva muestra2 (estado);
muestra2.operer ();
}
}
En el ejemplo anterior, tenemos dos acciones empuje y tirar.
Tenga en cuenta que en el ejemplo anterior, el cambio de estado es solo una simple tarea de color. Uso.
Por ejemplo: las cuentas bancarias a menudo cambian entre el estado abierto y el estado cerrado.
Por ejemplo: la clásica TCPConnection, el estado de TCP tiene tres estados: la creación de cierres de escucha y las conversiones repetidas no se pueden completar en solo una o dos oraciones, y es adecuado para usar el estado.
Por ejemplo: la cuenta POP de buzón tendrá cuatro estados, inicio de la renuncia autorizada de nombre de nombre, el comportamiento correspondiente de cada estado debe ser relativamente grande, adecuado para usar el estado.
Por ejemplo: la selección de diferentes herramientas en la caja de herramientas puede considerarse como conmutación entre diferentes herramientas, adecuada para usar el estado. Por ejemplo, si tiene un programa de dibujo específico, los usuarios pueden elegir diferentes herramientas para dibujar la curva recta.
Cómo usar el modo de estado
El estado requiere que participen dos tipos de entidades:
1. estatal gerente es un cambio.
2. La clase principal implementada por clases abstractas o interfaces, diferentes estados están heredando diferentes subclases de esta clase principal.
Tomando el contexto anterior como ejemplo, queremos modificarlo y crear dos tipos de entidades.
El primer paso es crear una clase principal:
La copia del código es la siguiente:
Estado de clase abstracta pública {
Public Abstract Void HandlePush (contexto C);
Public Abstract Void HandlePull (contexto C);
Public Abstract void getColor ();
}
Los métodos en la clase principal deben corresponder al comportamiento del interruptor en el gerente estatal. debe manejarse específicamente.
Las siguientes son las implementaciones de subclases específicas:
La copia del código es la siguiente:
clase pública Bluestate extiende el estado {
public void maneepush (contexto c) {
// Según el método de empuje "Si es azul, cambie a Green";
C.SetState (new GreenState ());
}
public void HandlePull (contexto c) {
// Según el método de extracción "Si es azul, cambie a rojo";
C.SetState (new RedState ());
}
public abstract void getColor () {return (color.blue)}
}
Del mismo modo, las subclases en otros estados se implementan como azules.
El segundo paso es reescribir al gerente estatal, que es el contexto de este ejemplo:
La copia del código es la siguiente:
contexto de clase UBLIC {
Estado de Sate privado = NULL;
// setState se usa para cambiar el estado de estado usando SetState para lograr el cambio de estado
Pulic void setstate (estado de estado) {
this.state = state;
}
public void push () {
// Los detalles de la conmutación de estado son en este caso el cambio de color, que ha sido encapsulado en el manejo de la subclase, y no es necesario que se preocupe por State.handlepush (esto);
// Debido a que la muestra debe usar un resultado de conmutación en estado, use getColor ()
Muestra muestra = nueva muestra (state.getColor ());
muestra.operate ();
}
public void Pull () {
state.handlePull (esto);
Sample2 sample2 = new sample2 (state.getColor ());
muestra2.operer ();
}
}
En este punto, hemos implementado el proceso de refactorización de estado.
Lo anterior es solo un ejemplo bastante simple.