Comment implémenter un modèle de commande dans un modèle de conception Java

Compréhension personnelle : Séparez plusieurs commandes dans une classe et placez une commande dans chaque classe pour réaliser le découplage. Une classe ne correspond qu'à une seule fonction. Lors de l'utilisation de la commande, une autre classe gérera toutes les commandes de manière uniforme.

Inconvénients : S'il y a trop de fonctions, trop de classes seront créées

Le modèle de commande est un modèle de conception basé sur les données, qui appartient au modèle comportemental # 🎜🎜# . La requête est enveloppée dans un objet sous la forme d'une commande et transmise à l'objet appelant. L'objet appelant recherche un objet approprié capable de gérer la commande et transmet la commande à l'objet correspondant, qui exécute la commande.

Introduction

Intention : Encapsuler une requête dans un objet, vous permettant de paramétrer des clients ayant des requêtes différentes.

Solution principale : dans les systèmes logiciels, les demandeurs de comportement et les implémenteurs de comportement ont généralement une relation étroitement couplée, mais dans certains cas, comme la nécessité d'enregistrer et d'annuler des comportements ou de refaire, des transactions, etc., cela une sorte de conception étroitement couplée qui ne peut pas résister aux changements ne convient pas.

Quand utiliser : Dans certaines situations, telles que "enregistrement, annulation/rétablissement, transaction" et autres traitements de comportements, ce type de couplage étroit qui ne peut pas résister aux changements n'est pas approprié. Dans ce cas, comment découpler le « demandeur de comportement » du « implémenteur de comportement » ? L'abstraction d'un ensemble de comportements en objets peut permettre d'obtenir un couplage lâche entre eux.

Comment résoudre : Appelez le destinataire via l'appelant pour exécuter la commande, l'ordre est : appelant→commande→récepteur.

Code clé : Séparez les commandes dans la classe pour créer des classes pour elles. Ces classes de commandes ont la même classe parent.

Avantages :

• Attelage réduit.

• De nouvelles commandes peuvent être facilement ajoutées au système.

Inconvénients : L'utilisation du mode commande peut amener certains systèmes à avoir trop de classes de commandes spécifiques.

Scénarios d'utilisation : Le mode commande peut être utilisé partout où des commandes sont prises en compte, par exemple : 1. Chaque bouton de l'interface graphique est une commande. 2. Simulez CMD.

Remarque : le système doit prendre en charge l'opération d'annulation (Annuler) et l'opération de récupération (Rétablir) de la commande, et vous pouvez également envisager d'utiliser le mode commande.

Implementation

Nous créons d'abord l'interface Order en tant que commande, puis créons la classe Stock en tant que requête. Les classes de commandes d'entité BuyStock et SellStock implémentent l'interface Order et effectueront le traitement réel des commandes. Créez un courtier de classe comme objet appelant, qui accepte les commandes et peut passer des commandes. L'objet Broker utilise le mode commande pour déterminer quel objet exécute quelle commande en fonction du type de commande. La classe CommandPatternDemo utilise la classe Broker pour démontrer le modèle de commande.

Étapes spécifiques de mise en œuvre

1 Créez un projet Java.

2. Créer une classe de demande de stock Stock.

package src.com.设计模式.命令模式;
/*
* 股票类
* */
public class Stock {
    private String name;
    private int quantity;
    public Stock(String name, int quantity) {
        this.name = name;
        this.quantity = quantity;
    }
    public void buy(){
        System.out.println("股票买入成功"+name+",股数："+quantity);
    }
    public void sell(){
        System.out.println("股票卖出成功"+name+",股数： "+quantity);
    }
}

3. Créez une interface de commande Commande.

package src.com.设计模式.命令模式;
public interface Order {
    void execute();
}

4. Créez une classe d'entité BuyStock qui implémente l'interface Order.

package src.com.设计模式.命令模式;
public class BuyStock implements Order{
    //依赖于Stock对象
    private Stock stock;
    public BuyStock(Stock stock) {
        this.stock = stock;
    }
    @Override
    public void execute() {
        //购买目标股票的业务操作
        stock.buy();
    }
}

5. Créez une classe d'entité SellStock qui implémente l'interface Order.

package src.com.设计模式.命令模式;
public class SellStock implements Order{
    private Stock stock;

    public SellStock(Stock stock) {
        this.stock = stock;
    }
    @Override
    public void execute() {
        stock.sell();
    }
}

6. Créez une commande appelant la classe Broker.

package src.com.设计模式.命令模式;
import java.util.ArrayList;
import java.util.List;
/*
* 股票经纪人类
* */
public class Broker {
    private List<Order> orderList = new ArrayList<>();
    //1.接受订单
    public void takeOrder(Order order){
        orderList.add(order);
    }
    //2.执行订单
    public void placeOrders(){
        orderList.forEach(fun ->{
            fun.execute();
        });
    }
}

7. Créez la classe CommandPatternDemo, puis utilisez la classe Broker pour accepter et exécuter les commandes.

package src.com.设计模式.命令模式;
public class CommandPatternDemo {
    public static void main(String[] args) {
        Stock stock = new Stock("002607",100);
        BuyStock buyStock = new BuyStock(stock);
        SellStock sellStock = new SellStock(stock);
        Broker broker = new Broker();
        broker.takeOrder(buyStock);
        broker.takeOrder(sellStock);
        broker.placeOrders();
    }
}

8. Exécutez le programme et affichez les résultats.

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!