Mode de commande du modèle de conception
1. Mode de commande
1.1 Définition et caractéristiques
Le mode de commande est défini comme suit: une demande est encapsulée en tant qu'objet et la responsabilité de l'émission de la demande est séparée de la responsabilité de l'exécution de la demande. De cette manière, les deux communiquent entre eux via l'objet de commande, ce qui est pratique pour stocker, transférer, appeler, ajouter et gérer l'objet de commande.
Les principaux avantages du mode commande sont les suivants:
- Réduisez le couplage du système.
- Le mode de commande peut dissocier l'objet qui appelle l'opération de l'objet qui implémente l'opération.
- Il est très pratique d'ajouter ou de supprimer des commandes.
- L'ajout et la suppression de commandes en mode commande n'affecteront pas les autres classes. Il répond au "principe d'ouverture et de fermeture" et est plus flexible pour l'expansion.
- Des macro-commandes peuvent être implémentées.
- Le mode de commande peut être combiné avec le mode combiné pour assembler plusieurs commandes en une commande combinée, qui est une macro-commande.
- Facile à implémenter les opérations d'annulation et de rétablissement.
- Le mode commande peut être combiné avec le mode mémo introduit plus tard pour réaliser l'annulation et la restauration des commandes.
Les inconvénients du mode commande sont:
- Un grand nombre de classes de commandes spécifiques peuvent être générées.
- Parce qu'il est nécessaire de concevoir une classe de commande spécifique pour chaque opération spécifique, cela augmentera la complexité du système.
1.2 Structure du modèle
Le mode de commande comprend les rôles principaux suivants:
- Rôle de classe de commande abstraite (Command): déclare l'interface pour exécuter les commandes et a la méthode abstraite execute () pour exécuter les commandes.
- Le rôle de commande concrète (Concrete
Command): est une classe d'implémentation concrète de la classe de commande abstraite, qui possède l'objet récepteur, et termine l'opération à effectuer par la commande en appelant la fonction récepteur. - Le rôle de l'implémenteur / récepteur (récepteur): pour effectuer les opérations pertinentes de la fonction de commande, est le véritable implémenteur de l'entreprise d'objet de commande spécifique.
- Rôle Invocateur / demandeur (Invocateur): est l'expéditeur de la demande, il a généralement beaucoup d'objets de commande, et accède à l'objet de commande pour effectuer des demandes connexes, il n'accède pas directement au récepteur.
1.3 Origine du problème
Dans les systèmes de développement logiciel, il existe souvent une relation de couplage étroit entre les «demandeurs de méthode» et les «implémenteurs de méthode». Cela n'est pas propice à l'expansion et à la maintenance des fonctions logicielles. Par exemple, il n'est pas pratique de vouloir effectuer des actions "annuler, refaire, enregistrer" et d'autres actions sur le comportement, alors "comment découpler le demandeur de méthode de son implémenteur?" Devient très important et le modèle de commande peut être bien résolu Cette question. Dans la vie réelle, il existe de nombreux exemples de ce type. Par exemple, l'
exemple de code d'une télécommande de TV (demandeur de méthode) TV (récepteur de commande) est le suivant:
/**
* @author tbb
* 家用电器类
*/
public abstract class HouseholdElectricalAppliances
{
abstract String kind();
abstract void open();
abstract void close();
}
/**
* @author tbb
* 空调
*/
public class AirConditioning extends HouseholdElectricalAppliances {
@Override
public void open()
{
System.out.println("打开" + kind());
}
@Override
public void close()
{
System.out.println("关闭" + kind());
}
@Override
String kind() {
return "空调";
}
}
/**
* @author tbb
* 电视类
*/
public class Tv extends HouseholdElectricalAppliances
{
@Override
public void open()
{
System.out.println("打开" + kind());
}
@Override
public void close()
{
System.out.println("关闭" + kind());
}
@Override
String kind() {
return "电视";
}
}
/**
* @author tbb
* 控制器
*/
public class Control
{
public void open(HouseholdElectricalAppliances hea)
{
hea.open();
}
public void close(HouseholdElectricalAppliances hea)
{
hea.close();
}
}
public class Test
{
public static void main(String[] args)
{
Tv tv = new Tv();
Control control = new Control();
AirConditioning airConditioning = new AirConditioning();
control.open(tv);
control.close(tv);
control.open(airConditioning);
control.close(airConditioning);
/*
打开电视
关闭电视
打开空调
关闭空调
*/
}
}
1.4 Solutions
La solution consiste à utiliser le modèle de commande. La première étape consiste à dissocier le "demandeur de méthode" du "réalisateur de méthode", comme la télécommande TV (demandeur de méthode) et la télécommande TV (implémenteur de méthode). Le découplage, est divisé en télécommande du téléviseur (émetteur de commande) pour contrôler le téléviseur (récepteur de commande) via des boutons (commandes spécifiques).
1.5 Types UML
1.6 Solution
/**
* @author tbb
* 命令
*/
public interface Command
{
void execute();
}
/**
* @author tbb
* 打开命令
*/
public class OpenCommand implements Command
{
private HouseholdElectricalAppliances hev;
@Override
public void execute()
{
this.hev.open();
}
public OpenCommand(HouseholdElectricalAppliances hev) {
super();
this.hev = hev;
}
}
/**
* @author tbb
* 关闭命令
*/
public class CloseCommand implements Command
{
private HouseholdElectricalAppliances hev;
@Override
public void execute()
{
hev.close();
}
public CloseCommand(HouseholdElectricalAppliances hev) {
super();
this.hev = hev;
}
}
/**
* @author tbb
* 控制器
*/
public abstract class Control
{
abstract void open();
abstract void close();
}
/**
* @author tbb
* 家电类控制器
*/
public class HouseholdElectricalControl extends Control{
private Command openCommand;
private Command closeCommand;
public HouseholdElectricalControl(OpenCommand openCommand,CloseCommand closeCommand) {
super();
this.openCommand = openCommand;
this.closeCommand = closeCommand;
}
@Override
void open()
{
this.openCommand.execute();
}
@Override
void close()
{
this.closeCommand.execute();
}
}
/**
* @author tbb
* 家用电器类
*/
public abstract class HouseholdElectricalAppliances
{
abstract String kind();
abstract void open();
abstract void close();
}
/**
* @author tbb
* 空调
*/
public class AirConditioning extends HouseholdElectricalAppliances {
@Override
public void open()
{
System.out.println("打开" + kind());
}
@Override
public void close()
{
System.out.println("关闭" + kind());
}
@Override
String kind() {
return "空调";
}
}
/**
* @author tbb
* 电视类
*/
public class Tv extends HouseholdElectricalAppliances
{
@Override
public void open()
{
System.out.println("打开" + kind());
}
@Override
public void close()
{
System.out.println("关闭" + kind());
}
@Override
String kind() {
return "电视";
}
}
public class Test
{
public static void main(String[] args)
{
Tv tv = new Tv();
OpenCommand openCommand = new OpenCommand(tv);
CloseCommand closeCommand = new CloseCommand(tv);
HouseholdElectricalControl control = new HouseholdElectricalControl(openCommand, closeCommand);
control.open();
control.close();
AirConditioning airConditioning = new AirConditioning();
openCommand = new OpenCommand(airConditioning);
closeCommand = new CloseCommand(airConditioning);
control = new HouseholdElectricalControl(openCommand, closeCommand);
control.open();
control.close();
/*
打开电视
关闭电视
打开空调
关闭空调
*/
}
}
