Dans le processus de développement de logiciels, l'application de certains objets peuvent rendre les comportements différents selon les circonstances, nous appelons cet objet appelé objets stateful, et les propriétés d'une influence sur le comportement d'un objet ou dynamique multiple état appelé. Lorsque l'état d'un objet pour interagir avec des événements extérieurs, il changera son état interne, de sorte que leur comportement va changer en conséquence. Tels que les émotions humaines ont un temps heureux et un temps triste, différentes émotions ont un comportement différent, bien sûr, le monde extérieur a également une incidence sur leurs changements d'humeur.
Cet objet a un état de la programmation, la solution traditionnelle est la suivante : toutes ces situations en considération sont possibles, et si-else déclarations font utiliser la détermination de l' Etat, le traitement des situations différentes. Mais beaucoup état de l'objet, la procédure devient très compliquée. Et pour ajouter un nouveau statut Pour ajouter un nouveau if-else déclaration, ce qui est contraire au « principe d'ouverture et de fermeture » est pas propice à l'expansion du programme.
Si les problèmes ci - dessus, « mode d'état » peut être un bon résolu. Je pensais que le modèle de l' Etat est résolu: Lorsque le contrôle de l' expression conditionnelle d'une transition d'état de l' objet est trop complexe, la « Analyse logique » pertinente extrait, dans une série de classes entre l'état, de sorte que la logique complexe d' origine peut être la détermination simplifiée.
définition du modèle d'État et caractéristiques
mode d'état défini (état): l'état d'un sujet, la « logique de décision » complexe objets extraits à un état différent, ce qui permet à l'état de l'objet change de comportement lorsque ses changements d'états internes.
modèle étatique est un modèle de comportement de l' objet, ses principaux avantages sont les suivants.
- modèle d'état associé à l'état spécifique à un comportement d'état localisé, et le comportement des différents états séparés, se rencontrent « principe de responsabilité unique. »
- Réduire interdépendances entre les objets. Les cibles différents états feront l'introduction d'une transition d'état séparé deviennent plus clairs, et de réduire les interdépendances entre les objets.
- En faveur de l'extension. Grâce à la nouvelle définition de sous-classe ajouter facilement de nouveaux états et les transitions.
Le principal inconvénient de l'état du mode sont comme suit.
- Le nombre de classes et des objets en utilisant le système augmente inévitablement modèle d'état.
- Structure et mise en œuvre du modèle de l'État sont plus complexes, si elle est utilisée de manière incorrecte peut entraîner une confusion et la structure du code de programme.
Architecture et mise en œuvre du modèle d'état
L'état du modèle d'objet à un changement de comportement par l'emballage de l'environnement dans un objet état différent, l'intention est de faire un objet de modifier son état interne lorsque leur comportement a changé. Maintenant, nous devons analyser la structure de base et la mise en œuvre.
1. Structure modèle
modèle de l'État se compose du rôle majeur suivant.
- Environnement (Contexte) Rôle: Aussi appelé contexte, qui définit l'interface d'intérêt pour les clients, le maintien d'un état actuel et de l'état commandé lié à l'état de fonctionnement actuel de l'objet à manipuler.
- état abstrait (État) Rôle: la définition d'une interface pour un objet d'état d'environnement de paquet particulier correspondant au comportement.
- état spécifique (Etat béton) Rôle: Les états abstraits comportement correspondant.
La structure représentée sur la figure 1.
2. Mode de réalisation
codes de motif de l'Etat sont les suivantes:
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());
}
}Les résultats du Programme sont les suivants:
当前状态是 A.
当前状态是 B.
当前状态是 A.
当前状态是 B.Des exemples de l'application de motif état
[Exemple 1] avec un « état de modèle » Concevoir un rendement des élèves du programme de transition de l' État.
Analyse: Cet exemple inclut le « échec », « moyen » et « excellent » trois états, lorsque le score de l' étudiant est temps partagé à moins de 60 « fail » état, lorsque le score est supérieur ou égal à 60 et inférieur à 90 minutes pour le temps partagé « Medium « état, lorsque le score est supérieur ou égal à 90 temps partagé comme » excellent état », nous utilisons le modèle de l' Etat pour réaliser ce programme.
Tout d' abord, la définition d'une classe abstraite de l' État (AbstractState), qui contient les attributs environnementaux, le nom d'attribut et les attributs d'état actuel score et méthode sous-soustraction addScore (INTX) et vérifier l'état actuel de la méthode abstraite checkState (), puis la définition de « non passant « LowState de classe d'état, » intermédiaire « classe d'état MiddleState et » excellent « HighState de classe d'état, ils sont la catégorie d'état spécifique, la réalisation de la méthode checkState (), est chargé de vérifier leur état, et selon la conversion, et enfin, la définition de l' environnement ( ScoreContext), qui contient l'état actuel de l'objet et la méthode des points de soustraction ajouter (score int), pour changer l'état de la performance de la classe client par cette méthode. La figure 2 est une vue structurelle.
Code est la suivante:
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));
}
}
}Les résultats du Programme sont les suivants:
学生成绩状态测试：
加上：30分， 当前分数：30分， 当前状态：不及格
加上：40分， 当前分数：70分， 当前状态：中等
加上：25分， 当前分数：95分， 当前状态：优秀
加上：-15分， 当前分数：80分， 当前状态：中等
加上：-25分， 当前分数：55分， 当前状态：不及格
[Exemple 2] Programme condition de conception de conversion « de modèle d'état » un multi-thread.
Analyse: Multithreading Il y a cinq états, à savoir le nouvel état, état prêt, état de fonctionnement, état de blocage et de l' état de la mort, chaque Etat rencontrera lors de la conversion à d' autres états où événementielles invocation de méthode appropriée ou, comme indiqué dans sa règle de transition d'état 3 représenté sur la figure.
Enfiler 3 diagramme de transition d'état de la Fig.
Maintenant, définir l'état d'une classe abstraite (TheadState), la conception d'un état particulier pour chaque type d'état représenté sur la figure 3, qui est le nouvel état (nouveau), l'état prêt (le Runnable), l'état de fonctionnement (marche), état bloqué ( bloqué) et de l'état de mort (mort), chaque état dispose d'une méthode de déclenchement transition d'état de celle-ci, de l'environnement (ThreadContext) dans un état initial dans M. (New), et de fournir un procédé de déclenchement, le fil est un diagramme de transition d'état représenté sur la fig. 4 la structure du programme de la Fig.
Structure de. La figure 4 la figure état de thread de programme de conversion
Code est la suivante:
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("当前线程处于：死亡状态.");
}
}Les résultats du Programme sont les suivants:
当前线程处于：新建状态.
调用start()方法-->当前线程处于：就绪状态.
获得CPU时间-->当前线程处于：运行状态.
调用suspend()方法-->当前线程处于：阻塞状态.
调用resume()方法-->当前线程处于：就绪状态.
获得CPU时间-->当前线程处于：运行状态.
调用stop()方法-->当前线程处于：死亡状态.
mode d'état des scénarios d'application
En général, le modèle d'état utilisé peut être envisagée dans les cas suivants.
- Lorsque le comportement d'un objet dépend de son état, et il doit changer son comportement en fonction de l'état lors de l'exécution, vous pouvez envisager le mode d'état d'utilisation.
- Lors de l'utilisation d'une grande structure ramifiée contenue dans, et détermine l'état des branches de l'objet.
Mode d'état élargi
Dans certains cas, il peut y avoir plusieurs objets doivent partager un ensemble d'état de l'environnement, la nécessité d'introduire Flyweight, en particulier ceux dans l'état ensemble de l'objet pour le partage du programme, la structure représentée à la figure 5.
Analyse: état partagé, sauf modèle est augmentée dans l'environnement d'un HashMap associé de classe pour sauver l'état peut être acquis à partir d'un certain état si nécessaire, dont le code est le suivant:
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"));
}
}Les résultats du Programme sont les suivants:
当前状态是： 状态1
当前状态是： 状态2
当前状态是： 状态1
当前状态是： 状态2
