Field.get: примеры (JAVA)

Базовые примеры использования

Ниже приведены несколько компактных примеров и ожидаемые результаты.

Публичное поле экземпляра

class Person {
    public String name = "Alice";
}

// Получение
Field f = Person.class.getField("name");
Object val = f.get(new Person());
System.out.println(val);

Alice

Приватное поле с setAccessible

class Secret {
    private int code = 123;
}

Field f = Secret.class.getDeclaredField("code");
f.setAccessible(true); // в старых JVM снимает ограничение
Object val = f.get(new Secret());
System.out.println(val + " (" + val.getClass().getSimpleName() + ")");

123 (Integer)

Статическое поле (obj игнорируется)

class C {
    public static String TAG = "v1";
}

Field f = C.class.getField("TAG");
Object val1 = f.get(null);          // допустимо
Object val2 = f.get(new C());      // тоже допустимо
System.out.println(val1);
System.out.println(val2);

v1
v1

Ошибка: неверный объект

class A { public int x; }
class B { }
Field f = A.class.getField("x");
// f.get(new B()) приведет к исключению
f.get(new B());

Exception in thread "main" java.lang.IllegalArgumentException: object is not an instance of declaring class
 ...

Похожие механизмы в Java

Краткий обзор альтернатив внутри Java и их особенности:

• Field.getInt/Boolean/...() - специализированные геттеры для примитивов. Полезны при необходимости избежать автоупаковки и дополнительных проверок типов.
• Field.set() - запись значения в поле; схожая семантика по аргументам и исключениям.
• Method.invoke() - вызов методов рефлексивно, используется для выполнения логики, а не чтения полей.
• VarHandle (Java 9+) - более современный и безопасный способ доступа к полям и элементам массива; поддерживает атомарные операции и контроль видимости.
• MethodHandles.Lookup.unreflectGetter() - получение прямого доступа к геттеру в виде MethodHandle, что даёт лучшую производительность в сравнении с отражением.

Рекомендации по выбору:

• Для простого чтения полей в одноразовых утилитах Field.get() подходит.
• Для внутрицифровых и высокопроизводительных сценариев предпочтительнее VarHandle или MethodHandle.
• Для примитивов - соответствующие специализированные методы getInt и т.д., чтобы избежать упаковки.

Аналоги в других языках и их различия

Краткие сравнения с примерами и результатами.

PHP (ReflectionProperty::getValue)

class C { public $v = "x"; }
$p = new ReflectionProperty(C::class, 'v');
echo $p->getValue(new C());

x

Особенности: простая модель, нет упаковки примитивов, доступ к приватным свойствам можно получить при соответствующих настройках.

JavaScript (Reflect.get / прямой доступ)

const obj = {a:1};
console.log(Reflect.get(obj, 'a'));
console.log(obj['a']);

1
1

Особенность: динамическая модель, приватные поля (начиная с #) недоступны через Reflect.get.

Python (getattr)

class A:
    def __init__(self):
        self.x = 5

print(getattr(A(), 'x'))

5

Особенность: простота и динамика; манглинг имён для «приватных» полей, но доступ возможен.

C# (Reflection: PropertyInfo/GetValue или FieldInfo/GetValue)

class A { public int x = 1; }
var f = typeof(A).GetField("x");
Console.WriteLine(f.GetValue(new A()));

1

Особенность: поведение похоже на Java, есть привязка к CLR, есть отличия в моделях безопасности и модификаторах доступа.

Go (reflect package)

type T struct{ X int }
var v = reflect.ValueOf(&T{X:2}).Elem().FieldByName("X")
fmt.Println(v.Int())

2

Особенность: требуется работать с reflect.Value и учитывать экспортируемость полей (некоторые поля недоступны вне пакета).

Kotlin

class A(var x: Int)
val f = A::class.java.getField("x")
println(f.get(A(3)))

3

Особенность: использует ту же JVM-рефлексию, но есть kotlin-reflect с более удобным API для свойств.

Lua

t = {a=1}
print(t.a) -- или t['a']

1

Особенность: динамическая таблица как основа объектов, никаких специальных reflection-API по умолчанию.

Вывод: в большинстве динамических языков чтение поля проще и прямее. Java требует явной работы с отражением; современные JVM предлагают VarHandle/MethodHandle для более строгого и быстрого подхода.

Типичные ошибки и причины

Ниже перечислены часто встречающиеся ошибки при использовании Field.get() с примерами и ожидаемыми ошибками.

IllegalArgumentException - неверный объект

class A { public int x; }
class B { }
Field f = A.class.getField("x");
f.get(new B());

java.lang.IllegalArgumentException: object is not an instance of declaring class
 ...

IllegalAccessException - закрытый доступ без снятия ограничений

class S { private int p = 1; }
Field f = S.class.getDeclaredField("p");
// f.setAccessible(true) не вызван
f.get(new S());

java.lang.IllegalAccessException: class ... cannot access a member of class ... with modifiers "private"
 ...

NullPointerException - попытка чтения экземплярного поля с null

class A { public int x; }
Field f = A.class.getField("x");
// Для экземплярного поля передан null
f.get(null);

java.lang.NullPointerException
 ...

InaccessibleObjectException / модули Java 9+

// Попытка сделать setAccessible(true) для поля из закрытого модуля
Field f = SomeJdkClass.class.getDeclaredField("someField");
f.setAccessible(true);

java.lang.reflect.InaccessibleObjectException: Unable to make ... accessible: module ... does not "opens" to ...
 ...

Примечание: начиная с Java 9 модульная система может блокировать снятие доступа через setAccessible. Для таких случаев возникают исключения уровня InaccessibleObjectException или требуется запуск с аргументом --add-opens или использование MethodHandles/VarHandle с корректным Lookup.

Изменения и эволюция поведения в последних версиях Java

Ключевые изменения в поведении рефлексии, влияющие на Field.get():

• Java 9: введение модульной системы (Jigsaw). Строгая инкапсуляция пакетов привела к тому, что setAccessible(true) может приводить к InaccessibleObjectException для закрытых модулей, если не добавлены специальные открывания (--add-opens).
• Java 9: появление VarHandle и улучшений в MethodHandles, как рекомендуемых альтернатив отражению для производительного доступа к полям.
• Позже: усиление ограничений при изменении static final полей; в новых версиях JVM изменение таких полей через отражение становится сложнее или недоступно без специальных флагов.
• Депрекации и рекомендации: прямое снятие видимости через setAccessible считается менее предпочтительным; предлагается использовать API MethodHandles/VarHandle или официальные механизмы доступа.

Расширенные и нетиповые примеры

Несколько продвинутых сценариев с пояснениями и результатами.

Чтение и изменение private static final (парадоксальное изменение константы)

class ConstHolder {
    private static final String SECRET = "ORIG";
}

Field f = ConstHolder.class.getDeclaredField("SECRET");
f.setAccessible(true);
// Для изменения final в старых JVM требовалось снять флаг final через поле modifiers
Field mods = Field.class.getDeclaredField("modifiers");
mods.setAccessible(true);
mods.setInt(f, f.getModifiers() & ~java.lang.reflect.Modifier.FINAL);

f.set(null, "CHANGED");
System.out.println(f.get(null));
// Примечание: в современных JVM поведение может отличаться; оптимизации компилятора/кэши могут оставить старое значение в местах использования.

CHANGED
(возможны отличия в зависимости от JVM и версии)

Комментарий: подобные приёмы небезопасны и в новых версиях JVM часто блокируются.

VarHandle как современная альтернатива

import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;

class S { public volatile int cnt = 7; }

VarHandle vh = MethodHandles.lookup().findVarHandle(S.class, "cnt", int.class);
S s = new S();
int old = (int)vh.getAndAdd(s, 3);
System.out.println(old);
System.out.println(s.cnt);

7
10

Комментарий: VarHandle позволяет атомарные операции и избегает некоторых ограничений модулей при правильном Lookup.

Получение поля суперкласса

class Base { protected String data = "base"; }
class Sub extends Base { }

Field f = Base.class.getDeclaredField("data");
f.setAccessible(true);
System.out.println(f.get(new Sub()));

base

MethodHandle для ускоренного доступа

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;

class P { public int v = 42; }

MethodHandles.Lookup lk = MethodHandles.lookup();
Field f = P.class.getField("v");
MethodHandle getter = lk.unreflectGetter(f);
System.out.println(getter.invoke(new P()));

42

Комментарий: MethodHandle часто быстрее рефлексии и может работать в контекстах, где setAccessible ограничен, при получении корректного Lookup.

Чтение элемента массива через поле, содержащего массив

class A { public int[] arr = {1,2,3}; }
Field f = A.class.getField("arr");
int[] a = (int[]) f.get(new A());
System.out.println(a[1]);

2

Заключение: для нетиповых задач доступны разные приёмы - изменение модификаторов, MethodHandles, VarHandle. При этом важно учитывать безопасность, стабильность и совместимость с версиями JVM.