Bonjour, j'essaie une nouvelle approche dans un programme où j'essaie d'y incorporer des interfaces.
Voilà un exemple de code, où je vous expliquerai mon problème par la suite:
 

 
Bon ça peut peut-être semblé difficile à comprendre, mais ce type de code va me sauver beaucoup de temps éventuellement en empêchant de la redondance de code. Mais voici mon problème, mon interface contient plusieurs méthodes, certaines classes en utiliseront qu'une, d'autres p-e 2, qui sait.... Je ne veux pas avoir à redéfinir chaque fois les méthodes que je n'utilise pas pour chaque classe....
 
Jusqu'à maintenant, le seul moyen que j'ai trouvé pour cela, c'est de mettre le mot clef "abstract" devant la signature de mes classes, mais malheureusement, ceci empêche du même coup l'instanciation de cette même classe, ce dont j'ai besoin de pouvoir faire....
 
Y existe-t-il un mot clef ou qqc qui n'oblige pas une classe implantant une interface de redéfinir toutes les méthodes de cet interface?

non  
a la limite , tu fais des méthodes vide ( ou mieux, des méthodes qui lèvent ue exception si tu les appelle)

Ok, j'avais déjà pensé à cette option, je voulais seulement éviter de toujours tout redéfinir les fonctions que je n'utilise pas, surtout que beaucoup de classes risque d'implémenter cette interface....
 
Le but était seulement de m'éviter du travail et de gagner du temps!

Ouais mais c'est pas le but d'une interface. Une interface, c'est justement pour dire "hey, je suis un objet qui sait faire ça et ça".
Donc déjà, si tu te dis que tu auras plusieurs objets qui n'implémenteront pas telle ou telle méthode, pose-toi les questions : "est-ce que mon interface est bien définie ? Est-ce que c'est bien cette interface que mon objet doit implémenter ?" Quitte à faire plusieurs interfaces pour modéliser plusieurs comportements.

Après, si effectivement tu as besoin du comportement que tu décris, pense plutôt à faire un adapter : classe abstraite implémentant l'interface en renvoyant une exception ou un résultat par défaut. Tu dériveras ensuite cette classe en ne surchargeant que les méthodes que tu veux implémenter.
(attention, ce n'est pas toujours une bonne idée, pense bien à ce que tu veux faire)

En fait je cherche à simuler le passage d'une fonction en paramètre à une autre. Pour ce faire, les fonctions que je voudrais passer en paramètre se retrouve à être des classe implémentant un interface, ayant elle même plusieurs fonctions portant le même nom, mais se différenciant par les paramètres reçu...
 
De cette façon, au lieu de passer une fonction je passe un objet (D'où l'importance que ça puisse être instancier, donc non-abstrait), cela me permet alors de sauver beaucoup de redondance de code. En effet, si j'ai 10 méthodes qui ont chaque une boucle dans une boucle (Traversant exactement les mêmes éléments) mais n'en faisant simplement pas le même usage, j'ai une méthode représentant ce modèle de boucle, et je lui passe en paramètre à l'aide d'un objet l'utilisation que je veux en faire...
 
La raison des différentes signature de cette même fonction, c'est que j'ai plusieurs cas de code qui doit se répéter ainsi, donc dans chaque cas, je n'en voie pas nécessairement les mêmes informations à mon utilisation centrale.... (J'sais pas si c'est clair... :-s)

   
 
http://java.sun.com/j2se/1.5.0/doc [...] nable.html
http://java.sun.com/j2se/1.5.0/doc [...] lable.html
http://google-collections.googleco [...] ction.html

J'Vois pas vraiment en quoi ces 3 liens peuvent m'aider...
 
Le premier parle des threads, je sais ce que c'est, et je n'en ai pas besoin dans ce context...
Le 2e semble est un interface permettant à une classe d'être appellée... j'comprend plus ou moins le principe, mais ça ne semble pas utile dans mon contexte
Le 3e semble servire à convertir un objet en un autre....
 
Au pire, j'irai avec plusieurs interface, ou je lancerai des exception, je regarde encore ce qui serait le mieux, de toute façon ce sont des méthodes au privée, alors si je m'arrnage pour ne pas appeller les mauvaises méthode de l'interface, je devrais m'en tirer..