Comment utiliser le modèle de conception d'état Java pour implémenter la transition d'état d'objet

Introduction

Java State Pattern est un modèle de conception orienté objet qui encapsule l'état d'un objet dans un objet d'état indépendant et dissocie le comportement de l'objet de l'objet d'état. Il permet à l'objet de stocker son état interne lorsqu'un changement se produit, son comportement change. Ce modèle encapsule le comportement de l'objet dans différents objets d'état, plutôt que de mettre tous les comportements dans une classe.

Le modèle d'état Java se compose généralement des 3 rôles suivants :

• State Interface (State Interface) : définit. un ensemble de méthodes liées aux objets de contexte, qui seront implémentées par des objets spécifiques dans différents états.

• Concrete State (Concrete State) : implémente l'interface d'état, en particulier les objets State sont différentes implémentations d'état.

• Context : Un objet avec plusieurs états. L'objet contextuel peut changer l'état au moment de l'exécution, modifiant ainsi son comportement

Il convient de noter que l'état Java Il existe de nombreuses façons d'implémenter des modèles, comme l'utilisation d'interfaces et de classes abstraites pour implémenter des états. , en utilisant des énumérations pour implémenter des états, etc. La méthode de mise en œuvre spécifique dépend des besoins et des scénarios spécifiques

Mise en œuvre

Supposons que nous ayons un jeu simple, le protagoniste de peut effectuer différentes opérations dans différents états. modèle pour implémenter la conception de ce jeu.

Interface d'état

public interface State {
    /**
     * 移动
     */
    void move();
    /**
     * 攻击
     */
    void attack();
}

État spécifique

public class IdleState implements State{
    /**
     * 移动
     */
    @Override
    public void move() {
        System.out.println("静止状态下不能移动...");
    }
    /**
     * 攻击
     */
    @Override
    public void attack() {
        System.out.println("静止状态下不能攻击...");
    }
}
public class MoveState implements State{
    /**
     * 移动
     */
    @Override
    public void move() {
        System.out.println("移动中...");
    }
    /**
     * 攻击
     */
    @Override
    public void attack() {
        System.out.println("移动状态下不能攻击...");
    }
}
public class AttackState implements State{
    /**
     * 移动
     */
    @Override
    public void move() {
        System.out.println("攻击状态下不能移动...");
    }
    /**
     * 攻击
     */
    @Override
    public void attack() {
        System.out.println("攻击中...");
    }
}

Context

public class Context {
    private State state;
    public Context() {
        // 默认静止状态
        this.state = new IdleState();
    }
    public void setState(State state) {
        this.state = state;
    }
    /**
     * 移动
     */
    public void move() {
        state.move();
    }
    /**
     * 攻击
     */
    public void attack() {
        state.attack();
    }
}

Test

public class Demo {
    public static void main(String[] args) {
        // 静止状态
        Context context = new Context();
        context.move();
        context.attack();
        // 移动状态
        context.setState(new MoveState());
        context.move();
        context.attack();
        // 攻击状态
        context.setState(new AttackState());
        context.move();
        context.attack();
    }
}

Dans Dans l'exemple ci-dessus, nous définissons d'abord une interface d'état, puis nous en définissons trois. des classes d'état spécifiques, IdleState, MoveState et AttackState, qui représentent respectivement l'état d'inactivité, l'état de mouvement et l'état d'attaque du protagoniste. Ces états implémentent tous l'interface State. Ensuite, nous définissons un contexte Context, qui contient un objet State pour représenter l'état actuel. Dans la classe Context, nous définissons une méthode setState pour changer l'état, ainsi que les méthodes de déplacement et d'attaque pour effectuer les opérations correspondantes.

Résumé

Avantages

• Le modèle d'état facilite l'ajout d'un état, il suffit d'ajouter un nouvelle classe d'état.

• Le modèle d'état rend l'état de l'objet en encapsulant la logique de transition d'état dans la classe d'état. Les changements sont plus spécifiques et clairs

• Le modèle d'état simplifie le changement d'état, il suffit d'appeler le. méthode de transition d'état de l'objet.

Inconvénients

• Le modèle d'état entraînera une augmentation du nombre de classes dans le système, augmentant la complexité du code

• Le modèle d'état peut provoquer le. le processus de changement d'état devient compliqué.

Scénarios d'application

• Lorsque le comportement d'un objet dépend de son état et que l'état peut être modifié au moment de l'exécution, le modèle State est un bon choix lorsque des changements se produisent.

Le modèle State est utile lorsqu'un objet doit effectuer différentes opérations en fonction de son état
Lorsque de nouveaux comportements doivent être ajoutés dynamiquement à l'objet Quand, le mode état est un bon choix. les scénarios d'application courants incluent : l'état de la commande ; l'état de connexion de l'utilisateur ; l'état du jeu, etc.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!