Wie rufe ich eine Java-Methode auf, wenn der Name der Methode als String angegeben ist?

Question

Wenn ich zwei Variablen habe:

Object obj;
String methodName = "getName";

Ohne Kenntnis der Klasse der obj wie kann ich die Methode aufrufen, die durch methodName darauf?

Die aufgerufene Methode hat keine Parameter, und ein String Rückgabewert. Es ist ein Getter für eine Java-Bohne .

Answer 1

Student.java

class Student{
    int rollno;
    String name;

    void m1(int x,int y){
        System.out.println("add is" +(x+y));
    }

    private void m3(String name){
        this.name=name;
        System.out.println("danger yappa:"+name);
    }
    void m4(){
        System.out.println("This is m4");
    }
}

StudentTest.java

import java.lang.reflect.Method;
public class StudentTest{

     public static void main(String[] args){

        try{

            Class cls=Student.class;

            Student s=(Student)cls.newInstance();

            String x="kichha";
            Method mm3=cls.getDeclaredMethod("m3",String.class);
            mm3.setAccessible(true);
            mm3.invoke(s,x);

            Method mm1=cls.getDeclaredMethod("m1",int.class,int.class);
            mm1.invoke(s,10,20);

        }
        catch(Exception e){
            e.printStackTrace();
        }
     }
}

Answer 2

Angenommen, Sie rufen eine statische Methode von einer statischen Methode innerhalb derselben Klasse auf. Dazu können Sie den folgenden Code verwenden.

class MainClass
{
  public static int foo()
  {
    return 123;
  }

  public static void main(String[] args)
  {
    Method method = MainClass.class.getMethod("foo");
    int result = (int) method.invoke(null); // answer evaluates to 123
  }
}

Zur Erklärung: Da wir hier keine echte objektorientierte Programmierung durchführen und somit die Erstellung unnötiger Objekte vermeiden wollen, werden wir stattdessen die class Eigenschaft zum Aufrufen von getMethod() .

Dann werden wir in null für die invoke() Methode, weil wir kein Objekt haben, mit dem wir diesen Vorgang durchführen können.

Und schließlich, weil wir, die Programmierer, wissen, dass wir eine Ganzzahl erwarten, dann wir explizit den Rückgabewert der invoke() Aufruf in eine Ganzzahl umzuwandeln.

Jetzt werden Sie sich vielleicht fragen: "Was ist überhaupt der Sinn dieser ganzen nicht objektorientierten Programmierung in Java?"

Mein Anwendungsfall war die Lösung von Projekt-Euler-Problemen in Java. Ich habe eine einzige Java-Quelldatei, die alle Lösungen enthält, und ich wollte Befehlszeilenargumente übergeben, um zu bestimmen, welches Project Euler-Problem ausgeführt werden soll.

Answer 3

Mit import java.lang.reflect.*;

public static Object launchProcess(String className, String methodName, Class<?>[] argsTypes, Object[] methodArgs)
        throws Exception {

    Class<?> processClass = Class.forName(className); // convert string classname to class
    Object process = processClass.newInstance(); // invoke empty constructor

    Method aMethod = process.getClass().getMethod(methodName,argsTypes);
    Object res = aMethod.invoke(process, methodArgs); // pass arg
    return(res);
}

und so verwenden Sie es:

String className = "com.example.helloworld";
String methodName = "print";
Class<?>[] argsTypes = {String.class,  String.class};
Object[] methArgs = { "hello", "world" };   
launchProcess(className, methodName, argsTypes, methArgs);

Answer 4

Bei mir funktioniert das einwandfrei:

public class MethodInvokerClass {
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, ClassNotFoundException, InvocationTargetException, InstantiationException {
        Class c = Class.forName(MethodInvokerClass.class.getName());
        Object o = c.newInstance();
        Class[] paramTypes = new Class[1];
        paramTypes[0]=String.class;
        String methodName = "countWord";
         Method m = c.getDeclaredMethod(methodName, paramTypes);
         m.invoke(o, "testparam");
}
public void countWord(String input){
    System.out.println("My input "+input);
}

}

Sortie :

My input testparam

Ich kann die Methode aufrufen, indem ich ihren Namen an eine andere Methode (wie main) übergebe.

Answer 5

Sie sollten Reflexion verwenden - init ein Klassenobjekt, dann eine Methode in dieser Klasse, und dann rufen Sie diese Methode auf ein Objekt mit optional Parameter. Denken Sie daran, den folgenden Ausschnitt in try-catch Block

Hoffentlich hilft das!

Class<?> aClass = Class.forName(FULLY_QUALIFIED_CLASS_NAME);
Method method = aClass.getMethod(methodName, YOUR_PARAM_1.class, YOUR_PARAM_2.class);
method.invoke(OBJECT_TO_RUN_METHOD_ON, YOUR_PARAM_1, YOUR_PARAM_2);