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 ?

[herve91]

Peut-être qq chose comme ça :

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

[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

[herve91]

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 :

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

private String[] args;

en

Code :

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

private Object[] args;

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

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

1
2
3
4
5
6
abstract class Indice {
	static void sansDonnees(Cours[] action,Config conf)
	{
	....
	}
}

[Ceubex]

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