Introduction simple et en douceur
Bonjour,
Voilà je voudrais juste donner un coup de pouce à ceux qui ne connaîtraient pas ou peu ce pattern, et ceci sans prétention, et qui cherchent à (mieux le) comprendre.
(Nota: Je ne parlerai pas ici de la méthode annuler() que pourrait comporter l'interface ICommand, et pas non plus des macro-commandes ).
Expliqué à ma façon, ça donne donc:
La Commande peut-être vue comme un ORDRE ("fait telle chose...") destiné à un Objet appelé le récepteur.
La Commande est en fait un objet qui encapsule complètement l'ORDRE, à savoir: recepteur.faitTelleChose();
(dans mon exemple l'Ordre est au final: lePortail.open() ).
Une commande est un objet qui possèdera une méthode executer(),
et c'est l'invocation de cette dernière qui lancera l'ORDRE:
this.recepteur.faitTelleChose(). (Avec this: l'objet Commande).
Enfin, il y a l'invocateur: c'est tout bêtement celui qui effectuera l'appel commandeConcrete.executer(); voilà!
L'invocateur est un objet qui encapsule un objet Commande.
L'invocateur ne connaît absolument pas l'ORDRE(recepteur.faitTelleChose()) qu'il lance, et encore moins son Destinataire(récepteur)!
C'est l'un des intérêts du pattern Commande.
Petit bout de code JAVA en guise d'exemple minimaliste:
-------------------------------------------------------
interface ICommand { void executer(); }
//L'objet Commande encapsule l'ORDRE.
class commande_Ouvrir_Portail implements ICommand
{
private IPortail lePortail; //récepteur de l'Ordre
commandOuvrir_Portail(IPortail lePortail) //Constructeur
{ this.lePortail=lePortail; } //Initialise le membre récepteur de l'Ordre.
//--- Implémentation de ICommand:
//Execution de la commande: l'appel à cette méthode-ci fera
//que le récepteur (this.lePortail) se verra ordonner une certaine tâche:
//ici open() .
void executer() { this.lePortail.open(); } //Lance l'ORDRE encapsulé.
}
//--------------------
//Le récepteur peut-être n'importe quel objet on s'en fiche.
//Il faut juste qu'il implémente une interface pour l'objet Commande.
interface IPortail { void open(); } //RECEPTEUR, DESTINATAIRE DE L'ORDRE
//Récepteur concret
class portail_de_droite implements IPortail
{void open() {System.out.println("Je suis le portail de droite et je m'ouvre"); }
//---------------------
//L'INVOCATEUR: celui qui fait this.objetCommande.executer() .
//L'invocateur est comme une télécommande programmable.
class invocateur
{
private ICommand commande;
invocateur( ICommand commande ) //Constructeur
{ this.commande=commande; }
//L'appel de cette méthode va appeler la méthode executer() de l'objet
//commande encapsulé: this.commande.
void clicSurBoutonX()
{ this.commande.executer(); }
}
//----- LE CODE CLIENT: -----------------------------
/*Ne sait pas quelle méthode du IPortail va être appelée
lorsque la méthode executer() de la ICommand sera invoquée par l'invocateur.L'invocateur ne sait même pas le contenu de l'opération, l'ordre dont il //demande l'exécution par son telecommande.clicSurBoutonX().
*/
IPortail monPortail =new portail_de_droite(); //Le futur récepteur
ICommand monORDRE=new commande_Ouvrir_Portail( monPortail );
//Association du lancement de l'ORDRE avec le BoutonX de la télécommande.
Invocateur telecommande=new invocateur( monORDRE );
//L'invocateur lance l'ORDRE que son objet commande encapsule.
telecommande.clicSurBoutonX();
//Résultat: affichera "Je suis le portail de droite et je m'ouvre" .
//------------------
Remarque: un invocateur peut très bien encapsuler plusieurs objets commandes.
Voilà,
j'espère que l'exemple que je donne sera clair et compréhensible par un max. de personnes.
;)
