Para obtener información sobre un método de objeto dinámico, primero tiene que crear un tipo de método de objeto o matriz por uno de los métodos siguientes.
getMethods()
getMethods(String name,Class<?> …parameterTypes)
getDeclaredMethods()
getDeclaredMethods(String name,Class<?>...parameterTypes)
El método de acceso a la configuración especificada, es necesario acceder a los parámetros de acuerdo con el tipo del proceso de entrada . Por ejemplo, el acceso a un nombre max, de entrada y parámetros de tipo String eran tipos int.
A continuación se puede lograr de dos maneras:
objectClass.getDeclaredConstructor("max",int.class,String.class);
objectClass.getDeclaredConstructor("max",new Class[]{int.class,String.class});
método común clase Método
| Nombre del método estático | explicación |
|---|---|
| getName () | Obtiene el nombre del método |
| getParameterType () | Devuelve los diversos parámetros del método en orden de la declaración en la forma de una clase de tipo de matriz |
| GetReturnType () | Tipo de retorno del método se obtiene en forma de objetos Class |
| getExceptionTypes () | Este tipo de método para obtener una excepción podría ser lanzado en forma de una matriz de Clase |
| invoke (Object obj, objeto ... args) | Realización de la obj objeto especificado en el método que utiliza el parámetro args, el valor de retorno de tipo Object |
| isVarArgs () | Para ver si el método permite un número variable de parámetros, si se permite que devolver verdadero, falso en caso contrario |
| getModifiers () | Puede ser obtenido mediante el análisis del método utiliza el modificador de número entero |
Método método ilustrativo de cómo llamar a la información de clase adquiridos en el método de la clase dinámica.
1. En primer lugar crear una clase de libro, y escribir cuatro métodos tienen diferentes alcances. Libro de la clase código final de la siguiente manera:
public class Book {
// static 作用域方法
static void staticMethod() {
System.out.println("执行staticMethod()方法");
}
// public 作用域方法
public int publicMethod(int i) {
System.out.println("执行publicMethod()方法");
return 100 + i;
}
// protected 作用域方法
protected int protectedMethod(String s, int i) throws NumberFormatException {
System.out.println("执行protectedMethod()方法");
return Integer.valueOf(s) + i;
}
// private 作用域方法
private String privateMethod(String... strings) {
System.out.println("执行privateMethod()方法");
StringBuffer sb = new StringBuffer();
for (int i = 0; i < sb.length(); i++) {
sb.append(strings[i]);
}
return sb.toString();
}
}
2) preparación de prueba clase de prueba, la clase en el método main () para el acceso de toda clase libro métodos reflexión, y si el método con el parámetro tipo de variable, un tipo de entrada de parámetro de salida y el tipo de información que puede ser arrojado a consola.
código de clase de prueba de la siguiente manera:
public class Test {
public static void main(String[] args) {
// 获取动态类Book1
Book book = new Book();
Class class1 = book.getClass();
// 获取Book1类的所有方法
Method[] declaredMethods = class1.getDeclaredMethods();
for (int i = 0; i < declaredMethods.length; i++) {
Method method = declaredMethods[i];
System.out.println("方法名称为：" + method.getName());
System.out.println("方法是否带有可变数量的参数：" + method.isVarArgs());
System.out.println("方法的参数类型依次为：");
// 获取所有参数类型
Class[] methodType = method.getParameterTypes();
for (int j = 0; j < methodType.length; j++) {
System.out.println(" " + methodType[j]);
}
// 获取返回值类型
System.out.println("方法的返回值类型为：" + method.getReturnType());
System.out.println("方法可能抛出的异常类型有：");
// 获取所有可能抛出的异常
Class[] methodExceptions = method.getExceptionTypes();
for (int j = 0; j < methodExceptions.length; j++) {
System.out.println(" " + methodExceptions[j]);
}
boolean isTurn = true;
while (isTurn) {
try { // 如果该成员变量的访问权限为private，则抛出异常
isTurn = false;
if (method.getName().equals("staticMethod")) { // 调用没有参数的方法
method.invoke(book);
} else if (method.getName().equals("publicMethod")) { // 调用一个参数的方法
System.out.println("publicMethod(10)的返回值为：" + method.invoke(book, 10));
} else if (method.getName().equals("protectedMethod")) { // 调用两个参数的方法
System.out.println("protectedMethod(\"10\",15)的返回值为：" + method.invoke(book, "10", 15));
} else if (method.getName().equals("privateMethod")) { // 调用可变数量参数的方法
Object[] parameters = new Object[] { new String[] { "J", "A", "V", "A" } };
System.out.println("privateMethod()的返回值为：" + method.invoke(book, parameters));
}
} catch (Exception e) {
System.out.println("在设置成员变量值时抛出异常，下面执行setAccessible()方法");
method.setAccessible(true); // 设置为允许访问private方法
isTurn = true;
}
}
System.out.println("=============================\n");
}
}
}
3) ejecutar la prueba de clase de prueba, seguido de un programa dinámico tendrá acceso a todos los métodos de la clase libro. Método de acceso métodoestático efecto en funcionamiento () es como sigue:
方法名称为：staticMethod
方法是否带有可变数量的参数：false
方法的参数类型依次为：
方法的返回值类型为：void
方法可能抛出的异常类型有：
执行staticMethod()方法
=============================
Método de acceso efecto corriendo publicMethod () es como sigue:
方法名称为：publicMethod
方法是否带有可变数量的参数：false
方法的参数类型依次为：
int
方法的返回值类型为：int
方法可能抛出的异常类型有：
执行publicMethod()方法
publicMethod(10)的返回值为：110
=============================
Método de acceso efecto corriendo protectedMethod () es como sigue:
方法名称为：protectedMethod
方法是否带有可变数量的参数：false
方法的参数类型依次为：
class java.lang.String
int
方法的返回值类型为：int
方法可能抛出的异常类型有：
class java.lang.NumberFormatException
执行protectedMethod()方法
protectedMethod("10",15)的返回值为：25
=============================
Método de acceso efecto corriendo privateMethod () es como sigue:
方法名称为：privateMethod
方法是否带有可变数量的参数：true
方法的参数类型依次为：
class java.lang.String;
方法的返回值类型为：class java.lang.String
方法可能抛出的异常类型有：
在设置成员变量值时抛出异常，下面执行setAccessible()方法
执行privateMethod()方法
privateMethod()的返回值为：
=============================
