Modèle de visiteur générique dans Java

Question

L'implémentation java suivante du modèle de visiteur utilisant des génériques est-elle assez générale pour être utile? (Je suppose que c'est).

Pourrait-il être amélioré d'une manière ou d'une autre? Il est important d'être facilement appelable en utilisant des classes anonymes. Merci.

(Exemple d'utilisation):

Vector<Number> numbers = new Vector<Number>(); 

     numbers.add(new Double(1.2)); 
     numbers.add(new Float(-1.2)); 
     numbers.add(new Double(4.8)); 
     numbers.add(new Float(-3.4)); 
     numbers.add(new Long(123456)); 
     numbers.add(new Short("14")); 

     For.each(numbers, new Visitor<Number>() { 
      public void doIt(Double n) { 
       System.out.println("doIt() for double: " + n); 
      } 
      public void doIt(Float n) { 
       System.out.println("doIt() for float: " + n); 
      } 
      public void doIt(Number n) { 
       System.out.println("doIt() for Number: " + n); 
      } 
     }); 

     Visitor<Number> visi = new Visitor<Number>() { 
      private StringBuffer all = new StringBuffer(); 
      public void doIt(Number n) { 
       System.out.println("doIt() for Number: " + n); 
       all.append(n.toString() + " "); 
      } 
      public Object getResult() { 
       return all; 
      } 
     }; 

     For.each(numbers, visi); 

     System.out.println ("all -> " + visi.getResult()); 

Définitions:

//............................................ 
abstract class Visitor<T> { 
    public void visit(T n) { 
     try { 
      this.getClass().getDeclaredMethod("doIt", n.getClass()).invoke(this, n); 
     } catch (Exception ex) { 
      doIt((T) n); 
     } 
    } 
    public void doIt(T n) { 
     System.out.println("doIt() for base " + n); 
    } 
    public Object getResult() { 
     return null; 
    } 
} // class 

//............................................ 
class For { 
    public static <T> void each (Collection<T> c, Visitor<T> f) { 
     for (T v : c) { 
      f.visit(v); 
     } 
    } //() 
} // class 

Answer 1

Merci à la réponse de donroby au sujet de mon code initial ne pas mettre en œuvre le modèle de visiteur je suis venu à cette nouvelle version. Je suppose qu'il implémente désormais le modèle de visiteur sans avoir besoin de modifier l'élément visité avec une méthode accept(). Quoi qu'il en soit, il est capable d'appeler la bonne méthode en fonction du type d'élément (je suppose que c'est la mission de l'accept()), grâce à la réflexion.

D'abord, un exemple d'utilisation:

Vector<Number> numbers = new Vector<Number>(); 

    numbers.add(new Double(1.2)); 
    numbers.add(new Float(-1.2)); 
    numbers.add(new Double(4.8)); 
    numbers.add(new Float(-3.4)); 
    numbers.add(new Long(123456)); 
    numbers.add(new Short("14")); 

    For.each(numbers, new Visitor<Number>() { 
     public void doIt(Double n) { 
      System.out.println("doIt() for double: " + n); 
     } 
     public void doIt(Float n) { 
      System.out.println("doIt() for float: " + n); 
     } 
     public void doIt(Number n) { 
      System.out.println("doIt() for Number: " + n); 
     } 
    }); 

qui produit cette sortie

 
doIt() for double: 1.2 
doIt() for float: -1.2 
doIt() for double: 4.8 
doIt() for float: -3.4 
doIt() for Number: 123456 
doIt() for Number: 14 

Et enfin le code

abstract class Visitor<T> { 
public void visit(T n) { 
    try { 
     this.getClass().getDeclaredMethod("doIt", n.getClass()).invoke(this, n); 
    } catch (Exception ex) { 
     doIt((T) n); 
    } 
} 
public void doIt(T n) { 
    System.out.println("doIt() for base " + n); 
} 
public Object getResult() { 
    return null; 
} 

}

class For { 
public static <T> void each (Collection<T> c, Visitor<T> f) { 
    for (T v : c) { 
     f.visit(v); 
    } 
} //() 

}

Answer 2

Ce n'est pas Visitor Pattern. Le visiteur est caractérisé par une méthode accept(Visitor v) qui interagit avec une méthode de visite chez le visiteur en prenant comme paramètre le visiteur et surchargé pour le type variable du visiteur, formant un mécanisme de «double expédition».

Je cite la section « Application » pour des visiteurs à Design Patterns:

Utilisez le modèle des visiteurs lorsque

• une structure d'objet contient de nombreuses classes d'objets avec différentes interfaces et que vous souhaitez effectuer opérations sur ces objets que dépendent de leurs classes concrètes.
• de nombreuses opérations distinctes et indépendantes doivent être effectuées sur objets dans une structure d'objet, et vous voulez éviter « polluer » leurs cours de ces opérations. Visitor permet de conserver les opérations associées en les définissant dans une classe. Lorsque la structure de l'objet est partagée par de nombreuses applications de , utilisez Visitor pour mettre les opérations dans les applications suivantes: qui en ont besoin. Les classes définissant la structure de l'objet changent rarement, mais vous voulez souvent définir de nouvelles opérations sur la structure . La modification des classes de structure d'objet nécessite redéfinissant l'interface pour tous les visiteurs , ce qui est potentiellement coûteux. Si les classes de la structure d'objet changent souvent, il est probablement préférable de définir les opérations dans ces classes.

Donc ce modèle est pour traiter opertaions similaires sur des objets de plusieurs types. Dans vos exemples, les objets que vous appelez les visiteurs ne peuvent traiter que d'un seul type. Dans votre réponse réviser pour utiliser la réflexion pour gérer plusieurs types (qui d'ailleurs serait mieux fait comme un edit à la question ou comme une question séparée), vous évitez de créer une méthode accept(Visitor v) dans les classes visitées par en utilisant la réflexion, qui est dans une certaine mesure en accomplissant le même but, mais quelque peu maladroitement. Je résisterais toujours à l'appeler une implémentation de Visitor.

Si le code dans le style que vous avez écrit ici est utile pour vous, utilisez-le, mais ne l'appelez pas Visiteur. Cela ressemble plus à un Strategy Pattern ou un Function Object, et si vous renommez la classe générique d'une manière qui reflète cela, c'est en fait utile, et votre utilisation est similaire aux modèles courants de gestion de liste dans les langages fonctionnels.

Ce que je probablement faire avec le code de la question est Renommez votre Visitor<T>-Operation<T> et Renommez votre visit(T t)-execute(T t) ou apply(T t), la pensée d'un Operation comme Function sans valeur de retour. En fait, j'ai utilisé exactement ceci d'une manière similaire à ce que vous faites, et j'ai utilisé des tactiques similaires pour la «cartographie» de collection en utilisant des objets Function<Domain, Range> génériques. Je ne suis pas sûr du nom du motif, mais ce n'est pas Visitor. Il apporte un style de compréhension de liste fonctionnelle à un monde OO où les fonctions ne sont pas naturellement des objets de première classe.

Answer 3

comment sur

for(String s : words) 
     System.out.println (s.toUpperCase()); 

    int total = 0; 
    for(String s : words) 
     total = total + s.length(); 
    System.out.println (" sum of lengths = " + total);