instanceof ou mauvais polymorphisme ?

Version imprimable

Voir 40 message(s) de cette discussion en une page

26/10/2007, 10h31
guams

Mais je n'ai jamais dit qu'il fallait appliqué le pattern visitor pour cet exemple...;)

Ceci dit, je pense qu'il ne faudrait passer qu'un argument à la methode visit du Visitor, l'autre argument pourrait etre passer dans le constructeur du visitor.
02/11/2007, 09h47
Morgoth_fr

Bonjour,

Sujet très intéressant. Je sais pas si vous avez lu ces liens :

http://accu.org/index.php/journals/496
http://multijava.sourceforge.net/

Bon courage !

En tout cas, c'est certain que le pattern visitor ne peut rien faire dans votre cas.

une autre idée

Une methode qui utilise la reflexion.

Attention je sens qu'il y en a qui vont pas aimer.
Moi non plus je ne suis pas trop satisfait il faut dire... Noament du au probleme d'heritage avec la method getMethod...

Code:

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
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
 
public abstract class Solid {
 
 
 
 
	public boolean collision(Solid solid) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		Method method = null ;
 
		try {
			method = PEngine.class.getMethod("computeCollision", new Class[]{this.getClass(),solid.getClass()});
			return ((Boolean)method.invoke(null, new Object[]{this,solid} )).booleanValue();
		} catch (NoSuchMethodException e) {
			method = PEngine.class.getMethod("computeCollision", new Class[]{solid.getClass(),this.getClass()});
			return ((Boolean)method.invoke(null, new Object[]{solid,this} )).booleanValue();
		}
 
	}
 
 
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public class PEngine {
 
 
	  public static boolean computeCollision(SolidCircle circle1, SolidCircle circle2)
	  {
	    System.out.println("Collision Circle " + circle1 + " with Circle " + circle2);
	    return true;
	  }
 
	  public static boolean computeCollision(SolidCircle circle, SolidRectangle rect)
	  {
	    System.out.println("Collision Circle " + circle + " with Rectangle " + rect);
	    return true;
	  }
 
	  public static boolean computeCollision(SolidRectangle rect1, SolidRectangle rect2)
	  {
	    System.out.println("Collision Rectangle " + rect1 + " with Rectangle " + rect2);
	    return true;
	  }
 
}

Citation:
Envoyé par guams
Merci pour le lien, c'est tres instructif et j'en ai profité pour lire le lien sur le double dispatch dont je me suis inspiré pour adapter ton code en utilisant une interface:
Code:

1 2 3 4 5 6 7 8 9 interface Collidable { boolean collideWith(Collidable aSolid); boolean collideWithSolidCircle(SolidCircle aSolid); boolean collideWithSolidRectangle(SolidRectangle aSolidRectangle); }
J'ai pas suivi toute la discussion, mais je me dis que saupoudrer un peu de generics pourrait simplifier la chose.

Par exemple on pourrait transformer ton interface en :
Code:

1 2 3 4 5 interface Collidable<S extends Solid> { boolean collideWith(Collidable aSolid); boolean collideWith(S aSolid); }
Puis, il te suffirait par exemple pour ta classe SolidCircle de faire un truc du genre :
Code:

1 2 class SolidCircle extends Solid implements Collidable<SolidCircle>,Collidable<SolidRectangle> { ...
Ça éviterait comme disait bulbo de devoir modifier ton interface si tu ajoutais une classe dérivée de Solid.

Bon, je dis ça, mais j'ai vraiment pas tout suivi :mrgreen:

08/11/2007, 16h48
lafeuil
Citation:
Envoyé par bobuse

J'ai pas suivi toute la discussion, mais je me dis que saupoudrer un peu de generics pourrait simplifier la chose.

Par exemple on pourrait transformer ton interface en :

Code:

1 2 3 4 5 interface Collidable<S extends Solid> { boolean collideWith(Collidable aSolid); boolean collideWith(S aSolid); }

Puis, il te suffirait par exemple pour ta classe SolidCircle de faire un truc du genre :

Code:

1 2 class SolidCircle extends Solid implements Collidable<SolidCircle>,Collidable<SolidRectangle> { ...

Ça éviterait comme disait bulbo de devoir modifier ton interface si tu ajoutais une classe dérivée de Solid.

Bon, je dis ça, mais j'ai vraiment pas tout suivi :mrgreen:
Bonjour
J'ai essayé ta solution que je trouvais assez surprenante mais celle ci ne compile pas. Avec Eclipse, voici le message que j'ai :

Code:

The interface Collidable cannot be implemented more than once with different arguments: Collidable<SolidCircle> and Collidable<SolidRectangle>

Est ce normal ? Ai je loupé un truc ?
Thomas
12/11/2007, 16h18
bobuse

Ha, ba peut-être que c'est pas possible. Zut :mrgreen:

Voir 40 message(s) de cette discussion en une page