Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Crear objetos por reflexión con Constructor.newInstance

Invoca un constructor concreto en Java SE 21 y distingue los fallos de búsqueda o de invocación de las excepciones que lanza el propio constructor.

Versión: Java SE 21

Sintaxis

public T newInstance(Object... initargs)
    throws InstantiationException, IllegalAccessException,
           IllegalArgumentException, InvocationTargetException

Constructor.newInstance, de java.lang.reflect, invoca el constructor representado por un objeto Constructor<T> y devuelve una instancia nueva de tipo T. Primero selecciona el constructor por los tipos exactos de sus parámetros formales, en el orden de declaración. getConstructor(...) solo busca constructores públicos; getDeclaredConstructor(...) también encuentra los no públicos, pero encontrarlos no concede permiso para invocarlos. Si no hay coincidencia, la búsqueda lanza NoSuchMethodException.

Al invocar, pasa valores, no objetos Class que describan sus tipos. No se vuelve a seleccionar una sobrecarga. La reflexión permite desempaquetar valores y realizar conversiones primitivas de ampliación, pero no de estrechamiento. Para un constructor sin parámetros, llama a ctor.newInstance(). Si el parámetro es un array, incluso si es un parámetro varargs del constructor, pasa un array ya preparado como un solo argumento; convertir un array de referencias a (Object) impide que se use como lista completa de argumentos de newInstance. Para una clase miembro no estática, el primer argumento es la instancia envolvente.

Si se aplican los controles de acceso, un constructor inaccesible provoca IllegalAccessException. trySetAccessible() puede devolver false si las reglas de los módulos impiden desactivar esos controles. Un número incorrecto de argumentos, un argumento incompatible o el intento de instanciar un tipo enum provoca IllegalArgumentException; una clase abstracta provoca InstantiationException. Si la invocación desencadena una inicialización de clase que falla, puede producirse ExceptionInInitializerError.

Si el propio constructor lanza una excepción, la reflexión la envuelve en la excepción comprobada InvocationTargetException; usa getCause() para consultar la causa original. Así distingues una excepción interna del constructor de una llamada rechazada por la reflexión. El método obsoleto Class.newInstance() solo puede invocar un constructor sin parámetros y propaga su excepción sin envolverla.

Ejemplos

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ConstructorDemo {
    public static void main(String[] args) throws ReflectiveOperationException {
        Constructor<StringBuilder> fromText =
                StringBuilder.class.getConstructor(String.class);
        StringBuilder builder = fromText.newInstance("Java");
        System.out.println(builder.append(" 21"));

        Constructor<StringBuilder> fromCapacity =
                StringBuilder.class.getConstructor(int.class);
        try {
            fromCapacity.newInstance(-1);
            throw new AssertionError("Expected a negative capacity to fail");
        } catch (InvocationTargetException e) {
            System.out.println(e.getCause().getClass().getSimpleName());
        }
    }
}

Resultado

Java 21
NegativeArraySizeException

`StringBuilder(String)` crea un objeto al que el programa añade `" 21"`. Después, `StringBuilder(int)` rechaza la capacidad `-1`: el bloque `catch` captura `InvocationTargetException` e imprime el nombre del tipo de la causa original. Los demás fallos comprobados de reflexión se propagan.

Lecciones relacionadas

  • Java · Lección 13 · Avanzado · Versión: 2

Fuentes