Pour implémenter le modèle de conception de commande, il doit d'abord clarifier sa composition de base et l'implémenter pas à pas. 1. Comprendre les composants principaux du mode de commande: y compris l'interface de commande, les classes de commande spécifiques, les récepteurs, les appelants et les clients; 2. Définir les interfaces de commande, incluant généralement la méthode EXECUTE (); 3. Créer des classes de destinataires qui effectuent des opérations réelles telles que la lumière; 4. Implémentez des classes de commande spécifiques telles que LightOnCommand et LightOffCommand pour encapsuler les méthodes du récepteur; 5. Utilisez des appelants tels que RemoteControl pour déclencher des commandes; 6. Créer et lier des commandes et des récepteurs sur le client et exécutez les opérations via l'appelant. Ce mode met en ?uvre l'encapsulation demandée, le découplage de l'opération et l'expansion fonctionnelle.

La mise en ?uvre du modèle de conception de commande dans Java est un moyen solide de résumer les demandes en tant qu'objets, vous permettant de paramétrer les clients avec des opérations, des demandes de file d'attente ou de journal et de prendre en charge les actions à prévoir. Il est particulièrement utile lorsque vous souhaitez découpler l'objet qui invoque une opération de celle qui sait comment l'exécuter.

Faisons de la fa?on de faire ce pas par étape.

1. Comprendre les composants centraux du modèle de commande

Avant d'écrire un code, il est utile de comprendre quelles pièces constituent le modèle de commande:

• Commande - Une interface ou une classe abstraite qui déclare une méthode execute() .
• Commande de béton - implémente la méthode execute() en appelant la méthode appropriée sur un récepteur.
• Récepteur - L'objet réel qui effectue l'action.
• Invoker - détient une commande et appelle sa méthode execute() en cas de besoin.
• Client - Crée la commande et définit le récepteur.

Cette structure permet une flexibilité, telle que la file d'attente ou l'ajout de fonctionnalités d'annulation plus tard.

2. Définissez l'interface de commande

Commencez par créer une interface simple que toutes les commandes concrètes implémenteront. La version la plus élémentaire ne comprend qu'une seule méthode: execute() .

 Commande d'interface publique {
    void execute ();
}

Vous pouvez également étendre cette interface pour inclure des choses comme undo() , mais restez simple au début.

3. Créez une classe de récepteur

Le récepteur fait le vrai travail. Par exemple, imaginez un système d'interrupteur d'éclairage. Vous pourriez avoir une classe Light comme ceci:

 classe publique Light {
    public void Turnon () {
        System.out.println ("La lumière est allumée");
    }

    public Void Turnoff () {
        System.out.println ("La lumière est éteinte");
    }
}

C'est là que réside la logique réelle - la commande appellera ces méthodes indirectement.

4. Implémentez les classes de commande en béton

Créez maintenant une commande qui utilise le récepteur. Pour allumer la lumière:

 classe publique LightOnCommand implémente la commande {
    lumière privée de lumière;

    public LightOnCommand (lumière lumineuse) {
        this.light = lumière;
    }

    @Outrepasser
    public void execute () {
        Light.Turnon ();
    }
}

Et si vous souhaitez soutenir le désactiver:

 classe publique LightOffCommand implémente la commande {
    lumière privée de lumière;

    public LightOffCommand (lumière lumineuse) {
        this.light = lumière;
    }

    @Outrepasser
    public void execute () {
        Light.Turoff ();
    }
}

Ces objets de commande agissent comme des emballages autour des méthodes du récepteur.

5. Utilisez un invocateur pour déclencher des commandes

Un invocateur ne sait pas ce que fait la commande - il déclenche simplement l'exécution. En voici un simple:

 classe publique RemoteControl {
    Commande de commande privée;

    public void setCommand (Command Command) {
        this.command = commande;
    }

    public void Pressbutton () {
        Command.execute ();
    }
}

Vous pouvez étendre cela pour gérer plusieurs boutons ou files d'attente, mais cela vous donne l'idée.

6. Mettez le tout dans le client

Enfin, cablez tout dans votre classe principale ou votre code client:

 Client de classe publique {
    public static void main (String [] args) {
        // Créer le récepteur
        Lumière Lumière = Nouvelle Lumière ();

        // Créer la commande et passer le récepteur
        Command LightOn = new LightCommand (Light);

        // Créer l'invocateur et définir la commande
        RemoteControl Remote = new RemoteControl ();
        Remote.setCommand (Lighton);

        // déclenche la commande
        Remote.PressButton ();
    }
}

Si vous exécutez ceci, vous verrez:

 La lumière est allumée

Changez la commande en LightOffCommand et appuyez sur le bouton le désactive à la place.

Cette configuration maintient votre code modulaire et facilite l'ajout de nouvelles commandes sans modifier celles existantes. Une fois que vous avez les bases, vous pouvez facilement l'étendre pour prendre en charge les commandes par lots d'annulation, de journalisation ou de style macro.

Fondamentalement, c'est tout.

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!