Notes sur les modèles d'état des modèles de conception
illustrer
Enregistrez la méthode d'écriture pour apprendre le modèle d'état du modèle de conception. La version du JDK utilisée est la version 1.8.
Etat(état)
Intention : autoriser un objet à modifier son comportement lorsque son état interne change.
Structure :
dans:
- Le contexte définit l'interface qui intéresse le client ; maintient une instance de la sous-classe ConcreteState, qui définit l'état actuel.
- L'état définit une interface pour encapsuler le comportement lié à un état spécifique du contexte.
- ConcreteState (sous-classe d'état concret) Chaque sous-classe implémente un comportement lié à un état de Contexte.
applicabilité :
- Le comportement d'un objet est déterminé par son état et il doit modifier son comportement en fonction de son état au moment de l'exécution.
- Une opération contient un grand nombre d’instructions conditionnelles avec plusieurs branches, et ces branches dépendent de l’état de l’objet.
Table des matières
Exemple de diagramme de classes de modèle d'état
[Exemple] Utilisez des boutons pour contrôler l'état d'un ascenseur. Un ascenseur a un état d'ouverture de porte, un état de fermeture, un état d'arrêt et un état de fonctionnement. Chaque changement d'état peut devoir être mis à jour en fonction d'autres états. Par exemple, si la porte de l'ascenseur est actuellement dans un état de fonctionnement, l'opération d'ouverture de porte ne peut pas être effectuée, mais si la porte de l'ascenseur est dans un état arrêté, l'opération d'ouverture de porte peut être effectuée.
Implémentez l'exemple de modèle d'état avec ce diagramme de classes UML.
classe d'état abstrait
package com.example.deesign_patterns.state;
//抽象状态类
public abstract class LiftState {
//定义一个环境角色，也就是封装状态的变化引起的功能变化
//声明环境角色类变量
protected Context context;
public void setContext(Context context) {
this.context = context;
}
//电梯开启操作
public abstract void open();
//电梯关闭操作
public abstract void close();
//电梯运行操作
public abstract void run();
//电梯停止操作
public abstract void stop();
}
Classe de rôle environnemental
package com.example.deesign_patterns.state;
//环境角色类
public class Context {
//定义对应状态对象的常量
public final static OpeningState OPENING_STATE=new OpeningState();
public final static ClosingState CLOSING_STATE=new ClosingState();
public final static RunningState RUNNING_STATE=new RunningState();
public final static StoppingState STOPPING_STATE=new StoppingState();
//定义一个当前电梯状态变量
private LiftState liftState;
public LiftState getLiftState() {
return liftState;
}
//设置当前状态对象
public void setLiftState(LiftState liftState) {
this.liftState = liftState;
//设置当前状态对象中的Context对象
this.liftState.setContext(this);
}
public void open(){
this.liftState.open();
}
public void close(){
this.liftState.close();
}
public void run(){
this.liftState.run();
}
public void stop(){
this.liftState.stop();
}
}
Classe de statut d'ascenseur ouvert
package com.example.deesign_patterns.state;
//电梯开启状态类
public class OpeningState extends LiftState{
//当前状态要执行的方法
@Override
public void open() {
System.out.println("电梯开启。。。");
}
@Override
public void close() {
//修改状态
super.context.setLiftState(Context.CLOSING_STATE);
//调用当前状态中的context中的close方法
super.context.close();
}
@Override
public void run() {
//因为要开启，还没到运行所以什么都不做
}
@Override
public void stop() {
//因为要开启，还没到停止所以什么都不做
}
}
Classe de statut d'ascenseur fermé
package com.example.deesign_patterns.state;
//电梯关闭状态类
public class ClosingState extends LiftState{
//电梯门关闭再打开，很合理
@Override
public void open() {
//修改状态
super.context.setLiftState(Context.OPENING_STATE);
//调用当前状态中的context中的open方法
super.context.open();
}
//当前状态要执行的方法
@Override
public void close() {
System.out.println("电梯门关闭。。。");
}
//电梯门关了再运行，很合理
@Override
public void run() {
//修改状态
super.context.setLiftState(Context.RUNNING_STATE);
//调用当前状态中的context中的run方法
super.context.run();
}
//电梯门关着，我就不按楼层
@Override
public void stop() {
//修改状态
super.context.setLiftState(Context.STOPPING_STATE);
//调用当前状态中的context中的stop方法
super.context.stop();
}
}
Classe d'état de fonctionnement de l'ascenseur
package com.example.deesign_patterns.state;
//电梯运行状态类
public class RunningState extends LiftState{
//运行的时候开电梯门，是不允许的，所以什么都不做
@Override
public void open() {
}
//运行状态电梯门肯定是关闭的，所以什么也不做
@Override
public void close() {
}
//当前状态要执行的方法
@Override
public void run() {
System.out.println("电梯正在运行。。。");
}
//既能运行，必然要停止
@Override
public void stop() {
//修改状态
super.context.setLiftState(Context.STOPPING_STATE);
//调用当前状态中的context中的stop方法
super.context.stop();
}
}
Classe de statut d'arrêt d'ascenseur
package com.example.deesign_patterns.state;
//电梯停止状态类
public class StoppingState extends LiftState{
//电梯停止再开门，很合理
@Override
public void open() {
//修改状态
super.context.setLiftState(Context.OPENING_STATE);
//动作委托为CloseState来执行，也就是委托给ClosingState子类执行这个歌动作
super.context.getLiftState().open();
}
//虽然可以关闭，但这个状态不归我管
@Override
public void close() {
//修改状态
super.context.setLiftState(Context.CLOSING_STATE);
//动作委托为CloseState来执行，也就是委托给ClosingState子类执行这个歌动作
super.context.getLiftState().close();
}
//电梯停止再运行起来，很合理
@Override
public void run() {
//修改状态
super.context.setLiftState(Context.RUNNING_STATE);
//动作委托为CloseState来执行，也就是委托给ClosingState子类执行这个歌动作
super.context.getLiftState().run();
}
//当前状态要执行的方法
@Override
public void stop() {
System.out.println("电梯停止了。。。");
}
}
Classe d'essai
package com.example.deesign_patterns.state;
//测试类
public class Client {
public static void main(String[] args) {
//创建环境角色对象
Context context=new Context();
//设置当前电梯状态,这里设置为正在运行状态
context.setLiftState(new RunningState());
context.open();
context.close();
context.run();
context.stop();
}
}
avantage:
- Mettez tous les comportements liés à un certain état dans une classe et vous pourrez facilement ajouter de nouveaux états. Il vous suffit de changer l'état de l'objet pour changer le comportement de l'objet.
- Permet d'intégrer la logique de transition d'état à l'objet d'état au lieu d'un énorme bloc d'instructions conditionnelles.
défaut:
- L'utilisation du mode état augmentera inévitablement le nombre de classes et d'objets système.
- La structure et la mise en œuvre du modèle d'état sont relativement complexes. S'il est mal utilisé, il entraînera une confusion dans la structure et le code du programme.
- Le modèle d’état ne supporte pas très bien le principe ouvert-fermé.