Continuez à concevoir le modèle, aujourd'hui nous apportons le modèle de commande, sans parler de la définition:
Définition: Encapsulez les "demandes" dans des objets afin que différentes demandes, files d'attente ou journaux puissent être utilisés pour paramétrer d'autres objets. Le mode de commande prend également en charge les opérations annulables.
Cette définition Nima est pénible à voir, mais si vous ne la comprenez pas, calmez-vous, je vais la simplifier un peu: encapsuler la requête dans un objet, et découpler le demandeur d'action et l'exécuteur d'action. D'accord, utilisez simplement un exemple pour illustrer.
Demande: Les appareils électroménagers intelligents sont très chauds récemment. À l'avenir, Nima estime que les réfrigérateurs utiliseront Alipay pour acheter automatiquement des choses``, en supposant qu'il y ait des téléviseurs, des ordinateurs, des lumières et d'autres appareils ménagers, vous devez maintenant faire une télécommande pour contrôler les interrupteurs de tous les appareils ménagers. La fonction correspondant à chaque bouton peut être personnalisée pour les utilisateurs, et elle doit avoir une très forte évolutivité pour les appareils ménagers nouvellement achetés.
En regardant cette exigence, si Nyima n'a aucune personnalisation et extensibilité, vous pouvez en parler. Ciblez directement le onClick de chaque bouton de la télécommande, puis écrivez le code dedans pour le faire, mais à quel point il est personnalisé, il doit y avoir des extensions Sexe. . .
Eh bien, le mode de commande suivant sort. Le cœur du mode de commande est d'encapsuler les commandes dans des classes. L'exécuteur de commande n'a pas besoin de savoir quelle commande spécifique est exécutée.
1. Regardez d'abord l'API des appareils ménagers que nous avons:
package com.zhy.pattern.command;
/**
* 门
* @author zhy
*
*/
public class Door
{
public void open()
{
System.out.println("打开门");
}
public void close()
{
System.out.println("关闭门");
}
}
package com.zhy.pattern.command;
/**
* 电灯
* @author zhy
*
*/
public class Light
{
public void on()
{
System.out.println("打开电灯");
}
public void off()
{
System.out.println("关闭电灯");
}
}
package com.zhy.pattern.command;
/**
* 电脑
* @author zhy
*
*/
public class Computer
{
public void on()
{
System.out.println("打开电脑");
}
public void off()
{
System.out.println("关闭电脑");
}
}
Il semble que nous ayons des lumières, des ordinateurs et des portes, et l'interface de commutation est conçue. Ensuite, voyons comment encapsuler des commandes dans des classes:
package com.zhy.pattern.command;
public interface Command
{
public void execute();
}
package com.zhy.pattern.command;
/**
* 关闭电灯的命令
* @author zhy
*
*/
public class LightOffCommond implements Command
{
private Light light ;
public LightOffCommond(Light light)
{
this.light = light;
}
@Override
public void execute()
{
light.off();
}
}
package com.zhy.pattern.command;
/**
* 打开电灯的命令
* @author zhy
*
*/
public class LightOnCommond implements Command
{
private Light light ;
public LightOnCommond(Light light)
{
this.light = light;
}
@Override
public void execute()
{
light.on();
}
}
package com.zhy.pattern.command;
/**
* 开电脑的命令
* @author zhy
*
*/
public class ComputerOnCommond implements Command
{
private Computer computer ;
public ComputerOnCommond( Computer computer)
{
this.computer = computer;
}
@Override
public void execute()
{
computer.on();
}
}
package com.zhy.pattern.command;
/**
* 关电脑的命令
* @author zhy
*
*/
public class ComputerOffCommond implements Command
{
private Computer computer ;
public ComputerOffCommond( Computer computer)
{
this.computer = computer;
}
@Override
public void execute()
{
computer.off();
}
}
Comme il y a beaucoup de commandes, selon le principe de conception, nous devons avoir une commande de super-type, puis chaque sous-catégorie, voir que nous encapsulons chaque commande (requête) dans une catégorie. Regardez ensuite notre télécommande.
package com.zhy.pattern.command;
/**
* 控制器面板，一共有9个按钮
*
* @author zhy
*
*/
public class ControlPanel
{
private static final int CONTROL_SIZE = 9;
private Command[] commands;
public ControlPanel()
{
commands = new Command[CONTROL_SIZE];
/**
* 初始化所有按钮指向空对象
*/
for (int i = 0; i < CONTROL_SIZE; i++)
{
commands[i] = new NoCommand();
}
}
/**
* 设置每个按钮对应的命令
* @param index
* @param command
*/
public void setCommand(int index, Command command)
{
commands[index] = command;
}
/**
* 模拟点击按钮
* @param index
*/
public void keyPressed(int index)
{
commands[index].execute();
}
}
package com.zhy.pattern.command;
/**
* @author zhy
*
*/
public class NoCommand implements Command
{
@Override
public void execute()
{
}
}
Notez que notre télécommande dispose de 9 boutons, qui permettent de définir la fonction et de cliquer sur chaque bouton. Notez également que nous utilisons un objet NoCommand appelé objet vide. L'avantage de cet objet est que nous n'avons pas besoin de l'exécuter avant Les deux jugent un if (! = Null) et fournissent des opérations cohérentes.
Enfin, testez le code:
package com.zhy.pattern.command;
public class Test
{
public static void main(String[] args)
{
/**
* 三个家电
*/
Light light = new Light();
Door door = new Door();
Computer computer = new Computer();
/**
* 一个控制器，假设是我们的app主界面
*/
ControlPanel controlPanel = new ControlPanel();
// 为每个按钮设置功能
controlPanel.setCommand(0, new LightOnCommond(light));
controlPanel.setCommand(1, new LightOffCommond(light));
controlPanel.setCommand(2, new ComputerOnCommond(computer));
controlPanel.setCommand(3, new ComputerOffCommond(computer));
controlPanel.setCommand(4, new DoorOnCommond(door));
controlPanel.setCommand(5, new DoorOffCommond(door));
// 模拟点击
controlPanel.keyPressed(0);
controlPanel.keyPressed(2);
controlPanel.keyPressed(3);
controlPanel.keyPressed(4);
controlPanel.keyPressed(5);
controlPanel.keyPressed(8);// 这个没有指定，但是不会出任何问题，我们的NoCommand的功劳
}
}
Résultat de sortie:
Vous pouvez voir que n'importe quel bouton peut être configuré avec n'importe quelle commande à volonté, et il n'est pas nécessaire que Nima change le code, et l'utilisateur peut le personnaliser de toute façon. En fait, c'est blanc, on peut aussi configurer les paramètres ici dans un fichier de configuration, qui est complètement découplé.
Eh bien, l'utilisateur n'est peut-être pas trop satisfait de ce bouton. L'utilisateur espère qu'en pleine nuit, il pourra fournir un bouton pour fermer directement la porte, éteindre la lumière et allumer l'ordinateur. ,,, tout le monde comprend ,,, nous modifions légèrement le code pour le satisfaire
Définissez une commande, l'utilisateur peut faire une série de choses, configurables, et garder l'interface cohérente avec la commande d'origine:
package com.zhy.pattern.command;
/**
* 定义一个命令，可以干一系列的事情
*
* @author zhy
*
*/
public class QuickCommand implements Command
{
private Command[] commands;
public QuickCommand(Command[] commands)
{
this.commands = commands;
}
@Override
public void execute()
{
for (int i = 0; i < commands.length; i++)
{
commands[i].execute();
}
}
}
D'accord, les besoins de Diaosi ont été satisfaits. Testons et voyons.
// 定义一键搞定模式
QuickCommand quickCommand = new QuickCommand(new Command[] { new DoorOffCommond(door),
new LightOffCommond(light), new ComputerOnCommond(computer) });
System.out.println("****点击一键搞定按钮****");
controlPanel.setCommand(8, quickCommand);
controlPanel.keyPressed(8);
Est-ce parfait?
Enfin, parlons du mode commande. Le mode commande consiste à encapsuler la commande dans un objet, puis à découpler complètement le demandeur d'action de l'exécuteur d'action. Dans l'exemple ci-dessus, les boutons de la télécommande n'ont rien à voir avec les appareils électriques.
N'oubliez pas que la file d'attente est mentionnée dans la définition. Comment le mode de commande est-il utilisé pour la file d'attente. Par exemple, il y a de nombreux endroits pour commander de la nourriture dans un restaurant et il y a un endroit pour cuisiner. La commande est considérée comme une commande et la cuisine est considérée comme l'exécuteur de la commande, et il y a toujours des gens Commander équivaut à ajouter des plats à la file d'attente. Pour ceux qui cuisinent, il suffit de les sortir de la file d'attente et d'en prendre un pour en faire un.
Les journaux sont également mentionnés dans la définition. Les journaux sont généralement utilisés pour enregistrer le comportement de l'utilisateur ou pour récupérer des exceptions. Par exemple, chaque commande contient désormais deux méthodes, une pour exécuter l'exécution et une pour annuler (dans l'exemple ci-dessus, pour votre commodité, il n'y a pas Write undo), nous pouvons enregistrer tous les appels de commande de l'utilisateur dans le journal, tels que le fonctionnement incorrect de l'utilisateur, les appareils électriques anormaux, il suffit de retirer toutes les commandes du journal et d'exécuter une annulation et il sera complètement restauré, c'est vrai. sens.
D'accord, tout le monde m'aide à laisser un commentaire et à aimer, merci à tous ~