Interface et implémentation de méthodes

Bonjour à tous,

Je travaille actuellement sur un petit projet consistant à créer une classe abstraite de graphe la plus générale possible pour ensuite l'appliquer sur un problème d'application.
Je suis parti sur un code avec 4 interfaces représentant chacun un graphe, un noeud, un coté et le "label" des noeuds/cotés (pour des raisons de généralisation, même si à priori dans la plupart des cas, j'imagine qu'utiliser un String aurait suffit).

Je rencontre un petit problème dont je n'arrive pas à sortir ; voici les portions de code concernées :

Interface Edge :

Code:

---

1 2 3 4 5

public interface Edge<T> { public void addData(T data); public void removeData(T data); public boolean compareTo(Edge<T> edge); }

---

Implémentation :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

import java.util.ArrayList;   public class EdgeImplementation<T> implements Edge<T> { private Label<T> label; private int start; private int end; private ArrayList<T> data;   public boolean compareTo(EdgeImplementation<T> edge){ // ligne de l'erreur if (this.start == edge.start && this.end == edge.end){ ArrayList<T> data1 = this.data; ArrayList<T> data2 = edge.data; return data1.equals(data2); } else return false; }   // portion de code en plus ...   }

---

Ce à quoi Eclipse m'affiche une erreur disant que je dois implémenter la méthode héritée compareTo(Edge<T>). Le problème, c'est que si je modifie la ligne de l'erreur en

Code:

---

public boolean compareTo(Edge<T> edge)

---

... les variables end, start et data ne sont plus reconnues (puisqu'elles sont dans la classe EdgeImplementation et non Edge).
Du coup, il y a sans doute quelque chose que j'ai mal compris sur la manière d'utiliser les interfaces ; pourriez vous m'aider ?

Merci

C'est pas que tu as pas compris, c'est un problème réel de définition des typages : quand on définit une interface qui peut agir avec une autre instance d'elle-même, est-ce que ça veut dire
- que l'autre instance peut être n'importe quelle implémentation de l'interface ? (Exemple : une Collection à laquelle on ajoute tous les éléments d'une autre Collection)
- que l'autre instance doit être de la même implémentation que l'implémentation actuelle de l'interface ? (Exemple : un Comparable, ne peut en général être comparé qu'à ses semblables, genre une Date implémente Comparable et ne peut être comparée qu'à une autre Date.)

L'un comme l'autre ont du sens, mais quand tu mets un paramètre dont le type est l'interface, ça veut dire n'importe quel objet de cette interface, c'est-à-dire exactement la même chose que d'habitude.
Tu veux le deuxième cas, mais ton interface exprime clairement le premier cas.

Il fut un temps où on ne pouvait pas exprimer le deuxième cas. Où la seule solution était :

Code:

---

1 2 3 4

public boolean compareTo(Edge<T> edge){ EdgeImplementation<T> edgeImpl = (EdgeImplementation<T>)edge; if (this.start == edgeImpl.start && this.end == edgeImpl.end){ // ...

---

Ce n'est pas une mauvais utilisation des interfaces. C'est juste que ton implémentation a une limitation : elle ne peut travailler qu'avec les instances de même implémentation. Ça n'empêche pas que tant que tu ne mélanges pas les implémentations, ton code est générique et fonctionne. Tu peux utiliser une implémentation pour un de tes graphes, une autre pour un autre graphe, le code pour gérer les deux est le même, c'est juste que les deux graphes n'ont pas le droit de se parler.

... Depuis l'arrivée des génériques, il y a mieux.
Tu te rappelles pour le deuxième cas, j'ai parlé de Comparable. Eh bien il suffit de faire pareil. Comparable prend simplement un paramètre générique, pour dire à quoi il peut être comparé, et ce quoi doit lui-même être Comparable. Les implémentations forcent simplement ce paramètre à dire "comparable à moi."
Exemple :

Code:

---

1 2 3 4 5 6

class Date implements Comparable<Date> { @Override int compareTo(Date date) { // ... } }

---

Comme tu as déjà un paramètre générique, ça veut dire qu'il va t'en falloir un deuxième, qui fait ça.

Je ne pense pas avoir compris ton explication sur la deuxième méthode ; dans mon cas, on aurait :

Code:

---

1 2 3 4 5 6 7 8 9

public class EdgeImplementation<T> implements Edge<T,EdgeImplementation<T>> {   public boolean compareTo(EdgeImplementation<T> edge){ // ... }   // ...   }

---

et

Code:

---

1 2 3

public interface Edge<T,Imp> { public boolean compareTo(Edge<T,Imp> edge); }

---

Auquel cas, on obtient toujours le message "The type EdgeImplementation<T> must implement the inherited abstract method
Edge<T,EdgeImplementation<T>>.compareTo(Edge<T,EdgeImplementation<T>>)"

Du coup je pense que c'est plutôt les génériques que j'ai mal compris, mais je ne vois pas pas quoi. Si tu peux essayer de m'éclaire, ça serait très sympa !

Merci

Comme je te l'ai dit, l'idée c'est de faire la même chose que l'interface Comparable.

Donc,

Code:

---

1 2 3

interface Edge<T, E extends Edge<T, E>> { public boolean compareTo(E edge); }

---