Discussion :

[Djakisback]

Salut,
quelqu'un connait-il la méthode la plus simple pour définir une fonction de Callback en général ? Y a-t-il un moyen d'appeler dynamiquement une méthode d'objet en fonction d'un String ? ca donnerait un truc du style mais comment effectuer le cast, avec un getClass() ? :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Callback {
private Object source;
private String method;
 
public Callback(Object source, String method) {
this.source = source;
this.method = method;
}
 
public void run() {
// ici le but étant d'appeler la méthode this.method de this.source
}
}

J'ai vu quelques exemples créant une classe Function ou encore les "méthodes outrepassées" mais un peu lourds.
Quelqu'un aurait-il une solution simple à proposer ?
Merci d'avance.

[BugFactory]

Code :

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

object.getClass().getMethod(name, parameterTypes).invoke(object, args);

ou

Code :

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

Method[] methodsArray = object.getClass().getMethods();

Rechercher la fonction avec le bon nom.

Code :

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

method.invoke(object, args);

Conseil gratuit : mettre un marque page sur le lien dans ma signature.

[Djakisback]

Merci, ça marche nickel

[Djakisback]

Par contre c'est pas très pratique pour l'appel sans arguments :

Code :

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

this.getClass().getMethod("method", new Class[]{}), new Object[]{})

si je mets les types et les arguments à null j'ai un warning d'Eclipse.

[BugFactory]

D'après la Javadoc vous avez le droit à null pour ces deux arguments. Quelle version de Java utilisez vous?

Sinon il y a toujours la possibilité de se faire sa propre méthode.

[Djakisback]

Bonjour,
j'utilise la 1.6.
Oui effectivement ça pourrait être pratique de créer une méthode pour ça, merci.

[adiGuba]

Salut,


Ton problème de warning vient du fait que depuis Java 1.5 ces méthodes utilisent l'ellipse, une nouveauté de la 1.5 qui permet d'utiliser un nombre d'argument variable (ce qui est traité en interne comme un tableau).


Ainsi désormais au lieu d'écrire :

Code :

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

getMethod("method", new Class[]{ String.class, Integer.class });

On peut désormais écrire directement :

Code :

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

getMethod("method", String.class, Integer.class );

Ce qui revient exactement au même...


Le problème lorsque tu passes null c'est que le compilateur ne sait pas si tu veux faire exactement :

Code :

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

1
2
getMethod("method", new Class[]{ null }); // pour passer un tableau contenant un null
getMethod("method", null); // pour passer null directement

Par ce warning, le compilateur t'invite à lui donner plus d'information via un cast :

Code :

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

1
2
getMethod("method", (Class) null ); // pour générer new Class[]{ null }
getMethod("method", (Class[]) null ); // pour passer null directement

Mais avec l'ellipse il y a une dernière solution :

Code :

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

getMethod("method");

Qui est équivalent à ceci :

Code :

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

getMethod("method", new Class[0]); // un tableau vide

a++

PS : Au fait, pourquoi ne pas utiliser une interface pour le callback ???

[Djakisback]

Merci pour ces informations très instructives

Le problème lorsque tu passes null c'est que le compilateur ne sait pas si tu veux faire exactement :
Code :
getMethod("method", new Class[]{ null }); // pour passer un tableau contenant un null
getMethod("method", null); // pour passer null directement

Effectivement c'est ce que je me disais.

Quant à l'utilisation d'une interface, l'intervalle d'appel du ou des callback peut être différent selon les instances et j'avais besoin d'un modèle générique extérieur. En fait il s'agit de gérer des comportements d'AI pour des instances, donc j'appelle telle ou telle méthode M d'une instance I à un instant T mais pour une autre instance je veux pouvoir appeler une autre méthode M2.

[Fifan31]

Si j'ai bien compris, tu veux appeler une méthode M1 dans certains cas et une méthode M2 dans une autre situation. Tu devrais regarder du côté du modèle de conception état (design pattern state)
A+

[Djakisback]

Merci pour l'info, bien que cela ne se prête pas tout à fait à mon cas, je viens de lire quelques articles très intéressants.