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

CKTIS / Java

Réflexion sur les classes : noms, champs, constructeurs et annotations

Inspectez la classe réelle d’un objet en Java SE 21 : lisez son nom, repérez ses champs et constructeurs déclarés et distinguez les annotations directes des annotations héritées.

Version : Java SE 21

Syntaxe

static void inspect(Base value) throws NoSuchMethodException {
    Class<Item> type = Item.class;
    Class<?> runtimeType = value.getClass();
    String name = type.getName();
    Field[] fields = type.getDeclaredFields();
    java.lang.reflect.Constructor<?>[] constructors = type.getDeclaredConstructors();
    java.lang.reflect.Constructor<Item> constructor = type.getDeclaredConstructor(int.class);
    boolean audited = type.isAnnotationPresent(Audited.class);
}

Si vous connaissez le type, utilisez un littéral de classe comme Item.class. Une variable de type telle que T ne peut pas figurer dans un littéral de classe. Sur un objet, Object.getClass() donne sa classe réelle à l’exécution, indépendamment du type déclaré de la variable. Class.getName() renvoie le nom binaire d’une classe ou interface non cachée, par exemple Main$Item. Le nom d’un type caché contient / suivi d’un suffixe, celui d’un tableau est encodé, par exemple [I, et celui d’un type primitif ou de void correspond au mot-clé.

Class.getDeclaredFields() renvoie un Field[] contenant les champs déclarés dans cette classe ou interface, quel que soit leur niveau d’accès, sans les champs hérités. getFields() ne renvoie que les champs publics, y compris ceux qui sont hérités. L’ordre n’est garanti dans aucun des deux tableaux.

Class.getDeclaredConstructors() renvoie un Constructor<?>[] contenant tous les constructeurs de la classe, y compris les constructeurs privés ou déclarés implicitement, sans ordre garanti. Les constructeurs ne s’héritent pas. getConstructors() ne renvoie que les constructeurs publics. Les deux méthodes renvoient un tableau vide pour une interface, un type tableau, un type primitif ou void.

Class.getDeclaredConstructor(...) renvoie un seul Constructor<T>. Indiquez les types exacts des paramètres formels, dans l’ordre de déclaration : int.class n’est pas Integer.class, et l’absence d’arguments cible un constructeur sans paramètre. Pour une classe interne déclarée dans un contexte non statique, indiquez d’abord le type de l’instance englobante. Sans correspondance, la méthode lève NoSuchMethodException. Trouver un membre n’autorise pas à lire ou écrire un champ ni à appeler un constructeur ; les frontières des modules peuvent empêcher la désactivation des contrôles d’accès.

Class.isAnnotationPresent(A.class) vérifie que l’annotation de déclaration A est visible à l’exécution (RetentionPolicy.RUNTIME) et présente directement ou, avec @Inherited, via la chaîne des superclasses, pas via les interfaces. Pour tester uniquement la présence directe, utilisez getDeclaredAnnotation(A.class) != null. Pour lire les annotations répétables stockées dans un conteneur, utilisez getAnnotationsByType(A.class).

Exemples

import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Arrays;

public class Main {
    @Inherited
    @Retention(RetentionPolicy.RUNTIME)
    @interface Audited {}

    @Audited
    static class Base {
        public int inheritedId;
    }

    static final class Item extends Base {
        private final int size;
        public String label = "item";

        public Item() { this(0); }
        private Item(int size) { this.size = size; }
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Base value = new Item();
        Class<?> type = value.getClass();
        System.out.println("type: " + type.getName());
        System.out.println("fields: " + Arrays.stream(type.getDeclaredFields())
                .map(Field::getName).sorted().toList());
        System.out.println("constructors: " + type.getDeclaredConstructors().length);
        var constructor = type.getDeclaredConstructor(int.class);
        System.out.println("int constructor is private: " + Modifier.isPrivate(constructor.getModifiers()));
        System.out.println("annotation present: " + type.isAnnotationPresent(Audited.class));
        System.out.println("annotation declared: " + (type.getDeclaredAnnotation(Audited.class) != null));
    }
}

Résultat

type: Main$Item
fields: [label, size]
constructors: 2
int constructor is private: true
annotation present: true
annotation declared: false

La variable est déclarée de type `Base`, mais l’objet est un `Item`. La liste triée contient le champ privé `size`, mais pas le champ hérité `inheritedId`. Le programme trouve le constructeur privé qui prend un `int` sans l’appeler. `Audited` provient de `Base` et n’est pas déclarée directement sur `Item`.

Leçons associées

  • Java · Leçon 59 · Avancé · Version : 2

Sources