Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Constructor — examiner et appeler des constructeurs par réflexion

java.lang.reflect.Constructor<T> décrit un constructeur de la classe T. Il permet de consulter les types de paramètres et les annotations, ainsi que de créer des objets, dans le respect des contrôles d’accès et des limites entre modules de Java SE 21.

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

Syntaxe

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> représente un constructeur de la classe T, et non un objet construit. Class.getConstructor(...) recherche un constructeur public, tandis que Class.getDeclaredConstructor(...) trouve aussi les constructeurs non publics déclarés par cette classe. La recherche exige les types de paramètres exacts : int.class et Integer.class ne sont pas interchangeables. Trouver un constructeur ne donne pas à lui seul le droit de l’appeler.

Constructor.getParameterTypes() renvoie un tableau Class<?>[] dans l’ordre de déclaration ; il est vide si le constructeur n’a aucun paramètre. Il peut inclure des paramètres implicites, par exemple l’instance englobante d’une classe interne non statique. La méthode héritée Constructor.isAnnotationPresent(...) vérifie une annotation du constructeur, et non de ses paramètres. Une annotation doit avoir RetentionPolicy.RUNTIME pour être accessible par réflexion.

Constructor.setAccessible(true) demande la suppression des contrôles d’accès du langage Java ; cela ne modifie pas la déclaration du constructeur. Cette méthode ne permet pas de franchir arbitrairement les limites des modules : pour accéder à un constructeur privé d’un autre module, son package doit être ouvert au module appelant. Un refus peut produire InaccessibleObjectException ou SecurityException. setAccessible(false) rétablit les contrôles, tandis que trySetAccessible() peut renvoyer false si l’accès ne peut être activé. Préférez les API publiques accessibles aux constructeurs privés de bibliothèques.

Constructor.newInstance(...) crée et initialise un objet. La méthode accepte le déballage des arguments et les conversions d’élargissement autorisées, mais pas les conversions réductrices. Des arguments incorrects provoquent IllegalArgumentException, un constructeur inaccessible provoque IllegalAccessException et une classe abstraite provoque InstantiationException. Une exception levée par le constructeur est enveloppée dans InvocationTargetException ; consultez-la avec getCause().

L’exemple utilise une classe de premier niveau distincte, Item ; Main ne bénéficie donc d’aucun accès spécial de membre du même nid à son constructeur privé. Sur le classpath, setAccessible(true) permet l’appel. Cette notice concerne Java SE 21 ; l’environnement de production n’a pas été attesté.

Exemples

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

Résultat

[class java.lang.String]
true
Ada

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources