Lorsque l'état de l'objet change, il change également son comportement, c'est facile à comprendre! Prenons l'exemple de QQ. Il y a plusieurs états, en ligne, invisible, occupé, etc. Chaque état correspond à une opération différente, et vos amis peuvent également voir votre état. Par conséquent, le mode d'état a deux points: 1. Modifiez l'état pour obtenir des comportements différents. 2. Vos amis peuvent voir vos modifications en même temps.
Le mode État permet à un objet de modifier son comportement lorsque son état interne change. Cet objet semble avoir changé de classe.
Diagramme de classe
La classe State est une classe d'état et la classe Context peut être commutée.
Exemple de code
Classe d'état:
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. }
Classe de contexte:
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. }
Catégorie de test:
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. }
Selon cette fonctionnalité, le mode état est beaucoup utilisé dans le développement quotidien, en particulier lors de la construction d'un site Web, on espère parfois distinguer certaines de leurs fonctions en fonction d'un certain attribut de l'objet, comme le simple contrôle des permissions.
La structure du modèle d'état
En une phrase, le modèle d'état emballe le comportement de l'objet étudié dans différents objets d'état, et chaque objet d'état appartient à une sous-classe d'une classe d'état abstraite. L'intention du modèle d'état est de faire en sorte qu'un objet modifie son comportement lorsque son état interne change.
Les rôles impliqués dans le modèle d'état sont:
Le rôle de l'environnement (Contexte) est aussi un contexte: définissez l'interface qui intéresse le client et conservez une instance d'une classe d'état spécifique. L'instance de cette classe d'état concrète donne l'état actuel de cet objet d'environnement.
● Rôle état abstrait (State): définissez une interface pour encapsuler le comportement correspondant à un état spécifique de l'objet d'environnement (Contexte).
● Rôle état concret (ConcreteState): chaque classe d'état concret implémente le comportement correspondant à un état de l'environnement (Context).
Scénario d'application
Envisagez l’application d’un système de vote en ligne, afin d’obtenir le contrôle du même utilisateur, il ne peut voter qu’un seul vote. Si un utilisateur vote à plusieurs reprises et que le nombre de votes dépasse 5 fois, il est considéré comme un brossage malveillant et la qualification de l’utilisateur pour voter sera annulée. Pour annuler son vote, si un utilisateur vote plus de 8 fois, il entrera dans la liste noire, se connectera et utilisera le système est interdit.
Pour utiliser le mode état à réaliser, vous devez d'abord définir les différents états du processus de vote, qui peuvent être grossièrement divisés en quatre états selon la description ci-dessus: vote normal, vote répété, brossage malveillant et inscription sur la liste noire. Créez ensuite un objet de gestion de vote (équivalent à Contexte).
Classe d'état abstraite
public interface VoteState {
/**
* 处理状态对应的行为
* @param user 投票人
* @param voteItem 投票项
* @param voteManager 投票上下文，用来在实现状态对应的功能处理的时候，
* 可以回调上下文的数据
*/
public void vote(String user,String voteItem,VoteManager voteManager);
}
Statut spécifique du vote normal par classe
public class NormalVoteState implements VoteState {
@Override
public void vote(String user, String voteItem, VoteManager voteManager) {
//正常投票，记录到投票记录中
voteManager.getMapVote().put(user, voteItem);
System.out.println("恭喜投票成功");
}
}
Vote répété par classe de statut spécifique
public class RepeatVoteState implements VoteState {
@Override
public void vote(String user, String voteItem, VoteManager voteManager) {
//重复投票，暂时不做处理
System.out.println("请不要重复投票");
}
}
Balayage malveillant de classe d'état spécifique
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("你有恶意刷屏行为，取消投票资格");
}
}
Liste noire de classe de statut spécifique
public class BlackVoteState implements VoteState {
@Override
public void vote(String user, String voteItem, VoteManager voteManager) {
//记录黑名单中，禁止登录系统
System.out.println("进入黑名单，将禁止登录和使用本系统");
}
}
Catégorie environnementale:
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);
}
}
Classe de client:
public class Client {
public static void main(String[] args) {
VoteManager vm = new VoteManager();
for(int i=0;i<9;i++){
vm.vote("u1","A");
}
}
}