Différences entre les versions de « Patrons de conception/Double-dispatch »

+
(+)
(+)
Ce patron de conception est lié à la notion de surcharge de méthode, et au polymorphisme. Il utilise le patron de conception [[../Visiteur/]].
 
== Introduction : notion de dispatch ==
 
Une classe peut définir une méthode qui peut être redéfinie dans une sous-classe (en C++ il s'agit de méthodes virtuelles, en Java toutes les méthodes sont virtuelles).
<source lang="java">
// Une classe Object comportant un attribut : le nom de l'objet
static class Object
{
protected String name;
Affiche :
A simple display for object (a simple book) and object (a simple card)
L'exemple précédent démontre que le langage Java ne permet pas nativement le '''multiple-dispatch'''. Dans le cas contraire, la méthode <source enclose="none" lang="java">SimpleDisplay.display(SimpleObject, SimpleObject)</source> aurait été appelée et l'affichage aurait été le suivant :
A simple display for simple object (a simple book) and simple object (a simple card)
 
== Double-dispatch ==
Le '''double-dispatch''' est un patron de conception utilisant le patron [[../Visiteur/]] pour implémenter partiellement le multiple-dispatch, étendant le '''simple-dispatch''' en utilisant le type dynamique de l'un des arguments.
 
Le principe est d'ajouter une méthode dans les classes des arguments, appelée grâce au polymorphisme (le '''simple-dispatch'''). Cette méthode appelant la méthode originale, avec le pointeur this en argument dont le type réel est connu à la compilation.
 
Exemple en Java :
<source lang="java">
// Une classe Object comportant un attribut : le nom de l'objet
class Object
{
protected String name;
public Object(String name)
{ this.name = name; }
public String toString()
{ return "a "+name; }
// méthode ajoutée pour implémentation du double-dispatch:
public void display(Display d)
{ d.display(this); } // this de type Object
}
 
// Une classe SimpleObject précisant que l'objet est simple
class SimpleObject extends Object
{
public SimpleObject(String name)
{ super(name); }
public String toString()
{ return "a simple "+name; }
// méthode ajoutée pour implémentation du double-dispatch:
public void display(Display d)
{ d.display(this); } // this de type SimpleObject
}
 
// Une classe Display pour afficher Object et SimpleObject
class Display
{
public void display(Object o1)
{ System.out.println("A display for object ("+o1+")"); }
public void display(SimpleObject o1)
{ System.out.println("A display for simple object ("+o1+")"); }
}
 
// Une classe SimpleDisplay pour afficher simplement Object et SimpleObject
class SimpleDisplay extends Display
{
public void display(Object o1)
{ System.out.println("A simple display for object ("+o1+")"); }
public void display(SimpleObject o1)
{ System.out.println("A simple display for simple object ("+o1+")"); }
}
 
// Le test :
Object book = new SimpleObject("book");
Display disp = new SimpleDisplay();
book.display(disp); // SimpleObject.display(Display) -> SimpleDisplay.display(SimpleObject)
</source>
Affiche :
A simple display for simple object (a simple book)
 
== Voir aussi ==