1 /*
   2  * Copyright (c) 1996, 2015, 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.misc.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 sun.reflect.generics.repository.FieldRepository;
  34 import sun.reflect.generics.factory.CoreReflectionFactory;
  35 import sun.reflect.generics.factory.GenericsFactory;
  36 import sun.reflect.generics.scope.ClassScope;
  37 import java.lang.annotation.Annotation;
  38 import java.util.Map;
  39 import java.util.Objects;
  40 import sun.reflect.annotation.AnnotationParser;
  41 import sun.reflect.annotation.AnnotationSupport;
  42 import sun.reflect.annotation.TypeAnnotation;
  43 import sun.reflect.annotation.TypeAnnotationParser;
  44 
  45 /**
  46  * A {@code Field} provides information about, and dynamic access to, a
  47  * single field of a class or an interface.  The reflected field may
  48  * be a class (static) field or an instance field.
  49  *
  50  * <p>A {@code Field} permits widening conversions to occur during a get or
  51  * set access operation, but throws an {@code IllegalArgumentException} if a
  52  * narrowing conversion would occur.
  53  *
  54  * @see Member
  55  * @see java.lang.Class
  56  * @see java.lang.Class#getFields()
  57  * @see java.lang.Class#getField(String)
  58  * @see java.lang.Class#getDeclaredFields()
  59  * @see java.lang.Class#getDeclaredField(String)
  60  *
  61  * @author Kenneth Russell
  62  * @author Nakul Saraiya
  63  * @since 1.1
  64  */
  65 public final
  66 class Field extends AccessibleObject implements Member {
  67 
  68     private Class<?>            clazz;
  69     private int                 slot;
  70     // This is guaranteed to be interned by the VM in the 1.4
  71     // reflection implementation
  72     private String              name;
  73     private Class<?>            type;
  74     private int                 modifiers;
  75     // Generics and annotations support
  76     private transient String    signature;
  77     // generic info repository; lazily initialized
  78     private transient FieldRepository genericInfo;
  79     private byte[]              annotations;
  80     // Cached field accessor created without override
  81     private FieldAccessor fieldAccessor;
  82     // Cached field accessor created with override
  83     private FieldAccessor overrideFieldAccessor;
  84     // For sharing of FieldAccessors. This branching structure is
  85     // currently only two levels deep (i.e., one root Field and
  86     // potentially many Field objects pointing to it.)
  87     //
  88     // If this branching structure would ever contain cycles, deadlocks can
  89     // occur in annotation code.
  90     private Field               root;
  91 
  92     // Generics infrastructure
  93 
  94     private String getGenericSignature() {return signature;}
  95 
  96     // Accessor for factory
  97     private GenericsFactory getFactory() {
  98         Class<?> c = getDeclaringClass();
  99         // create scope and factory
 100         return CoreReflectionFactory.make(c, ClassScope.make(c));
 101     }
 102 
 103     // Accessor for generic info repository
 104     private FieldRepository getGenericInfo() {
 105         // lazily initialize repository if necessary
 106         if (genericInfo == null) {
 107             // create and cache generic info repository
 108             genericInfo = FieldRepository.make(getGenericSignature(),
 109                                                getFactory());
 110         }
 111         return genericInfo; //return cached repository
 112     }
 113 
 114 
 115     /**
 116      * Package-private constructor used by ReflectAccess to enable
 117      * instantiation of these objects in Java code from the java.lang
 118      * package via sun.reflect.LangReflectAccess.
 119      */
 120     Field(Class<?> declaringClass,
 121           String name,
 122           Class<?> type,
 123           int modifiers,
 124           int slot,
 125           String signature,
 126           byte[] annotations)
 127     {
 128         this.clazz = declaringClass;
 129         this.name = name;
 130         this.type = type;
 131         this.modifiers = modifiers;
 132         this.slot = slot;
 133         this.signature = signature;
 134         this.annotations = annotations;
 135     }
 136 
 137     /**
 138      * Package-private routine (exposed to java.lang.Class via
 139      * ReflectAccess) which returns a copy of this Field. The copy's
 140      * "root" field points to this Field.
 141      */
 142     Field copy() {
 143         // This routine enables sharing of FieldAccessor objects
 144         // among Field objects which refer to the same underlying
 145         // method in the VM. (All of this contortion is only necessary
 146         // because of the "accessibility" bit in AccessibleObject,
 147         // which implicitly requires that new java.lang.reflect
 148         // objects be fabricated for each reflective call on Class
 149         // objects.)
 150         if (this.root != null)
 151             throw new IllegalArgumentException("Can not copy a non-root Field");
 152 
 153         Field res = new Field(clazz, name, type, modifiers, slot, signature, annotations);
 154         res.root = this;
 155         // Might as well eagerly propagate this if already present
 156         res.fieldAccessor = fieldAccessor;
 157         res.overrideFieldAccessor = overrideFieldAccessor;
 158 
 159         return res;
 160     }
 161 
 162     /**
 163      * @throws InaccessibleObjectException {@inheritDoc}
 164      * @throws SecurityException {@inheritDoc}
 165      */
 166     @Override
 167     @CallerSensitive
 168     public void setAccessible(boolean flag) {
 169         AccessibleObject.checkPermission();






 170         if (flag) checkCanSetAccessible(Reflection.getCallerClass());
 171         setAccessible0(flag);
 172     }
 173 
 174     @Override
 175     void checkCanSetAccessible(Class<?> caller) {
 176         checkCanSetAccessible(caller, clazz);
 177     }
 178 
 179     /**
 180      * Returns the {@code Class} object representing the class or interface
 181      * that declares the field represented by this {@code Field} object.
 182      */
 183     @Override
 184     public Class<?> getDeclaringClass() {
 185         return clazz;
 186     }
 187 
 188     /**
 189      * Returns the name of the field represented by this {@code Field} object.
 190      */
 191     public String getName() {
 192         return name;
 193     }
 194 
 195     /**
 196      * Returns the Java language modifiers for the field represented
 197      * by this {@code Field} object, as an integer. The {@code Modifier} class should
 198      * be used to decode the modifiers.
 199      *
 200      * @see Modifier
 201      */
 202     public int getModifiers() {
 203         return modifiers;
 204     }
 205 
 206     /**
 207      * Returns {@code true} if this field represents an element of
 208      * an enumerated type; returns {@code false} otherwise.
 209      *
 210      * @return {@code true} if and only if this field represents an element of
 211      * an enumerated type.
 212      * @since 1.5
 213      */
 214     public boolean isEnumConstant() {
 215         return (getModifiers() & Modifier.ENUM) != 0;
 216     }
 217 
 218     /**
 219      * Returns {@code true} if this field is a synthetic
 220      * field; returns {@code false} otherwise.
 221      *
 222      * @return true if and only if this field is a synthetic
 223      * field as defined by the Java Language Specification.
 224      * @since 1.5
 225      */
 226     public boolean isSynthetic() {
 227         return Modifier.isSynthetic(getModifiers());
 228     }
 229 
 230     /**
 231      * Returns a {@code Class} object that identifies the
 232      * declared type for the field represented by this
 233      * {@code Field} object.
 234      *
 235      * @return a {@code Class} object identifying the declared
 236      * type of the field represented by this object
 237      */
 238     public Class<?> getType() {
 239         return type;
 240     }
 241 
 242     /**
 243      * Returns a {@code Type} object that represents the declared type for
 244      * the field represented by this {@code Field} object.
 245      *
 246      * <p>If the {@code Type} is a parameterized type, the
 247      * {@code Type} object returned must accurately reflect the
 248      * actual type parameters used in the source code.
 249      *
 250      * <p>If the type of the underlying field is a type variable or a
 251      * parameterized type, it is created. Otherwise, it is resolved.
 252      *
 253      * @return a {@code Type} object that represents the declared type for
 254      *     the field represented by this {@code Field} object
 255      * @throws GenericSignatureFormatError if the generic field
 256      *     signature does not conform to the format specified in
 257      *     <cite>The Java&trade; Virtual Machine Specification</cite>
 258      * @throws TypeNotPresentException if the generic type
 259      *     signature of the underlying field refers to a non-existent
 260      *     type declaration
 261      * @throws MalformedParameterizedTypeException if the generic
 262      *     signature of the underlying field refers to a parameterized type
 263      *     that cannot be instantiated for any reason
 264      * @since 1.5
 265      */
 266     public Type getGenericType() {
 267         if (getGenericSignature() != null)
 268             return getGenericInfo().getGenericType();
 269         else
 270             return getType();
 271     }
 272 
 273 
 274     /**
 275      * Compares this {@code Field} against the specified object.  Returns
 276      * true if the objects are the same.  Two {@code Field} objects are the same if
 277      * they were declared by the same class and have the same name
 278      * and type.
 279      */
 280     public boolean equals(Object obj) {
 281         if (obj != null && obj instanceof Field) {
 282             Field other = (Field)obj;
 283             return (getDeclaringClass() == other.getDeclaringClass())
 284                 && (getName() == other.getName())
 285                 && (getType() == other.getType());
 286         }
 287         return false;
 288     }
 289 
 290     /**
 291      * Returns a hashcode for this {@code Field}.  This is computed as the
 292      * exclusive-or of the hashcodes for the underlying field's
 293      * declaring class name and its name.
 294      */
 295     public int hashCode() {
 296         return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
 297     }
 298 
 299     /**
 300      * Returns a string describing this {@code Field}.  The format is
 301      * the access modifiers for the field, if any, followed
 302      * by the field type, followed by a space, followed by
 303      * the fully-qualified name of the class declaring the field,
 304      * followed by a period, followed by the name of the field.
 305      * For example:
 306      * <pre>
 307      *    public static final int java.lang.Thread.MIN_PRIORITY
 308      *    private int java.io.FileDescriptor.fd
 309      * </pre>
 310      *
 311      * <p>The modifiers are placed in canonical order as specified by
 312      * "The Java Language Specification".  This is {@code public},
 313      * {@code protected} or {@code private} first, and then other
 314      * modifiers in the following order: {@code static}, {@code final},
 315      * {@code transient}, {@code volatile}.
 316      *
 317      * @return a string describing this {@code Field}
 318      * @jls 8.3.1 Field Modifiers
 319      */
 320     public String toString() {
 321         int mod = getModifiers();
 322         return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
 323             + getType().getTypeName() + " "
 324             + getDeclaringClass().getTypeName() + "."
 325             + getName());
 326     }
 327 
 328     @Override
 329     String toShortString() {
 330         return "field " + getDeclaringClass().getTypeName() + "." + getName();
 331     }
 332 
 333     /**
 334      * Returns a string describing this {@code Field}, including
 335      * its generic type.  The format is the access modifiers for the
 336      * field, if any, followed by the generic field type, followed by
 337      * a space, followed by the fully-qualified name of the class
 338      * declaring the field, followed by a period, followed by the name
 339      * of the field.
 340      *
 341      * <p>The modifiers are placed in canonical order as specified by
 342      * "The Java Language Specification".  This is {@code public},
 343      * {@code protected} or {@code private} first, and then other
 344      * modifiers in the following order: {@code static}, {@code final},
 345      * {@code transient}, {@code volatile}.
 346      *
 347      * @return a string describing this {@code Field}, including
 348      * its generic type
 349      *
 350      * @since 1.5
 351      * @jls 8.3.1 Field Modifiers
 352      */
 353     public String toGenericString() {
 354         int mod = getModifiers();
 355         Type fieldType = getGenericType();
 356         return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
 357             + fieldType.getTypeName() + " "
 358             + getDeclaringClass().getTypeName() + "."
 359             + getName());
 360     }
 361 
 362     /**
 363      * Returns the value of the field represented by this {@code Field}, on
 364      * the specified object. The value is automatically wrapped in an
 365      * object if it has a primitive type.
 366      *
 367      * <p>The underlying field's value is obtained as follows:
 368      *
 369      * <p>If the underlying field is a static field, the {@code obj} argument
 370      * is ignored; it may be null.
 371      *
 372      * <p>Otherwise, the underlying field is an instance field.  If the
 373      * specified {@code obj} argument is null, the method throws a
 374      * {@code NullPointerException}. If the specified object is not an
 375      * instance of the class or interface declaring the underlying
 376      * field, the method throws an {@code IllegalArgumentException}.
 377      *
 378      * <p>If this {@code Field} object is enforcing Java language access control, and
 379      * the underlying field is inaccessible, the method throws an
 380      * {@code IllegalAccessException}.
 381      * If the underlying field is static, the class that declared the
 382      * field is initialized if it has not already been initialized.
 383      *
 384      * <p>Otherwise, the value is retrieved from the underlying instance
 385      * or static field.  If the field has a primitive type, the value
 386      * is wrapped in an object before being returned, otherwise it is
 387      * returned as is.
 388      *
 389      * <p>If the field is hidden in the type of {@code obj},
 390      * the field's value is obtained according to the preceding rules.
 391      *
 392      * @param obj object from which the represented field's value is
 393      * to be extracted
 394      * @return the value of the represented field in object
 395      * {@code obj}; primitive values are wrapped in an appropriate
 396      * object before being returned
 397      *
 398      * @exception IllegalAccessException    if this {@code Field} object
 399      *              is enforcing Java language access control and the underlying
 400      *              field is inaccessible.
 401      * @exception IllegalArgumentException  if the specified object is not an
 402      *              instance of the class or interface declaring the underlying
 403      *              field (or a subclass or implementor thereof).
 404      * @exception NullPointerException      if the specified object is null
 405      *              and the field is an instance field.
 406      * @exception ExceptionInInitializerError if the initialization provoked
 407      *              by this method fails.
 408      */
 409     @CallerSensitive
 410     @ForceInline // to ensure Reflection.getCallerClass optimization
 411     public Object get(Object obj)
 412         throws IllegalArgumentException, IllegalAccessException
 413     {
 414         if (!override) {
 415             Class<?> caller = Reflection.getCallerClass();
 416             checkAccess(caller, obj);
 417         }
 418         return getFieldAccessor(obj).get(obj);
 419     }
 420 
 421     /**
 422      * Gets the value of a static or instance {@code boolean} field.
 423      *
 424      * @param obj the object to extract the {@code boolean} value
 425      * from
 426      * @return the value of the {@code boolean} field
 427      *
 428      * @exception IllegalAccessException    if this {@code Field} object
 429      *              is enforcing Java language access control and the underlying
 430      *              field is inaccessible.
 431      * @exception IllegalArgumentException  if the specified object is not
 432      *              an instance of the class or interface declaring the
 433      *              underlying field (or a subclass or implementor
 434      *              thereof), or if the field value cannot be
 435      *              converted to the type {@code boolean} by a
 436      *              widening conversion.
 437      * @exception NullPointerException      if the specified object is null
 438      *              and the field is an instance field.
 439      * @exception ExceptionInInitializerError if the initialization provoked
 440      *              by this method fails.
 441      * @see       Field#get
 442      */
 443     @CallerSensitive
 444     @ForceInline // to ensure Reflection.getCallerClass optimization
 445     public boolean getBoolean(Object obj)
 446         throws IllegalArgumentException, IllegalAccessException
 447     {
 448         if (!override) {
 449             Class<?> caller = Reflection.getCallerClass();
 450             checkAccess(caller, obj);
 451         }
 452         return getFieldAccessor(obj).getBoolean(obj);
 453     }
 454 
 455     /**
 456      * Gets the value of a static or instance {@code byte} field.
 457      *
 458      * @param obj the object to extract the {@code byte} value
 459      * from
 460      * @return the value of the {@code byte} field
 461      *
 462      * @exception IllegalAccessException    if this {@code Field} object
 463      *              is enforcing Java language access control and the underlying
 464      *              field is inaccessible.
 465      * @exception IllegalArgumentException  if the specified object is not
 466      *              an instance of the class or interface declaring the
 467      *              underlying field (or a subclass or implementor
 468      *              thereof), or if the field value cannot be
 469      *              converted to the type {@code byte} by a
 470      *              widening conversion.
 471      * @exception NullPointerException      if the specified object is null
 472      *              and the field is an instance field.
 473      * @exception ExceptionInInitializerError if the initialization provoked
 474      *              by this method fails.
 475      * @see       Field#get
 476      */
 477     @CallerSensitive
 478     @ForceInline // to ensure Reflection.getCallerClass optimization
 479     public byte getByte(Object obj)
 480         throws IllegalArgumentException, IllegalAccessException
 481     {
 482         if (!override) {
 483             Class<?> caller = Reflection.getCallerClass();
 484             checkAccess(caller, obj);
 485         }
 486         return getFieldAccessor(obj).getByte(obj);
 487     }
 488 
 489     /**
 490      * Gets the value of a static or instance field of type
 491      * {@code char} or of another primitive type convertible to
 492      * type {@code char} via a widening conversion.
 493      *
 494      * @param obj the object to extract the {@code char} value
 495      * from
 496      * @return the value of the field converted to type {@code char}
 497      *
 498      * @exception IllegalAccessException    if this {@code Field} object
 499      *              is enforcing Java language access control and the underlying
 500      *              field is inaccessible.
 501      * @exception IllegalArgumentException  if the specified object is not
 502      *              an instance of the class or interface declaring the
 503      *              underlying field (or a subclass or implementor
 504      *              thereof), or if the field value cannot be
 505      *              converted to the type {@code char} by a
 506      *              widening conversion.
 507      * @exception NullPointerException      if the specified object is null
 508      *              and the field is an instance field.
 509      * @exception ExceptionInInitializerError if the initialization provoked
 510      *              by this method fails.
 511      * @see Field#get
 512      */
 513     @CallerSensitive
 514     @ForceInline // to ensure Reflection.getCallerClass optimization
 515     public char getChar(Object obj)
 516         throws IllegalArgumentException, IllegalAccessException
 517     {
 518         if (!override) {
 519             Class<?> caller = Reflection.getCallerClass();
 520             checkAccess(caller, obj);
 521         }
 522         return getFieldAccessor(obj).getChar(obj);
 523     }
 524 
 525     /**
 526      * Gets the value of a static or instance field of type
 527      * {@code short} or of another primitive type convertible to
 528      * type {@code short} via a widening conversion.
 529      *
 530      * @param obj the object to extract the {@code short} value
 531      * from
 532      * @return the value of the field converted to type {@code short}
 533      *
 534      * @exception IllegalAccessException    if this {@code Field} object
 535      *              is enforcing Java language access control and the underlying
 536      *              field is inaccessible.
 537      * @exception IllegalArgumentException  if the specified object is not
 538      *              an instance of the class or interface declaring the
 539      *              underlying field (or a subclass or implementor
 540      *              thereof), or if the field value cannot be
 541      *              converted to the type {@code short} by a
 542      *              widening conversion.
 543      * @exception NullPointerException      if the specified object is null
 544      *              and the field is an instance field.
 545      * @exception ExceptionInInitializerError if the initialization provoked
 546      *              by this method fails.
 547      * @see       Field#get
 548      */
 549     @CallerSensitive
 550     @ForceInline // to ensure Reflection.getCallerClass optimization
 551     public short getShort(Object obj)
 552         throws IllegalArgumentException, IllegalAccessException
 553     {
 554         if (!override) {
 555             Class<?> caller = Reflection.getCallerClass();
 556             checkAccess(caller, obj);
 557         }
 558         return getFieldAccessor(obj).getShort(obj);
 559     }
 560 
 561     /**
 562      * Gets the value of a static or instance field of type
 563      * {@code int} or of another primitive type convertible to
 564      * type {@code int} via a widening conversion.
 565      *
 566      * @param obj the object to extract the {@code int} value
 567      * from
 568      * @return the value of the field converted to type {@code int}
 569      *
 570      * @exception IllegalAccessException    if this {@code Field} object
 571      *              is enforcing Java language access control and the underlying
 572      *              field is inaccessible.
 573      * @exception IllegalArgumentException  if the specified object is not
 574      *              an instance of the class or interface declaring the
 575      *              underlying field (or a subclass or implementor
 576      *              thereof), or if the field value cannot be
 577      *              converted to the type {@code int} by a
 578      *              widening conversion.
 579      * @exception NullPointerException      if the specified object is null
 580      *              and the field is an instance field.
 581      * @exception ExceptionInInitializerError if the initialization provoked
 582      *              by this method fails.
 583      * @see       Field#get
 584      */
 585     @CallerSensitive
 586     @ForceInline // to ensure Reflection.getCallerClass optimization
 587     public int getInt(Object obj)
 588         throws IllegalArgumentException, IllegalAccessException
 589     {
 590         if (!override) {
 591             Class<?> caller = Reflection.getCallerClass();
 592             checkAccess(caller, obj);
 593         }
 594         return getFieldAccessor(obj).getInt(obj);
 595     }
 596 
 597     /**
 598      * Gets the value of a static or instance field of type
 599      * {@code long} or of another primitive type convertible to
 600      * type {@code long} via a widening conversion.
 601      *
 602      * @param obj the object to extract the {@code long} value
 603      * from
 604      * @return the value of the field converted to type {@code long}
 605      *
 606      * @exception IllegalAccessException    if this {@code Field} object
 607      *              is enforcing Java language access control and the underlying
 608      *              field is inaccessible.
 609      * @exception IllegalArgumentException  if the specified object is not
 610      *              an instance of the class or interface declaring the
 611      *              underlying field (or a subclass or implementor
 612      *              thereof), or if the field value cannot be
 613      *              converted to the type {@code long} by a
 614      *              widening conversion.
 615      * @exception NullPointerException      if the specified object is null
 616      *              and the field is an instance field.
 617      * @exception ExceptionInInitializerError if the initialization provoked
 618      *              by this method fails.
 619      * @see       Field#get
 620      */
 621     @CallerSensitive
 622     @ForceInline // to ensure Reflection.getCallerClass optimization
 623     public long getLong(Object obj)
 624         throws IllegalArgumentException, IllegalAccessException
 625     {
 626         if (!override) {
 627             Class<?> caller = Reflection.getCallerClass();
 628             checkAccess(caller, obj);
 629         }
 630         return getFieldAccessor(obj).getLong(obj);
 631     }
 632 
 633     /**
 634      * Gets the value of a static or instance field of type
 635      * {@code float} or of another primitive type convertible to
 636      * type {@code float} via a widening conversion.
 637      *
 638      * @param obj the object to extract the {@code float} value
 639      * from
 640      * @return the value of the field converted to type {@code float}
 641      *
 642      * @exception IllegalAccessException    if this {@code Field} object
 643      *              is enforcing Java language access control and the underlying
 644      *              field is inaccessible.
 645      * @exception IllegalArgumentException  if the specified object is not
 646      *              an instance of the class or interface declaring the
 647      *              underlying field (or a subclass or implementor
 648      *              thereof), or if the field value cannot be
 649      *              converted to the type {@code float} by a
 650      *              widening conversion.
 651      * @exception NullPointerException      if the specified object is null
 652      *              and the field is an instance field.
 653      * @exception ExceptionInInitializerError if the initialization provoked
 654      *              by this method fails.
 655      * @see Field#get
 656      */
 657     @CallerSensitive
 658     @ForceInline // to ensure Reflection.getCallerClass optimization
 659     public float getFloat(Object obj)
 660         throws IllegalArgumentException, IllegalAccessException
 661     {
 662         if (!override) {
 663             Class<?> caller = Reflection.getCallerClass();
 664             checkAccess(caller, obj);
 665         }
 666         return getFieldAccessor(obj).getFloat(obj);
 667     }
 668 
 669     /**
 670      * Gets the value of a static or instance field of type
 671      * {@code double} or of another primitive type convertible to
 672      * type {@code double} via a widening conversion.
 673      *
 674      * @param obj the object to extract the {@code double} value
 675      * from
 676      * @return the value of the field converted to type {@code double}
 677      *
 678      * @exception IllegalAccessException    if this {@code Field} object
 679      *              is enforcing Java language access control and the underlying
 680      *              field is inaccessible.
 681      * @exception IllegalArgumentException  if the specified object is not
 682      *              an instance of the class or interface declaring the
 683      *              underlying field (or a subclass or implementor
 684      *              thereof), or if the field value cannot be
 685      *              converted to the type {@code double} by a
 686      *              widening conversion.
 687      * @exception NullPointerException      if the specified object is null
 688      *              and the field is an instance field.
 689      * @exception ExceptionInInitializerError if the initialization provoked
 690      *              by this method fails.
 691      * @see       Field#get
 692      */
 693     @CallerSensitive
 694     @ForceInline // to ensure Reflection.getCallerClass optimization
 695     public double getDouble(Object obj)
 696         throws IllegalArgumentException, IllegalAccessException
 697     {
 698         if (!override) {
 699             Class<?> caller = Reflection.getCallerClass();
 700             checkAccess(caller, obj);
 701         }
 702         return getFieldAccessor(obj).getDouble(obj);
 703     }
 704 
 705     /**
 706      * Sets the field represented by this {@code Field} object on the
 707      * specified object argument to the specified new value. The new
 708      * value is automatically unwrapped if the underlying field has a
 709      * primitive type.
 710      *
 711      * <p>The operation proceeds as follows:
 712      *
 713      * <p>If the underlying field is static, the {@code obj} argument is
 714      * ignored; it may be null.
 715      *
 716      * <p>Otherwise the underlying field is an instance field.  If the
 717      * specified object argument is null, the method throws a
 718      * {@code NullPointerException}.  If the specified object argument is not
 719      * an instance of the class or interface declaring the underlying
 720      * field, the method throws an {@code IllegalArgumentException}.
 721      *
 722      * <p>If this {@code Field} object is enforcing Java language access control, and
 723      * the underlying field is inaccessible, the method throws an
 724      * {@code IllegalAccessException}.
 725      *
 726      * <p>If the underlying field is final, the method throws an
 727      * {@code IllegalAccessException} unless {@code setAccessible(true)}
 728      * has succeeded for this {@code Field} object
 729      * and the field is non-static. Setting a final field in this way
 730      * is meaningful only during deserialization or reconstruction of
 731      * instances of classes with blank final fields, before they are
 732      * made available for access by other parts of a program. Use in
 733      * any other context may have unpredictable effects, including cases
 734      * in which other parts of a program continue to use the original
 735      * value of this field.
 736      *
 737      * <p>If the underlying field is of a primitive type, an unwrapping
 738      * conversion is attempted to convert the new value to a value of
 739      * a primitive type.  If this attempt fails, the method throws an
 740      * {@code IllegalArgumentException}.
 741      *
 742      * <p>If, after possible unwrapping, the new value cannot be
 743      * converted to the type of the underlying field by an identity or
 744      * widening conversion, the method throws an
 745      * {@code IllegalArgumentException}.
 746      *
 747      * <p>If the underlying field is static, the class that declared the
 748      * field is initialized if it has not already been initialized.
 749      *
 750      * <p>The field is set to the possibly unwrapped and widened new value.
 751      *
 752      * <p>If the field is hidden in the type of {@code obj},
 753      * the field's value is set according to the preceding rules.
 754      *
 755      * @param obj the object whose field should be modified
 756      * @param value the new value for the field of {@code obj}
 757      * being modified
 758      *
 759      * @exception IllegalAccessException    if this {@code Field} object
 760      *              is enforcing Java language access control and the underlying
 761      *              field is either inaccessible or final.
 762      * @exception IllegalArgumentException  if the specified object is not an
 763      *              instance of the class or interface declaring the underlying
 764      *              field (or a subclass or implementor thereof),
 765      *              or if an unwrapping conversion fails.
 766      * @exception NullPointerException      if the specified object is null
 767      *              and the field is an instance field.
 768      * @exception ExceptionInInitializerError if the initialization provoked
 769      *              by this method fails.
 770      */
 771     @CallerSensitive
 772     @ForceInline // to ensure Reflection.getCallerClass optimization
 773     public void set(Object obj, Object value)
 774         throws IllegalArgumentException, IllegalAccessException
 775     {
 776         ensureNotValueClass();
 777 
 778         if (!override) {
 779             Class<?> caller = Reflection.getCallerClass();
 780             checkAccess(caller, obj);
 781         }
 782         getFieldAccessor(obj).set(obj, value);
 783     }
 784 
 785     /**
 786      * Sets the value of a field as a {@code boolean} on the specified object.
 787      * This method is equivalent to
 788      * {@code set(obj, zObj)},
 789      * where {@code zObj} is a {@code Boolean} object and
 790      * {@code zObj.booleanValue() == z}.
 791      *
 792      * @param obj the object whose field should be modified
 793      * @param z   the new value for the field of {@code obj}
 794      * being modified
 795      *
 796      * @exception IllegalAccessException    if this {@code Field} object
 797      *              is enforcing Java language access control and the underlying
 798      *              field is either inaccessible or final.
 799      * @exception IllegalArgumentException  if the specified object is not an
 800      *              instance of the class or interface declaring the underlying
 801      *              field (or a subclass or implementor thereof),
 802      *              or if an unwrapping conversion fails.
 803      * @exception NullPointerException      if the specified object is null
 804      *              and the field is an instance field.
 805      * @exception ExceptionInInitializerError if the initialization provoked
 806      *              by this method fails.
 807      * @see       Field#set
 808      */
 809     @CallerSensitive
 810     @ForceInline // to ensure Reflection.getCallerClass optimization
 811     public void setBoolean(Object obj, boolean z)
 812         throws IllegalArgumentException, IllegalAccessException
 813     {
 814         ensureNotValueClass();
 815 
 816         if (!override) {
 817             Class<?> caller = Reflection.getCallerClass();
 818             checkAccess(caller, obj);
 819         }
 820         getFieldAccessor(obj).setBoolean(obj, z);
 821     }
 822 
 823     /**
 824      * Sets the value of a field as a {@code byte} on the specified object.
 825      * This method is equivalent to
 826      * {@code set(obj, bObj)},
 827      * where {@code bObj} is a {@code Byte} object and
 828      * {@code bObj.byteValue() == b}.
 829      *
 830      * @param obj the object whose field should be modified
 831      * @param b   the new value for the field of {@code obj}
 832      * being modified
 833      *
 834      * @exception IllegalAccessException    if this {@code Field} object
 835      *              is enforcing Java language access control and the underlying
 836      *              field is either inaccessible or final.
 837      * @exception IllegalArgumentException  if the specified object is not an
 838      *              instance of the class or interface declaring the underlying
 839      *              field (or a subclass or implementor thereof),
 840      *              or if an unwrapping conversion fails.
 841      * @exception NullPointerException      if the specified object is null
 842      *              and the field is an instance field.
 843      * @exception ExceptionInInitializerError if the initialization provoked
 844      *              by this method fails.
 845      * @see       Field#set
 846      */
 847     @CallerSensitive
 848     @ForceInline // to ensure Reflection.getCallerClass optimization
 849     public void setByte(Object obj, byte b)
 850         throws IllegalArgumentException, IllegalAccessException
 851     {
 852         ensureNotValueClass();
 853 
 854         if (!override) {
 855             Class<?> caller = Reflection.getCallerClass();
 856             checkAccess(caller, obj);
 857         }
 858         getFieldAccessor(obj).setByte(obj, b);
 859     }
 860 
 861     /**
 862      * Sets the value of a field as a {@code char} on the specified object.
 863      * This method is equivalent to
 864      * {@code set(obj, cObj)},
 865      * where {@code cObj} is a {@code Character} object and
 866      * {@code cObj.charValue() == c}.
 867      *
 868      * @param obj the object whose field should be modified
 869      * @param c   the new value for the field of {@code obj}
 870      * being modified
 871      *
 872      * @exception IllegalAccessException    if this {@code Field} object
 873      *              is enforcing Java language access control and the underlying
 874      *              field is either inaccessible or final.
 875      * @exception IllegalArgumentException  if the specified object is not an
 876      *              instance of the class or interface declaring the underlying
 877      *              field (or a subclass or implementor thereof),
 878      *              or if an unwrapping conversion fails.
 879      * @exception NullPointerException      if the specified object is null
 880      *              and the field is an instance field.
 881      * @exception ExceptionInInitializerError if the initialization provoked
 882      *              by this method fails.
 883      * @see       Field#set
 884      */
 885     @CallerSensitive
 886     @ForceInline // to ensure Reflection.getCallerClass optimization
 887     public void setChar(Object obj, char c)
 888         throws IllegalArgumentException, IllegalAccessException
 889     {
 890         ensureNotValueClass();
 891 
 892         if (!override) {
 893             Class<?> caller = Reflection.getCallerClass();
 894             checkAccess(caller, obj);
 895         }
 896         getFieldAccessor(obj).setChar(obj, c);
 897     }
 898 
 899     /**
 900      * Sets the value of a field as a {@code short} on the specified object.
 901      * This method is equivalent to
 902      * {@code set(obj, sObj)},
 903      * where {@code sObj} is a {@code Short} object and
 904      * {@code sObj.shortValue() == s}.
 905      *
 906      * @param obj the object whose field should be modified
 907      * @param s   the new value for the field of {@code obj}
 908      * being modified
 909      *
 910      * @exception IllegalAccessException    if this {@code Field} object
 911      *              is enforcing Java language access control and the underlying
 912      *              field is either inaccessible or final.
 913      * @exception IllegalArgumentException  if the specified object is not an
 914      *              instance of the class or interface declaring the underlying
 915      *              field (or a subclass or implementor thereof),
 916      *              or if an unwrapping conversion fails.
 917      * @exception NullPointerException      if the specified object is null
 918      *              and the field is an instance field.
 919      * @exception ExceptionInInitializerError if the initialization provoked
 920      *              by this method fails.
 921      * @see       Field#set
 922      */
 923     @CallerSensitive
 924     @ForceInline // to ensure Reflection.getCallerClass optimization
 925     public void setShort(Object obj, short s)
 926         throws IllegalArgumentException, IllegalAccessException
 927     {
 928         ensureNotValueClass();
 929 
 930         if (!override) {
 931             Class<?> caller = Reflection.getCallerClass();
 932             checkAccess(caller, obj);
 933         }
 934         getFieldAccessor(obj).setShort(obj, s);
 935     }
 936 
 937     /**
 938      * Sets the value of a field as an {@code int} on the specified object.
 939      * This method is equivalent to
 940      * {@code set(obj, iObj)},
 941      * where {@code iObj} is an {@code Integer} object and
 942      * {@code iObj.intValue() == i}.
 943      *
 944      * @param obj the object whose field should be modified
 945      * @param i   the new value for the field of {@code obj}
 946      * being modified
 947      *
 948      * @exception IllegalAccessException    if this {@code Field} object
 949      *              is enforcing Java language access control and the underlying
 950      *              field is either inaccessible or final.
 951      * @exception IllegalArgumentException  if the specified object is not an
 952      *              instance of the class or interface declaring the underlying
 953      *              field (or a subclass or implementor thereof),
 954      *              or if an unwrapping conversion fails.
 955      * @exception NullPointerException      if the specified object is null
 956      *              and the field is an instance field.
 957      * @exception ExceptionInInitializerError if the initialization provoked
 958      *              by this method fails.
 959      * @see       Field#set
 960      */
 961     @CallerSensitive
 962     @ForceInline // to ensure Reflection.getCallerClass optimization
 963     public void setInt(Object obj, int i)
 964         throws IllegalArgumentException, IllegalAccessException
 965     {
 966         ensureNotValueClass();
 967 
 968         if (!override) {
 969             Class<?> caller = Reflection.getCallerClass();
 970             checkAccess(caller, obj);
 971         }
 972         getFieldAccessor(obj).setInt(obj, i);
 973     }
 974 
 975     /**
 976      * Sets the value of a field as a {@code long} on the specified object.
 977      * This method is equivalent to
 978      * {@code set(obj, lObj)},
 979      * where {@code lObj} is a {@code Long} object and
 980      * {@code lObj.longValue() == l}.
 981      *
 982      * @param obj the object whose field should be modified
 983      * @param l   the new value for the field of {@code obj}
 984      * being modified
 985      *
 986      * @exception IllegalAccessException    if this {@code Field} object
 987      *              is enforcing Java language access control and the underlying
 988      *              field is either inaccessible or final.
 989      * @exception IllegalArgumentException  if the specified object is not an
 990      *              instance of the class or interface declaring the underlying
 991      *              field (or a subclass or implementor thereof),
 992      *              or if an unwrapping conversion fails.
 993      * @exception NullPointerException      if the specified object is null
 994      *              and the field is an instance field.
 995      * @exception ExceptionInInitializerError if the initialization provoked
 996      *              by this method fails.
 997      * @see       Field#set
 998      */
 999     @CallerSensitive
1000     @ForceInline // to ensure Reflection.getCallerClass optimization
1001     public void setLong(Object obj, long l)
1002         throws IllegalArgumentException, IllegalAccessException
1003     {
1004         ensureNotValueClass();
1005 
1006         if (!override) {
1007             Class<?> caller = Reflection.getCallerClass();
1008             checkAccess(caller, obj);
1009         }
1010         getFieldAccessor(obj).setLong(obj, l);
1011     }
1012 
1013     /**
1014      * Sets the value of a field as a {@code float} on the specified object.
1015      * This method is equivalent to
1016      * {@code set(obj, fObj)},
1017      * where {@code fObj} is a {@code Float} object and
1018      * {@code fObj.floatValue() == f}.
1019      *
1020      * @param obj the object whose field should be modified
1021      * @param f   the new value for the field of {@code obj}
1022      * being modified
1023      *
1024      * @exception IllegalAccessException    if this {@code Field} object
1025      *              is enforcing Java language access control and the underlying
1026      *              field is either inaccessible or final.
1027      * @exception 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      * @exception NullPointerException      if the specified object is null
1032      *              and the field is an instance field.
1033      * @exception 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 setFloat(Object obj, float f)
1040         throws IllegalArgumentException, IllegalAccessException
1041     {
1042         ensureNotValueClass();
1043 
1044         if (!override) {
1045             Class<?> caller = Reflection.getCallerClass();
1046             checkAccess(caller, obj);
1047         }
1048         getFieldAccessor(obj).setFloat(obj, f);
1049     }
1050 
1051     /**
1052      * Sets the value of a field as a {@code double} on the specified object.
1053      * This method is equivalent to
1054      * {@code set(obj, dObj)},
1055      * where {@code dObj} is a {@code Double} object and
1056      * {@code dObj.doubleValue() == d}.
1057      *
1058      * @param obj the object whose field should be modified
1059      * @param d   the new value for the field of {@code obj}
1060      * being modified
1061      *
1062      * @exception IllegalAccessException    if this {@code Field} object
1063      *              is enforcing Java language access control and the underlying
1064      *              field is either inaccessible or final.
1065      * @exception IllegalArgumentException  if the specified object is not an
1066      *              instance of the class or interface declaring the underlying
1067      *              field (or a subclass or implementor thereof),
1068      *              or if an unwrapping conversion fails.
1069      * @exception NullPointerException      if the specified object is null
1070      *              and the field is an instance field.
1071      * @exception ExceptionInInitializerError if the initialization provoked
1072      *              by this method fails.
1073      * @see       Field#set
1074      */
1075     @CallerSensitive
1076     @ForceInline // to ensure Reflection.getCallerClass optimization
1077     public void setDouble(Object obj, double d)
1078         throws IllegalArgumentException, IllegalAccessException
1079     {
1080         ensureNotValueClass();
1081 
1082         if (!override) {
1083             Class<?> caller = Reflection.getCallerClass();
1084             checkAccess(caller, obj);
1085         }
1086         getFieldAccessor(obj).setDouble(obj, d);
1087     }
1088 
1089     // check access to field
1090     private void checkAccess(Class<?> caller, Object obj)
1091         throws IllegalAccessException
1092     {
1093         checkAccess(caller, clazz,
1094                     Modifier.isStatic(modifiers) ? null : obj.getClass(),
1095                     modifiers);
1096     }
1097 
1098     /*
1099      * Ensure the declaring class is not a value class.
1100      */
1101     private void ensureNotValueClass() throws IllegalAccessException {
1102         if (clazz.isValue()) {
1103             throw new IllegalAccessException("cannot set this field of a value class "
1104                 + clazz.getName());
1105         }
1106     }
1107 
1108     // security check is done before calling this method
1109     private FieldAccessor getFieldAccessor(Object obj)
1110         throws IllegalAccessException
1111     {
1112         boolean ov = override;
1113         FieldAccessor a = (ov) ? overrideFieldAccessor : fieldAccessor;
1114         return (a != null) ? a : acquireFieldAccessor(ov);
1115     }
1116 
1117     // NOTE that there is no synchronization used here. It is correct
1118     // (though not efficient) to generate more than one FieldAccessor
1119     // for a given Field. However, avoiding synchronization will
1120     // probably make the implementation more scalable.
1121     private FieldAccessor acquireFieldAccessor(boolean overrideFinalCheck) {
1122         // First check to see if one has been created yet, and take it
1123         // if so
1124         FieldAccessor tmp = null;
1125         if (root != null) tmp = root.getFieldAccessor(overrideFinalCheck);
1126         if (tmp != null) {
1127             if (overrideFinalCheck)
1128                 overrideFieldAccessor = tmp;
1129             else
1130                 fieldAccessor = tmp;
1131         } else {
1132             // Otherwise fabricate one and propagate it up to the root
1133             tmp = reflectionFactory.newFieldAccessor(this, overrideFinalCheck);
1134             setFieldAccessor(tmp, overrideFinalCheck);
1135         }
1136 
1137         return tmp;
1138     }
1139 
1140     // Returns FieldAccessor for this Field object, not looking up
1141     // the chain to the root
1142     private FieldAccessor getFieldAccessor(boolean overrideFinalCheck) {
1143         return (overrideFinalCheck)? overrideFieldAccessor : fieldAccessor;
1144     }
1145 
1146     // Sets the FieldAccessor for this Field object and
1147     // (recursively) its root
1148     private void setFieldAccessor(FieldAccessor accessor, boolean overrideFinalCheck) {
1149         if (overrideFinalCheck)
1150             overrideFieldAccessor = accessor;
1151         else
1152             fieldAccessor = accessor;
1153         // Propagate up
1154         if (root != null) {
1155             root.setFieldAccessor(accessor, overrideFinalCheck);
1156         }
1157     }
1158 
1159     /**
1160      * @throws NullPointerException {@inheritDoc}
1161      * @since 1.5
1162      */
1163     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
1164         Objects.requireNonNull(annotationClass);
1165         return annotationClass.cast(declaredAnnotations().get(annotationClass));
1166     }
1167 
1168     /**
1169      * {@inheritDoc}
1170      * @throws NullPointerException {@inheritDoc}
1171      * @since 1.8
1172      */
1173     @Override
1174     public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
1175         Objects.requireNonNull(annotationClass);
1176 
1177         return AnnotationSupport.getDirectlyAndIndirectlyPresent(declaredAnnotations(), annotationClass);
1178     }
1179 
1180     /**
1181      * {@inheritDoc}
1182      */
1183     public Annotation[] getDeclaredAnnotations()  {
1184         return AnnotationParser.toArray(declaredAnnotations());
1185     }
1186 
1187     private transient volatile Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
1188 
1189     private Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
1190         Map<Class<? extends Annotation>, Annotation> declAnnos;
1191         if ((declAnnos = declaredAnnotations) == null) {
1192             synchronized (this) {
1193                 if ((declAnnos = declaredAnnotations) == null) {
1194                     Field root = this.root;
1195                     if (root != null) {
1196                         declAnnos = root.declaredAnnotations();
1197                     } else {
1198                         declAnnos = AnnotationParser.parseAnnotations(
1199                                 annotations,
1200                                 SharedSecrets.getJavaLangAccess()
1201                                         .getConstantPool(getDeclaringClass()),
1202                                 getDeclaringClass());
1203                     }
1204                     declaredAnnotations = declAnnos;
1205                 }
1206             }
1207         }
1208         return declAnnos;
1209     }
1210 
1211     private native byte[] getTypeAnnotationBytes0();
1212 
1213     /**
1214      * Returns an AnnotatedType object that represents the use of a type to specify
1215      * the declared type of the field represented by this Field.
1216      * @return an object representing the declared type of the field
1217      * represented by this Field
1218      *
1219      * @since 1.8
1220      */
1221     public AnnotatedType getAnnotatedType() {
1222         return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
1223                                                        SharedSecrets.getJavaLangAccess().
1224                                                            getConstantPool(getDeclaringClass()),
1225                                                        this,
1226                                                        getDeclaringClass(),
1227                                                        getGenericType(),
1228                                                        TypeAnnotation.TypeAnnotationTarget.FIELD);
1229 }
1230 }
--- EOF ---