Discussion :

[Ceubex]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[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..)

[herve91]

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 :

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
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;
	}
}

[Ceubex]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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 ?

[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

[herve91]

Quand tu dis

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 ?