Cuando el estado del objeto cambia, también cambia su comportamiento ¡Es fácil de entender! Tome QQ como ejemplo, hay varios estados, en línea, invisible, ocupado, etc. Cada estado corresponde a una operación diferente, y sus amigos también pueden ver su estado, por lo tanto, el modo de estado tiene dos puntos: 1. Cambie el estado para obtener diferentes comportamientos. 2. Tus amigos pueden ver tus cambios al mismo tiempo.
El modo de estado permite que un objeto cambie su comportamiento cuando cambia su estado interno. Este objeto parece que ha cambiado de clase.
Diagrama de clase
La clase de estado es una clase de estado y la clase de contexto se puede cambiar.
Ejemplo de código
Clase estatal:
1. package com.xtfggef.dp.state;
2.
3. /**
4. * 状态类的核心类
5. * 2012-12-1
7. *
8. */
9. public class State {
10.
11. private String value;
12.
13. public String getValue() {
14. return value;
15. }
16.
17. public void setValue(String value) {
18. this.value = value;
19. }
20.
21. public void method1(){
22. System.out.println("execute the first opt!");
23. }
24.
25. public void method2(){
26. System.out.println("execute the second opt!");
27. }
28. }
Clase de contexto:
1. package com.xtfggef.dp.state;
2.
3. /**
4. * 状态模式的切换类 2012-12-1
5. * @author erqing
6. *
7. */
8. public class Context {
9.
10. private State state;
11.
12. public Context(State state) {
13. this.state = state;
14. }
15.
16. public State getState() {
17. return state;
18. }
19.
20. public void setState(State state) {
21. this.state = state;
22. }
23.
24. public void method() {
25. if (state.getValue().equals("state1")) {
26. state.method1();
27. } else if (state.getValue().equals("state2")) {
28. state.method2();
29. }
30. }
31. }
Categoría de prueba:
1. public class Test {
2.
3. public static void main(String[] args) {
4.
5. State state = new State();
6. Context context = new Context(state);
7.
8. //设置第一种状态
9. state.setValue("state1");
10. context.method();
11.
12. //设置第二种状态
13. state.setValue("state2");
14. context.method();
15. }
16. }
De acuerdo con esta característica, el modo de estado se usa mucho en el desarrollo diario, especialmente al construir un sitio web, a veces esperamos distinguir algunas de sus funciones en función de un determinado atributo del objeto, como el simple control de permisos.
La estructura del patrón estatal
En una oración, el patrón de estado empaqueta el comportamiento del objeto en estudio en diferentes objetos de estado, y cada objeto de estado pertenece a una subclase de una clase de estado abstracta. La intención del patrón de estado es hacer que un objeto cambie su comportamiento cuando cambia su estado interno.
Los roles involucrados en el modelo estatal son:
El rol del entorno (contexto), también conocido como contexto: define la interfaz en la que está interesado el cliente y retiene una instancia de una clase de estado específica. La instancia de esta clase de estado concreta proporciona el estado actual de este objeto de entorno.
● Rol de estado abstracto (estado): define una interfaz para encapsular el comportamiento correspondiente a un estado específico del objeto del entorno (contexto).
● Rol de estado concreto (ConcreteState): cada clase de estado concreto implementa el comportamiento correspondiente a un estado del entorno (contexto).
Escenario de aplicación
Considere la aplicación de un sistema de votación en línea, con el fin de lograr el control del mismo usuario solo puede emitir un voto. Si un usuario vota repetidamente y el número de votos excede 5 veces, se juzga como cepillado malicioso y la calificación del usuario para votar será cancelada. Para cancelar su voto; si un usuario vota más de 8 veces, ingresará a la lista negra, y se prohíbe iniciar sesión y usar el sistema.
Para usar el modo de estado para lograrlo, primero debe definir los diversos estados del proceso de votación, que se pueden dividir aproximadamente en cuatro estados de acuerdo con la descripción anterior: votación normal, votación repetida, cepillado malicioso e ingreso a la lista negra. A continuación, cree un objeto de gestión de votaciones (equivalente a Contexto).
Clase de estado abstracto
public interface VoteState {
/**
* 处理状态对应的行为
* @param user 投票人
* @param voteItem 投票项
* @param voteManager 投票上下文，用来在实现状态对应的功能处理的时候，
* 可以回调上下文的数据
*/
public void vote(String user,String voteItem,VoteManager voteManager);
}
Estado específico clase-votación normal
public class NormalVoteState implements VoteState {
@Override
public void vote(String user, String voteItem, VoteManager voteManager) {
//正常投票，记录到投票记录中
voteManager.getMapVote().put(user, voteItem);
System.out.println("恭喜投票成功");
}
}
Votación repetida de clase de estado específico
public class RepeatVoteState implements VoteState {
@Override
public void vote(String user, String voteItem, VoteManager voteManager) {
//重复投票，暂时不做处理
System.out.println("请不要重复投票");
}
}
Deslizamiento malicioso de clase de estado específico
public class SpiteVoteState implements VoteState {
@Override
public void vote(String user, String voteItem, VoteManager voteManager) {
// 恶意投票，取消用户的投票资格，并取消投票记录
String str = voteManager.getMapVote().get(user);
if(str != null){
voteManager.getMapVote().remove(user);
}
System.out.println("你有恶意刷屏行为，取消投票资格");
}
}
Lista negra de clase de estado específico
public class BlackVoteState implements VoteState {
@Override
public void vote(String user, String voteItem, VoteManager voteManager) {
//记录黑名单中，禁止登录系统
System.out.println("进入黑名单，将禁止登录和使用本系统");
}
}
Categoría medioambiental:
public class VoteManager {
//持有状体处理对象
private VoteState state = null;
//记录用户投票的结果，Map<String,String>对应Map<用户名称，投票的选项>
private Map<String,String> mapVote = new HashMap<String,String>();
//记录用户投票次数，Map<String,Integer>对应Map<用户名称，投票的次数>
private Map<String,Integer> mapVoteCount = new HashMap<String,Integer>();
/**
* 获取用户投票结果的Map
*/
public Map<String, String> getMapVote() {
return mapVote;
}
/**
* 投票
* @param user 投票人
* @param voteItem 投票的选项
*/
public void vote(String user,String voteItem){
//1.为该用户增加投票次数
//从记录中取出该用户已有的投票次数
Integer oldVoteCount = mapVoteCount.get(user);
if(oldVoteCount == null){
oldVoteCount = 0;
}
oldVoteCount += 1;
mapVoteCount.put(user, oldVoteCount);
//2.判断该用户的投票类型，就相当于判断对应的状态
//到底是正常投票、重复投票、恶意投票还是上黑名单的状态
if(oldVoteCount == 1){
state = new NormalVoteState();
}
else if(oldVoteCount > 1 && oldVoteCount < 5){
state = new RepeatVoteState();
}
else if(oldVoteCount >= 5 && oldVoteCount <8){
state = new SpiteVoteState();
}
else if(oldVoteCount > 8){
state = new BlackVoteState();
}
//然后转调状态对象来进行相应的操作
state.vote(user, voteItem, this);
}
}
Clase de cliente:
public class Client {
public static void main(String[] args) {
VoteManager vm = new VoteManager();
for(int i=0;i<9;i++){
vm.vote("u1","A");
}
}
}