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