Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Constructor — esaminare e invocare i costruttori tramite reflection

java.lang.reflect.Constructor<T> descrive un costruttore della classe T. Consente di consultare i tipi dei parametri e le annotazioni e di creare oggetti, nel rispetto dei controlli di accesso e dei confini tra moduli di Java SE 21.

Versione: Java SE 21; repository runtime, production runtime not attested

Sintassi

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> rappresenta un costruttore della classe T, non un oggetto costruito. Class.getConstructor(...) cerca un costruttore pubblico, mentre Class.getDeclaredConstructor(...) trova anche i costruttori non pubblici dichiarati in quella classe. La ricerca richiede tipi dei parametri esatti: int.class e Integer.class non sono intercambiabili. Trovare un costruttore non dà, di per sé, il permesso di invocarlo.

Constructor.getParameterTypes() restituisce un array Class<?>[] nell’ordine di dichiarazione; è vuoto se il costruttore non ha parametri. Può includere parametri impliciti, come l’istanza contenitore di una classe interna non statica. Il metodo ereditato Constructor.isAnnotationPresent(...) controlla un’annotazione del costruttore, non dei suoi parametri. Per essere disponibile tramite reflection, un’annotazione deve avere RetentionPolicy.RUNTIME.

Constructor.setAccessible(true) richiede di sopprimere i controlli di accesso del linguaggio Java; non modifica la dichiarazione del costruttore. Non consente di aggirare arbitrariamente i confini tra moduli: per accedere a un costruttore privato in un altro modulo, il relativo package deve essere aperto al modulo chiamante. Il rifiuto può causare InaccessibleObjectException o SecurityException. setAccessible(false) ripristina i controlli, mentre trySetAccessible() può restituire false se non è possibile abilitare l’accesso. Preferisci API pubbliche accessibili ai costruttori privati delle librerie.

Constructor.newInstance(...) crea e inizializza un oggetto. Supporta l’unboxing degli argomenti e le conversioni di ampliamento consentite, ma non quelle di restringimento. Argomenti non validi causano IllegalArgumentException, l’assenza di accesso causa IllegalAccessException e le classi astratte causano InstantiationException. Un’eccezione generata dal costruttore è racchiusa in InvocationTargetException; esaminala con getCause().

L’esempio usa una classe di primo livello separata, Item, quindi Main non ha accesso speciale da membro dello stesso nest al suo costruttore privato. Nel class path, setAccessible(true) ne consente l’invocazione. Questa voce riguarda Java SE 21; l’ambiente di produzione non è stato attestato.

Esempi

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);
    }
}

Risultato

[class java.lang.String]
true
Ada

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti