Méthode implémentée ET surchargée
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 :
Code:
1
2
3
4
|
public interface IA {
void execute(Object o);
} |
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:
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");
}
} |
Et un main pour tester :
Code:
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"));
} |
Au runtime, la méthode implémentée (donc A#execute(Object)) reçoit une instance de la classe 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.
