Làm thế nào để tôi gọi một phương thức Java khi được đặt tên phương thức là một chuỗi?

Nếu tôi có hai biến:

Object obj;
String methodName = "getName";

Không biết lớp của obj, làm thế nào tôi có thể gọi phương thức được xác định bởi methodNamenó?

Phương thức được gọi không có tham số và Stringgiá trị trả về. Đó là một getter cho một Java bean .

Mã hóa từ hông, nó sẽ là một cái gì đó như:

java.lang.reflect.Method method;
try {
  method = obj.getClass().getMethod(methodName, param1.class, param2.class, ..);
} catch (SecurityException e) { ... }
  catch (NoSuchMethodException e) { ... }

Các tham số xác định phương thức rất cụ thể mà bạn cần (nếu có sẵn một số quá tải, nếu phương thức không có đối số, chỉ đưa ra methodName).

Sau đó, bạn gọi phương thức đó bằng cách gọi

try {
  method.invoke(obj, arg1, arg2,...);
} catch (IllegalArgumentException e) { ... }
  catch (IllegalAccessException e) { ... }
  catch (InvocationTargetException e) { ... }

Một lần nữa, bỏ qua các đối số trong .invoke, nếu bạn không có bất kỳ. Nhưng vâng. Đọc về Phản xạ Java

Sử dụng lời gọi phương thức từ sự phản chiếu:

Class<?> c = Class.forName("class name");
Method method = c.getDeclaredMethod("method name", parameterTypes);
method.invoke(objectToInvokeOn, params);

Ở đâu:

• "class name" là tên của lớp
• objectToInvokeOn thuộc loại Object và là đối tượng bạn muốn gọi phương thức trên
• "method name" là tên của phương thức bạn muốn gọi
• parameterTypeslà kiểu Class[]và khai báo các tham số mà phương thức lấy
• paramslà kiểu Object[]và khai báo các tham số được truyền cho phương thức

Đối với những người muốn có một ví dụ mã thẳng trong Java 7:

Dog lớp học:

package com.mypackage.bean;

public class Dog {
    private String name;
    private int age;

    public Dog() {
        // empty constructor
    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void printDog(String name, int age) {
        System.out.println(name + " is " + age + " year(s) old.");
    }
}

ReflectionDemo lớp học:

package com.mypackage.demo;

import java.lang.reflect.*;

public class ReflectionDemo {

    public static void main(String[] args) throws Exception {
        String dogClassName = "com.mypackage.bean.Dog";
        Class<?> dogClass = Class.forName(dogClassName); // convert string classname to class
        Object dog = dogClass.newInstance(); // invoke empty constructor

        String methodName = "";

        // with single parameter, return void
        methodName = "setName";
        Method setNameMethod = dog.getClass().getMethod(methodName, String.class);
        setNameMethod.invoke(dog, "Mishka"); // pass arg

        // without parameters, return string
        methodName = "getName";
        Method getNameMethod = dog.getClass().getMethod(methodName);
        String name = (String) getNameMethod.invoke(dog); // explicit cast

        // with multiple parameters
        methodName = "printDog";
        Class<?>[] paramTypes = {String.class, int.class};
        Method printDogMethod = dog.getClass().getMethod(methodName, paramTypes);
        printDogMethod.invoke(dog, name, 3); // pass args
    }
}

Đầu ra: Mishka is 3 year(s) old.

Bạn có thể gọi hàm tạo với các tham số theo cách này:

Constructor<?> dogConstructor = dogClass.getConstructor(String.class, int.class);
Object dog = dogConstructor.newInstance("Hachiko", 10);

Ngoài ra, bạn có thể loại bỏ

String dogClassName = "com.mypackage.bean.Dog";
Class<?> dogClass = Class.forName(dogClassName);
Object dog = dogClass.newInstance();

và làm

Dog dog = new Dog();

Method method = Dog.class.getMethod(methodName, ...);
method.invoke(dog, ...);

Đề nghị đọc: Tạo trường hợp lớp mới

Phương thức có thể được gọi như thế này. Ngoài ra còn có nhiều khả năng hơn (kiểm tra api phản chiếu), nhưng đây là cách đơn giản nhất:

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

import org.junit.Assert;
import org.junit.Test;

public class ReflectionTest {

    private String methodName = "length";
    private String valueObject = "Some object";

    @Test
    public void testGetMethod() throws SecurityException, NoSuchMethodException, IllegalArgumentException,
            IllegalAccessException, InvocationTargetException {
        Method m = valueObject.getClass().getMethod(methodName, new Class[] {});
        Object ret = m.invoke(valueObject, new Object[] {});
        Assert.assertEquals(11, ret);
    }



}

Đầu tiên, đừng. Tránh loại mã này. Nó có xu hướng là mã thực sự xấu và cũng không an toàn (xem phần 6 của Nguyên tắc mã hóa bảo mật cho ngôn ngữ lập trình Java, phiên bản 2.0 ).

Nếu bạn phải làm điều đó, thích java.beans để phản ánh. Đậu kết thúc phản xạ cho phép truy cập tương đối an toàn và thông thường.

Để hoàn thành câu trả lời của đồng nghiệp của tôi, Bạn có thể muốn chú ý đến:

• các cuộc gọi tĩnh hoặc cá thể (trong một trường hợp, bạn không cần một thể hiện của lớp, trong trường hợp khác, bạn có thể cần phải dựa vào một hàm tạo mặc định hiện có có thể có hoặc không có ở đó)
• Cuộc gọi phương thức công khai hoặc không công khai (đối với cuộc gọi sau, bạn cần gọi setAccessible trên phương thức trong một khối doPriv đặc quyền , các công cụ tìm kiếm khác sẽ không vui )
• gói gọn vào một ngoại lệ áp dụng dễ quản lý hơn nếu bạn muốn loại bỏ nhiều ngoại lệ của hệ thống java (do đó, CCException trong mã bên dưới)

Đây là một mã java1.4 cũ có tính đến các điểm đó:

/**
 * Allow for instance call, avoiding certain class circular dependencies. <br />
 * Calls even private method if java Security allows it.
 * @param aninstance instance on which method is invoked (if null, static call)
 * @param classname name of the class containing the method 
 * (can be null - ignored, actually - if instance if provided, must be provided if static call)
 * @param amethodname name of the method to invoke
 * @param parameterTypes array of Classes
 * @param parameters array of Object
 * @return resulting Object
 * @throws CCException if any problem
 */
public static Object reflectionCall(final Object aninstance, final String classname, final String amethodname, final Class[] parameterTypes, final Object[] parameters) throws CCException
{
    Object res;// = null;
    try {
        Class aclass;// = null;
        if(aninstance == null)
        {
            aclass = Class.forName(classname);
        }
        else
        {
            aclass = aninstance.getClass();
        }
        //Class[] parameterTypes = new Class[]{String[].class};
    final Method amethod = aclass.getDeclaredMethod(amethodname, parameterTypes);
        AccessController.doPrivileged(new PrivilegedAction() {
    public Object run() {
                amethod.setAccessible(true);
                return null; // nothing to return
            }
        });
        res = amethod.invoke(aninstance, parameters);
    } catch (final ClassNotFoundException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+CLASS, e);
    } catch (final SecurityException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_SECURITY_ISSUE, e);
    } catch (final NoSuchMethodException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_NOT_FOUND, e);
    } catch (final IllegalArgumentException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_ILLEGAL_ARGUMENTS+String.valueOf(parameters)+GenericConstants.CLOSING_ROUND_BRACKET, e);
    } catch (final IllegalAccessException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_ACCESS_RESTRICTION, e);
    } catch (final InvocationTargetException e) {
    throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_INVOCATION_ISSUE, e);
    } 
    return res;
}

Object obj;

Method method = obj.getClass().getMethod("methodName", null);

method.invoke(obj, null);

//Step1 - Using string funClass to convert to class
String funClass = "package.myclass";
Class c = Class.forName(funClass);

//Step2 - instantiate an object of the class abov
Object o = c.newInstance();
//Prepare array of the arguments that your function accepts, lets say only one string here
Class[] paramTypes = new Class[1];
paramTypes[0]=String.class;
String methodName = "mymethod";
//Instantiate an object of type method that returns you method name
 Method m = c.getDeclaredMethod(methodName, paramTypes);
//invoke method with actual params
m.invoke(o, "testparam");

Nếu bạn thực hiện cuộc gọi nhiều lần, bạn có thể sử dụng các điều khiển phương thức mới được giới thiệu trong Java 7. Ở đây chúng tôi sẽ cho phương thức của bạn trả về một Chuỗi:

Object obj = new Point( 100, 200 );
String methodName = "toString";  
Class<String> resultType = String.class;

MethodType mt = MethodType.methodType( resultType );
MethodHandle methodHandle = MethodHandles.lookup().findVirtual( obj.getClass(), methodName, mt );
String result = resultType.cast( methodHandle.invoke( obj ) );

System.out.println( result );  // java.awt.Point[x=100,y=200]

Điều này nghe có vẻ như có thể thực hiện được với gói Java Reflection.

http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html

Đặc biệt theo Phương thức gọi theo tên:

nhập java.lang.reflect. *;

public class method2 {
  public int add(int a, int b)
  {
     return a + b;
  }

  public static void main(String args[])
  {
     try {
       Class cls = Class.forName("method2");
       Class partypes[] = new Class[2];
        partypes[0] = Integer.TYPE;
        partypes[1] = Integer.TYPE;
        Method meth = cls.getMethod(
          "add", partypes);
        method2 methobj = new method2();
        Object arglist[] = new Object[2];
        arglist[0] = new Integer(37);
        arglist[1] = new Integer(47);
        Object retobj 
          = meth.invoke(methobj, arglist);
        Integer retval = (Integer)retobj;
        System.out.println(retval.intValue());
     }
     catch (Throwable e) {
        System.err.println(e);
     }
  }
}

Lập chỉ mục (nhanh hơn)

Bạn có thể sử dụng FunctionalInterfaceđể lưu các phương thức trong một thùng chứa để lập chỉ mục cho chúng. Bạn có thể sử dụng bộ chứa mảng để gọi chúng bằng số hoặc hàm băm để gọi chúng theo chuỗi. Bằng thủ thuật này, bạn có thể lập chỉ mục các phương thức của mình để gọi chúng một cách linh hoạt nhanh hơn .

@FunctionalInterface
public interface Method {
    double execute(int number);
}

public class ShapeArea {
    private final static double PI = 3.14;

    private Method[] methods = {
        this::square,
        this::circle
    };

    private double square(int number) {
        return number * number;
    }

    private double circle(int number) {
        return PI * number * number;
    }

    public double run(int methodIndex, int number) {
        return methods[methodIndex].execute(aNumber);
    }
}

Cú pháp Lambda

Bạn cũng có thể sử dụng cú pháp lambda:

public class ShapeArea {
    private final static double PI = 3.14;

    private Method[] methods = {
        number -> {
            return number * number;
        },
        number -> {
            return PI * number * number;
        },
    };

    public double run(int methodIndex, int number) {
        return methods[methodIndex].execute(aNumber);
    }
}

Method method = someVariable.class.getMethod(SomeClass);
String status = (String) method.invoke(method);

SomeClasslà lớp và someVariablelà một biến.

Tôi làm như thế này:

try {
    YourClass yourClass = new YourClass();
    Method method = YourClass.class.getMethod("yourMethodName", ParameterOfThisMethod.class);
    method.invoke(yourClass, parameter);
} catch (Exception e) {
    e.printStackTrace();
}

Vui lòng tham khảo mã sau đây có thể giúp bạn.

public static Method method[];
public static MethodClass obj;
public static String testMethod="A";

public static void main(String args[]) 
{
    obj=new MethodClass();
    method=obj.getClass().getMethods();
    try
    {
        for(int i=0;i<method.length;i++)
        {
            String name=method[i].getName();
            if(name==testMethod)
            {   
                method[i].invoke(name,"Test Parameters of A");
            }
        }
    }
    catch(Exception ex)
    {
        System.out.println(ex.getMessage());
    }
}

Cảm ơn....

Dưới đây là S READN SÀNG SỬ DỤNG PHƯƠNG PHÁP:

Để gọi một phương thức, không có đối số:

public static void callMethodByName(Object object, String methodName) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    object.getClass().getDeclaredMethod(methodName).invoke(object);
}

Để gọi một phương thức, với các đối số:

    public static void callMethodByName(Object object, String methodName, int i, String s) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        object.getClass().getDeclaredMethod(methodName, int.class, String.class).invoke(object, i, s);
    }

Sử dụng các phương pháp trên như dưới đây:

package practice;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

public class MethodInvoke {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, IOException {
        String methodName1 = "methodA";
        String methodName2 = "methodB";
        MethodInvoke object = new MethodInvoke();
        callMethodByName(object, methodName1);
        callMethodByName(object, methodName2, 1, "Test");
    }

    public static void callMethodByName(Object object, String methodName) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        object.getClass().getDeclaredMethod(methodName).invoke(object);
    }

    public static void callMethodByName(Object object, String methodName, int i, String s) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        object.getClass().getDeclaredMethod(methodName, int.class, String.class).invoke(object, i, s);
    }

    void methodA() {
        System.out.println("Method A");
    }

    void methodB(int i, String s) {
        System.out.println("Method B: "+"\n\tParam1 - "+i+"\n\tParam 2 - "+s);
    }
}

Đầu ra:

Phương pháp A  
Phương pháp B:  
	Tham số 1 - 1  
	Tham số 2 - Kiểm tra

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

Bạn nên sử dụng sự phản chiếu - khởi tạo một đối tượng lớp, sau đó là một phương thức trong lớp này và sau đó gọi phương thức này trên một đối tượng với các tham số tùy chọn . Nhớ bọc đoạn mã sau trong khối thử

Hy vọng nó giúp!

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

Điều này đang làm việc tốt cho tôi:

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

}

Đầu ra:

My input testparam

Tôi có thể gọi phương thức bằng cách chuyển tên của nó sang phương thức khác (như chính).

sử dụng 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);
}

và đây là cách bạn sử dụng nó:

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

Với jooR, nó chỉ đơn thuần là:

on(obj).call(methodName /*params*/).get()

Dưới đây là một ví dụ chi tiết hơn:

public class TestClass {

    public int add(int a, int b) { return a + b; }
    private int mul(int a, int b) { return a * b; }
    static int sub(int a, int b) { return a - b; }

}

import static org.joor.Reflect.*;

public class JoorTest {

    public static void main(String[] args) {
        int add = on(new TestClass()).call("add", 1, 2).get(); // public
        int mul = on(new TestClass()).call("mul", 3, 4).get(); // private
        int sub = on(TestClass.class).call("sub", 6, 5).get(); // static
        System.out.println(add + ", " + mul + ", " + sub);
    }
}

Bản in này:

3, 12, 1

đối với tôi một cách chứng minh khá đơn giản và ngu ngốc sẽ chỉ đơn giản là tạo một phương thức gọi phương thức như vậy:

public static object methodCaller(String methodName)
{
    if(methodName.equals("getName"))
        return className.getName();
}

sau đó khi bạn cần gọi phương thức đơn giản chỉ cần đặt một cái gì đó như thế này

//calling a toString method is unnessary here, but i use it to have my programs to both rigid and self-explanitory 
System.out.println(methodCaller(methodName).toString());