1 /*
2 * Copyright (c) 1996, 2022, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.lang.reflect;
27
28 import jdk.internal.access.SharedSecrets;
29 import jdk.internal.value.PrimitiveClass;
30 import jdk.internal.reflect.CallerSensitive;
31 import jdk.internal.reflect.FieldAccessor;
32 import jdk.internal.reflect.Reflection;
33 import jdk.internal.vm.annotation.ForceInline;
34 import jdk.internal.vm.annotation.Stable;
35 import sun.reflect.generics.repository.FieldRepository;
36 import sun.reflect.generics.factory.CoreReflectionFactory;
37 import sun.reflect.generics.factory.GenericsFactory;
38 import sun.reflect.generics.scope.ClassScope;
39 import java.lang.annotation.Annotation;
40 import java.util.Map;
41 import java.util.Set;
42 import java.util.Objects;
43 import sun.reflect.annotation.AnnotationParser;
44 import sun.reflect.annotation.AnnotationSupport;
45 import sun.reflect.annotation.TypeAnnotation;
46 import sun.reflect.annotation.TypeAnnotationParser;
47
48 /**
49 * A {@code Field} provides information about, and dynamic access to, a
50 * single field of a class or an interface. The reflected field may
51 * be a class (static) field or an instance field.
52 *
53 * <p>A {@code Field} permits widening conversions to occur during a get or
54 * set access operation, but throws an {@code IllegalArgumentException} if a
55 * narrowing conversion would occur.
56 *
57 * @see Member
58 * @see java.lang.Class
59 * @see java.lang.Class#getFields()
60 * @see java.lang.Class#getField(String)
61 * @see java.lang.Class#getDeclaredFields()
62 * @see java.lang.Class#getDeclaredField(String)
63 *
64 * @author Kenneth Russell
65 * @author Nakul Saraiya
66 * @since 1.1
67 */
68 public final
69 class Field extends AccessibleObject implements Member {
70 private final Class<?> clazz;
71 private final int slot;
72 // This is guaranteed to be interned by the VM in the 1.4
73 // reflection implementation
74 private final String name;
75 private final Class<?> type;
76 private final int modifiers;
77 private final boolean trustedFinal;
78 // Generics and annotations support
79 private final transient String signature;
80 // generic info repository; lazily initialized
81 private transient FieldRepository genericInfo;
82 private final byte[] annotations;
83 // Cached field accessor created without override
84 @Stable
85 private FieldAccessor fieldAccessor;
86 // Cached field accessor created with override
87 @Stable
88 private FieldAccessor overrideFieldAccessor;
89 // For sharing of FieldAccessors. This branching structure is
90 // currently only two levels deep (i.e., one root Field and
91 // potentially many Field objects pointing to it.)
92 //
93 // If this branching structure would ever contain cycles, deadlocks can
94 // occur in annotation code.
95 private Field root;
96
97 // Generics infrastructure
98
99 private String getGenericSignature() {return signature;}
100
101 // Accessor for factory
102 private GenericsFactory getFactory() {
103 Class<?> c = getDeclaringClass();
104 // create scope and factory
105 return CoreReflectionFactory.make(c, ClassScope.make(c));
106 }
107
108 // Accessor for generic info repository
109 private FieldRepository getGenericInfo() {
110 // lazily initialize repository if necessary
111 if (genericInfo == null) {
112 // create and cache generic info repository
113 genericInfo = FieldRepository.make(getGenericSignature(),
114 getFactory());
115 }
116 return genericInfo; //return cached repository
117 }
118
119
120 /**
121 * Package-private constructor
122 */
123 @SuppressWarnings("deprecation")
124 Field(Class<?> declaringClass,
125 String name,
126 Class<?> type,
127 int modifiers,
128 boolean trustedFinal,
129 int slot,
130 String signature,
131 byte[] annotations)
132 {
133 assert PrimitiveClass.isPrimaryType(declaringClass);
134 this.clazz = declaringClass;
135 this.name = name;
136 this.type = type;
137 this.modifiers = modifiers;
138 this.trustedFinal = trustedFinal;
139 this.slot = slot;
140 this.signature = signature;
141 this.annotations = annotations;
142 }
143
144 /**
145 * Package-private routine (exposed to java.lang.Class via
146 * ReflectAccess) which returns a copy of this Field. The copy's
147 * "root" field points to this Field.
148 */
149 Field copy() {
150 // This routine enables sharing of FieldAccessor objects
151 // among Field objects which refer to the same underlying
152 // method in the VM. (All of this contortion is only necessary
153 // because of the "accessibility" bit in AccessibleObject,
154 // which implicitly requires that new java.lang.reflect
155 // objects be fabricated for each reflective call on Class
156 // objects.)
157 if (this.root != null)
158 throw new IllegalArgumentException("Can not copy a non-root Field");
159
160 Field res = new Field(clazz, name, type, modifiers, trustedFinal, slot, signature, annotations);
161 res.root = this;
162 // Might as well eagerly propagate this if already present
163 res.fieldAccessor = fieldAccessor;
164 res.overrideFieldAccessor = overrideFieldAccessor;
165
166 return res;
167 }
168
169 /**
170 * @throws InaccessibleObjectException {@inheritDoc}
171 * @throws SecurityException {@inheritDoc}
172 */
173 @Override
174 @CallerSensitive
175 public void setAccessible(boolean flag) {
176 AccessibleObject.checkPermission();
177 if (flag) checkCanSetAccessible(Reflection.getCallerClass());
178 setAccessible0(flag);
179 }
180
181 @Override
182 void checkCanSetAccessible(Class<?> caller) {
183 checkCanSetAccessible(caller, clazz);
184 }
185
186 /**
187 * Returns the {@code Class} object representing the class or interface
188 * that declares the field represented by this {@code Field} object.
189 */
190 @Override
191 public Class<?> getDeclaringClass() {
192 return clazz;
193 }
194
195 /**
196 * Returns the name of the field represented by this {@code Field} object.
197 */
198 public String getName() {
199 return name;
200 }
201
202 /**
203 * Returns the Java language modifiers for the field represented
204 * by this {@code Field} object, as an integer. The {@code Modifier} class should
205 * be used to decode the modifiers.
206 *
207 * @see Modifier
208 * @see #accessFlags()
209 * @jls 8.3 Field Declarations
210 * @jls 9.3 Field (Constant) Declarations
211 */
212 public int getModifiers() {
213 return modifiers;
214 }
215
216 /**
217 * {@return an unmodifiable set of the {@linkplain AccessFlag
218 * access flags} for this field, possibly empty}
219 * The {@code AccessFlags} may depend on the class file format version of the class.
220 *
221 * @see #getModifiers()
222 * @jvms 4.5 Fields
223 * @since 20
224 */
225 @Override
226 public Set<AccessFlag> accessFlags() {
227 int major = SharedSecrets.getJavaLangAccess().classFileFormatVersion(getDeclaringClass()) & 0xffff;
228 var cffv = ClassFileFormatVersion.fromMajor(major);
229 return AccessFlag.maskToAccessFlags(getModifiers(),
230 AccessFlag.Location.FIELD,
231 cffv);
232 }
233
234 /**
235 * Returns {@code true} if this field represents an element of
236 * an enumerated class; returns {@code false} otherwise.
237 *
238 * @return {@code true} if and only if this field represents an element of
239 * an enumerated class.
240 * @since 1.5
241 * @jls 8.9.1 Enum Constants
242 */
243 public boolean isEnumConstant() {
244 return (getModifiers() & Modifier.ENUM) != 0;
245 }
246
247 /**
248 * Returns {@code true} if this field is a synthetic
249 * field; returns {@code false} otherwise.
250 *
251 * @return true if and only if this field is a synthetic
252 * field as defined by the Java Language Specification.
253 * @since 1.5
254 * @see <a
255 * href="{@docRoot}/java.base/java/lang/reflect/package-summary.html#LanguageJvmModel">Java
256 * programming language and JVM modeling in core reflection</a>
257 */
258 public boolean isSynthetic() {
259 return Modifier.isSynthetic(getModifiers());
260 }
261
262 /**
263 * Returns a {@code Class} object that identifies the
264 * declared type for the field represented by this
265 * {@code Field} object.
266 *
267 * @return a {@code Class} object identifying the declared
268 * type of the field represented by this object
269 */
270 public Class<?> getType() {
271 return type;
272 }
273
274 /**
275 * Returns a {@code Type} object that represents the declared type for
276 * the field represented by this {@code Field} object.
277 *
278 * <p>If the declared type of the field is a parameterized type,
279 * the {@code Type} object returned must accurately reflect the
280 * actual type arguments used in the source code.
281 *
282 * <p>If the type of the underlying field is a type variable or a
283 * parameterized type, it is created. Otherwise, it is resolved.
284 *
285 * @return a {@code Type} object that represents the declared type for
286 * the field represented by this {@code Field} object
287 * @throws GenericSignatureFormatError if the generic field
288 * signature does not conform to the format specified in
289 * <cite>The Java Virtual Machine Specification</cite>
290 * @throws TypeNotPresentException if the generic type
291 * signature of the underlying field refers to a non-existent
292 * class or interface declaration
293 * @throws MalformedParameterizedTypeException if the generic
294 * signature of the underlying field refers to a parameterized type
295 * that cannot be instantiated for any reason
296 * @since 1.5
297 */
298 public Type getGenericType() {
299 if (getGenericSignature() != null)
300 return getGenericInfo().getGenericType();
301 else
302 return getType();
303 }
304
305
306 /**
307 * Compares this {@code Field} against the specified object. Returns
308 * true if the objects are the same. Two {@code Field} objects are the same if
309 * they were declared by the same class and have the same name
310 * and type.
311 */
312 public boolean equals(Object obj) {
313 if (obj instanceof Field other) {
314 return (getDeclaringClass() == other.getDeclaringClass())
315 && (getName() == other.getName())
316 && (getType() == other.getType());
317 }
318 return false;
319 }
320
321 /**
322 * Returns a hashcode for this {@code Field}. This is computed as the
323 * exclusive-or of the hashcodes for the underlying field's
324 * declaring class name and its name.
325 */
326 public int hashCode() {
327 return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
328 }
329
330 /**
331 * Returns a string describing this {@code Field}. The format is
332 * the access modifiers for the field, if any, followed
333 * by the field type, followed by a space, followed by
334 * the fully-qualified name of the class declaring the field,
335 * followed by a period, followed by the name of the field.
336 * For example:
337 * <pre>
338 * public static final int java.lang.Thread.MIN_PRIORITY
339 * private int java.io.FileDescriptor.fd
340 * </pre>
341 *
342 * <p>The modifiers are placed in canonical order as specified by
343 * "The Java Language Specification". This is {@code public},
344 * {@code protected} or {@code private} first, and then other
345 * modifiers in the following order: {@code static}, {@code final},
346 * {@code transient}, {@code volatile}.
347 *
348 * @return a string describing this {@code Field}
349 * @jls 8.3.1 Field Modifiers
350 */
351 public String toString() {
352 int mod = getModifiers();
353 return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
354 + getType().getTypeName() + " "
355 + getDeclaringClassTypeName() + "."
356 + getName());
357 }
358
359 @Override
360 String toShortString() {
361 return "field " + getDeclaringClassTypeName() + "." + getName();
362 }
363
364 String getDeclaringClassTypeName() {
365 Class<?> c = getDeclaringClass();
366 if (PrimitiveClass.isPrimitiveClass(c)) {
367 c = PrimitiveClass.asValueType(c);
368 }
369 return c.getTypeName();
370 }
371
372 /**
373 * Returns a string describing this {@code Field}, including
374 * its generic type. The format is the access modifiers for the
375 * field, if any, followed by the generic field type, followed by
376 * a space, followed by the fully-qualified name of the class
377 * declaring the field, followed by a period, followed by the name
378 * of the field.
379 *
380 * <p>The modifiers are placed in canonical order as specified by
381 * "The Java Language Specification". This is {@code public},
382 * {@code protected} or {@code private} first, and then other
383 * modifiers in the following order: {@code static}, {@code final},
384 * {@code transient}, {@code volatile}.
385 *
386 * @return a string describing this {@code Field}, including
387 * its generic type
388 *
389 * @since 1.5
390 * @jls 8.3.1 Field Modifiers
391 */
392 public String toGenericString() {
393 int mod = getModifiers();
394 Type fieldType = getGenericType();
395 return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
396 + fieldType.getTypeName() + " "
397 + getDeclaringClassTypeName() + "."
398 + getName());
399 }
400
401 /**
402 * Returns the value of the field represented by this {@code Field}, on
403 * the specified object. The value is automatically wrapped in an
404 * object if it has a primitive type.
405 *
406 * <p>The underlying field's value is obtained as follows:
407 *
408 * <p>If the underlying field is a static field, the {@code obj} argument
409 * is ignored; it may be null.
410 *
411 * <p>Otherwise, the underlying field is an instance field. If the
412 * specified {@code obj} argument is null, the method throws a
413 * {@code NullPointerException}. If the specified object is not an
414 * instance of the class or interface declaring the underlying
415 * field, the method throws an {@code IllegalArgumentException}.
416 *
417 * <p>If this {@code Field} object is enforcing Java language access control, and
418 * the underlying field is inaccessible, the method throws an
419 * {@code IllegalAccessException}.
420 * If the underlying field is static, the class that declared the
421 * field is initialized if it has not already been initialized.
422 *
423 * <p>Otherwise, the value is retrieved from the underlying instance
424 * or static field. If the field has a primitive type, the value
425 * is wrapped in an object before being returned, otherwise it is
426 * returned as is.
427 *
428 * <p>If the field is hidden in the type of {@code obj},
429 * the field's value is obtained according to the preceding rules.
430 *
431 * @param obj object from which the represented field's value is
432 * to be extracted
433 * @return the value of the represented field in object
434 * {@code obj}; primitive values are wrapped in an appropriate
435 * object before being returned
436 *
437 * @throws IllegalAccessException if this {@code Field} object
438 * is enforcing Java language access control and the underlying
439 * field is inaccessible.
440 * @throws IllegalArgumentException if the specified object is not an
441 * instance of the class or interface declaring the underlying
442 * field (or a subclass or implementor thereof).
443 * @throws NullPointerException if the specified object is null
444 * and the field is an instance field.
445 * @throws ExceptionInInitializerError if the initialization provoked
446 * by this method fails.
447 */
448 @CallerSensitive
449 @ForceInline // to ensure Reflection.getCallerClass optimization
450 public Object get(Object obj)
451 throws IllegalArgumentException, IllegalAccessException
452 {
453 if (!override) {
454 Class<?> caller = Reflection.getCallerClass();
455 checkAccess(caller, obj);
456 return getFieldAccessor().get(obj);
457 } else {
458 return getOverrideFieldAccessor().get(obj);
459 }
460 }
461
462 /**
463 * Gets the value of a static or instance {@code boolean} field.
464 *
465 * @param obj the object to extract the {@code boolean} value
466 * from
467 * @return the value of the {@code boolean} field
468 *
469 * @throws IllegalAccessException if this {@code Field} object
470 * is enforcing Java language access control and the underlying
471 * field is inaccessible.
472 * @throws IllegalArgumentException if the specified object is not
473 * an instance of the class or interface declaring the
474 * underlying field (or a subclass or implementor
475 * thereof), or if the field value cannot be
476 * converted to the type {@code boolean} by a
477 * widening conversion.
478 * @throws NullPointerException if the specified object is null
479 * and the field is an instance field.
480 * @throws ExceptionInInitializerError if the initialization provoked
481 * by this method fails.
482 * @see Field#get
483 */
484 @CallerSensitive
485 @ForceInline // to ensure Reflection.getCallerClass optimization
486 public boolean getBoolean(Object obj)
487 throws IllegalArgumentException, IllegalAccessException
488 {
489 if (!override) {
490 Class<?> caller = Reflection.getCallerClass();
491 checkAccess(caller, obj);
492 return getFieldAccessor().getBoolean(obj);
493 } else {
494 return getOverrideFieldAccessor().getBoolean(obj);
495 }
496 }
497
498 /**
499 * Gets the value of a static or instance {@code byte} field.
500 *
501 * @param obj the object to extract the {@code byte} value
502 * from
503 * @return the value of the {@code byte} field
504 *
505 * @throws IllegalAccessException if this {@code Field} object
506 * is enforcing Java language access control and the underlying
507 * field is inaccessible.
508 * @throws IllegalArgumentException if the specified object is not
509 * an instance of the class or interface declaring the
510 * underlying field (or a subclass or implementor
511 * thereof), or if the field value cannot be
512 * converted to the type {@code byte} by a
513 * widening conversion.
514 * @throws NullPointerException if the specified object is null
515 * and the field is an instance field.
516 * @throws ExceptionInInitializerError if the initialization provoked
517 * by this method fails.
518 * @see Field#get
519 */
520 @CallerSensitive
521 @ForceInline // to ensure Reflection.getCallerClass optimization
522 public byte getByte(Object obj)
523 throws IllegalArgumentException, IllegalAccessException
524 {
525 if (!override) {
526 Class<?> caller = Reflection.getCallerClass();
527 checkAccess(caller, obj);
528 return getFieldAccessor().getByte(obj);
529 } else {
530 return getOverrideFieldAccessor().getByte(obj);
531 }
532 }
533
534 /**
535 * Gets the value of a static or instance field of type
536 * {@code char} or of another primitive type convertible to
537 * type {@code char} via a widening conversion.
538 *
539 * @param obj the object to extract the {@code char} value
540 * from
541 * @return the value of the field converted to type {@code char}
542 *
543 * @throws IllegalAccessException if this {@code Field} object
544 * is enforcing Java language access control and the underlying
545 * field is inaccessible.
546 * @throws IllegalArgumentException if the specified object is not
547 * an instance of the class or interface declaring the
548 * underlying field (or a subclass or implementor
549 * thereof), or if the field value cannot be
550 * converted to the type {@code char} by a
551 * widening conversion.
552 * @throws NullPointerException if the specified object is null
553 * and the field is an instance field.
554 * @throws ExceptionInInitializerError if the initialization provoked
555 * by this method fails.
556 * @see Field#get
557 */
558 @CallerSensitive
559 @ForceInline // to ensure Reflection.getCallerClass optimization
560 public char getChar(Object obj)
561 throws IllegalArgumentException, IllegalAccessException
562 {
563 if (!override) {
564 Class<?> caller = Reflection.getCallerClass();
565 checkAccess(caller, obj);
566 return getFieldAccessor().getChar(obj);
567 } else {
568 return getOverrideFieldAccessor().getChar(obj);
569 }
570 }
571
572 /**
573 * Gets the value of a static or instance field of type
574 * {@code short} or of another primitive type convertible to
575 * type {@code short} via a widening conversion.
576 *
577 * @param obj the object to extract the {@code short} value
578 * from
579 * @return the value of the field converted to type {@code short}
580 *
581 * @throws IllegalAccessException if this {@code Field} object
582 * is enforcing Java language access control and the underlying
583 * field is inaccessible.
584 * @throws IllegalArgumentException if the specified object is not
585 * an instance of the class or interface declaring the
586 * underlying field (or a subclass or implementor
587 * thereof), or if the field value cannot be
588 * converted to the type {@code short} by a
589 * widening conversion.
590 * @throws NullPointerException if the specified object is null
591 * and the field is an instance field.
592 * @throws ExceptionInInitializerError if the initialization provoked
593 * by this method fails.
594 * @see Field#get
595 */
596 @CallerSensitive
597 @ForceInline // to ensure Reflection.getCallerClass optimization
598 public short getShort(Object obj)
599 throws IllegalArgumentException, IllegalAccessException
600 {
601 if (!override) {
602 Class<?> caller = Reflection.getCallerClass();
603 checkAccess(caller, obj);
604 return getFieldAccessor().getShort(obj);
605 } else {
606 return getOverrideFieldAccessor().getShort(obj);
607 }
608 }
609
610 /**
611 * Gets the value of a static or instance field of type
612 * {@code int} or of another primitive type convertible to
613 * type {@code int} via a widening conversion.
614 *
615 * @param obj the object to extract the {@code int} value
616 * from
617 * @return the value of the field converted to type {@code int}
618 *
619 * @throws IllegalAccessException if this {@code Field} object
620 * is enforcing Java language access control and the underlying
621 * field is inaccessible.
622 * @throws IllegalArgumentException if the specified object is not
623 * an instance of the class or interface declaring the
624 * underlying field (or a subclass or implementor
625 * thereof), or if the field value cannot be
626 * converted to the type {@code int} by a
627 * widening conversion.
628 * @throws NullPointerException if the specified object is null
629 * and the field is an instance field.
630 * @throws ExceptionInInitializerError if the initialization provoked
631 * by this method fails.
632 * @see Field#get
633 */
634 @CallerSensitive
635 @ForceInline // to ensure Reflection.getCallerClass optimization
636 public int getInt(Object obj)
637 throws IllegalArgumentException, IllegalAccessException
638 {
639 if (!override) {
640 Class<?> caller = Reflection.getCallerClass();
641 checkAccess(caller, obj);
642 return getFieldAccessor().getInt(obj);
643 } else {
644 return getOverrideFieldAccessor().getInt(obj);
645 }
646 }
647
648 /**
649 * Gets the value of a static or instance field of type
650 * {@code long} or of another primitive type convertible to
651 * type {@code long} via a widening conversion.
652 *
653 * @param obj the object to extract the {@code long} value
654 * from
655 * @return the value of the field converted to type {@code long}
656 *
657 * @throws IllegalAccessException if this {@code Field} object
658 * is enforcing Java language access control and the underlying
659 * field is inaccessible.
660 * @throws IllegalArgumentException if the specified object is not
661 * an instance of the class or interface declaring the
662 * underlying field (or a subclass or implementor
663 * thereof), or if the field value cannot be
664 * converted to the type {@code long} by a
665 * widening conversion.
666 * @throws NullPointerException if the specified object is null
667 * and the field is an instance field.
668 * @throws ExceptionInInitializerError if the initialization provoked
669 * by this method fails.
670 * @see Field#get
671 */
672 @CallerSensitive
673 @ForceInline // to ensure Reflection.getCallerClass optimization
674 public long getLong(Object obj)
675 throws IllegalArgumentException, IllegalAccessException
676 {
677 if (!override) {
678 Class<?> caller = Reflection.getCallerClass();
679 checkAccess(caller, obj);
680 return getFieldAccessor().getLong(obj);
681 } else {
682 return getOverrideFieldAccessor().getLong(obj);
683 }
684 }
685
686 /**
687 * Gets the value of a static or instance field of type
688 * {@code float} or of another primitive type convertible to
689 * type {@code float} via a widening conversion.
690 *
691 * @param obj the object to extract the {@code float} value
692 * from
693 * @return the value of the field converted to type {@code float}
694 *
695 * @throws IllegalAccessException if this {@code Field} object
696 * is enforcing Java language access control and the underlying
697 * field is inaccessible.
698 * @throws IllegalArgumentException if the specified object is not
699 * an instance of the class or interface declaring the
700 * underlying field (or a subclass or implementor
701 * thereof), or if the field value cannot be
702 * converted to the type {@code float} by a
703 * widening conversion.
704 * @throws NullPointerException if the specified object is null
705 * and the field is an instance field.
706 * @throws ExceptionInInitializerError if the initialization provoked
707 * by this method fails.
708 * @see Field#get
709 */
710 @CallerSensitive
711 @ForceInline // to ensure Reflection.getCallerClass optimization
712 public float getFloat(Object obj)
713 throws IllegalArgumentException, IllegalAccessException
714 {
715 if (!override) {
716 Class<?> caller = Reflection.getCallerClass();
717 checkAccess(caller, obj);
718 return getFieldAccessor().getFloat(obj);
719 } else {
720 return getOverrideFieldAccessor().getFloat(obj);
721 }
722 }
723
724 /**
725 * Gets the value of a static or instance field of type
726 * {@code double} or of another primitive type convertible to
727 * type {@code double} via a widening conversion.
728 *
729 * @param obj the object to extract the {@code double} value
730 * from
731 * @return the value of the field converted to type {@code double}
732 *
733 * @throws IllegalAccessException if this {@code Field} object
734 * is enforcing Java language access control and the underlying
735 * field is inaccessible.
736 * @throws IllegalArgumentException if the specified object is not
737 * an instance of the class or interface declaring the
738 * underlying field (or a subclass or implementor
739 * thereof), or if the field value cannot be
740 * converted to the type {@code double} by a
741 * widening conversion.
742 * @throws NullPointerException if the specified object is null
743 * and the field is an instance field.
744 * @throws ExceptionInInitializerError if the initialization provoked
745 * by this method fails.
746 * @see Field#get
747 */
748 @CallerSensitive
749 @ForceInline // to ensure Reflection.getCallerClass optimization
750 public double getDouble(Object obj)
751 throws IllegalArgumentException, IllegalAccessException
752 {
753 if (!override) {
754 Class<?> caller = Reflection.getCallerClass();
755 checkAccess(caller, obj);
756 return getFieldAccessor().getDouble(obj);
757 } else {
758 return getOverrideFieldAccessor().getDouble(obj);
759 }
760 }
761
762 /**
763 * Sets the field represented by this {@code Field} object on the
764 * specified object argument to the specified new value. The new
765 * value is automatically unwrapped if the underlying field has a
766 * primitive type.
767 *
768 * <p>The operation proceeds as follows:
769 *
770 * <p>If the underlying field is static, the {@code obj} argument is
771 * ignored; it may be null.
772 *
773 * <p>Otherwise the underlying field is an instance field. If the
774 * specified object argument is null, the method throws a
775 * {@code NullPointerException}. If the specified object argument is not
776 * an instance of the class or interface declaring the underlying
777 * field, the method throws an {@code IllegalArgumentException}.
778 *
779 * <p>If this {@code Field} object is enforcing Java language access control, and
780 * the underlying field is inaccessible, the method throws an
781 * {@code IllegalAccessException}.
782 *
783 * <p>If the underlying field is final, this {@code Field} object has
784 * <em>write</em> access if and only if the following conditions are met:
785 * <ul>
786 * <li>{@link #setAccessible(boolean) setAccessible(true)} has succeeded for
787 * this {@code Field} object;</li>
788 * <li>the field is non-static; and</li>
789 * <li>the field's declaring class is not a {@linkplain Class#isHidden()
790 * hidden class};</li>
791 * <li>the field's declaring class is not a {@linkplain Class#isValue()
792 * value class}; and</li>
793 * <li>the field's declaring class is not a {@linkplain Class#isRecord()
794 * record class}.</li>
795 * </ul>
796 * If any of the above checks is not met, this method throws an
797 * {@code IllegalAccessException}.
798 *
799 * <p> Setting a final field in this way
800 * is meaningful only during deserialization or reconstruction of
801 * instances of classes with blank final fields, before they are
802 * made available for access by other parts of a program. Use in
803 * any other context may have unpredictable effects, including cases
804 * in which other parts of a program continue to use the original
805 * value of this field.
806 *
807 * <p>If the underlying field is of a primitive type, an unwrapping
808 * conversion is attempted to convert the new value to a value of
809 * a primitive type. If this attempt fails, the method throws an
810 * {@code IllegalArgumentException}.
811 *
812 * <p>If, after possible unwrapping, the new value cannot be
813 * converted to the type of the underlying field by an identity or
814 * widening conversion, the method throws an
815 * {@code IllegalArgumentException}.
816 *
817 * <p>If the underlying field is static, the class that declared the
818 * field is initialized if it has not already been initialized.
819 *
820 * <p>The field is set to the possibly unwrapped and widened new value.
821 *
822 * <p>If the field is hidden in the type of {@code obj},
823 * the field's value is set according to the preceding rules.
824 *
825 * @param obj the object whose field should be modified
826 * @param value the new value for the field of {@code obj}
827 * being modified
828 *
829 * @throws IllegalAccessException if this {@code Field} object
830 * is enforcing Java language access control and the underlying
831 * field is inaccessible or final;
832 * or if this {@code Field} object has no write access.
833 * @throws IllegalArgumentException if the specified object is not an
834 * instance of the class or interface declaring the underlying
835 * field (or a subclass or implementor thereof),
836 * or if an unwrapping conversion fails.
837 * @throws NullPointerException if the specified object is null
838 * and the field is an instance field.
839 * @throws ExceptionInInitializerError if the initialization provoked
840 * by this method fails.
841 */
842 @CallerSensitive
843 @ForceInline // to ensure Reflection.getCallerClass optimization
844 public void set(Object obj, Object value)
845 throws IllegalArgumentException, IllegalAccessException
846 {
847 if (!override) {
848 Class<?> caller = Reflection.getCallerClass();
849 checkAccess(caller, obj);
850 getFieldAccessor().set(obj, value);
851 } else {
852 getOverrideFieldAccessor().set(obj, value);
853 }
854 }
855
856 /**
857 * Sets the value of a field as a {@code boolean} on the specified object.
858 * This method is equivalent to
859 * {@code set(obj, zObj)},
860 * where {@code zObj} is a {@code Boolean} object and
861 * {@code zObj.booleanValue() == z}.
862 *
863 * @param obj the object whose field should be modified
864 * @param z the new value for the field of {@code obj}
865 * being modified
866 *
867 * @throws IllegalAccessException if this {@code Field} object
868 * is enforcing Java language access control and the underlying
869 * field is either inaccessible or final;
870 * or if this {@code Field} object has no write access.
871 * @throws IllegalArgumentException if the specified object is not an
872 * instance of the class or interface declaring the underlying
873 * field (or a subclass or implementor thereof),
874 * or if an unwrapping conversion fails.
875 * @throws NullPointerException if the specified object is null
876 * and the field is an instance field.
877 * @throws ExceptionInInitializerError if the initialization provoked
878 * by this method fails.
879 * @see Field#set
880 */
881 @CallerSensitive
882 @ForceInline // to ensure Reflection.getCallerClass optimization
883 public void setBoolean(Object obj, boolean z)
884 throws IllegalArgumentException, IllegalAccessException
885 {
886 if (!override) {
887 Class<?> caller = Reflection.getCallerClass();
888 checkAccess(caller, obj);
889 getFieldAccessor().setBoolean(obj, z);
890 } else {
891 getOverrideFieldAccessor().setBoolean(obj, z);
892 }
893 }
894
895 /**
896 * Sets the value of a field as a {@code byte} on the specified object.
897 * This method is equivalent to
898 * {@code set(obj, bObj)},
899 * where {@code bObj} is a {@code Byte} object and
900 * {@code bObj.byteValue() == b}.
901 *
902 * @param obj the object whose field should be modified
903 * @param b the new value for the field of {@code obj}
904 * being modified
905 *
906 * @throws IllegalAccessException if this {@code Field} object
907 * is enforcing Java language access control and the underlying
908 * field is either inaccessible or final;
909 * or if this {@code Field} object has no write access.
910 * @throws IllegalArgumentException if the specified object is not an
911 * instance of the class or interface declaring the underlying
912 * field (or a subclass or implementor thereof),
913 * or if an unwrapping conversion fails.
914 * @throws NullPointerException if the specified object is null
915 * and the field is an instance field.
916 * @throws ExceptionInInitializerError if the initialization provoked
917 * by this method fails.
918 * @see Field#set
919 */
920 @CallerSensitive
921 @ForceInline // to ensure Reflection.getCallerClass optimization
922 public void setByte(Object obj, byte b)
923 throws IllegalArgumentException, IllegalAccessException
924 {
925 if (!override) {
926 Class<?> caller = Reflection.getCallerClass();
927 checkAccess(caller, obj);
928 getFieldAccessor().setByte(obj, b);
929 } else {
930 getOverrideFieldAccessor().setByte(obj, b);
931 }
932 }
933
934 /**
935 * Sets the value of a field as a {@code char} on the specified object.
936 * This method is equivalent to
937 * {@code set(obj, cObj)},
938 * where {@code cObj} is a {@code Character} object and
939 * {@code cObj.charValue() == c}.
940 *
941 * @param obj the object whose field should be modified
942 * @param c the new value for the field of {@code obj}
943 * being modified
944 *
945 * @throws IllegalAccessException if this {@code Field} object
946 * is enforcing Java language access control and the underlying
947 * field is either inaccessible or final;
948 * or if this {@code Field} object has no write access.
949 * @throws IllegalArgumentException if the specified object is not an
950 * instance of the class or interface declaring the underlying
951 * field (or a subclass or implementor thereof),
952 * or if an unwrapping conversion fails.
953 * @throws NullPointerException if the specified object is null
954 * and the field is an instance field.
955 * @throws ExceptionInInitializerError if the initialization provoked
956 * by this method fails.
957 * @see Field#set
958 */
959 @CallerSensitive
960 @ForceInline // to ensure Reflection.getCallerClass optimization
961 public void setChar(Object obj, char c)
962 throws IllegalArgumentException, IllegalAccessException
963 {
964 if (!override) {
965 Class<?> caller = Reflection.getCallerClass();
966 checkAccess(caller, obj);
967 getFieldAccessor().setChar(obj, c);
968 } else {
969 getOverrideFieldAccessor().setChar(obj, c);
970 }
971 }
972
973 /**
974 * Sets the value of a field as a {@code short} on the specified object.
975 * This method is equivalent to
976 * {@code set(obj, sObj)},
977 * where {@code sObj} is a {@code Short} object and
978 * {@code sObj.shortValue() == s}.
979 *
980 * @param obj the object whose field should be modified
981 * @param s the new value for the field of {@code obj}
982 * being modified
983 *
984 * @throws IllegalAccessException if this {@code Field} object
985 * is enforcing Java language access control and the underlying
986 * field is either inaccessible or final;
987 * or if this {@code Field} object has no write access.
988 * @throws IllegalArgumentException if the specified object is not an
989 * instance of the class or interface declaring the underlying
990 * field (or a subclass or implementor thereof),
991 * or if an unwrapping conversion fails.
992 * @throws NullPointerException if the specified object is null
993 * and the field is an instance field.
994 * @throws ExceptionInInitializerError if the initialization provoked
995 * by this method fails.
996 * @see Field#set
997 */
998 @CallerSensitive
999 @ForceInline // to ensure Reflection.getCallerClass optimization
1000 public void setShort(Object obj, short s)
1001 throws IllegalArgumentException, IllegalAccessException
1002 {
1003 if (!override) {
1004 Class<?> caller = Reflection.getCallerClass();
1005 checkAccess(caller, obj);
1006 getFieldAccessor().setShort(obj, s);
1007 } else {
1008 getOverrideFieldAccessor().setShort(obj, s);
1009 }
1010 }
1011
1012 /**
1013 * Sets the value of a field as an {@code int} on the specified object.
1014 * This method is equivalent to
1015 * {@code set(obj, iObj)},
1016 * where {@code iObj} is an {@code Integer} object and
1017 * {@code iObj.intValue() == i}.
1018 *
1019 * @param obj the object whose field should be modified
1020 * @param i the new value for the field of {@code obj}
1021 * being modified
1022 *
1023 * @throws IllegalAccessException if this {@code Field} object
1024 * is enforcing Java language access control and the underlying
1025 * field is either inaccessible or final;
1026 * or if this {@code Field} object has no write access.
1027 * @throws IllegalArgumentException if the specified object is not an
1028 * instance of the class or interface declaring the underlying
1029 * field (or a subclass or implementor thereof),
1030 * or if an unwrapping conversion fails.
1031 * @throws NullPointerException if the specified object is null
1032 * and the field is an instance field.
1033 * @throws ExceptionInInitializerError if the initialization provoked
1034 * by this method fails.
1035 * @see Field#set
1036 */
1037 @CallerSensitive
1038 @ForceInline // to ensure Reflection.getCallerClass optimization
1039 public void setInt(Object obj, int i)
1040 throws IllegalArgumentException, IllegalAccessException
1041 {
1042 if (!override) {
1043 Class<?> caller = Reflection.getCallerClass();
1044 checkAccess(caller, obj);
1045 getFieldAccessor().setInt(obj, i);
1046 } else {
1047 getOverrideFieldAccessor().setInt(obj, i);
1048 }
1049 }
1050
1051 /**
1052 * Sets the value of a field as a {@code long} on the specified object.
1053 * This method is equivalent to
1054 * {@code set(obj, lObj)},
1055 * where {@code lObj} is a {@code Long} object and
1056 * {@code lObj.longValue() == l}.
1057 *
1058 * @param obj the object whose field should be modified
1059 * @param l the new value for the field of {@code obj}
1060 * being modified
1061 *
1062 * @throws IllegalAccessException if this {@code Field} object
1063 * is enforcing Java language access control and the underlying
1064 * field is either inaccessible or final;
1065 * or if this {@code Field} object has no write access.
1066 * @throws IllegalArgumentException if the specified object is not an
1067 * instance of the class or interface declaring the underlying
1068 * field (or a subclass or implementor thereof),
1069 * or if an unwrapping conversion fails.
1070 * @throws NullPointerException if the specified object is null
1071 * and the field is an instance field.
1072 * @throws ExceptionInInitializerError if the initialization provoked
1073 * by this method fails.
1074 * @see Field#set
1075 */
1076 @CallerSensitive
1077 @ForceInline // to ensure Reflection.getCallerClass optimization
1078 public void setLong(Object obj, long l)
1079 throws IllegalArgumentException, IllegalAccessException
1080 {
1081 if (!override) {
1082 Class<?> caller = Reflection.getCallerClass();
1083 checkAccess(caller, obj);
1084 getFieldAccessor().setLong(obj, l);
1085 } else {
1086 getOverrideFieldAccessor().setLong(obj, l);
1087 }
1088 }
1089
1090 /**
1091 * Sets the value of a field as a {@code float} on the specified object.
1092 * This method is equivalent to
1093 * {@code set(obj, fObj)},
1094 * where {@code fObj} is a {@code Float} object and
1095 * {@code fObj.floatValue() == f}.
1096 *
1097 * @param obj the object whose field should be modified
1098 * @param f the new value for the field of {@code obj}
1099 * being modified
1100 *
1101 * @throws IllegalAccessException if this {@code Field} object
1102 * is enforcing Java language access control and the underlying
1103 * field is either inaccessible or final;
1104 * or if this {@code Field} object has no write access.
1105 * @throws IllegalArgumentException if the specified object is not an
1106 * instance of the class or interface declaring the underlying
1107 * field (or a subclass or implementor thereof),
1108 * or if an unwrapping conversion fails.
1109 * @throws NullPointerException if the specified object is null
1110 * and the field is an instance field.
1111 * @throws ExceptionInInitializerError if the initialization provoked
1112 * by this method fails.
1113 * @see Field#set
1114 */
1115 @CallerSensitive
1116 @ForceInline // to ensure Reflection.getCallerClass optimization
1117 public void setFloat(Object obj, float f)
1118 throws IllegalArgumentException, IllegalAccessException
1119 {
1120 if (!override) {
1121 Class<?> caller = Reflection.getCallerClass();
1122 checkAccess(caller, obj);
1123 getFieldAccessor().setFloat(obj, f);
1124 } else {
1125 getOverrideFieldAccessor().setFloat(obj, f);
1126 }
1127 }
1128
1129 /**
1130 * Sets the value of a field as a {@code double} on the specified object.
1131 * This method is equivalent to
1132 * {@code set(obj, dObj)},
1133 * where {@code dObj} is a {@code Double} object and
1134 * {@code dObj.doubleValue() == d}.
1135 *
1136 * @param obj the object whose field should be modified
1137 * @param d the new value for the field of {@code obj}
1138 * being modified
1139 *
1140 * @throws IllegalAccessException if this {@code Field} object
1141 * is enforcing Java language access control and the underlying
1142 * field is either inaccessible or final;
1143 * or if this {@code Field} object has no write access.
1144 * @throws IllegalArgumentException if the specified object is not an
1145 * instance of the class or interface declaring the underlying
1146 * field (or a subclass or implementor thereof),
1147 * or if an unwrapping conversion fails.
1148 * @throws NullPointerException if the specified object is null
1149 * and the field is an instance field.
1150 * @throws ExceptionInInitializerError if the initialization provoked
1151 * by this method fails.
1152 * @see Field#set
1153 */
1154 @CallerSensitive
1155 @ForceInline // to ensure Reflection.getCallerClass optimization
1156 public void setDouble(Object obj, double d)
1157 throws IllegalArgumentException, IllegalAccessException
1158 {
1159 if (!override) {
1160 Class<?> caller = Reflection.getCallerClass();
1161 checkAccess(caller, obj);
1162 getFieldAccessor().setDouble(obj, d);
1163 } else {
1164 getOverrideFieldAccessor().setDouble(obj, d);
1165 }
1166 }
1167
1168 // check access to field
1169 private void checkAccess(Class<?> caller, Object obj)
1170 throws IllegalAccessException
1171 {
1172 checkAccess(caller, clazz,
1173 Modifier.isStatic(modifiers) ? null : obj.getClass(),
1174 modifiers);
1175 }
1176
1177 // security check is done before calling this method
1178 private FieldAccessor getFieldAccessor() {
1179 FieldAccessor a = fieldAccessor;
1180 return (a != null) ? a : acquireFieldAccessor();
1181 }
1182
1183 private FieldAccessor getOverrideFieldAccessor() {
1184 FieldAccessor a = overrideFieldAccessor;
1185 return (a != null) ? a : acquireOverrideFieldAccessor();
1186 }
1187
1188 // NOTE that there is no synchronization used here. It is correct
1189 // (though not efficient) to generate more than one FieldAccessor
1190 // for a given Field. However, avoiding synchronization will
1191 // probably make the implementation more scalable.
1192 private FieldAccessor acquireFieldAccessor() {
1193 // First check to see if one has been created yet, and take it
1194 // if so
1195 Field root = this.root;
1196 FieldAccessor tmp = root == null ? null : root.fieldAccessor;
1197 if (tmp != null) {
1198 fieldAccessor = tmp;
1199 } else {
1200 // Otherwise fabricate one and propagate it up to the root
1201 tmp = reflectionFactory.newFieldAccessor(this, false);
1202 setFieldAccessor(tmp);
1203 }
1204 return tmp;
1205 }
1206
1207 private FieldAccessor acquireOverrideFieldAccessor() {
1208 // First check to see if one has been created yet, and take it
1209 // if so
1210 Field root = this.root;
1211 FieldAccessor tmp = root == null ? null : root.overrideFieldAccessor;
1212 if (tmp != null) {
1213 overrideFieldAccessor = tmp;
1214 } else {
1215 // Otherwise fabricate one and propagate it up to the root
1216 tmp = reflectionFactory.newFieldAccessor(this, true);
1217 setOverrideFieldAccessor(tmp);
1218 }
1219 return tmp;
1220 }
1221
1222 // Sets the fieldAccessor for this Field object and
1223 // (recursively) its root
1224 private void setFieldAccessor(FieldAccessor accessor) {
1225 fieldAccessor = accessor;
1226 // Propagate up
1227 Field root = this.root;
1228 if (root != null) {
1229 root.setFieldAccessor(accessor);
1230 }
1231 }
1232
1233 // Sets the overrideFieldAccessor for this Field object and
1234 // (recursively) its root
1235 private void setOverrideFieldAccessor(FieldAccessor accessor) {
1236 overrideFieldAccessor = accessor;
1237 // Propagate up
1238 Field root = this.root;
1239 if (root != null) {
1240 root.setOverrideFieldAccessor(accessor);
1241 }
1242 }
1243
1244 @Override
1245 /* package-private */ Field getRoot() {
1246 return root;
1247 }
1248
1249 /* package-private */ boolean isTrustedFinal() {
1250 return trustedFinal;
1251 }
1252
1253 /**
1254 * {@inheritDoc}
1255 *
1256 * @throws NullPointerException {@inheritDoc}
1257 * @since 1.5
1258 */
1259 @Override
1260 public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
1261 Objects.requireNonNull(annotationClass);
1262 return annotationClass.cast(declaredAnnotations().get(annotationClass));
1263 }
1264
1265 /**
1266 * {@inheritDoc}
1267 *
1268 * @throws NullPointerException {@inheritDoc}
1269 * @since 1.8
1270 */
1271 @Override
1272 public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
1273 Objects.requireNonNull(annotationClass);
1274
1275 return AnnotationSupport.getDirectlyAndIndirectlyPresent(declaredAnnotations(), annotationClass);
1276 }
1277
1278 /**
1279 * {@inheritDoc}
1280 */
1281 @Override
1282 public Annotation[] getDeclaredAnnotations() {
1283 return AnnotationParser.toArray(declaredAnnotations());
1284 }
1285
1286 private transient volatile Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
1287
1288 private Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
1289 Map<Class<? extends Annotation>, Annotation> declAnnos;
1290 if ((declAnnos = declaredAnnotations) == null) {
1291 synchronized (this) {
1292 if ((declAnnos = declaredAnnotations) == null) {
1293 Field root = this.root;
1294 if (root != null) {
1295 declAnnos = root.declaredAnnotations();
1296 } else {
1297 declAnnos = AnnotationParser.parseAnnotations(
1298 annotations,
1299 SharedSecrets.getJavaLangAccess()
1300 .getConstantPool(getDeclaringClass()),
1301 getDeclaringClass());
1302 }
1303 declaredAnnotations = declAnnos;
1304 }
1305 }
1306 }
1307 return declAnnos;
1308 }
1309
1310 private native byte[] getTypeAnnotationBytes0();
1311
1312 /**
1313 * Returns an AnnotatedType object that represents the use of a type to specify
1314 * the declared type of the field represented by this Field.
1315 * @return an object representing the declared type of the field
1316 * represented by this Field
1317 *
1318 * @since 1.8
1319 */
1320 public AnnotatedType getAnnotatedType() {
1321 return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
1322 SharedSecrets.getJavaLangAccess().
1323 getConstantPool(getDeclaringClass()),
1324 this,
1325 getDeclaringClass(),
1326 getGenericType(),
1327 TypeAnnotation.TypeAnnotationTarget.FIELD);
1328 }
1329 }