Java反射中Method类invoke方法的用法

最新推荐文章于 2024-05-03 20:45:44 发布

xjk201

最新推荐文章于 2024-05-03 20:45:44 发布

阅读量941

点赞数

public Object invoke(Object obj,
                     Object... args)
              throws IllegalAccessException,
                     IllegalArgumentException,
                     InvocationTargetException

对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。个别参数被自动解包，以便与基本形参相匹配，基本参数和引用参数都随需服从方法调用转换。

如果底层方法是静态的，那么可以忽略指定的 obj 参数。该参数可以为 null。

如果底层方法所需的形参数为 0，则所提供的 args 数组长度可以为 0 或 null。

如果底层方法是静态的，并且尚未初始化声明此方法的类，则会将其初始化。

如果方法正常完成，则将该方法返回的值返回给调用者；如果该值为基本类型，则首先适当地将其包装在对象中。但是，如果该值的类型为一组基本类型，则数组元素不被包装在对象中；换句话说，将返回基本类型的数组。如果底层方法返回类型为 void，则该调用返回 null。

obj - 从中调用底层方法的对象（简单的说就是调用谁的方法用谁的对象）args - 用于方法调用的参数

package test922;
public class InvokeObj {
public void show() {
System.out.println("无参show()方法。");
}
public void show (String name) {
System.out.println("show方法：" + name);
}
public String[] arrayShow (String[] arr) {
return arr;
}
public String StringShow (String str) {
return str;
}
public int intShow (int num) {
return num;
}
}

package test922;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class MethodInvokeTest {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Class<InvokeObj> clazz = InvokeObj.class;
Method[] methods = clazz.getMethods();
System.out.println("以下输出InvokeObj类的方法：");
for (Method method : methods) {
System.out.println(method);
}
System.out.println("InvokeObj类的无参show()方法：");
Method method1 = clazz.getMethod("show", null);
//会执行无参show()方法
Object obj = method1.invoke(new InvokeObj(),null);
System.out.println("输出无参show()方法的返回值："+obj);
System.out.println("InvokeObj类的show()方法： ");
Method method2 = clazz.getMethod("show", String.class);
Object obj1 = method2.invoke(new InvokeObj(), "hello,world");
System.out.println("输出有参show()方法： ");
System.out.println("InvokeObj类的arrayShow()方法： ");
Method method3 = clazz.getMethod("arrayShow", String[].class);
String[] strs = new String[]{"hello", "world", "!"};
//数组类型的参数必须包含在new Object[]{}中，否则会报IllegalArgumentException
String[] strings = (String[]) method3.invoke(new InvokeObj(), new Object[]{strs});
for (String str : strings) {
System.out.println("arrayShow的数组元素：" + str);
}
System.out.println("InvokeObj类的StringShow()方法： ");
Method method4 = clazz.getMethod("StringShow", String.class);
String string = (String) method4.invoke(new InvokeObj(), "Thinking in java");
System.out.println("StringShow()方法的返回值： " + string);
System.out.println("InvokeObj类的intShow()方法： ");
Method method5 = clazz.getMethod("intShow", int.class);
int num = (int) method5.invoke(new InvokeObj(), 89);
System.out.println("intShow()方法的返回值： " + num);
}
}

以下输出InvokeObj类的方法：
public void test922.InvokeObj.show(java.lang.String)
public void test922.InvokeObj.show()
public java.lang.String[] test922.InvokeObj.arrayShow(java.lang.String[])
public java.lang.String test922.InvokeObj.StringShow(java.lang.String)
public int test922.InvokeObj.intShow(int)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
InvokeObj类的无参show()方法：
无参show()方法。
输出无参show()方法的返回值：null
InvokeObj类的show()方法：
show方法：hello,world
输出有参show()方法：
InvokeObj类的arrayShow()方法：
arrayShow的数组元素：hello
arrayShow的数组元素：world
arrayShow的数组元素：!
InvokeObj类的StringShow()方法：
StringShow()方法的返回值： Thinking in java
InvokeObj类的intShow()方法：
intShow()方法的返回值： 89

Method getMethod(String name, Class<?>... parameterTypes)
--返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。

方法后面接收的就是Class类的对象，而如：String.class、int.class这些字节码才是Class类的对象

也可以此种方式：

//getMethod第一个参数是方法名，第二个参数是该方法的参数类型，
//因为存在同方法名不同参数这种情况，所以只有同时指定方法名和参数类型才能唯一确定一个方法

Method method = XXX.getClass().getMethod(methodName,new Class[0]);

//第一个参数是具体调用该方法的对象
//第二个参数是执行该方法的具体参数

如一个函数 int Test(int a, String str);

对应的getMethod方法：

1. getMethod("Test",int.class,String.class);

2. getMethod("Test",new Class[]{int.class,String.class});

然后通过invoke来调用此方法：

函数原型：Object Java.lang.reflect.Method.invoke(Object receiver, Object... args)

//Method类的invoke(Object obj,Object args[])方法接收的参数必须为对象，
//如果参数为基本类型数据，必须转换为相应的包装类型的对象。invoke()方法的返回值总是对象，
//如果实际被调用的方法的返回类型是基本类型数据，那么invoke()方法会把它转换为相应的包装类型的对象，再将其返回

receiver：该方法所在类的一个对象

args：传入的参数如 100，“hello”

详细参见：http://www.linuxidc.com/Linux/2009-09/21571.htm

import java.lang.reflect.Method;

public class InvokeTester {

public int add(int param1, int param2) {
return param1 + param2;
}

public String echo(String mesg) {
return "echo" + mesg;
}

public static void main(String[] args) throws Exception {
Class classType = InvokeTester.class;
Object invokertester = classType.newInstance();

Method addMethod = classType.getMethod("add", new Class[] { int.class,
    int.class });
//Method类的invoke(Object obj,Object args[])方法接收的参数必须为对象，
//如果参数为基本类型数据，必须转换为相应的包装类型的对象。invoke()方法的返回值总是对象，
//如果实际被调用的方法的返回类型是基本类型数据，那么invoke()方法会把它转换为相应的包装类型的对象，
//再将其返回
Object result = addMethod.invoke(invokertester, new Object[] {
    new Integer(100), new Integer(200) });
//在jdk5.0中有了装箱拆箱机制 new Integer(100)可以用100来代替，系统会自动在int 和integer之间转换
System.out.println(result);

Method echoMethod = classType.getMethod("echo",
new Class[] { String.class });
result = echoMethod.invoke(invokertester, new Object[] { "hello" });
System.out.println(result);
}
}

public class Test {
public static void main(String[] args) throws Exception {
String field = "UserName";
String methodName = "";
World world = new World();
Class xom = world.getClass();
methodName = "set"+field;
Method method = xom.getMethod(methodName, String.class);
Object[] obj = new Object[1];
obj[0] = "guolei";
method.invoke(world, obj);
// System.out.println(world.getUserName());
methodName = "get"+field;
Method method2 = xom.getMethod(methodName);
System.out.println(method2.invoke(world));

}
}

xjk201

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java反射中Method类invoke方法的用法

public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTarget...
复制链接

扫一扫