Discussion :

[anitshka]

Bonjour,

J'ai une problématique qui me demande de me pencher sur le pattern visitor... En effet, j'ai des objets Effet qui peuvent etre de plusieurs types plus fins (via l'héritage): Read et Update.

Ces effets n'on que tres peu en commun et je souhaite développer un objet générique me permettant de généraliser ces effets.
Pour cela j'ai développé une classe Generalise qui a 2 méthodes statiques

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

GenericEffect general(Read r){...}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

GenericEffect  general(Update u){...}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

GenericEffect  general(Effect e){...}

or quand je déroule ma liste d'effets, il n'arrive pas a caster selon mon type (en d'autre terme, il passe toujours par la méthode sur les effets).

Un solution pas propre est de caster via des instanceof dans ma méthodes effets... mais ca ne me plait pas...

Donc si vous pensez comme moi que la solution vient du pattern visitable, pouvez vous me passer une implémentation bateau pour que je puisse en comprendre les rouages
d'avance!

[JHelp]

Juste une question,
tu envoies quoi qui marche pas ?
Est-ce que tuas as des choses du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
Effet effetRead = new Read(...);
GenericEffect.general(effetRead);

Ou alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
Read read = new Read(...);
GenericEffect.general(read);

...
?

[anitshka]

j'itère sur une liste qui stock des effets...
et sur l'objet casté en Effect e récupéré de cette liste je fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

GenericEffect.general(e);

apres j'ai pas compris ta question

[nicgando]

Dans le visitor, le cast de l'Interface vers l'objet se fait par le biais du polymorphisme (cast descendant) Visitable.accept(Visitor)
Et le cast ascendant se fait par le jeux des surcharges de méthode (cast ascendant en quelques sortes)

Ici dans le main, le polymorphisme va choisir la méthode accept (ici de Car) et la surcharge de méthodes va choisir la méthode de PrintVisitor (ici
public void visit(Car car) { System.out.println("Visiting car"); } )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
interface Visitor {
    void visit(Wheel wheel);
    void visit(Engine engine);
    void visit(Body body);
    void visit(Car car);
}
 
interface Visitable {
    void accept(Visitor visitor);
}
 
class Wheel implements Visitable {
    private String name;
    Wheel(String name) {
        this.name = name;
    }
    String getName() {
        return this.name;
    }
    void accept(Visitor visitor) {
        visitor.visit(this);
    }
}
 
class Engine implements Visitable{
    void accept(Visitor visitor) {
        visitor.visit(this);
    }
}
 
class Body implements Visitable{
    void accept(Visitor visitor) {
        visitor.visit(this);
    }
}
 
class Car implements Visitable {
    private Engine  engine = new Engine();
    private Body    body   = new Body();
    private Wheel[] wheels 
        = { new Wheel("front left"), new Wheel("front right"),
            new Wheel("back left") , new Wheel("back right")  };
    void accept(Visitor visitor) {
        visitor.visit(this);
        engine.accept( visitor );
        body.accept( visitor );
        for(int i=0; i<wheels.length; ++i)
            wheels[i].accept( visitor );
    }
}
 
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("Visiting car");
    }
}
 
public class VisitorDemo {
    static public void main(String[] args){
        Visitable car = new Car();
        Visitor visitor = new PrintVisitor();
        car.accept(visitor);
    }
}

[anitshka]

c'est exactement ce dont j'avais besoin

[edit]un bon petit lien sur les pattern a garder bien au chaud ici [/edit]