Visiteur (patron de conception)

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
Page d'aide sur l'homonymie Pour les articles homonymes, voir Visiteur.

En programmation orientée objet et en génie logiciel, le patron de conception comportemental visiteur est une manière de séparer un algorithme d'une structure de données.

Principe[modifier | modifier le code]

Visitorpattern.png

Ce modèle de conception permet à une classe externe d'accéder aux variables internes d'autres classes (allant à l'encontre des concepts de la POO). Ce modèle est utile lorsqu'on a un nombre raisonnable d'instances d'un petit nombre de classes et qu'on désire effectuer des opérations qui les impliquent toutes (ou un bon nombre d'entre elles).

Si déporter des opérations contenues dans une classe vers une autre peut sembler mauvais au sens POO, il y a de bonnes raisons pour le faire. En effet, si ces opérations sont identiques pour chaque classe au lieu de dupliquer cette méthode il est préférable de mettre ces opérations dans un visiteur (centralisation de l'opération). Le visiteur utilisera ensuite les données internes de chaque objet pour effectuer l'opération demandée.

En pratique, le modèle de conception visiteur est réalisé de la façon suivante : chaque classe pouvant être « visitée » doit mettre à disposition une méthode publique « accepter » prenant comme argument un objet du type « visiteur ». La méthode « accepter » appellera la méthode « visite » de l'objet du type « visiteur » avec pour argument l'objet visité. De cette manière, un objet visiteur pourra connaître la référence de l'objet visité et appeler ses méthodes publiques pour obtenir les données nécessaires au traitement à effectuer (calcul, génération de rapport, etc.).

Exemples[modifier | modifier le code]

Prenons une classe ObjetPere, de laquelle hériteront Objet1, Objet2 et Objet3, elles posséderont la méthode accept(Visitor v).

En C++[modifier | modifier le code]

 void ObjetDeType1::accept( Visitor * v ) {
   v->visitObjetDeType1( this ) ;
 }

Créons la classe Visitor, dont hériteront Visiteur1 et Visiteur2. Dans chacun de ces objets, on retrouvera une méthode visiterObjet1(Objet1 a), visiterObjet2(Objet2 b) et visiterObjet3(Objet3 c).

  void MonVisiteur::visitObjetDeType1( ObjetDeType1 * objet ) {
    // Traitement d'un objet de type 1
  }
 
  void MonVisiteur::visitObjetDeType2( ObjetDeType2 * objet ) {
    // Traitement d'un objet de type 2
  }
 
  void MonVisiteur::visitObjetDeType3( ObjetDeType3 * objet ) {
    // Traitement d'un objet de type 3
  }

En Java[modifier | modifier le code]

Aucune importation n'est nécessaire, il suffit de créer une interface (ou classe) visiteuse, et une pour l'objet père l'acceptant :

interface Visitor {
   void visit(ObjetPere objet);
}


interface ObjetPere {
   void accept(Visitor v);
}


public class Objet1 implements ObjetPere {	
    public void accept(Visitor v) {
        v.visit(this);
    }
}


public class Objet2 implements ObjetPere {	
    public void accept(Visitor v) {
        v.visit(this);
    }
}


public class Objet3 implements ObjetPere {	
    public void accept(Visitor v) {
        v.visit(this);
    }
}

Lien externe[modifier | modifier le code]

Sur les autres projets Wikimedia :