Réutiliser une fonction par laquelle on est passer

Version imprimable

Bonjour,

J'aimerais réaliser une fonction qui fait ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
typeRetour Ma fonction(type1 arg1,type2 arg2)
{
   //traitement
   memoire.nom=getLeNomDeLaFonctionQueJUtilise();
   memoire.parametres=getLesParametresDeLaFonctionQueJUtilise();
   //retour
}
 
void Execution()
{
  memoire.parametres[0]=nouveauParametre; //on change le premier paramètre
  executer(<memoire.nom>(<memoire.parametres>) );
}

J'espère que ce pseudo code est assez parlant. La question est est-ce que c'est possible ?

12/10/2010, 15h01
seeme

Je ne suis pas sûr d'avoir compris, mais pour moi, ce que décris là est proche d'un comportement d'interface..

On se fiche de savoir ce que l'objet fait, on sait juste qu'il existe tel méthode, qui prend tels arguments et renvois tel type (après, ce qu'elle fait et comment elle le fait... on s'en fiche)..

Je ne sais pas si je suis à côté, mais sinon, à part utiliser un tableau de pointeur de fonctions (solution à éviter en courant), je ne vois pas ce que tu veux faire..

(je réitère, pour moi, ta conception est mauvaise mais laisse transparaitre l'idée d'interface..)

On peut effectivement passer par une ou plusieurs interfaces.
Maintenant, tout dépend du besoin réel : si on veut être plus généraliste, on peut passer par la réflexivité, cela donne qq chose comme ça (tous les paramètres sont supposés de type String)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class Evaluator<T> {
 
	protected List<String> parametres = new ArrayList<String>();
 
	public void addParametre(int index, String element) {
		parametres.add(index, element);
	}
 
	public boolean addParametre(String o) {
		return parametres.add(o);
	}
 
	public String removeParametre(int index) {
		return parametres.remove(index);
	}
 
	@SuppressWarnings("unchecked")
	public T eval(Object target, String methodName) {
		Class[] types = new Class[parametres.size()];
		for (int i = 0; i < types.length; i++) {
			types[i] = String.class;
		}
 
		try {
			Method m = target.getClass().getDeclaredMethod(methodName, types);
			return (T) m.invoke(target, parametres.toArray());
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		return null;
	}
}

Merci pour l'info c'est effectivement de reflexivité que j'ai besoin (je ne savais pas que ça existait mais j'ai appris).
Il y a juste un detail sur lequel je bute, je sais créer une variable Method mais comment faire
Code:

1 2 3 4 5 6 7 8 Class monObjet { void maMethode(String monParametre) { Method methodeEnCours=getLaMethodeQuiSExecuteEnCeMoment(); //ici "maMethode", si j'ai son nom ça me va aussi Object[] parametres=getLesParametresDeCetteMethode(); } }
Si je demande ça s'est parce que j'ai une centaine de méthode où je devrais mettre ça et si ça pouvait se faire automatiquement ça serais assez cool

14/10/2010, 11h26
herve91

Récupérer le nom de la méthode est possible en levant une exception et en consultant la stack trace. Par contre, pour les paramètres, je n'en ai aucune idée.
Sinon, il est possible de scanner la classe à la recherche des méthodes pour en déduire les types des paramètres.
Quel est le besoin exact ?
14/10/2010, 19h16
Ceubex

Je souhaite en fait enregistrer les noms et paramètres de manière à pouvoir rappeler la fonction par laquelle je suis passé (sachant qu'il y a un grand nombre de fonctions par lesquelles on peut passer et que toutes on des paramètres différents).

Le but c'est d'actualiser les données et leur interprétation par la fonction choisie par l'utilisateur puis de les afficher sur un graphique

Mais je crois que je suis bon pour mettre manuellement tous les noms et tableaux d'arguments dans des variables mémoire
14/10/2010, 19h26
herve91

Quand tu dis

Citation:

Je souhaite en fait enregistrer les noms et paramètres

il s'agit des valeurs des paramètres ou des types des paramètres ?
Tu veux pouvoir rappeler la méthode avec les mêmes valeurs que lors du 1er appel, c'est bien ça ?

Peut-être qq chose comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
	abstract class Recallable<T> {
 
		private boolean recording = true;
		private String[] args;
 
		public final T call(String... args) {
			if (recording) {
				this.args = args;
			}
			return f(args);
		}
 
		public final T recall() {
			if (args == null) {
				throw new IllegalStateException("aucun appel mémorisé");
			}
			return f(args);
		}
 
		public boolean isRecording() {
			return recording;
		}
 
		public void setRecording(boolean recording) {
			this.recording = recording;
		}
 
		protected abstract T f(String... args);
	}

14/10/2010, 19h31
Ceubex

Non pas les types, les valeurs seulement.
Je rappelle la méthode avec les même paramètres à l'exception du premier qui est du même type pour toutes mes fonctions et que je change
14/10/2010, 19h33
herve91

Citation:

Envoyé par Ceubex

Non pas les types, les valeurs seulement.
Je rappelle la méthode avec les même paramètres à l'exception du premier qui est du même type pour toutes mes fonctions et que je change

Ok, le code que je viens de poster au-dessus considère que tous les paramètres sont du même type (String). Ou alors tu changes

Code:

private String[] args;

en

Code:

private Object[] args;
18/10/2010, 10h26
Ceubex
Ok merci ça marche pour moi.
Dernières questions, avec la reflexivité on a la méthode : maMethode.invoke(objet, parametres);
Mon soucis est que ma méthode est dans une classe abstraite, du coup il n'y a pas d'objet à mettre dans le invoke. Comment faire pour passer outre ce problème ?

Sinon j'ai un autre problème, j'ai l'impression que java n'aime pas trop tout ce qui est abstrait/static, j'ai l'erreur "java.lang.NoSuchMethodException: Indice.sansDonnees([LCours;, Config)" lorque je prend ma methode avec m = c.getMethod("sansDonnees", paramTypes);
Ma méthode est definie comme il suit :
Code:

1 2 3 4 5 6 abstract class Indice { static void sansDonnees(Cours[] action,Config conf) { .... } }
19/10/2010, 13h04
Ceubex

Ok alors pour mes des questions :
- il faut mettre null
- il faut declarer la fonction en public