Con el fin de obtener dinámico constructor de objetos de información, crear primero un tipo de objeto o matriz Constructor por uno de los métodos siguientes.
getConstructors()
getConstructor(Class<?>…parameterTypes)
getDeclaredConstructors()
getDeclaredConstructor(Class<?>...parameterTypes)
Si la estructura de acceso se especifica método, se necesita acceder de acuerdo con el tipo de los parámetros de la entrada del constructor. Por ejemplo, una entrada de parámetro de tipo de acceso eran int y tipo String de método de construcción, los dos métodos siguientes pueden ser implementados.
objectClass.getDeclaredConstructor(int.class,String.class);
objectClass.getDeclaredConstructor(new Class[]{int.class,String.class});
Cada objeto constructor Constructor crea una representación, a continuación, utilizar el método de operación Constructor objeto constructor.
método común de clase constructor
| nombre del método | explicación |
|---|---|
| isVarArgs () | Compruebe si permite que el método de construcción con un número variable de parámetros, si se le permite, devuelve true, false en caso contrario |
| getParameterTypes () | La obtención de los parámetros individuales del constructor en orden de la declaración en la forma de una clase de tipo de matriz |
| getExceptionTypes () | Obtener el tipo de excepción constructor puede lanzar en forma de una serie de Clase |
| newInstance (Objeto ... initargs) | Esto crea un objeto de tipo utilizando los parámetros especificados por el fabricante, si el parámetro no está establecido, indica el constructor por defecto sin argumentos |
| setAccessiable (bandera booleana) | Si el permiso del constructor es privado, el defecto no se permite crear un objeto mediante la reflexión método netlnstance () de. Si el método se lleva a cabo primero, y la entrada del parámetro establecido en true, se permite que el objeto para crear |
| getModifiers () | Esta configuración se puede obtener por el método de análisis sintáctico utilizando modificador de número entero |
Modificadores pueden analizar los getMocMers valores de retorno () de la clase representada por la java.lang.reflect.Modifier. Proporciona una serie de métodos estáticos utilizados para resolver en la clase y se puede ver modificador si se ha especificado una modificación, también se puede obtener todas las cadenas de modificadores.
Los métodos comunes de la clase de modificadores
| Nombre del método estático | explicación |
|---|---|
| isStatic (int mod) | Vueltas Si se está utilizando una estática modificado modificador verdadero, falso en caso contrario |
| IsPublic (int mod) | Devoluciones Si está utilizando modificador público modificadas verdadero, falso en caso contrario |
| isProtected (int mod) | Vueltas Si se utiliza el modificador protected modificados verdadero, falso en caso contrario |
| IsPrivate (int mod) | Vueltas Si está utilizando el modificador privada modificados verdadero, falso en caso contrario |
| isFinal (modo int) | Vueltas Si está utilizando el modificador última modificación verdadero, falso en caso contrario |
| toString (int mod) | Devuelve una cadena de todos modificador |
El código siguiente determina la con objeto constructor está representado por el público si se modifica, la construcción y el método de obtención de una cadena de todos los modificadores.
int modifiers = con.getModifiers(); // 获取构造方法的修饰符整数
boolean isPublic = Modifier.isPublic(modifiers); // 判断修饰符整数是否为public
string allModifiers = Modifier.toString(modifiers);
ejemplo de la clase constructor de cómo llamar a un método para obtener información sobre los métodos de construcción.
1. En primer lugar crear una clase libro representa una información del libro. En esta clase declara una variable cadena representa el nombre del libro, dos variables int representan el número de libros y los precios, y proporciona tres constructores.
Libro de la clase código final de la siguiente manera:
public class Book {
String name; // 图书名称
int id, price; // 图书编号和价格
// 空的构造方法
private Book() {
}
// 带两个参数的构造方法
protected Book(String _name, int _id) {
this.name = _name;
this.id = _id;
}
// 带可变参数的构造方法
public Book(String... strings) throws NumberFormatException {
if (0 < strings.length)
id = Integer.valueOf(strings[0]);
if (1 < strings.length)
price = Integer.valueOf(strings[1]);
}
// 输出图书信息
public void print() {
System.out.println("name=" + name);
System.out.println("id=" + id);
System.out.println("price=" + price);
}
}
2. Escribir la clase de prueba prueba, la clase en el método main () para el acceso de todos los constructores de clase reflectantes libro, y la información de tipo de excepción si el método de construcción con un tipo de variable de parámetros, tipos de parámetros, y la entrada puede ser lanzado salida en la consola.
código de clase de prueba de la siguiente manera:
public class Test {
public static void main(String[] args) {
// 获取动态类Book
Class book = Book.class;
// 获取Book类的所有构造方法
Constructor[] declaredContructors = book.getDeclaredConstructors();
// 遍历所有构造方法
for (int i = 0; i < declaredContructors.length; i++) {
Constructor con = declaredContructors[i];
// 判断构造方法的参数是否可变
System.out.println("查看是否允许带可变数量的参数：" + con.isVarArgs());
System.out.println("该构造方法的入口参数类型依次为：");
// 获取所有参数类型
Class[] parameterTypes = con.getParameterTypes();
for (int j = 0; j < parameterTypes.length; j++) {
System.out.println(" " + parameterTypes[j]);
}
System.out.println("该构造方法可能拋出的异常类型为：");
// 获取所有可能拋出的异常类型
Class[] exceptionTypes = con.getExceptionTypes();
for (int j = 0; j < exceptionTypes.length; j++) {
System.out.println(" " + parameterTypes[j]);
}
// 创建一个未实例化的Book类实例
Book book1 = null;
while (book1 == null) {
try { // 如果该成员变量的访问权限为private，则拋出异常
if (i == 1) {
// 通过执行带两个参数的构造方法实例化book1
book1 = (Book) con.newInstance("Java 教程", 10);
} else if (i == 2) {
// 通过执行默认构造方法实例化book1
book1 = (Book) con.newInstance();
} else {
// 通过执行可变数量参数的构造方法实例化book1
Object[] parameters = new Object[] { new String[] { "100", "200" } };
book1 = (Book) con.newInstance(parameters);
}
} catch (Exception e) {
System.out.println("在创建对象时拋出异常，下面执行 setAccessible() 方法");
con.setAccessible(true); // 设置允许访问 private 成员
}
}
book1.print();
System.out.println("=============================\n");
}
}
}
3. Ejecutar la clase test, el constructor por defecto cuando la reflexión de acceso a la agenda (), consulte la salida se muestra a continuación.
查看是否允许带可变数量的参数：false
该构造方法的入口参数类型依次为：
该构造方法可能抛出的异常类型为：
在创建对象时抛出异常，下面执行setAccessible()方法
name = null
id = 0
price = 0
=============================
Cuando reflejada por el constructor libro dos parámetros de acceso (string_name, int_id), se ve el resultado que se muestra a continuación.
查看是否允许带可变数量的参数：false
该构造方法的入口参数类型依次为：
class java.lang.String
int
该构造方法可能抛出的异常类型为：
在创建对象时抛出异常，下面执行setAccessible()方法
name = null
id = 0
price = 0
=============================
Cuando el número de parámetros variables constructor libro (String ... cuerdas) se accede por la reflexión, podrás ver el resultado que se muestra a continuación.
查看是否允许带可变数量的参数：true
该构造方法的入口参数类型依次为：
class java.lang.String;
该构造方法可能抛出的异常类型为：
class java.lang.String;
在创建对象时抛出异常，下面执行setAccessible()方法
name = null
id = 0
price = 0
=============================
