# Visito/Besucher Design-Pattern/Strukturmuster



## MatheStein (5. Mai 2012)

Hey Leute,

versuche gerade den Sinn hinter dem Visito/Besucher Design-Pattern/Strukturmuster zu verstehen.
Betrachtet man Beispielsweise den zugehörigen Wiki-Artiklen, dann kann ich die Unklarheit zunächst am besten an dem angegebenen Beispiel erläutern:

Visitor ? Wikipedia


Ich finde Beispielsweise bei dem "PrintVisitor"


```
class PrintVisitor implements Visitor {
 
    public void visit(Wheel wheel) {      
        System.out.println("Visiting "+ wheel.getName()
                            + " wheel");
    }
    public void visit(Engine engine) {
        System.out.println("Visiting engine");
    }
    public void visit(Body body) {
        System.out.println("Visiting body");
    }
 
    public void visit(Car car) {
        System.out.println("\nVisiting car");
        for(CarElement element : car.getElements()) {
            element.accept(this);
        }
        System.out.println("Visited car");
    }
 
}
```


die Schleife unnötig umständlich. Warum macht man das Ganze nicht einfach so:


```
class PrintVisitor implements Visitor {
 
    public void visit(Wheel wheel) {      
        System.out.println("Visiting "+ wheel.getName()
                            + " wheel");
    }
    public void visit(Engine engine) {
        System.out.println("Visiting engine");
    }
    public void visit(Body body) {
        System.out.println("Visiting body");
    }
 
    public void visit(Car car) {
        System.out.println("\nVisiting car");
        for(CarElement element : car.getElements()) {
            this.visit(element); // HIER IST DIE ÄNDERUNG !!!
        }
        System.out.println("Visited car");
    }
 
}
```


D.h. warum geht man als Besucher jedes Element durch (per for-Schleife) und sagt diesem (per " element.accept(this);"), dass er einen besuchen soll, was das Element anschließend macht (per "visitor.visit(this);").
Man kann doch viel besser als Besucher jedes Element durchgehen und dieses direkt besuchen, so wie ich es in meinem Ansatz versucht habe (ohne das man unnötige Umwege geht)


Das heißt das Verständnisproblem ist dass ich nicht verstehe, warum man den Elementen sagt sie sollen dem Besucher sagen, dass er sie besuchen soll und man nicht direkt dem Besucher reihenweise die Elemente gibt, die er besuch soll.

Viele Grüße und schönes Wochenende an alle


----------



## Marco13 (5. Mai 2012)

Hast du mal versucht, die geänderte Variante zu compilieren?


----------



## xehpuk (5. Mai 2012)

Hey,

eigentlich wird schon ersichtlich, dass das nicht geht, wenn du es so probierst.
Du hast keine Methode 
	
	
	
	





```
Visitor#visit(CarElement)
```
, weswegen es einen Compiler-Fehler gibt. Der Umweg über 
	
	
	
	





```
CarElement#accept(Visitor)
```
 ist gerade deswegen nötig – um bestimmen zu können, welche 
	
	
	
	





```
visit()
```
-Methode aufgerufen werden soll.
Würdest du die Methode 
	
	
	
	





```
Visitor#visit(CarElement)
```
 erstellen, würde immer diese aufgerufen werden, weil in dem Fall schon zur Kompilier-Zeit bestimmt wird, welche Methode aufgerufen wird. Die Referenzvariable in der Schleife hat den Typ 
	
	
	
	





```
CarElement
```
 (und mehr ist nicht bekannt). Also passt auch nur diese eine Methode dazu.


----------



## maki (5. Mai 2012)

> Das heißt das Verständnisproblem ist dass ich nicht verstehe, warum man den Elementen sagt sie sollen dem Besucher sagen, dass er sie besuchen soll und man nicht direkt dem Besucher reihenweise die Elemente gibt, die er besuch soll.


Das ist ein "expliziter" Double Dispatch, muss man in Java Falle leider explizit machen, da Java nur Single Dispatch direkt unterstützt.
Steht ja auch so im WikiPedia Artikel:


> Man beachte, dass die accept-Methode tatsächlich in jeder Element-Klasse implementiert werden muss, damit der Compiler die richtige überladene visit-Methode auswählen kann.


----------



## MatheStein (5. Mai 2012)

Peinlich Peinlich 

Danke Jungs, jetzt ist alles klar


Vielen Dank und weiterhin schönes Wochenende an alle


----------

