Discussion :

[Djakisback]

Salut, j'ai un problème de base mais je ne comprends pas très bien le mécanisme à adopter, si quelqu'un pouvait me guider. J'ai par exemple, 3 classes :

Code :

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

1
2
3
4
5
6
7
8
 
public class SolidCircle extends Solid {
	public boolean collideWith(SolidCircle circle) {...}
}
 
public class SolidRectangle extends Solid {
	public boolean collideWith(SolidRectangle circle) {...}
}

Comment on fait pour récupérer et appeler la fonction adéquate dans le cas suivant, j'ai donc un vecteur qui contient des SolidRectangle et des SolidCircle :

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
public Vector movableSolids; // D'ailleurs il me semblait que Vector était pas trop optimisé pourtant c'est la seule structure que propose le CLDC 1.1 du J2ME
 
static public void computeCollisions() {
		for (int i = 0, solidsSize = PEngine.movableSolids.size(); i < solidsSize; i++) {
			Solid solid1 = ((Solid) (PEngine.movableSolids.elementAt(i)));
			for (int j = i + 1, solidsSize2 = PEngine.movableSolids.size(); j < solidsSize2; j++) {
				Solid solid2 = ((Solid) (PEngine.movableSolids.elementAt(j)));
				if (solid1.collideWith(solid2)) {
					PEngine.computeCollisionResponse(solid1, solid2);
				}
			}
		}
	}
 
	static public void computeCollisionResponse(SolidCircle circle1, SolidCircle circle2) {..}
 
	static public void computeCollisionResponse(SolidRectangle rectangle1, SolidRectangle rectangle2) {...}

J'ai pensé définir une méthode abstraite collideWith(Solid s) dans Solid mais ensuite il faut que j'en implémente une aussi dans SolidRectange et dans SolidCircle, ce qui n'a aucune utilité. Ma question est donc, comment appeler les bonnes méthodes collideWith et computeCollisionResponse, en fonction des types réels des instances, j'imagine qu'il y a moyen de faire ca sans instanceof ?
Merci d'avance ^^

[willoi]

A mon avis cette ligne :

Code :

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

PEngine.computeCollisionResponse(solid1, solid2);

doit te donner une erreur de compilation.Car tu passe les parametres Solid, Solid a ta methode et celle ci n'existe pas.

Donc une solution peut etre d'utiliser instanceof puis un casting a la classe adequate.

Ou sinon implementer des methodes au niveau de tes classes SolidRectangle et SolidCircle.
Exemple :

Code :

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

solid1.computeCollisionResponse(solid2);

et creer une methode dans ta classe Solid :

Code :

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

computeCollisionResponse(Solid solid);

[freakfm]

à mon avis tu ajoute ces deux method dans tes class, et comme ça seulon le type des parametre java va savoire quel méthod utiliser.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public class SolidCircle extends Solid {
	public boolean collideWith(SolidCircle circle) {...}
        public boolean collideWith(SolidRectangle rectangle) {...}
}
 
public class SolidRectangle extends Solid {
	public boolean collideWith(SolidRectangle rectangle) {...}
        public boolean collideWith(SolidCircle circle) {...}
}

et aussi dans l'autre classe il faut ajouter les deux methodes:

Code :

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

1
2
3
 
static public void computeCollisionResponse(SolidCircle circle, SolidCircle rectangle) {..}
static public void computeCollisionResponse(SolidRectangle rectangle,  SolidCircle circle) {...}

ou à mon avis je dit de n'importe quoi. pour ce deusiéme probléme il faut peut etre faire comme ce qu' à dit "willoi"

en tous cas, tu doit développer deux methodes

Code :

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

computeCollisionResponse(Solid solid);

dans chaque class (circle et rectangle)

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public class SolidCircle extends Solid {
	computeCollisionResponse(SolidCircle circle){...}
        computeCollisionResponse(SolidRectangle rectangle){...}
}
 
public class SolidRectangle extends Solid {
	computeCollisionResponse(SolidCircle circle){...}
        computeCollisionResponse(SolidRectangle rectangle){...}
}

[deltree]

Bonjour,
je vois bien une solution simple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
public abstract class Solid {
	public final boolean collideWith(Solid solid) {
             if (solid instanceof SolidCircle) return collideWith((SolidCircle) solid);
             if (solid instanceof SolidRectangle) return collideWith((SolidRectangle) solid);
            return false;
        }
 
  protected abstract boolean collideWith(SolidCircle circle);
  protected abstract boolean collideWith(SolidRectangle rectangle);
}

parce que le polymorphisme ne s'applique pas sur la surcharge: il y aurais peut-être un moyen de faire du vrai polymorphisme en extrayant des méthodes dans des stratégies ou des Visitor, mais ça deviendrais over-compliqué.

[manblaizo]

Bonjour,
Moi je préférerais plutôt ceci :

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
 
public abstract class Solid {
    public abstract boolean collideWith(Solid solid);
}
 
public class SolidCircle extends Solid {
    public boolean collideWith(Solid solid) {
         if (! solid instanceof SolidCircle)
               return false;
 
        // sinon faire le traitement spécifique aux objets SolidCircle
       // et retourner "true" ou "false" selon le résultat du traitement
       SolidCircle circle = (SolidCircle)solid;
        ...
    }
}
 
public class SolidRectangle extends Solid {
    public boolean collideWith(Solid solid) {
         if (! solid instanceof SolidRectangle)
               return false;
 
        // sinon faire le traitement spécifique aux objets SolidRectangle
       // et retourner "true" ou "false" selon le résultat du traitement
       SolidRectangle rect = (SolidRectangle)solid;
        ...
    }
}

Ceci a l'avantage de conserver le caractère polymorphique de la méthode collideWith() et permet d'ajouter de nouvelle sous-classes de la classe Solid sans affecter cette dernière.

[deltree]

C'est vrai qu'on est obligé de modifier la classe abstraite pour chaque classe ajoutée, mais tu oublie un point
ce code est faux:

Code :

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

1
2
3
4
 
    public boolean collideWith(Solid solid) {
         if (! solid instanceof SolidRectangle)
               return false;

car un rectangle peut être en collision avec un cercle, et de même si on ajoute un SolidTriangle, il faudra revoir les classes cercle et rectangle pour gérer les collisions Triangle-cercle et triangle-rectangle.

pour bien faire il faudrait des instance d'opérateur binaire isCollision(Solid,Solid) , surchargés pour chaque type de couple Solid-Solid (un peu comme un Comparator), ce qui trop compliqué pour un cas simple comme celui-ci.