Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Field — accesso riflessivo ai campi in Java

java.lang.reflect.Field descrive un campo e consente di accedere al suo valore durante l’esecuzione. Permette di esaminare metadati e annotazioni e di modificare valori, nel rispetto delle restrizioni di accesso e del sistema dei moduli.

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

Sintassi

Field f = Type.class.getDeclaredField("name");
f.getName(); f.getType();
f.setAccessible(true);
f.set(target, value); Object valueRead = f.get(target);
f.setInt(target, 42); int intRead = f.getInt(target);
f.getAnnotation(Mark.class); f.isAnnotationPresent(Mark.class);

java.lang.reflect.Field rappresenta un campo di istanza o statico. Class.getDeclaredField cerca un campo dichiarato in quella classe, compresi quelli privati ma non quelli ereditati. Class.getField cerca i campi pubblici, inclusi quelli ereditati. Se il campo non esiste, viene generata NoSuchFieldException; trovarlo non concede l’accesso.

Field.getName() restituisce il nome; Field.getType() restituisce il tipo dichiarato come Class<?>. Field.get(target) esegue il boxing dei risultati primitivi; Field.set(target, value) esegue l’unboxing dei valori per i campi primitivi. Field.getInt(target) legge int o un tipo ampliabile a int; Field.setInt(target, value) scrive un int, con ampliamento se necessario. Conversioni o oggetti riceventi non validi causano IllegalArgumentException. Per i campi di istanza, target == null causa NullPointerException; i campi statici ignorano il ricevente.

Field.setAccessible(true) richiede la disattivazione dei controlli di accesso del linguaggio, ma non supera i confini dei moduli: l’accesso privato tra moduli richiede che il package sia aperto al modulo chiamante. Il rifiuto può causare InaccessibleObjectException o SecurityException; letture o scritture non consentite causano IllegalAccessException. Non considerare questo metodo un’autorizzazione generale a modificare i campi final.

Field.getAnnotation(Mark.class) restituisce un’annotazione della dichiarazione oppure null; il metodo ereditato Field.isAnnotationPresent(Mark.class) ne segnala la presenza con un valore booleano. Per essere leggibile tramite reflection, un’annotazione deve avere RetentionPolicy.RUNTIME. L’esempio usa un campo privato e modificabile e un’annotazione esplicitamente mantenuta a runtime.

Esempi

import java.lang.annotation.*;
import java.lang.reflect.Field;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Mark {}

class Counter {
    @Mark
    private int count = 1;
}

public class Main {
    public static void main(String[] args) throws ReflectiveOperationException {
        Counter target = new Counter();
        Field f = Counter.class.getDeclaredField("count");
        System.out.println(f.getName() + ":" + f.getType().getName());
        f.setAccessible(true);
        f.set(target, 7);
        System.out.println(f.get(target));
        f.setInt(target, 9);
        System.out.println(f.getInt(target));
        System.out.println(f.isAnnotationPresent(Mark.class));
        System.out.println(f.getAnnotation(Mark.class) != null);
    }
}

Risultato

count:int
7
9
true
true

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