Se ti stai preparando per un colloquio di lavoro sul linguaggio di programmazione Java, sei arrivato nel posto giusto. In questo articolo ti spiegherò, infatti, che cos’è la Reflection in Java con relativi esempi!
Una delle domande immancabili durante un colloquio tecnico sul linguaggio #Java è sicuramente quella relativa alla Reflection. Ma che cos’è la Reflection? Di cosa si tratta?
Che cos’è la Reflection in JAVA?
In Java, la reflection è una feature che permette ad un programma di ispezionare, analizzare e modificare il comportamento di classi, metodi, campi e costruttori a runtime. Essenzialmente, la reflection consente di ottenere informazioni sulle strutture del codice Java e di manipolarle dinamicamente.
In passato, sempre su questo blog, ti avevo parlato di come operare sugli attributi di una classe tramite reflection. In questo nuovo articolo ti mostrerò degli esempi ancora più dettagliati sulle potenzialità della reflection java.
Ecco alcuni esempi di come utilizzare la #reflection in Java:
Esempio 1 – Ottenere informazioni sulla classe:
Class<MyClass> myClass = MyClass.class;
// Ottenere il nome della classe
String className = myClass.getName();
System.out.println("Nome della classe: " + className);
// Ottenere i modficatori di accesso della classe
int modifiers = myClass.getModifiers();
System.out.println("Modificatori di accesso: " + Modifier.toString(modifiers));
// Ottenere i campi della classe
Field[] fields = myClass.getDeclaredFields();
for (Field field : fields) {
System.out.println("Campo: " + field.getName());
}
// Ottenere i metodi della classe
Method[] methods = myClass.getDeclaredMethods();
for (Method method : methods) {
System.out.println("Metodo: " + method.getName());
}
Esempio 2 – Creare un’istanza di classe:
Class<MyClass> myClass = MyClass.class;
// Creare un'istanza di classe utilizzando il costruttore senza argomenti
MyClass instance = myClass.newInstance();
// Creare un'istanza di classe utilizzando un costruttore con argomenti
Constructor<MyClass> constructor = myClass.getConstructor(String.class, int.class);
MyClass instance = constructor.newInstance("valore", 10);
Esempio 3 – Invocare un metodo dinamicamente:
Class<MyClass> myClass = MyClass.class;
MyClass instance = myClass.newInstance();
// Invocare un metodo senza argomenti
Method myMethod = myClass.getDeclaredMethod("methodName");
myMethod.invoke(instance);
// Invocare un metodo con argomenti
Method myMethod = myClass.getDeclaredMethod("methodName", String.class, int.class);
myMethod.invoke(instance, "valore", 10);
Esempio 4 – Ottenere e impostare il valore di un campo dinamicamente:
Class<MyClass> myClass = MyClass.class;
MyClass instance = myClass.newInstance();
// Ottenere il valore di un campo
Field myField = myClass.getDeclaredField("fieldName");
myField.setAccessible(true); // Impostare l'accessibilità del campo
Object value = myField.get(instance);
System.out.println("Valore del campo: " + value);
// Impostare il valore di un campo
Field myField = myClass.getDeclaredField("fieldName");
myField.setAccessible(true); // Impostare l'accessibilità del campo
myField.set(instance, "nuovo valore");
