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