En el proceso de desarrollo de software, la aplicación de algunos objetos puede hacer que el comportamiento diferente en función de las circunstancias, llamamos a este objeto llamado objetos con estado y las propiedades de uno influyen en el comportamiento de un objeto o dinámica múltiple llamado estado. Cuando el estado de un objeto para interactuar con los acontecimientos externos, que va a cambiar su estado interno, por lo que su comportamiento cambiará en consecuencia. Tales como las emociones humanas tienen un tiempo feliz y un tiempo triste, diferentes emociones tienen un comportamiento diferente, por supuesto, el mundo exterior también afectará a sus cambios de humor.
Este objeto tiene un estado de la programación, la solución tradicional es: todas estas situaciones en consideración son posibles, y si-else hacen determinación del estado de uso, entonces el tratamiento de situaciones diferentes. Pero muchos estado del objeto, el procedimiento será muy complicado. Y para agregar nuevo estatus Para añadir una nueva instrucción if-else, lo cual es contrario al "principio de apertura y cierre" no es propicio para la expansión del programa.
Si los problemas anteriores, "régimen" puede ser una buena resuelto. Pensamos que el modelo de estado se resuelve: Cuando el control de la expresión condicional de un objeto de transición de estado es demasiado complejo, la "lógica Analizar" pertinente extraída, en una serie de clases entre el Estado, de modo que la lógica compleja original, se puede simplificar la determinación.
definición del patrón del estado y características
estado definido de modo (Estado): el estado de un sujeto, el complejo "lógica de decisión" extraído objetos a un estado diferente, que permite que el estado del objeto cambia el comportamiento cuando cambia su estado interno.
modelo de Estado es un patrón de comportamiento objeto, sus principales ventajas son las siguientes.
- modelo de estado asociada con el estado específico a un comportamiento del estado localizada, y el comportamiento de los diferentes estados separó, se reúnen "principio de responsabilidad individual."
- Reducir las interdependencias entre los objetos. El objetivo diferentes estados harán que la introducción de una transición de estado separado más claro, y reducir las interdependencias entre los objetos.
- A favor de la extensión. A través de la nueva definición subclase añadir fácilmente nuevos estados y transiciones.
La principal desventaja del estado de modo son como sigue.
- El número de clases y objetos utilizando el sistema aumenta inevitablemente patrón de estado.
- Estructura e implementación del modelo de Estado son más complejos, si se utiliza incorrectamente puede dar lugar a confusión y la estructura del código del programa.
Arquitectura e implementación del modelo de Estado
El estado del modelo de objetos para el cambio de comportamiento por un embalaje del medio ambiente en un estado diferente objeto, la intención es hacer que un objeto cambie su estado interno cuando su comportamiento ha cambiado. Ahora tenemos que analizar la estructura y la implementación básica.
1. Estructura Modelo
modelo de estado consiste en lo siguiente papel importante.
- Medio Ambiente (Contexto) Función: También llamado contexto, que define la interfaz de interés para los clientes, el mantenimiento de un estado actual y el estado encargado relacionada con el estado de funcionamiento actual del objeto de manejar.
- estado abstracto Roles (Estado): la definición de una interfaz para un objeto de estado de entorno paquete en particular correspondiente al comportamiento.
- estado específico (Estado de hormigón) Función: En el resumen comportamiento correspondientes.
La estructura mostrada en la Figura 1.
2. Modo de realización
códigos de patrones estatales son los siguientes:
package state;
public class StatePatternClient
{
public static void main(String[] args)
{
Context context=new Context(); //创建环境
context.Handle(); //处理请求
context.Handle();
context.Handle();
context.Handle();
}
}
//环境类
class Context
{
private State state;
//定义环境类的初始状态
public Context()
{
this.state=new ConcreteStateA();
}
//设置新状态
public void setState(State state)
{
this.state=state;
}
//读取状态
public State getState()
{
return(state);
}
//对请求做处理
public void Handle()
{
state.Handle(this);
}
}
//抽象状态类
abstract class State
{
public abstract void Handle(Context context);
}
//具体状态A类
class ConcreteStateA extends State
{
public void Handle(Context context)
{
System.out.println("当前状态是 A.");
context.setState(new ConcreteStateB());
}
}
//具体状态B类
class ConcreteStateB extends State
{
public void Handle(Context context)
{
System.out.println("当前状态是 B.");
context.setState(new ConcreteStateA());
}
}Los resultados del programa son los siguientes:
当前状态是 A.
当前状态是 B.
当前状态是 A.
当前状态是 B.Ejemplos del patrón de estado de la aplicación
[Ejemplo 1] con un "estado modelo" Diseño de un rendimiento de los estudiantes programa de transición de estado.
Análisis: En este ejemplo se incluye el "fracaso", "medio" y "excelente" tres estados, cuando la puntuación del estudiante es menor de 60 tiempo compartido "a prueba" del Estado, cuando la puntuación es mayor o igual a 60 y menor de 90 minutos para el tiempo compartido "Medium "estado, cuando la puntuación es mayor o igual a 90 veces compartido como" excelentes condiciones", se utiliza el modelo de estado para lograr este programa.
En primer lugar, la definición de una clase de estado abstracto (AbstractState), que contiene los atributos ambientales, nombre de atributo y atributos de estado de cuenta actual y addScore método sub-resta (inTX) y comprobando el estado actual del método abstracto checkState (), y luego, la definición de "sin pasar "LowState clase estado" intermedio "clase estado MiddleState y" excelente HighState clase estado", son categoría estado específico, logrando método checkState (), es responsable de comprobar su propio estado, y de acuerdo a la conversión y, por último, la definición de medio ambiente ( ScoreContext), que contiene el estado actual del objeto y el método de puntos de resta añadir (puntuación int), para cambiar el estado de rendimiento de la clase de cliente por este método. La Figura 2 es una vista estructural.
Código es el siguiente:
package state;
public class ScoreStateTest
{
public static void main(String[] args)
{
ScoreContext account=new ScoreContext();
System.out.println("学生成绩状态测试：");
account.add(30);
account.add(40);
account.add(25);
account.add(-15);
account.add(-25);
}
}
//环境类
class ScoreContext
{
private AbstractState state;
ScoreContext()
{
state=new LowState(this);
}
public void setState(AbstractState state)
{
this.state=state;
}
public AbstractState getState()
{
return state;
}
public void add(int score)
{
state.addScore(score);
}
}
//抽象状态类
abstract class AbstractState
{
protected ScoreContext hj; //环境
protected String stateName; //状态名
protected int score; //分数
public abstract void checkState(); //检查当前状态
public void addScore(int x)
{
score+=x;
System.out.print("加上："+x+"分，\t当前分数："+score );
checkState();
System.out.println("分，\t当前状态："+hj.getState().stateName);
}
}
//具体状态类：不及格
class LowState extends AbstractState
{
public LowState(ScoreContext h)
{
hj=h;
stateName="不及格";
score=0;
}
public LowState(AbstractState state)
{
hj=state.hj;
stateName="不及格";
score=state.score;
}
public void checkState()
{
if(score>=90)
{
hj.setState(new HighState(this));
}
else if(score>=60)
{
hj.setState(new MiddleState(this));
}
}
}
//具体状态类：中等
class MiddleState extends AbstractState
{
public MiddleState(AbstractState state)
{
hj=state.hj;
stateName="中等";
score=state.score;
}
public void checkState()
{
if(score<60)
{
hj.setState(new LowState(this));
}
else if(score>=90)
{
hj.setState(new HighState(this));
}
}
}
//具体状态类：优秀
class HighState extends AbstractState
{
public HighState(AbstractState state)
{
hj=state.hj;
stateName="优秀";
score=state.score;
}
public void checkState()
{
if(score<60)
{
hj.setState(new LowState(this));
}
else if(score<90)
{
hj.setState(new MiddleState(this));
}
}
}Los resultados del programa son los siguientes:
学生成绩状态测试：
加上：30分， 当前分数：30分， 当前状态：不及格
加上：40分， 当前分数：70分， 当前状态：中等
加上：25分， 当前分数：95分， 当前状态：优秀
加上：-15分， 当前分数：80分， 当前状态：中等
加上：-25分， 当前分数：55分， 当前状态：不及格
[Ejemplo 2] con el programa de conversión condición de diseño "patrón status" un multi-hilo.
Análisis: multihilo Hay cinco estados, a saber, para el nuevo estado, estado de listo, estado de ejecución, estado de bloqueo y el estado de la muerte, cada estado se encontrará en la conversión a otros estados donde la invocación o método relevante activadas por eventos, como se muestra en la regla de transición 3 se muestra en la figura.
Pase 3 diagrama de transición de estado de la figura.
Ahora definir el estado de una clase abstracta (TheadState), entonces el diseño de un estado particular para cada tipo de estado que se muestra en la Figura 3, que es el nuevo estado (Nuevo), el estado preparado (la Ejecutable), el estado de funcionamiento (funcionamiento), el estado bloqueado ( bloqueado) y estado de muerte (muerto), cada estado tiene una transición de estado método de activación de los mismos, del medio ambiente (ThreadContext) en un estado inicial en el Sr. (nuevo), y proporcionar un método de activación, el hilo es un diagrama de transición de estado mostrado en la Fig. 4 la estructura del programa de la figura.
Estructura de la Fig. Estado hilo programa de conversión 4 figura
Código es el siguiente:
package state;
public class ThreadStateTest
{
public static void main(String[] args)
{
ThreadContext context=new ThreadContext();
context.start();
context.getCPU();
context.suspend();
context.resume();
context.getCPU();
context.stop();
}
}
//环境类
class ThreadContext
{
private ThreadState state;
ThreadContext()
{
state=new New();
}
public void setState(ThreadState state)
{
this.state=state;
}
public ThreadState getState()
{
return state;
}
public void start()
{
((New) state).start(this);
}
public void getCPU()
{
((Runnable) state).getCPU(this);
}
public void suspend()
{
((Running) state).suspend(this);
}
public void stop()
{
((Running) state).stop(this);
}
public void resume()
{
((Blocked) state).resume(this);
}
}
//抽象状态类：线程状态
abstract class ThreadState
{
protected String stateName; //状态名
}
//具体状态类：新建状态
class New extends ThreadState
{
public New()
{
stateName="新建状态";
System.out.println("当前线程处于：新建状态.");
}
public void start(ThreadContext hj)
{
System.out.print("调用start()方法-->");
if(stateName.equals("新建状态"))
{
hj.setState(new Runnable());
}
else
{
System.out.println("当前线程不是新建状态，不能调用start()方法.");
}
}
}
//具体状态类：就绪状态
class Runnable extends ThreadState
{
public Runnable()
{
stateName="就绪状态";
System.out.println("当前线程处于：就绪状态.");
}
public void getCPU(ThreadContext hj)
{
System.out.print("获得CPU时间-->");
if(stateName.equals("就绪状态"))
{
hj.setState(new Running());
}
else
{
System.out.println("当前线程不是就绪状态，不能获取CPU.");
}
}
}
//具体状态类：运行状态
class Running extends ThreadState
{
public Running()
{
stateName="运行状态";
System.out.println("当前线程处于：运行状态.");
}
public void suspend(ThreadContext hj)
{
System.out.print("调用suspend()方法-->");
if(stateName.equals("运行状态"))
{
hj.setState(new Blocked());
}
else
{
System.out.println("当前线程不是运行状态，不能调用suspend()方法.");
}
}
public void stop(ThreadContext hj)
{
System.out.print("调用stop()方法-->");
if(stateName.equals("运行状态"))
{
hj.setState(new Dead());
}
else
{
System.out.println("当前线程不是运行状态，不能调用stop()方法.");
}
}
}
//具体状态类：阻塞状态
class Blocked extends ThreadState
{
public Blocked()
{
stateName="阻塞状态";
System.out.println("当前线程处于：阻塞状态.");
}
public void resume(ThreadContext hj)
{
System.out.print("调用resume()方法-->");
if(stateName.equals("阻塞状态"))
{
hj.setState(new Runnable());
}
else
{
System.out.println("当前线程不是阻塞状态，不能调用resume()方法.");
}
}
}
//具体状态类：死亡状态
class Dead extends ThreadState
{
public Dead()
{
stateName="死亡状态";
System.out.println("当前线程处于：死亡状态.");
}
}Los resultados del programa son los siguientes:
当前线程处于：新建状态.
调用start()方法-->当前线程处于：就绪状态.
获得CPU时间-->当前线程处于：运行状态.
调用suspend()方法-->当前线程处于：阻塞状态.
调用resume()方法-->当前线程处于：就绪状态.
获得CPU时间-->当前线程处于：运行状态.
调用stop()方法-->当前线程处于：死亡状态.
el modo de estado de escenarios de aplicación
Generalmente modelo de estado usado puede ser considerado en los casos siguientes.
- Cuando el comportamiento de un objeto depende de su estado, y debe cambiar su comportamiento en función del estado en tiempo de ejecución, se puede considerar el modo de estado de uso.
- Cuando se opera una estructura de rama grande contenida en, y determina el estado de las ramas del objeto.
el modo de estado ampliado
En algunos casos, puede haber varios objetos necesitan compartir un conjunto de estado ambiental, a continuación, la necesidad de introducir peso mosca, particularmente aquellos en el estado conjunto del objeto para el intercambio de programas, la estructura mostrada en la Figura 5.
Análisis: estado compartido excepto el modelo se aumenta en el entorno de un HashMap asociada clase para guardar el estado puede ser adquirido de un cierto estado cuando sea necesario, que el código es el siguiente:
package state;
import java.util.HashMap;
public class FlyweightStatePattern
{
public static void main(String[] args)
{
ShareContext context=new ShareContext(); //创建环境
context.Handle(); //处理请求
context.Handle();
context.Handle();
context.Handle();
}
}
//环境类
class ShareContext
{
private ShareState state;
private HashMap<String, ShareState> stateSet=new HashMap<String, ShareState>();
public ShareContext()
{
state=new ConcreteState1();
stateSet.put("1", state);
state=new ConcreteState2();
stateSet.put("2", state);
state=getState("1");
}
//设置新状态
public void setState(ShareState state)
{
this.state=state;
}
//读取状态
public ShareState getState(String key)
{
ShareState s=(ShareState)stateSet.get(key);
return s;
}
//对请求做处理
public void Handle()
{
state.Handle(this);
}
}
//抽象状态类
abstract class ShareState
{
public abstract void Handle(ShareContext context);
}
//具体状态1类
class ConcreteState1 extends ShareState
{
public void Handle(ShareContext context)
{
System.out.println("当前状态是： 状态1");
context.setState(context.getState("2"));
}
}
//具体状态2类
class ConcreteState2 extends ShareState
{
public void Handle(ShareContext context)
{
System.out.println("当前状态是： 状态2");
context.setState(context.getState("1"));
}
}Los resultados del programa son los siguientes:
当前状态是： 状态1
当前状态是： 状态2
当前状态是： 状态1
当前状态是： 状态2
