[JAVA]passare metodi come parametri

[giannimarz]

salve ragazzi,

è possibile passare un metodo come parametro in una procedura?se si come?

[R@ve M@ster]

No. Non è possibile. Ma perchè mai dovresti fare una cosa del genere? Il metodo che passeresti è cmq richiamabile all'interno del metodo che lo riceve (se si trova nella stessa classe).

[nether]

volendo si puo' con un po' di reflection, pero' perche' farlo? probabilmente si possono strutturare le cose in modo differente (e migliore)...

[Casper87]

salve, anch'io sono curioso sull'argomento.

Ho letto sulle api qualcosa sul Tipo "Method",

vorrei che una procedura "cerca", deve eseguire la ricerca e alcuni confronti su stringhe ottenute da metodi, i metodi possono differire (perchè possono restituire diverse stringhe da diversi campi di esemplare della classe a cui appartengono i metodi, ho diversi metodo per restituire i diversi campi di esemplare della classe)

@nether: come si potrebbe implementare?

[FreeManX]

Se ho capito bene quello che vuoi fare tu si fa realizzando un struttura di classi.

Ad esempio ha la tua interfaccia MyString:
interface MyString {
public String returnMyString();
}

e successivamente tante classi quante sono le tue differenti forme:

public class MyStringInversa implements MyString {
public String returnMyString() {
//come vuoi fare
}
}

Cosi non dovresti avere la necessità di scomodare la reflection.

[R@ve M@ster]

Originariamente inviato da Casper87
salve, anch'io sono curioso sull'argomento.

Ho letto sulle api qualcosa sul Tipo "Method",

vorrei che una procedura "cerca", deve eseguire la ricerca e alcuni confronti su stringhe ottenute da metodi, i metodi possono differire (perchè possono restituire diverse stringhe da diversi campi di esemplare della classe a cui appartengono i metodi, ho diversi metodo per restituire i diversi campi di esemplare della classe)

@nether: come si potrebbe implementare?

Se non sai a priori le classi a cui appartengono i metodi, ma queste vengono determinate a runtime, allora devi utilizzare la reflection. Ad esempio supponendo che il nome della classe sia determinato in base al valore assunto da una variabile intera num :

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

......

int num = ... //calcola il valore di num
String nome_classe = "";
String nome_metodo = "";

switch(num){
     case 1:
          nome_classe="classe1";
          nome_metodo="metodo1";
          break;
     case 2:
          nome_classe="classe2";
          nome_metodo="metodo2";
          break;
}

try {
     Class obj = Class.forName(nome_classe);
     Method m = obj.getMethod(nome_metodo,new Class[0]);
} catch (IllegalArgumentException ex) {
            ex.printStackTrace();
} catch (SecurityException ex) {
            ex.printStackTrace();
} catch (InvocationTargetException ex) {
            ex.printStackTrace();
} catch (IllegalAccessException ex) {
            ex.printStackTrace();
} catch (NoSuchMethodException ex) {
            ex.printStackTrace();
}

[Casper87]

@R@ve M@ster: hai quasi colpito nel segno,

però nel mio caso (e nel caso del mio collega giannimarz) ho da passare dei metodi di una classe di cui già so la conoscenza (classe "Documento"); in pratica dobbiamo passare ad una procedura ricerca, il metodo da cui deve estrarre una stringa da comparare con un'altra stringa. Per non riscriver codice, il nostro intento è quello di passare diversi metodi (dai quali otteniamo i vari campi di esemplare della classe) per eseguire lo stesso tipo di confronto su campi diversi della classe (che otteniamo come ho detto prima tramite metodi).

[R@ve M@ster]

Se ho capito bene, potresti passare al metodo ricerca un array di stringhe contenente i nomi dei metodi da invocare. Effettuare un ciclo di chiamate e memorizzare in un array i risultati delle ricerche; nell'esemipo l'array di ritorno l'ho ipotizzato di object, non sapendo cosa ritornano i tuoi metodi da invocare:

public Object[] ricerca(String[] metodi){
     Documento doc = new Documento();

     Object[] array_ritorno = new Object[metodi.length];

     Class obj = doc.getClass();
     for(int i=0;i<metodi.length;i++){
          Method m = obj.getMethod(metodi[i],new Class[0]);
          Object valore = (Object)m.invoke(doc,new Object[0]);
          array_ritorno[i] = valore;
     }
     return array_ritorno;
}

Ho eliminato il blocco try-catch per maggiore chiarezza. Ovviamente il codice va adattato al tuo caso particolare.

[nether]

ciao, discutiamo di alcune cose...
1) quale sarebbe l'utilita' di fare questo?

[...]
int num = ... //calcola il valore di num
String nome_classe = "";
String nome_metodo = "";

switch(num){
case 1:
nome_classe="classe1";
nome_metodo="metodo1";
break;
case 2:
nome_classe="classe2";
nome_metodo="metodo2";
break;
}
[....]

non vedo ragioni per non fare:

[...]
int num = ... //calcola il valore di num

switch(num){
     case 1:
          return new Classe1().metodo1();
     case 2:
          return new Classe2().metodo2();
}
[....]

2) leggiamo...

però nel mio caso (e nel caso del mio collega giannimarz) ho da passare dei metodi di una classe di cui già so la conoscenza (classe "Documento"); in pratica dobbiamo passare ad una procedura ricerca, il metodo da cui deve estrarre una stringa da comparare con un'altra stringa. Per non riscriver codice, il nostro intento è quello di passare diversi metodi (dai quali otteniamo i vari campi di esemplare della classe) per eseguire lo stesso tipo di confronto su campi diversi della classe (che otteniamo come ho detto prima tramite metodi).

Non sono affatto convinto di aver capito bene, ma spero che l'idea non sia passare i nomi dei metodi di una qualsiasi classe come parametro di un altro metodo... cioe' una cosa tipo:

oggettoDiUtilità.confrontaProprietà(oggettoSuCuiInvokareIMetodi, "getNome", "getTitolo", "getAutore");

gia' l'uso in se' delle stringhe (nel senso di parametri specificati "a mano" sotto forma di stringa) all'interno del codice sarebbe quantomeno da limitare il piu' possibile, figurati poi addirittura specificare in stringhe dei nomi di metodi: e' la cosa meno manutenibile (e solida) del mondo per una serie di motivi, tra cui:
- se un giorno per un qualsiasi motivo cambi la signature del metodo della classe interessata e ti dimentichi di cambiare ovunque la stringa passata come parametro si spacca tutto, e si spacca runtime, perche' il compilatore non puo' accorgersi di nulla;
- se un giorno per qualsiasi motivo decidi che su una delle proprieta' ritrovate vuoi effettuare una qualsiasi operazione prima di confrontarla con qualcos'altro, devi comunque riscrivere completamente il codice;
...
- (questo non c'entra granche', cmq...) usare la reflection e' meno performante che invokare direttamente i metodi.

Secondo me non ci sono motivi per rinunciare a questo per scrivere 10 (tra l'altro banalissime) righe di codice in meno.