Mode état (type de comportement)

Dans State Pattern, le comportement d'une classe change en fonction de son état. Ce type de modèle de conception est un modèle comportemental.

En mode état, nous créons des objets qui représentent divers états et un objet contextuel dont le comportement change au fur et à mesure que l'objet d'état change.

Présentation

Intention: permet à l'objet de modifier son comportement lorsque l'état interne change et que l'objet semble modifier sa classe.

Solution principale: Le comportement d'un objet dépend de son état (attributs), et son comportement associé peut être modifié en fonction de son changement d'état.

Quand l'utiliser: Le code contient un grand nombre d'instructions conditionnelles liées à l'état de l'objet.

Résolution: résumez toutes sortes de classes d'état concrètes.

Code clé: Il n'y a généralement qu'une seule méthode dans l'interface du mode de commande. Il existe une ou plusieurs méthodes dans l'interface en mode état. De plus, les méthodes de la classe d'implémentation du mode d'état retournent généralement des valeurs ou modifient la valeur des variables d'instance. En d'autres termes, le mode d'état est généralement lié à l'état de l'objet. Les méthodes de la classe d'implémentation ont différentes fonctions, couvrant les méthodes de l'interface. Le mode d'état est le même que le mode de commande et peut également être utilisé pour éliminer les instructions de sélection conditionnelle telles que if ... else.

Exemples d'application:  1. En jouant au basket-ball, les athlètes peuvent avoir un état normal, un état anormal et un état anormal. 2. Dans les carillons de Zeng Houyi, «l'horloge est une interface abstraite», «l'horloge A», etc. est un état concret et «les carillons de Zeng Houyi» est un contexte spécifique.

Avantages:  1. Encapsulez les règles de conversion. 2. Énumérer les états possibles Avant d'énumérer les états, vous devez déterminer le type d'état. 3. Mettez tous les comportements liés à un certain état dans une classe, et vous pouvez facilement ajouter de nouveaux états. Il vous suffit de changer l'état de l'objet pour changer le comportement de l'objet. 4. Autorisez l'intégration de la logique de transition d'état et des objets d'état, plutôt qu'un énorme bloc d'instructions conditionnelles. 5. Vous pouvez laisser plusieurs objets d'environnement partager un objet d'état, réduisant ainsi le nombre d'objets dans le système.

Inconvénients:  1. L'utilisation du mode état augmentera inévitablement le nombre de classes système et d'objets. 2. La structure et l'implémentation du mode état sont plus compliquées, si elles sont mal utilisées, cela entraînera une confusion dans la structure et le code du programme. 3. La prise en charge du "principe d'ouverture et de fermeture" dans le mode état n'est pas très bonne. Pour le mode état qui peut changer d'état, l'ajout d'une nouvelle classe d'état doit modifier le code source responsable de la transition d'état, sinon il ne peut pas basculer vers le nouvel état et modifier Le comportement d'une classe d'état doit également modifier le code source de la classe correspondante.

Utilisez des scénarios:  1. Scénarios où le comportement change à mesure que l'état change. 2. Remplacez les conditions et les déclarations de branche.

Remarque: Utilisez le mode état lorsque le comportement est contraint par l'état et qu'il n'y a pas plus de 5 états.

---

Atteindre

Nous allons créer une   interface d' état et  une classe d'état d'entité qui implémente l'  interface d' état . Le contexte  est une classe avec un certain état.

StatePatternDemo , notre classe de démonstration utilise   des objets Context et State pour illustrer le changement de comportement de Context lorsque l'état change.

Diagramme de première classe

 

Créez d'abord une machine d'état, qui a des variables d'objet d'état utilisées pour représenter l'état actuel

public class Context {

    //当前状态
    private State state;

    public void setState(State state) {
        this.state = state;
    }

    public State getState() {
        return state;
    }

    //启动
    public void start() {
        getState().start(this);
    }

    //关闭
    public void close() {
        getState().close(this);
    }
}

Créer un état d'interface d'état

public interface State
{
    public void start(Context context);
    public void close(Context context);
}

 

Lors de la création de deux classes d'état, implémentez l'interface d'état

/**
 * 开机状态
 */
public class StartState implements State {

    public void start(Context context) {
        System.out.println("already start");
    }

    public void close(Context context) {
        context.setState(new CloseState());//注意状态的切换
        System.out.println("close State");
    }
}


/**
 * 关闭状态
 */
public class CloseState implements State {

    public void start(Context context) {
        context.setState(new StartState());//注意状态的切换
        System.out.println("start State");
    }
    public void close(Context context) {
        System.out.println("already close");
    }
}

Commencez le test ci-dessous

/**
 * 客户端测试
 */
public class Client {
    public static void main(String... args) {
        Context context = new Context();
        
        // 初始为开始状态
        context.setState(new StartState());
        // 切换为关闭状态
        context.close();
        // 切换为开始状态
        context.start();
        context.start();
    }
}

close State
start State
already start

Process finished with exit code 0