CKTIS / Java
Constructor — inspeccionar e invocar constructores mediante reflexión
java.lang.reflect.Constructor<T> describe un constructor de la clase T. Permite consultar los tipos de los parámetros y las anotaciones, y crear objetos, respetando los controles de acceso y los límites entre módulos de Java SE 21.
Versión: Java SE 21; repository runtime, production runtime not attested
Sintaxis
Constructor<T> ctor = type.getDeclaredConstructor(parameterTypes);
Class<?>[] types = ctor.getParameterTypes();
boolean annotated = ctor.isAnnotationPresent(annotationType);
ctor.setAccessible(true);
T instance = ctor.newInstance(arguments);java.lang.reflect.Constructor<T> representa un constructor de la clase T, no un objeto construido. Class.getConstructor(...) busca un constructor público, mientras que Class.getDeclaredConstructor(...) también encuentra constructores no públicos declarados en esa clase. La búsqueda exige los tipos exactos de los parámetros: int.class y Integer.class no son intercambiables. Encontrar un constructor no concede por sí solo permiso para invocarlo.
Constructor.getParameterTypes() devuelve una matriz Class<?>[] en el orden de declaración; está vacía si el constructor no tiene parámetros. Puede incluir parámetros implícitos, como la instancia contenedora de una clase interna no estática. El método heredado Constructor.isAnnotationPresent(...) comprueba una anotación del constructor, no de sus parámetros. Para que una anotación esté disponible mediante reflexión, debe tener RetentionPolicy.RUNTIME.
Constructor.setAccessible(true) solicita suprimir los controles de acceso del lenguaje Java; no cambia la declaración del constructor. No permite saltarse arbitrariamente los límites entre módulos: para acceder a un constructor privado de otro módulo, su paquete debe estar abierto al módulo que realiza la llamada. La denegación puede producir InaccessibleObjectException o SecurityException. setAccessible(false) restablece los controles, mientras que trySetAccessible() puede devolver false si no es posible habilitar el acceso. Es preferible usar API públicas accesibles en vez de depender de constructores privados de bibliotecas.
Constructor.newInstance(...) crea e inicializa un objeto. Admite el desempaquetado de argumentos y las conversiones de ampliación permitidas, pero no las de estrechamiento. Los argumentos no válidos provocan IllegalArgumentException, la falta de acceso provoca IllegalAccessException y las clases abstractas provocan InstantiationException. Una excepción lanzada por el constructor queda envuelta en InvocationTargetException; consulta su causa con getCause().
El ejemplo usa la clase independiente de nivel superior Item, por lo que Main no tiene acceso especial por pertenecer al mismo nido a su constructor privado. En el class path, setAccessible(true) permite invocarlo. Esta entrada se refiere a Java SE 21; el entorno de producción no ha sido certificado.
Ejemplos
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.util.Arrays;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CONSTRUCTOR)
@interface Selected {}
final class Item {
final String name;
@Selected
private Item(String name) {
this.name = name;
}
}
public class Main {
public static void main(String[] args) throws ReflectiveOperationException {
Constructor<Item> ctor = Item.class.getDeclaredConstructor(String.class);
System.out.println(Arrays.toString(ctor.getParameterTypes()));
System.out.println(ctor.isAnnotationPresent(Selected.class));
ctor.setAccessible(true);
Item item = ctor.newInstance("Ada");
System.out.println(item.name);
}
}Resultado
[class java.lang.String] true Ada
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.