Bonjour à tous,
Je rencontre un dilemme sur une surcharge d'une méthode implémentée depuis une interface.
Voici ce dilemme illustré par un exemple TRÈS simple.
Une interface IA :
Une classe A avec 2 méthodes : la première méthode implémente IA#execute(Object) et la seconde méthode surcharge A#execute(Object) (donc la méthode implémentée) :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4 public interface IA { void execute(Object o); }
Et un main pour tester :
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 public class A implements IA { /** * Implementing {@link IA#execute(Object)}. */ public void execute(Object o) { this.execute(o); } /** * Overloading {@link A#execute(Object)}. * * @param a * an instance of String */ public void execute(String s) { /* do something stupid with s */ s = new String("another stupid string"); } }
Au runtime, la méthode implémentée (donc A#execute(Object)) reçoit une instance de la classe String.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11 /** * A main method to test. * * @param args * an array of arguments. Not used here. */ public static void main(String args[]) { IA a = new A(); a.execute(new String("just a stupid string")); }
Ainsi, la ligne this.execute(o); devrait appeler la méthode surchargée public void execute(String s) de la classe courante.
Ce n'est pas le cas : elle se rappelle elle même et donc boucle à l'infini !
Une idée ?
Un pattern disponible ?
Merci à tous.
Partager