CKTIS / Java
Reflexión en Java: nombres de tipos, miembros declarados y constructores
Consulta el nombre de un tipo, busca los campos y métodos que declara directamente y crea un objeto con un constructor elegido, sin confundir la búsqueda con el acceso.
Versión: Java SE 21
Sintaxis
String Class.getName()
String Class.getSimpleName()
Field[] Class.getDeclaredFields()
Field Class.getDeclaredField(String name) throws NoSuchFieldException
Method[] Class.getDeclaredMethods()
Method Class.getDeclaredMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException
Constructor<T> Class<T>.getDeclaredConstructor(Class<?>... parameterTypes) throws NoSuchMethodException
T Constructor<T>.newInstance(Object... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetExceptionEn Java SE 21, Class.getName() devuelve el nombre binario de una clase o interfaz no oculta, como demo.Main$Item. Un tipo oculto tiene un nombre especial con un sufijo tras /; un array usa una codificación como [I; un primitivo y void conservan la grafía de su palabra clave. Class.getSimpleName() devuelve el nombre simple del código fuente, como Item, una cadena vacía para clases anónimas y, para un array, el nombre simple del componente seguido de [].
getDeclaredFields() y getDeclaredMethods() devuelven un Field[] y un Method[], respectivamente. Incluyen los miembros declarados directamente en el tipo con cualquier visibilidad, incluso private, pero excluyen los heredados. getFields() y getMethods() se limitan a miembros públicos y pueden incluir los heredados. No se garantiza el orden; la lista de métodos puede incluir métodos puente u otros métodos sintéticos.
getDeclaredField(name) busca un campo por nombre y lanza NoSuchFieldException si no existe. getDeclaredMethod(name, parameterTypes...) busca por nombre y tipos formales exactos en orden de declaración. getDeclaredConstructor(parameterTypes...) coteja los parámetros del mismo modo y devuelve un Constructor<T>, aunque no sea público. Si falta el método o el constructor, lanza NoSuchMethodException. La búsqueda no aplica boxing ni admite subtipos como coincidencias: int.class e Integer.class son distintos. Para String..., indica String[].class; para una firma sin parámetros, no indiques tipos. El tipo de retorno no se pasa a la búsqueda: si coinciden varios métodos, se elige el que tenga un tipo de retorno más específico que todos los demás, si existe; en caso contrario, la elección es arbitraria.
Encontrar un miembro no concede permiso para usarlo. Para omitir las comprobaciones de acceso a un miembro privado de otro módulo, su paquete debe estar abierto al módulo que llama. Si las restricciones impiden omitirlas, trySetAccessible() devuelve false, mientras que setAccessible(true) lanza InaccessibleObjectException. En Java SE 21, ambos métodos pueden lanzar SecurityException si un gestor de seguridad instalado deniega el permiso ReflectPermission("suppressAccessChecks").
Al buscar un constructor, los objetos Class indican los tipos de los parámetros. Para invocar el constructor seleccionado, Constructor.newInstance recibe los valores reales de los argumentos, que pueden incluir un objeto Class si es compatible con el tipo del parámetro correspondiente. Admite conversiones como unboxing y las ampliaciones permitidas. En una clase miembro no estática, pasa primero el tipo de la clase envolvente al buscar y su instancia al invocar. Si las comprobaciones se superan, la clase se inicializa si hace falta antes de crear el objeto. El acceso denegado causa IllegalAccessException; una cantidad incorrecta de argumentos, los tipos incompatibles o un constructor de enum causan IllegalArgumentException; una clase abstracta causa InstantiationException. Una excepción del constructor se envuelve en InvocationTargetException; consulta getCause(). La inicialización de la clase puede fallar por separado con ExceptionInInitializerError. No lo confundas con Class.newInstance(), que solo llama a un constructor sin argumentos y está obsoleto desde Java 9.
Ejemplos
package demo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.Arrays;
public class Main {
static class Base {
public int inherited;
public void reset() {}
}
static final class Item extends Base {
private final int count;
private Item(int count) {
this.count = count;
}
private String label(int offset) { return "count=" + (count + offset); }
public String label(String prefix) { return prefix + count; }
}
public static void main(String[] args) throws ReflectiveOperationException {
Class<Item> type = Item.class;
System.out.println(type.getName());
System.out.println(type.getSimpleName());
System.out.println(Arrays.stream(type.getDeclaredFields())
.map(Field::getName).sorted().toList());
System.out.println(Arrays.stream(type.getDeclaredMethods())
.map(m -> m.getName() + "(" + m.getParameterTypes()[0].getSimpleName() + ")")
.sorted().toList());
System.out.println(type.getDeclaredField("count").getType().getName());
var method = type.getDeclaredMethod("label", int.class);
Constructor<Item> constructor = type.getDeclaredConstructor(int.class);
Item item = constructor.newInstance(7);
System.out.println(method.invoke(item, 0));
}
}Resultado
demo.Main$Item Item [count] [label(String), label(int)] int count=7
Las listas se ordenan antes de mostrarse. `inherited` y `reset` proceden de `Base`, por lo que no figuran en las listas de `Item`. `int.class` selecciona `label(int)` y `7` se pasa al constructor. `Main` e `Item` pertenecen al mismo nido de clases, así que no hace falta omitir las comprobaciones de acceso al constructor ni al método privados.
Lecciones relacionadas
- Java · Lección 54 · Avanzado · Versión: 2