parametrizzare un metodo

[alf83]

ciao, non sò se è possibile fare ciò che sto per chiedere ma provo ugualmente. Dato il nome di una classe (es C) e il nome di uno dei suoi metodi ( es m()), è possibile eseguire quel metoto sull'istanza di quella classe? Mi spiego:
sia meth() un generico metodo cosi definito:

public meth(String nomeClasse, String nomeMetodo)

quello che vorrei fare è new nomeClasse().nomeMetodo(). come faccio? Spero di essere riuscito a spiegarmi. (PEr inciso, so come ricavare l'oggetto Class a partire dal nome di una classe, con il Class.forName(nome), ma poi non os come parametrizzare il nome della funzione da richiamarci sopra, qualora ciò sia possibile).

[andbin]

Originariamente inviato da alf83
quello che vorrei fare è new nomeClasse().nomeMetodo(). come faccio? Spero di essere riuscito a spiegarmi. (PEr inciso, so come ricavare l'oggetto Class a partire dal nome di una classe, con il Class.forName(nome), ma poi non os come parametrizzare il nome della funzione da richiamarci sopra, qualora ciò sia possibile).

Quindi vuoi utilizzare la "reflection".
Ma devi comunque sapere, a priori, quanti e di che tipo sono i parametri del metodo.

[alf83]

se i parametri da passare alla funzione fossero zero?

[andbin]

Originariamente inviato da alf83
se i parametri da passare alla funzione fossero zero?

Ok ma devi comunque "saperlo".

Ecco un esempio:

import java.lang.reflect.*;

public class Prova {
    public static void main(String[] args) {
        try {
            Class c = Class.forName("javax.swing.JLabel");

            Object label = c.newInstance();

            Method m = c.getMethod("setText", new Class[] { String.class });
            m.invoke(label, new Object[] { "testo" });

            m = c.getMethod("setBounds", new Class[] { int.class, int.class, int.class, int.class });
            m.invoke(label, new Object[] { new Integer(10), new Integer(10), new Integer(100), new Integer(30) });
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

Il codice è pre Java 5. Se si usa Java 5 o superiore si può semplificare un pochino (perché getMethod e invoke li hanno resi metodi "varargs" e si può anche usare l'autoboxing).

Comunque vedi che devi conoscere quantità e tipo esatto dei parametri per poter ottenere un Method e nella invocazione di invoke devi passare tanti Object quanti sono i parametri (e questo vuol dire che i primitivi li devi convertire)

[Santinizer]

Comunque vedi che devi conoscere quantità e tipo esatto dei parametri per poter ottenere un Method e nella invocazione di invoke devi passare tanti Object quanti sono i parametri (e questo vuol dire che i primitivi li devi convertire)

è possibile memorizzare tutti i metodi di una classe in una Map in cui le chiavi sono i nomi dei metodi stessi (anche se c'è overloading con un pò di difficolta in più). Per cui è possibile "estrarre" un metodo anche senza conoscerne il numero e il tipo dei parametri (Class[] parameterTypes = m.getParameterTypes(). Infine si può richiamare un metodo senza conoscerne il numero dei parametri a priori, passando come parametro un array di Object (m.invoke(classe.newInstance(), params)). A titolo di esempio:

package test;  
import java.lang.reflect.*; 
import java.util.Hashtable;  
public class ReflectionTest {     
   //esempio di utilizzo java ReflectionTest <nomeClasse> <nomeMetodo> <parametro1> <parametro2> ...      
   public static void main(String args[]) throws Exception {         
      Class classe = Class.forName(args[0]);         
      String methodName = args[1];         
      Method[] methods = classe.getDeclaredMethods();         
      Hashtable<String, Method> methodHashtable = new Hashtable<String, Method>();         
      for (int i = 0; i < methods.length; i++) {             
         Method method = methods[i];             
         methodHashtable.put(method.getName(), method);         
      }         
      Method m = methodHashtable.get(methodName);         
      Class[] parameterTypes = m.getParameterTypes();         
      if (parameterTypes.length != args.length - 2) {             
         System.out.println("Numero di parametri errato");             
         System.exit(0);         
      }         
      Object[] params = new Object[parameterTypes.length];         
      for (int j = 0; j < params.length; j++) {             
         params[j] = parameterTypes[j].getConstructor(String.class).newInstance(args[j + 2]);         
      }         
      System.out.println(m.invoke(classe.newInstance(), params));     
   } 
}
  
class ReflectionTestClass {      
   public Integer sum(Integer i, Integer j) {         
      return i + j;     
   } 
} 

eseguendo "java test.ReflectionTest test.ReflectionTestClass sum 1 2", a video viene stampato "3".