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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : 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");
	}
}
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
 
        /**
         * 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.