Non JavaStorm l'attention du public pour plus de croissance.
Il faut environ 6 minutes pour lire. Collection après des suggestions de lecture.
Le fonctionnement en mode de commande ou une demande à un objet emballé. le mode de commande permet au système d'utiliser une autre demande des paramètres du client, la file d' attente de demande ou enregistrer les demandes, et peut fournir une récupération de commande undo.
GitHub Adresse: https://github.com/UniqueDong/zero-design-stu le paquet sous la tête la première de code.
contour
le mode de commande de la commande est encapsulé. le mode de commande pour émettre une commande de charge et de la responsabilité de l'exécution des commandes séparées, affectées à des objets différents.
Chaque commande est une opération: le demandeur demandant d'effectuer une opération requise; partie de réception reçoit la demande, et effectue une opération. Mode permet une commande et l'une des demandes reçues ouvertes indépendantes, de sorte que la partie requérante n'a pas à connaître l'interface d'une réception de la demande, de ne pas savoir comment a été reçu la demande, et si l'opération est réalisée, quand il a été réalisé, et comment le il est exécuté.
Commande permet une partie demande et recevoir des demandes peuvent être évolué indépendamment, de façon à avoir les avantages suivants:
(1) le mode de commande de sorte que la nouvelle commande facilement être ajouté au système.
(2) permet à un de décider si la demande reçue est une demande être rejetée.
(3) peut être plus facilement conçu une file d'attente de commande.
(4) peut être facilement réalisée pour annuler et demande de rétablissement.
(5) En cas de besoin, il peut être plus facilement commande connecté.
rôle
- rôle client (Client): pour créer un ConcreteCommand, et définissez son destinataire.
- (Command) Rôle: déclarer une interface à toutes les commandes. Appelez l'objet de commande exécuter méthode peut permettre au bénéficiaire d'effectuer des actions connexes, l'interface a aussi une méthode undo co-travailleur () a été retirée.
- ordre spécifique (ConcreteCommand) Rôle: couplage faible entre le récepteur et définit un comportement; implémenter la méthode execute (), est responsable pour le fonctionnement du destinataire de l' appel correspondant. méthode execute () est généralement appelée la méthode d'exécution. La nécessité de l' appelant ne peut exécuter la méthode demander, puis une ou plusieurs actions invoquées par le destinataire ConcreteCommand.
- L'appelant (Invoker) rôles: l'appelant à tenir un objet de commande exécuter méthode fournit un objet de commande de déclenchement d'appel de méthode, la commande sera exécutée.
- (Récepteur) Rôle: responsable de la mise en œuvre et l' exécution d' une demande. Toute classe peut être un récepteur, le mode d'exécution de la demande et la méthode dite d'action.
processus de mise en œuvre
- Le client crée un objet de commande.
- SetCommand client appelle la méthode sur l'objet de l'appelant.
- Dans le prochain point approprié dans le temps, l'appelant appelle la méthode execute de l'objet de commande.
- Commande confiée aux destinataires correspondants effectués par l'appelant. Pour compléter la tâche.
simulation de scène
A versatile télécommande programmable (6 emplacements dont chacun peut spécifier un autre appareil ménager), pour commander les appareils ménagers (TV, climatiseurs, réfrigérateurs, stéréo). Chaque emplacement a un bouton [ON] et [OFF]. Il dispose également d' un ensemble clé un bouton retiré. La demande est le retrait de l'affaire, comme la lampe est éteinte, puis appuyez sur le bouton pour allumer les lumières ont été ouvertes. Maintenant , si le bouton Annuler est pressé, l'action sera inversée. Ici, les lumières seront éteintes.
Appareils raccordés à la fente correspondante, l'instruction correspondante est un commutateur. Chaque appareil correspondant à deux instructions, à savoir le bouton [ouvert] et [OFF].
De nombreux appareils ont sur () et la méthode de (), en plus d'un certain nombre de setVolumn (), setTV (), setTemperature () méthode.
Nous ne pouvons pas écrire si slot1 == Lumière puis light.on () .
code mise en œuvre
Commande Rôles bénéficiaires
Tout d'abord, nous avons beaucoup d'appareils. En fait, ils sont le public pour l'exécution des commandes différentes.
- lumière
package com.zero.headfirst.command.receiver;
public class Light {
public void on() {
System.out.println("打开电灯。");
}
public void off() {
System.out.println("关灯。");
}
}
- son
package com.zero.headfirst.command.receiver;
public class Stereo {
public void on() {
System.out.println("打开音响");
}
public void off() {
System.out.println("关闭音响");
}
public void setCD() {
System.out.println("放入CD");
}
public void setVolume() {
System.out.println("音响音量设置为20");
}
}
rôle de commandement
Tout d'abord objet de commande qui implémente cette interface, respectivement, l'exécution de la commande et le retrait
package com.zero.headfirst.command;
/**
* 命令(Command)角色
*/
public interface Command {
/**
* 命令执行
*/
void execute();
/**
* 命令撤销
*/
void undo();
}
rôle de commande spécifique
- commande défini lumières pour atteindre exécuter. récepteur de commande est titulaire d'une lumière de référence, de sorte que lorsque l'appelant appelle le délégué pour exécuter le témoin de fonctionnement correspondant effectué.
package com.zero.headfirst.command.impl;
import com.zero.headfirst.command.Command;
import com.zero.headfirst.command.receiver.Light;
public class LightOnCommand implements Command {
/**
* 持有接受者实例，以便当命令execute执行的时候由接受者执行开灯
*/
private Light light;
@Override
public void execute() {
light.on();
}
@Override
public void undo() {
light.off();
}
/**
* 设置命令的接受者
* @param light
*/
public void setLight(Light light) {
this.light = light;
}
}
- lumières de commande définies
package com.zero.headfirst.command.impl;
import com.zero.headfirst.command.Command;
import com.zero.headfirst.command.receiver.Light;
public class LightOffCommand implements Command {
/**
* 持有接受者实例，以便当命令execute执行的时候由接受者执行
*/
private Light light;
@Override
public void execute() {
light.off();
}
@Override
public void undo() {
light.on();
}
public void setLight(Light light) {
this.light = light;
}
}
- Open Sound commande défini
package com.zero.headfirst.command.impl;
import com.zero.headfirst.command.Command;
import com.zero.headfirst.command.receiver.Stereo;
/**
* 音响开指令
*/
public class StereoOnCommand implements Command {
private Stereo stereo;
@Override
public void execute() {
stereo.on();
stereo.setCD();
stereo.setVolume();
}
@Override
public void undo() {
stereo.off();
}
public void setStereo(Stereo stereo) {
this.stereo = stereo;
}
}
- commande Fermer son définie
package com.zero.headfirst.command.impl;
import com.zero.headfirst.command.Command;
import com.zero.headfirst.command.receiver.Stereo;
public class StereoOffCommand implements Command {
private Stereo stereo;
public void setStereo(Stereo stereo) {
this.stereo = stereo;
}
@Override
public void execute() {
stereo.off();
}
@Override
public void undo() {
stereo.on();
stereo.setCD();
stereo.setVolume();
}
}
Le reste Allumez le téléviseur, éteignez le téléviseur, allumer la climatisation, fermez l'air de ne pas à donner. Le modèle est la même routine. Maintenant , le code spécifique peut GitHub adresse: https://github.com/UniqueDong/zero-design-stu le paquet sous la tête la première de code.
Le rôle de l'appelant
En fait, notre contrôle à distance.
package com.zero.headfirst.command;
import com.zero.headfirst.command.impl.NoCommand;
import java.util.Arrays;
/**
* 调用者：遥控器
*/
public class RemoteControl {
/**
* 一共4个家电插槽，每个插槽有 开与关命令。
*/
private Command[] onCommands;
private Command[] offCommands;
//用来保存前一个命令，用来实现撤销功能
private Command undoCommand;
/**
* 通过构造器初始化开关数组
*/
public RemoteControl() {
onCommands = new Command[4];
offCommands = new Command[4];
//初始化所有插槽为空指令
Command noCommand = new NoCommand();
for (int i = 0; i < 4; i++) {
onCommands[i] = noCommand;
offCommands[i] = noCommand;
}
//一开始没有所谓的前一个命令，所以默认无指令
undoCommand = noCommand;
}
/**
* 设置指定插槽对应的按钮指令
* @param slot 插槽位置
* @param onCommand 开指令
* @param offCaommand 关指令
*/
public void setCommand(int slot,Command onCommand, Command offCaommand) {
onCommands[slot] = onCommand;
offCommands[slot] = offCaommand;
}
/**
* 模拟按下指定插槽对应的【开】按键
*/
public void pressOnButton(int slot) {
onCommands[slot].execute();
//将当前指令记录下来，用于在撤销的时候能执行命令对应的 undo 方法从而实现撤销功能
undoCommand = onCommands[slot];
}
/**
* 模拟按下指定插槽对应的【关】按键
*/
public void pressOffButton(int slot) {
offCommands[slot].execute();
undoCommand = offCommands[slot];
}
/**
* 撤销功能
*/
public void pressUndoButton() {
undoCommand.undo();
}
@Override
public String toString() {
return "RemoteControl{" +
"onCommands=" + Arrays.toString(onCommands) +
", offCommands=" + Arrays.toString(offCommands) +
'}';
}
}
rôle client
L' obtention d'un contrôle à distance, et pour obtenir les lumières, récepteur de commande de climatisation. [Insérer l'ouverture correspondant respectivement] commande [OFF].
Lien à l'emplacement correspondant. Lorsque le bouton est appuyé sur la détente des instructions spécifiées.
package com.zero.headfirst.command;
import com.zero.headfirst.command.impl.*;
import com.zero.headfirst.command.receiver.AirConditioning;
import com.zero.headfirst.command.receiver.Light;
import com.zero.headfirst.command.receiver.Stereo;
import com.zero.headfirst.command.receiver.TV;
/**
* 客户端角色
*/
public class CommandClient {
public static void main(String[] args) {
//创建一个遥控器-调用者角色
RemoteControl remoteControl = new RemoteControl();
//1. 创建电灯-接受者角色
Light light = new Light();
//创建开灯、关灯命令-命令具体角色
LightOnCommand lightOnCommand = new LightOnCommand();
lightOnCommand.setLight(light);
LightOffCommand lightOffCommand = new LightOffCommand();
lightOffCommand.setLight(light);
//调用者设置电灯插槽以及对应的开关按键指令-调用者角色
remoteControl.setCommand(0, lightOnCommand, lightOffCommand);
// 2. 设置音响插槽与对应按键指令
Stereo stereo = new Stereo();
StereoOnCommand stereoOnCommand = new StereoOnCommand();
stereoOnCommand.setStereo(stereo);
StereoOffCommand stereoOffCommand = new StereoOffCommand();
stereoOffCommand.setStereo(stereo);
remoteControl.setCommand(1, stereoOnCommand, stereoOffCommand);
//3. 空调
AirConditioning airConditioning = new AirConditioning();
AirConditioningOnCommand airConditioningOnCommand = new AirConditioningOnCommand();
airConditioningOnCommand.setAirConditioning(airConditioning);
AirConditioningOffCommand airConditioningOffCommand = new AirConditioningOffCommand();
airConditioningOffCommand.setAirConditioning(airConditioning);
remoteControl.setCommand(2, airConditioningOnCommand, airConditioningOffCommand);
//4. 电视
TV tv = new TV();
TVOnCommand tvOnCommand = new TVOnCommand();
tvOnCommand.setTv(tv);
TVOffCommand tvOffCommand = new TVOffCommand();
tvOffCommand.setTv(tv);
remoteControl.setCommand(3, tvOnCommand, tvOffCommand);
//模拟按键
System.out.println("-------码农回家了，使用遥控开启电灯、音响、空调、电视----");
remoteControl.pressOnButton(0);
remoteControl.pressOnButton(1);
remoteControl.pressOnButton(2);
remoteControl.pressOnButton(3);
System.out.println("------码农睡觉了，使用遥控关闭电灯、音响、电视。不关空调--------");
remoteControl.pressOffButton(0);
remoteControl.pressOffButton(1);
remoteControl.pressOffButton(3);
System.out.println("----撤销测试，先打开电灯。再关闭电灯。然后按撤销----");
remoteControl.pressOnButton(0);
remoteControl.pressOffButton(0);
//一键撤销
remoteControl.pressUndoButton();
}
}
Résultats des tests
-------码农回家了，使用遥控开启电灯、音响、空调、电视----
打开电灯。
打开音响
放入CD
音响音量设置为20
打开空调
空调温度设置28°
打开电视
设置频道为宇宙电视台
电视音量设置为20
------码农睡觉了，使用遥控关闭电灯、音响、电视。不关空调--------
关灯。
关闭音响
关闭电视
----撤销测试，先打开电灯。再关闭电灯。然后按撤销----
打开电灯。
关灯。
打开电灯。
résumé
Les scénarios d'utilisation:
- file d'attente de travail: une fin de l'instruction d'addition, le but est atteint, tant que le mode de commande peut être mis dans la file d'attente. L'autre extrémité est le fil. Fil se déroule le travail suivant: une commande de la file d'attente, puis exécuter méthode est appelée, l'appel est mis au rebut après la commande, puis continuer à supprimer une commande.
- pool de threads.
Pas plus d'attention publique mode JavaStorm
