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