😄
Junkai’s Blogs
AboutDonate

Reflection

Tags
Published
Author

La riflessione

💡
La riflessione in Java (Reflection) è una potente API che consente di ispezionare e manipolare le classi, i metodi e gli oggetti a runtime.
Utilizzando la riflessione, è possibile ottenere informazioni su classi e metodi, invocare metodi dinamicamente, creare oggetti, accedere a campi privati e molto altro.
In Java, la riflessione è implementata principalmente attraverso le classi nel pacchetto java.lang.reflect, che fornisce strumenti per:
  • Recuperare informazioni su classi e metodi.
  • Creare istanze di oggetti.
  • Invocare metodi a runtime.
  • Accedere e modificare i campi di una classe.
La riflessione è particolarmente utile in situazioni in cui il comportamento del programma non può essere determinato a tempo di compilazione, ma deve essere risolto a runtime.

Le principali classi di riflessione

Alcune delle classi chiave della riflessione in Java sono:
  • Class: fornisce informazioni su una classe o un'interfaccia.
  • Method: permette di invocare metodi su oggetti o classi.
  • Field: consente di accedere ai campi di una classe, anche se privati.
  • Constructor: permette di creare oggetti dinamicamente.

Come utilizzare la riflessione in Java

1. Ottenere informazioni sulla classe

Il primo passo per lavorare con la riflessione in Java è ottenere un oggetto Class che rappresenta la classe che vogliamo ispezionare. Questo può essere fatto utilizzando il metodo getClass() o il metodo Class.forName().
Esempio:
public class EsempioRiflessione {
    private String nome;

    public EsempioRiflessione(String nome) {
        this.nome = nome;
    }

    public void saluta() {
        System.out.println("Ciao, " + nome);
    }

    public static void main(String[] args) throws ClassNotFoundException {
        // Creazione di un'istanza della classe
        EsempioRiflessione esempio = new EsempioRiflessione("Mario");

        // Ottieni l'oggetto Class
        Class<?> clazz = esempio.getClass();

        // Stampa il nome della classe
        System.out.println("Nome della classe: " + clazz.getName());

        // Recupera i metodi pubblici della classe
        System.out.println("Metodi della classe:");
        for (Method metodo : clazz.getDeclaredMethods()) {
            System.out.println(metodo.getName());
        }
    }
}
Output:
Nome della classe: EsempioRiflessione
Metodi della classe:
saluta
In questo esempio, viene creata una classe EsempioRiflessione con un metodo saluta(). Utilizzando la riflessione, otteniamo l'oggetto Class associato all'istanza esempio, e successivamente recuperiamo il nome della classe e i metodi dichiarati.

2. Creare un oggetto tramite riflessione

La riflessione consente anche di creare oggetti dinamicamente, senza conoscere la classe a tempo di compilazione. Questo viene fatto utilizzando il costruttore della classe tramite l'oggetto Constructor.
Esempio:
import java.lang.reflect.Constructor;

public class CreazioneOggettoRiflessione {
    private String nome;

    public CreazioneOggettoRiflessione(String nome) {
        this.nome = nome;
    }

    public void saluta() {
        System.out.println("Ciao, " + nome);
    }

    public static void main(String[] args) throws Exception {
        // Ottieni l'oggetto Class per la classe CreazioneOggettoRiflessione
        Class<?> clazz = Class.forName("CreazioneOggettoRiflessione");

        // Ottieni il costruttore della classe che accetta una Stringa
        Constructor<?> costruttore = clazz.getConstructor(String.class);

        // Crea un'istanza della classe utilizzando il costruttore
        Object oggetto = costruttore.newInstance("Giovanni");

        // Invoca il metodo saluta() sull'oggetto creato
        Method metodo = clazz.getMethod("saluta");
        metodo.invoke(oggetto);
    }
}
Output:
Ciao, Giovanni
In questo esempio, utilizziamo la riflessione per ottenere il costruttore della classe CreazioneOggettoRiflessione che accetta un parametro di tipo String. Poi creiamo dinamicamente un oggetto di questa classe e invochiamo il metodo saluta().

3. Accedere ai campi tramite riflessione

Uno degli usi più potenti della riflessione è l'accesso ai campi privati di una classe. La riflessione consente di aggirare i modificatori di accesso e di manipolare variabili private.
Esempio:
import java.lang.reflect.Field;

public class AccessoCampiPrivati {
    private String messaggio = "Messaggio Privato";

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        // Crea un'istanza della classe
        AccessoCampiPrivati esempio = new AccessoCampiPrivati();

        // Ottieni l'oggetto Class
        Class<?> clazz = esempio.getClass();

        // Ottieni il campo privato 'messaggio'
        Field campo = clazz.getDeclaredField("messaggio");

        // Impostare il campo come accessibile (anche se è privato)
        campo.setAccessible(true);

        // Modifica il valore del campo
        campo.set(esempio, "Nuovo Messaggio");

        // Stampa il nuovo valore del campo
        System.out.println("Messaggio modificato: " + esempio.messaggio);
    }
}
Output:
Messaggio modificato: Nuovo Messaggio
In questo esempio, accediamo al campo privato messaggio e lo modifichiamo utilizzando la riflessione. Grazie al metodo setAccessible(true), possiamo accedere anche ai campi privati.

Considerazioni sulle prestazioni

Anche se la riflessione è potente, va usata con cautela in quanto può avere un impatto negativo sulle prestazioni. L'accesso ai campi e ai metodi tramite riflessione è generalmente più lento rispetto a un normale accesso diretto. Per questo motivo, è importante evitare un uso eccessivo della riflessione in contesti che richiedono alte prestazioni, come in applicazioni di calcolo intensivo.

Back to →
🐚
Java