1. Uzyskiwanie informacji o polach
Czym różnią się getFields() i getDeclaredFields()
W Javie każda klasa ma pola (fields) — zmienne zadeklarowane wewnątrz klasy. Za pomocą refleksji możemy poznać ich nazwy, typy, modyfikatory dostępu (public/private), a także uzyskać do nich dostęp w czasie wykonywania. Główny punkt wejścia to obiekt Class<?>.
Podstawowe metody klasy Class do pracy z polami:
| Metoda | Co zwraca |
|---|---|
|
Tablica wszystkich pól public klasy, jej klas nadrzędnych i interfejsów |
|
Tablica wszystkich pól zadeklarowanych w tej klasie |
Analogicznie: getFields() — jak wycieczka tylko po salach wystawowych (public), a getDeclaredFields() — także po zapleczu technicznym (private, protected, package‑private).
Przykład: wypisujemy wszystkie pola klasy
Załóżmy, że mamy klasę:
public class Person {
public String name;
private int age;
protected String email;
}
Pobierzmy informacje o polach:
import java.lang.reflect.Field;
Class<?> clazz = Person.class;
// Wszystkie pola public (w tym odziedziczone)
System.out.println("Public fields:");
for (Field field : clazz.getFields()) {
System.out.println(field.getName() + " : " + field.getType().getSimpleName());
}
// Wszystkie zadeklarowane pola (w tym private, tylko własne)
System.out.println("\nDeclared fields:");
for (Field field : clazz.getDeclaredFields()) {
System.out.println(field.getName() + " : " + field.getType().getSimpleName());
}
Wynik:
Public fields:
name : String
Declared fields:
name : String
age : int
email : String
Jak poznać modyfikatory pola?
Każde pole (Field) ma modyfikatory (public/private/protected, static, final itd.). Można je pobrać przez getModifiers() i zamienić na ciąg znaków za pomocą Modifier:
import java.lang.reflect.Modifier;
for (Field field : clazz.getDeclaredFields()) {
int mods = field.getModifiers();
System.out.println(field.getName() + " : " + Modifier.toString(mods));
}
2. Uzyskiwanie informacji o metodach
Metody getMethods() i getDeclaredMethods()
Metody to działania, które może wykonywać obiekt. Za pomocą refleksji można sprawdzić, jakie metody ma klasa, ich parametry, typy zwracane, modyfikatory i adnotacje.
| Metoda | Co zwraca |
|---|---|
|
Wszystkie metody public klasy i jej klas nadrzędnych (w tym Object) |
|
Wszystkie metody zadeklarowane w tej klasie (w tym private) |
Przykład: wypisujemy wszystkie metody klasy
import java.lang.reflect.Method;
System.out.println("Public methods:");
for (Method method : clazz.getMethods()) {
System.out.println(method.getName());
}
System.out.println("\nDeclared methods:");
for (Method method : clazz.getDeclaredMethods()) {
System.out.println(method.getName());
}
Wynik (dla Person):
Public methods:
getClass
hashCode
equals
toString
notify
notifyAll
wait
wait
wait
Declared methods:
(nic, jeśli w Person nie zadeklarowano własnych metod)
Dodajmy metodę do Person:
public class Person {
public String name;
private int age;
protected String email;
public void sayHello() {
System.out.println("Hi!");
}
}
Teraz getDeclaredMethods() również go pokaże.
Jak poznać parametry i typ zwracany metody?
for (Method method : clazz.getDeclaredMethods()) {
System.out.print(Modifier.toString(method.getModifiers()) + " ");
System.out.print(method.getReturnType().getSimpleName() + " ");
System.out.print(method.getName() + "(");
Class<?>[] params = method.getParameterTypes();
for (int i = 0; i < params.length; i++) {
System.out.print(params[i].getSimpleName());
if (i < params.length - 1) System.out.print(", ");
}
System.out.println(");");
}
Wynik:
public void sayHello();
3. Uzyskiwanie informacji o konstruktorach
Konstruktory to specjalne metody używane do tworzenia obiektów.
| Metoda | Co zwraca |
|---|---|
|
Wszystkie public konstruktory |
|
Wszystkie konstruktory zadeklarowane w klasie |
Przykład: wypisujemy wszystkie konstruktory klasy
import java.lang.reflect.Constructor;
System.out.println("Constructors:");
for (Constructor<?> constructor : clazz.getDeclaredConstructors()) {
System.out.print(clazz.getSimpleName() + "(");
Class<?>[] params = constructor.getParameterTypes();
for (int i = 0; i < params.length; i++) {
System.out.print(params[i].getSimpleName());
if (i < params.length - 1) System.out.print(", ");
}
System.out.println(");");
}
Jeśli w klasie zadeklarowano tylko konstruktor domyślny, również zostanie wypisany.
4. Adnotacje: jak sprawdzić, czym oznaczono klasę, metodę lub pole
Adnotacje to specjalne metki, które można nakładać na klasy, metody, pola i parametry. Za pomocą refleksji można sprawdzić, jakie adnotacje ma dany element.
Pobieranie adnotacji
- Dla klasy: clazz.getAnnotations()
- Dla metody: method.getAnnotations()
- Dla pola: field.getAnnotations()
Przykład: sprawdźmy obecność adnotacji @Deprecated
for (Method method : clazz.getDeclaredMethods()) {
if (method.isAnnotationPresent(Deprecated.class)) {
System.out.println(method.getName() + " is @Deprecated");
}
}
Przykład: wypisujemy wszystkie adnotacje klasy
for (var annotation : clazz.getAnnotations()) {
System.out.println(annotation);
}
5. Praktyka: mini-program do analizy struktury klasy
Zbierzmy wszystko w całość i napiszmy małe narzędzie, które na podstawie nazwy klasy wypisze jej strukturę: pola, metody, konstruktory i adnotacje.
Przykład kodu: ClassInspector
import java.lang.reflect.*;
import java.util.Scanner;
public class ClassInspector {
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj pełną nazwę klasy (np. java.util.ArrayList): ");
String className = scanner.nextLine();
Class<?> clazz = Class.forName(className);
System.out.println("\n== Klasa: " + clazz.getName() + " ==");
// Adnotacje klasy
System.out.println("Adnotacje:");
for (Annotation annotation : clazz.getAnnotations()) {
System.out.println(" " + annotation);
}
// Pola
System.out.println("\nPola:");
for (Field field : clazz.getDeclaredFields()) {
System.out.println(" " + Modifier.toString(field.getModifiers())
+ " " + field.getType().getSimpleName()
+ " " + field.getName());
}
// Metody
System.out.println("\nMetody:");
for (Method method : clazz.getDeclaredMethods()) {
System.out.print(" " + Modifier.toString(method.getModifiers())
+ " " + method.getReturnType().getSimpleName()
+ " " + method.getName() + "(");
Class<?>[] params = method.getParameterTypes();
for (int i = 0; i < params.length; i++) {
System.out.print(params[i].getSimpleName());
if (i < params.length - 1) System.out.print(", ");
}
System.out.println(");");
}
// Konstruktory
System.out.println("\nKonstruktory:");
for (Constructor<?> constructor : clazz.getDeclaredConstructors()) {
System.out.print(" " + Modifier.toString(constructor.getModifiers())
+ " " + clazz.getSimpleName() + "(");
Class<?>[] params = constructor.getParameterTypes();
for (int i = 0; i < params.length; i++) {
System.out.print(params[i].getSimpleName());
if (i < params.length - 1) System.out.print(", ");
}
System.out.println(");");
}
}
}
Jak to działa?
- Użytkownik podaje pełną nazwę klasy (np. "java.util.ArrayList" lub własną klasę).
- Program dynamicznie ładuje klasę i wypisuje jej adnotacje, pola, metody oraz konstruktory.
- Wypróbuj na standardowych klasach JDK — zobaczysz, ile ciekawych rzeczy kryje się w środku!
6. Przydatne niuanse i wizualizacja
Schemat wizualny: czego można się dowiedzieć o klasie przez refleksję
graph TD
A[Class<?>] --> B["getFields/getDeclaredFields"]
A --> C[getMethods/getDeclaredMethods]
A --> D[getConstructors/getDeclaredConstructors]
A --> E[getAnnotations]
B --> F[Field: typ, nazwa, modyfikatory]
C --> G[Method: typ zwracany, parametry]
D --> H[Constructor: parametry]
E --> I["Annotation[]"]
Tabela: gdzie szukać informacji
| Co chcemy poznać | Jak uzyskać przez refleksję |
|---|---|
| Wszystkie pola public | |
| Wszystkie pola zadeklarowane | |
| Wszystkie metody public | |
| Wszystkie metody zadeklarowane | |
| Wszystkie konstruktory public | |
| Wszystkie konstruktory zadeklarowane | |
| Adnotacje klasy | |
| Adnotacje metody/pola | |
| Modyfikatory | |
7. Typowe błędy podczas pracy z refleksją
Błąd nr 1: Mylenie getFields() i getDeclaredFields().
Jeśli szukasz pól private, użyj getDeclaredFields(), a nie getFields(). Pierwszy zwraca wszystkie pola zadeklarowane w klasie, a drugi — tylko public (i odziedziczone!).
Błąd nr 2: Brak obsługi wyjątków typu checked.
Wiele metod refleksji zgłasza wyjątki (na przykład ClassNotFoundException lub SecurityException). Pamiętaj, aby je obsłużyć lub zadeklarować w sygnaturze metody.
Błąd nr 3: Nieuwzględnianie modyfikatorów dostępu.
Dostęp do pól i metod private jest możliwy dopiero po wywołaniu setAccessible(true), w przeciwnym razie wystąpi IllegalAccessException. Przykład:
Field field = clazz.getDeclaredField("age");
field.setAccessible(true); // Otwieramy dostęp do pola private
int value = (int) field.get(person);
Błąd nr 4: Oczekiwanie wyłącznie własnych metod/pól.
getMethods() i getFields() zwracają elementy public nie tylko bieżącej klasy, ale i wszystkich jej klas nadrzędnych, włącznie z Object. Może to zaskakiwać, jeśli oczekujesz zobaczyć tylko to, co sam napisałeś.
Błąd nr 5: Niepoprawne sprawdzanie obecności adnotacji.
Używaj isAnnotationPresent() do sprawdzania konkretnej adnotacji, zamiast bez potrzeby iterować ręcznie po tablicy adnotacji.
GO TO FULL VERSION