Comparable sur les classes mères et filles

Bonjour à tous,

J'ai un petit question qui peut paraître anodine mais je ne trouve pas la solution. On va supposer que j'ai une classe mère B héritant de A, suivant ce code :

Code:

---

1 2 3 4 5 6 7 8 9 10

public class A implements Comparable<A>{ private Truc champComparableA; ...   public int compareTo(A other){ return champComparableA.compareTo(other.champComparableA) } ... }

---

Et ma classe B :

Code:

---

1 2 3 4 5 6 7 8 9

public class B extends A implements Comparable<B>{ private Truc champComparableB; ...   public int compareTo(B other){ return champComparableB.compareTo(other.champComparableB) } ... }

---

Code:

---

Collections.sort(maCollectionA)

---

marche bien.
Par contre :

Code:

---

Collections.sort(maCollectionB)

---

effectue le tri sur le compareTo de la classe mère, donc ma question évidemment c'est comment dire à Java d'effectuer le compareTo sur la classe Fille quand c'est une collection de Type ClasseFille qu'on traite?

Salut,


Personnellement je n'arrive pas à compiler ce bout de code :

Code:

---

public class B extends A implements Comparable<B>{

---

:arrow: On ne peut pas implémenté plusieurs fois la même interface Generics avec des types différents : Comparable<A> et Comparable<B>



Il serait peut-être plus propre d'utiliser des Comparator plutôt que de redéfinir la méthode compareTo()...



a++

Merci pour la réponse.

Citation:

---

Envoyé par adiGuba

Salut,


Personnellement je n'arrive pas à compiler ce bout de code :

Code:

---

public class B extends A implements Comparable<B>{

---

:arrow: On ne peut pas implémenté plusieurs fois la même interface Generics avec des types différents : Comparable<A> et Comparable<B>

---

En effet, le code tel que mis ne compile pas en mettant l'erreur que tu as soulignée. Je suis obligé de mettre ca pour que ça compile :

Code:

---

public class B extends A implements Comparable<A>

---

Citation:

---

Envoyé par adiGuba

Il serait peut-être plus propre d'utiliser des Comparator plutôt que de redéfinir la méthode compareTo()...

---

C'est la solution provisoire que j'ai dû utiliser, mais si tu permets je ne la trouve pas très propre. Je suis un peu surpris qu'en java on ne puisse appeler le compareTo d'une classe Fille lors d'un tri.
Je vais attendre un peu avant de clore le sujet.

Citation:

---

Envoyé par DevServlet

En effet, le code tel que mis ne compile pas en mettant l'erreur que tu as soulignée. Je suis obligé de mettre ca pour que ça compile :

Code:

---

public class B extends A implements Comparable<A>

---

---

Dans ce cas tu doit redéfinir compareTo(A) et non pas compareTo(B). Sinon tu fais de la surcharge avec une méthode qui ne sera jamais appelé...




Mais plus que cela c'est assez casse-gueule comme comportement de changer l'implémentation de compareTo() dans une classe fille...

Citation:

---

Envoyé par DevServlet

Je suis un peu surpris qu'en java on ne puisse appeler le compareTo d'une classe Fille lors d'un tri.

---

Le problème c'est que c'est très casse-gueule si jamais tu as une collection mélangeant des objets A et B, car "des fois" tu utilisera une méthode, et "des fois" une autre.

:arrow: compareTo() représente l'ordre "naturel" du type, et ne devrais pas être redéfinie dans les classes filles.



Tu pourrais détailler ton besoin exact ???


a++

Voila fonctionnellement le besoin :
Je veux pouvoir trier 2 collections d'objets ayant une relation d'heritage, sachant que je ne veux pas trier la collection d'objet fille sur le même attribut que la collection d'objet Mère. Mais ce en gardant le principe du compareTo de la classe Mere. Voila l'utilisation propre au moment du tri que je veux :

Code:

---

1 2 3

Collections.sort(maCollectionA)==>Tri sur champA; Collections.sort(maCollectionB)==>Tri sur champB (sachant que champB n'est pas membre de ClasseA);

---

Mais voila mon code actuel :

Code:

---

1 2	Collections.sort(maCollectionA)

---

qui me va bien.
Mais pour la ClasseB :

Code:

---

1 2 3 4 5 6 7

Comparator<ClasseB> comparatorClasseB = new Comparator<ClasseB>(){ public int compare(ClasseB b1, ClasseB b2) { return b1.getChampB().compareTo(b2.getChampB()); }}; Collections.sort(this.maCollectionB,comparatorClasseB); ...

---

Qui me parait moins propre...

Citation:

---

Envoyé par DevServlet

Voila fonctionnellement le besoin :
Je veux pouvoir trier 2 collections d'objets ayant une relation d'heritage, sachant que je ne veux pas trier la collection d'objet fille sur le même attribut que la collection d'objet Mère. Mais ce en gardant le principe du compareTo de la classe Mere.

---

Tu peux redéfinir compareTo()... mais le comportement est indéfini si tu as une collections mélangeant les deux types d'objets...

Citation:

---

Envoyé par DevServlet

Qui me parait moins propre...

---

Pourquoi ?
Au contraire l'utilisation d'un Comparator t'assure justement que tu utiliseras bien le bon algorithme de tri...


a++

Ok va pour la solution du Comparator alors.
Merci

Après rien ne t'empêche d'utiliser un Comparator static si tu dois l'utiliser souvent :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class B extends A {   public static Comparator<B> COMPARE_BY_XXX_FIELD = new Comparator<B>() { @Override public int compare(B o1, B o2) { return // TODO : code du compareTo } };     // Code de la classe B   }

---

Pour une utilisation plus souple :

Code:

---

Collections.sort(this.maCollectionB, B.COMPARE_BY_XXX_FIELD);

---

a++

Citation:

---

Envoyé par adiGuba

Après rien ne t'empêche d'utiliser un Comparator static si tu dois l'utiliser souvent :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class B extends A {   public static Comparator<B> COMPARE_BY_XXX_FIELD = new Comparator<B>() { @Override public int compare(B o1, B o2) { return // TODO : code du compareTo } };     // Code de la classe B   }

---

Pour une utilisation plus souple :

Code:

---

Collections.sort(this.maCollectionB, B.COMPARE_BY_XXX_FIELD);

---

a++

---

En effet, merci pour ton aide.