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.