1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 /* 18 * Copyright (C) 2006-2007 The Android Open Source Project 19 * 20 * Licensed under the Apache License, Version 2.0 (the "License"); 21 * you may not use this file except in compliance with the License. 22 * You may obtain a copy of the License at 23 * 24 * http://www.apache.org/licenses/LICENSE-2.0 25 * 26 * Unless required by applicable law or agreed to in writing, software 27 * distributed under the License is distributed on an "AS IS" BASIS, 28 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 29 * See the License for the specific language governing permissions and 30 * limitations under the License. 31 */ 32 33 package java.lang; 34 35 import dalvik.system.VMStack; 36 import java.io.InputStream; 37 import java.io.Serializable; 38 import static java.lang.ClassCache.*; 39 import java.lang.annotation.Annotation; 40 import java.lang.annotation.Inherited; 41 import java.lang.ref.SoftReference; 42 import java.lang.reflect.AccessibleObject; 43 import java.lang.reflect.AnnotatedElement; 44 import java.lang.reflect.Constructor; 45 import java.lang.reflect.Field; 46 import java.lang.reflect.GenericDeclaration; 47 import java.lang.reflect.Member; 48 import java.lang.reflect.Method; 49 import java.lang.reflect.Modifier; 50 import java.lang.reflect.Type; 51 import java.lang.reflect.TypeVariable; 52 import java.net.URL; 53 import java.security.ProtectionDomain; 54 import java.util.Collection; 55 import java.util.HashMap; 56 import org.apache.harmony.kernel.vm.StringUtils; 57 import org.apache.harmony.luni.lang.reflect.GenericSignatureParser; 58 import org.apache.harmony.luni.lang.reflect.Types; 59 60 /** 61 * The in-memory representation of a Java class. This representation serves as 62 * the starting point for querying class-related information, a process usually 63 * called "reflection". There are basically three types of {@code Class} 64 * instances: those representing real classes and interfaces, those representing 65 * primitive types, and those representing array classes. 66 * 67 * <h4>Class instances representing object types (classes or interfaces)</h4> 68 * <p> 69 * These represent an ordinary class or interface as found in the class 70 * hierarchy. The name associated with these {@code Class} instances is simply 71 * the fully qualified class name of the class or interface that it represents. 72 * In addition to this human-readable name, each class is also associated by a 73 * so-called <em>signature</em>, which is the letter "L", followed by the 74 * class name and a semicolon (";"). The signature is what the runtime system 75 * uses internally for identifying the class (for example in a DEX file). 76 * </p> 77 * <h4>Classes representing primitive types</h4> 78 * <p> 79 * These represent the standard Java primitive types and hence share their 80 * names (for example "int" for the {@code int} primitive type). Although it is 81 * not possible to create new instances based on these {@code Class} instances, 82 * they are still useful for providing reflection information, and as the 83 * component type of array classes. There is one {@code Class} instance for each 84 * primitive type, and their signatures are: 85 * </p> 86 * <ul> 87 * <li>{@code B} representing the {@code byte} primitive type</li> 88 * <li>{@code S} representing the {@code short} primitive type</li> 89 * <li>{@code I} representing the {@code int} primitive type</li> 90 * <li>{@code J} representing the {@code long} primitive type</li> 91 * <li>{@code F} representing the {@code float} primitive type</li> 92 * <li>{@code D} representing the {@code double} primitive type</li> 93 * <li>{@code C} representing the {@code char} primitive type</li> 94 * <li>{@code Z} representing the {@code boolean} primitive type</li> 95 * <li>{@code V} representing void function return values</li> 96 * </ul> 97 * <p> 98 * <h4>Classes representing array classes</h4> 99 * <p> 100 * These represent the classes of Java arrays. There is one such {@code Class} 101 * instance per combination of array leaf component type and arity (number of 102 * dimensions). In this case, the name associated with the {@code Class} 103 * consists of one or more left square brackets (one per dimension in the array) 104 * followed by the signature of the class representing the leaf component type, 105 * which can be either an object type or a primitive type. The signature of a 106 * {@code Class} representing an array type is the same as its name. Examples 107 * of array class signatures are: 108 * </p> 109 * <ul> 110 * <li>{@code [I} representing the {@code int[]} type</li> 111 * <li>{@code [Ljava/lang/String;} representing the {@code String[]} type</li> 112 * <li>{@code [[[C} representing the {@code char[][][]} type (three dimensions!)</li> 113 * </ul> 114 */ 115 public final class Class<T> implements Serializable, AnnotatedElement, GenericDeclaration, Type { 116 117 private static final long serialVersionUID = 3206093459760846163L; 118 119 /** 120 * This field is initialized by dalvikvm when the class is loaded. 121 */ 122 private transient ProtectionDomain pd; 123 124 /** 125 * null-ok; cache of reflective information, wrapped in a soft 126 * reference 127 */ 128 private transient volatile SoftReference<ClassCache<T>> cacheRef; 129 130 /** 131 * Lazily computed name of this class; always prefer calling getName(). 132 */ 133 private transient String name; 134 Class()135 private Class() { 136 // Prevent this class to be instantiated, instance 137 // should be created by JVM only 138 } 139 140 /** 141 * Get the Signature attribute for this class. Returns null if not found. 142 */ getSignatureAttribute()143 private String getSignatureAttribute() { 144 Object[] annotation = getSignatureAnnotation(); 145 146 if (annotation == null) { 147 return null; 148 } 149 150 return StringUtils.combineStrings(annotation); 151 } 152 153 /** 154 * Get the Signature annotation for this class. Returns null if not found. 155 */ getSignatureAnnotation()156 native private Object[] getSignatureAnnotation(); 157 158 /** 159 * Returns a {@code Class} object which represents the class with the 160 * specified name. The name should be the name of a class as described in 161 * the {@link Class class definition}; however, {@code Class}es representing 162 * primitive types can not be found using this method. 163 * <p> 164 * If the class has not been loaded so far, it is being loaded and linked 165 * first. This is done through either the class loader of the calling class 166 * or one of its parent class loaders. The class is also being initialized, 167 * which means that a possible static initializer block is executed. 168 * 169 * @param className 170 * the name of the non-primitive-type class to find. 171 * @return the named {@code Class} instance. 172 * @throws ClassNotFoundException 173 * if the requested class can not be found. 174 * @throws LinkageError 175 * if an error occurs during linkage 176 * @throws ExceptionInInitializerError 177 * if an exception occurs during static initialization of a 178 * class. 179 */ forName(String className)180 public static Class<?> forName(String className) throws ClassNotFoundException { 181 return forName(className, true, VMStack.getCallingClassLoader()); 182 } 183 184 /** 185 * Returns a {@code Class} object which represents the class with the 186 * specified name. The name should be the name of a class as described in 187 * the {@link Class class definition}, however {@code Class}es representing 188 * primitive types can not be found using this method. Security rules will 189 * be obeyed. 190 * <p> 191 * If the class has not been loaded so far, it is being loaded and linked 192 * first. This is done through either the specified class loader or one of 193 * its parent class loaders. The caller can also request the class to be 194 * initialized, which means that a possible static initializer block is 195 * executed. 196 * 197 * @param className 198 * the name of the non-primitive-type class to find. 199 * @param initializeBoolean 200 * indicates whether the class should be initialized. 201 * @param classLoader 202 * the class loader to use to load the class. 203 * @return the named {@code Class} instance. 204 * @throws ClassNotFoundException 205 * if the requested class can not be found. 206 * @throws LinkageError 207 * if an error occurs during linkage 208 * @throws ExceptionInInitializerError 209 * if an exception occurs during static initialization of a 210 * class. 211 */ forName(String className, boolean initializeBoolean, ClassLoader classLoader)212 public static Class<?> forName(String className, boolean initializeBoolean, 213 ClassLoader classLoader) throws ClassNotFoundException { 214 215 if (classLoader == null) { 216 SecurityManager smgr = System.getSecurityManager(); 217 if (smgr != null) { 218 ClassLoader calling = VMStack.getCallingClassLoader(); 219 if (calling != null) { 220 smgr.checkPermission(new RuntimePermission("getClassLoader")); 221 } 222 } 223 224 classLoader = ClassLoader.getSystemClassLoader(); 225 } 226 // Catch an Exception thrown by the underlying native code. It wraps 227 // up everything inside a ClassNotFoundException, even if e.g. an 228 // Error occurred during initialization. This as a workaround for 229 // an ExceptionInInitilaizerError that's also wrapped. It is actually 230 // expected to be thrown. Maybe the same goes for other errors. 231 // Not wrapping up all the errors will break android though. 232 Class<?> result; 233 try { 234 result = classForName(className, initializeBoolean, 235 classLoader); 236 } catch (ClassNotFoundException e) { 237 Throwable cause = e.getCause(); 238 if (cause instanceof ExceptionInInitializerError) { 239 throw (ExceptionInInitializerError) cause; 240 } 241 throw e; 242 } 243 return result; 244 } 245 246 /* 247 * Returns a class by name without any security checks. 248 * 249 * @param className The name of the non-primitive type class to find 250 * @param initializeBoolean A boolean indicating whether the class should be 251 * initialized 252 * @param classLoader The class loader to use to load the class 253 * @return the named class. 254 * @throws ClassNotFoundException If the class could not be found 255 */ classForName(String className, boolean initializeBoolean, ClassLoader classLoader)256 static native Class<?> classForName(String className, boolean initializeBoolean, 257 ClassLoader classLoader) throws ClassNotFoundException; 258 259 /** 260 * Returns an array containing {@code Class} objects for all public classes 261 * and interfaces that are members of this class. This includes public 262 * members inherited from super classes and interfaces. If there are no such 263 * class members or if this object represents a primitive type then an array 264 * of length 0 is returned. 265 * 266 * @return the public class members of the class represented by this object. 267 * @throws SecurityException 268 * if a security manager exists and it does not allow member 269 * access. 270 */ getClasses()271 public Class<?>[] getClasses() { 272 checkPublicMemberAccess(); 273 return getFullListOfClasses(true); 274 } 275 276 /** 277 * Returns the annotation of the given type. If there is no such annotation 278 * then the method returns {@code null}. 279 * 280 * @param annotationClass 281 * the annotation type. 282 * @return the annotation of the given type, or {@code null} if there is no 283 * such annotation. 284 */ 285 @SuppressWarnings("unchecked") getAnnotation(Class<A> annotationClass)286 public <A extends Annotation> A getAnnotation(Class<A> annotationClass) { 287 Annotation[] list = getAnnotations(); 288 for (int i = 0; i < list.length; i++) { 289 if (annotationClass.isInstance(list[i])) { 290 return (A)list[i]; 291 } 292 } 293 294 return null; 295 } 296 297 /** 298 * Returns all the annotations of this class. If there are no annotations 299 * then an empty array is returned. 300 * 301 * @return a copy of the array containing this class' annotations. 302 * @see #getDeclaredAnnotations() 303 */ getAnnotations()304 public Annotation[] getAnnotations() { 305 /* 306 * We need to get the annotations declared on this class, plus the 307 * annotations from superclasses that have the "@Inherited" annotation 308 * set. We create a temporary map to use while we accumulate the 309 * annotations and convert it to an array at the end. 310 * 311 * It's possible to have duplicates when annotations are inherited. 312 * We use a Map to filter those out. 313 * 314 * HashMap might be overkill here. 315 */ 316 HashMap<Class, Annotation> map = new HashMap<Class, Annotation>(); 317 Annotation[] annos = getDeclaredAnnotations(); 318 319 for (int i = annos.length-1; i >= 0; --i) 320 map.put(annos[i].annotationType(), annos[i]); 321 322 for (Class sup = getSuperclass(); sup != null; 323 sup = sup.getSuperclass()) { 324 annos = sup.getDeclaredAnnotations(); 325 for (int i = annos.length-1; i >= 0; --i) { 326 Class clazz = annos[i].annotationType(); 327 if (!map.containsKey(clazz) && 328 clazz.isAnnotationPresent(Inherited.class)) { 329 map.put(clazz, annos[i]); 330 } 331 } 332 } 333 334 /* convert annotation values from HashMap to array */ 335 Collection<Annotation> coll = map.values(); 336 return coll.toArray(new Annotation[coll.size()]); 337 } 338 339 /** 340 * Returns the canonical name of this class. If this class does not have a 341 * canonical name as defined in the Java Language Specification, then the 342 * method returns {@code null}. 343 * 344 * @return this class' canonical name, or {@code null} if it does not have a 345 * canonical name. 346 */ getCanonicalName()347 public String getCanonicalName() { 348 if (isLocalClass() || isAnonymousClass()) 349 return null; 350 351 if (isArray()) { 352 /* 353 * The canonical name of an array type depends on the (existence of) 354 * the component type's canonical name. 355 */ 356 String name = getComponentType().getCanonicalName(); 357 if (name != null) { 358 return name + "[]"; 359 } 360 } else if (isMemberClass()) { 361 /* 362 * The canonical name of an inner class depends on the (existence 363 * of) the declaring class' canonical name. 364 */ 365 String name = getDeclaringClass().getCanonicalName(); 366 if (name != null) { 367 return name + "." + getSimpleName(); 368 } 369 } else { 370 /* 371 * The canonical name of a top-level class or primitive type is 372 * equal to the fully qualified name. 373 */ 374 return getName(); 375 } 376 377 /* 378 * Other classes don't have a canonical name. 379 */ 380 return null; 381 } 382 383 /** 384 * Returns the class loader which was used to load the class represented by 385 * this {@code Class}. Implementations are free to return {@code null} for 386 * classes that were loaded by the bootstrap class loader. The Android 387 * reference implementation, though, returns a reference to an actual 388 * representation of the bootstrap class loader. 389 * 390 * @return the class loader for the represented class. 391 * @throws SecurityException 392 * if a security manager exists and it does not allow accessing 393 * the class loader. 394 * @see ClassLoader 395 */ getClassLoader()396 public ClassLoader getClassLoader() { 397 SecurityManager smgr = System.getSecurityManager(); 398 ClassLoader loader = getClassLoaderImpl(); 399 if (smgr != null && loader != null) { 400 ClassLoader calling = VMStack.getCallingClassLoader(); 401 402 if (calling != null && !calling.isAncestorOf(loader)) { 403 smgr.checkPermission(new RuntimePermission("getClassLoader")); 404 } 405 } 406 407 if (this.isPrimitive()) { 408 return null; 409 } 410 411 if (loader == null) { 412 loader = BootClassLoader.getInstance(); 413 } 414 415 return loader; 416 } 417 418 /** 419 * This must be provided by the VM vendor, as it is used by other provided 420 * class implementations in this package. Outside of this class, it is used 421 * by SecurityManager.checkMemberAccess(), classLoaderDepth(), 422 * currentClassLoader() and currentLoadedClass(). Return the ClassLoader for 423 * this Class without doing any security checks. The bootstrap ClassLoader 424 * is returned, unlike getClassLoader() which returns null in place of the 425 * bootstrap ClassLoader. 426 * 427 * @return the ClassLoader 428 * @see ClassLoader#isSystemClassLoader() 429 */ getClassLoaderImpl()430 ClassLoader getClassLoaderImpl() { 431 ClassLoader loader = getClassLoader(this); 432 return loader == null ? BootClassLoader.getInstance() : loader; 433 } 434 435 /* 436 * Returns the defining class loader for the given class. 437 * 438 * @param clazz the class the class loader of which we want 439 * @return the class loader 440 */ getClassLoader(Class<?> clazz)441 private static native ClassLoader getClassLoader(Class<?> clazz); 442 443 /** 444 * Returns a {@code Class} object which represents the component type if 445 * this class represents an array type. Returns {@code null} if this class 446 * does not represent an array type. The component type of an array type is 447 * the type of the elements of the array. 448 * 449 * @return the component type of this class. 450 */ getComponentType()451 public native Class<?> getComponentType(); 452 453 /** 454 * Returns a {@code Constructor} object which represents the public 455 * constructor matching the specified parameter types. 456 * 457 * @param parameterTypes 458 * the parameter types of the requested constructor. 459 * {@code (Class[]) null} is equivalent to the empty array. 460 * @return the constructor described by {@code parameterTypes}. 461 * @throws NoSuchMethodException 462 * if the constructor can not be found. 463 * @throws SecurityException 464 * if a security manager exists and it does not allow member 465 * access. 466 * @see #getDeclaredConstructor(Class[]) 467 */ 468 @SuppressWarnings("unchecked") getConstructor(Class<?>.... parameterTypes)469 public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, 470 SecurityException { 471 checkPublicMemberAccess(); 472 return getMatchingConstructor(getDeclaredConstructors(this, true), parameterTypes); 473 } 474 475 /** 476 * Returns an array containing {@code Constructor} objects for all public 477 * constructors for the class represented by this {@code Class}. If there 478 * are no public constructors or if this {@code Class} represents an array 479 * class, a primitive type or void then an empty array is returned. 480 * 481 * @return an array with the public constructors of the class represented by 482 * this {@code Class}. 483 * @throws SecurityException 484 * if a security manager exists and it does not allow member 485 * access. 486 * @see #getDeclaredConstructors() 487 */ getConstructors()488 public Constructor<?>[] getConstructors() throws SecurityException { 489 checkPublicMemberAccess(); 490 return getDeclaredConstructors(this, true); 491 } 492 493 /** 494 * Returns the annotations that are directly defined on the class 495 * represented by this {@code Class}. Annotations that are inherited are not 496 * included in the result. If there are no annotations at all, an empty 497 * array is returned. 498 * 499 * @return a copy of the array containing the annotations defined for the 500 * class that this {@code Class} represents. 501 * @see #getAnnotations() 502 */ getDeclaredAnnotations()503 native public Annotation[] getDeclaredAnnotations(); 504 505 /** 506 * Returns an array containing {@code Class} objects for all classes and 507 * interfaces that are declared as members of the class which this {@code 508 * Class} represents. If there are no classes or interfaces declared or if 509 * this class represents an array class, a primitive type or void, then an 510 * empty array is returned. 511 * 512 * @return an array with {@code Class} objects for all the classes and 513 * interfaces that are used in member declarations. 514 * @throws SecurityException 515 * if a security manager exists and it does not allow member 516 * access. 517 */ getDeclaredClasses()518 public Class<?>[] getDeclaredClasses() throws SecurityException { 519 checkDeclaredMemberAccess(); 520 return getDeclaredClasses(this, false); 521 } 522 523 /* 524 * Returns the list of member classes without performing any security checks 525 * first. This includes the member classes inherited from superclasses. If no 526 * member classes exist at all, an empty array is returned. 527 * 528 * @param publicOnly reflects whether we want only public members or all of them 529 * @return the list of classes 530 */ getFullListOfClasses(boolean publicOnly)531 private Class<?>[] getFullListOfClasses(boolean publicOnly) { 532 Class<?>[] result = getDeclaredClasses(this, publicOnly); 533 534 // Traverse all superclasses 535 Class<?> clazz = this.getSuperclass(); 536 while (clazz != null) { 537 Class<?>[] temp = getDeclaredClasses(clazz, publicOnly); 538 if (temp.length != 0) { 539 result = arraycopy(new Class[result.length + temp.length], result, temp); 540 } 541 542 clazz = clazz.getSuperclass(); 543 } 544 545 return result; 546 } 547 548 /* 549 * Returns the list of member classes of the given class. No security checks 550 * are performed. If no members exist, an empty array is returned. 551 * 552 * @param clazz the class the members of which we want 553 * @param publicOnly reflects whether we want only public member or all of them 554 * @return the class' class members 555 */ getDeclaredClasses(Class<?> clazz, boolean publicOnly)556 native private static Class<?>[] getDeclaredClasses(Class<?> clazz, 557 boolean publicOnly); 558 559 /** 560 * Returns a {@code Constructor} object which represents the constructor 561 * matching the specified parameter types that is declared by the class 562 * represented by this {@code Class}. 563 * 564 * @param parameterTypes 565 * the parameter types of the requested constructor. 566 * {@code (Class[]) null} is equivalent to the empty array. 567 * @return the constructor described by {@code parameterTypes}. 568 * @throws NoSuchMethodException 569 * if the requested constructor can not be found. 570 * @throws SecurityException 571 * if a security manager exists and it does not allow member 572 * access. 573 * @see #getConstructor(Class[]) 574 */ 575 @SuppressWarnings("unchecked") getDeclaredConstructor(Class<?>.... parameterTypes)576 public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 577 throws NoSuchMethodException, SecurityException { 578 checkDeclaredMemberAccess(); 579 return getMatchingConstructor(getDeclaredConstructors(this, false), parameterTypes); 580 } 581 582 /** 583 * Returns an array containing {@code Constructor} objects for all 584 * constructors declared in the class represented by this {@code Class}. If 585 * there are no constructors or if this {@code Class} represents an array 586 * class, a primitive type or void then an empty array is returned. 587 * 588 * @return an array with the constructors declared in the class represented 589 * by this {@code Class}. 590 * 591 * @throws SecurityException 592 * if a security manager exists and it does not allow member 593 * access. 594 * @see #getConstructors() 595 */ getDeclaredConstructors()596 public Constructor<?>[] getDeclaredConstructors() throws SecurityException { 597 checkDeclaredMemberAccess(); 598 return getDeclaredConstructors(this, false); 599 } 600 601 /* 602 * Returns the list of constructors without performing any security checks 603 * first. If no constructors exist, an empty array is returned. 604 * 605 * @param clazz the class of interest 606 * @param publicOnly reflects whether we want only public constructors or all of them 607 * @return the list of constructors 608 */ getDeclaredConstructors(Class<T> clazz, boolean publicOnly)609 private static native <T> Constructor<T>[] getDeclaredConstructors(Class<T> clazz, boolean publicOnly); 610 611 /* 612 * Finds a constructor with a given signature. 613 * 614 * @param list the list of constructors to search through 615 * @param parameterTypes the formal parameter list 616 * @return the matching constructor 617 * @throws NoSuchMethodException if the constructor does not exist. 618 */ getMatchingConstructor( Constructor<T>[] list, Class<?>[] parameterTypes)619 private Constructor<T> getMatchingConstructor( 620 Constructor<T>[] list, Class<?>[] parameterTypes) 621 throws NoSuchMethodException { 622 for (int i = 0; i < list.length; i++) { 623 if (compareClassLists(list[i].getParameterTypes(), parameterTypes)) { 624 return list[i]; 625 } 626 } 627 628 // BEGIN android-changed 629 StringBuilder sb = new StringBuilder(); 630 sb.append(getSimpleName()); 631 sb.append('('); 632 boolean first = true; 633 if (parameterTypes != null) { 634 for (Class<?> p : parameterTypes) { 635 if (!first) { 636 sb.append(','); 637 } 638 first = false; 639 sb.append(p.getSimpleName()); 640 } 641 } 642 sb.append(')'); 643 throw new NoSuchMethodException(sb.toString()); 644 // END android-changed 645 } 646 647 /** 648 * Returns a {@code Field} object for the field with the specified name 649 * which is declared in the class represented by this {@code Class}. 650 * 651 * @param name 652 * the name of the requested field. 653 * @return the requested field in the class represented by this class. 654 * @throws NoSuchFieldException 655 * if the requested field can not be found. 656 * @throws SecurityException 657 * if a security manager exists and it does not allow member 658 * access. 659 * @see #getField(String) 660 */ getDeclaredField(String name)661 public Field getDeclaredField(String name) 662 throws NoSuchFieldException, SecurityException { 663 checkDeclaredMemberAccess(); 664 665 Field[] fields = getClassCache().getDeclaredFields(); 666 Field field = findFieldByName(fields, name); 667 668 /* 669 * Make a copy of the private (to the package) object, so that 670 * setAccessible() won't alter the private instance. 671 */ 672 return REFLECT.clone(field); 673 } 674 675 /** 676 * Returns an array containing {@code Field} objects for all fields declared 677 * in the class represented by this {@code Class}. If there are no fields or 678 * if this {@code Class} represents an array class, a primitive type or void 679 * then an empty array is returned. 680 * 681 * @return an array with the fields declared in the class represented by 682 * this class. 683 * @throws SecurityException 684 * if a security manager exists and it does not allow member 685 * access. 686 * @see #getFields() 687 */ getDeclaredFields()688 public Field[] getDeclaredFields() throws SecurityException { 689 checkDeclaredMemberAccess(); 690 691 // Return a copy of the private (to the package) array. 692 Field[] fields = getClassCache().getDeclaredFields(); 693 return ClassCache.deepCopy(fields); 694 } 695 696 /* 697 * Returns the list of fields without performing any security checks 698 * first. If no fields exist at all, an empty array is returned. 699 * 700 * @param clazz the class of interest 701 * @param publicOnly reflects whether we want only public fields or all of them 702 * @return the list of fields 703 */ getDeclaredFields(Class<?> clazz, boolean publicOnly)704 static native Field[] getDeclaredFields(Class<?> clazz, boolean publicOnly); 705 706 /** 707 * Returns a {@code Method} object which represents the method matching the 708 * specified name and parameter types that is declared by the class 709 * represented by this {@code Class}. 710 * 711 * @param name 712 * the requested method's name. 713 * @param parameterTypes 714 * the parameter types of the requested method. 715 * {@code (Class[]) null} is equivalent to the empty array. 716 * @return the method described by {@code name} and {@code parameterTypes}. 717 * @throws NoSuchMethodException 718 * if the requested constructor can not be found. 719 * @throws NullPointerException 720 * if {@code name} is {@code null}. 721 * @throws SecurityException 722 * if a security manager exists and it does not allow member 723 * access. 724 * @see #getMethod(String, Class[]) 725 */ getDeclaredMethod(String name, Class<?>... parameterTypes)726 public Method getDeclaredMethod(String name, Class<?>... parameterTypes) 727 throws NoSuchMethodException, SecurityException { 728 checkDeclaredMemberAccess(); 729 730 Method[] methods = getClassCache().getDeclaredMethods(); 731 Method method = findMethodByName(methods, name, parameterTypes); 732 733 /* 734 * Make a copy of the private (to the package) object, so that 735 * setAccessible() won't alter the private instance. 736 */ 737 return REFLECT.clone(method); 738 } 739 740 /** 741 * Returns an array containing {@code Method} objects for all methods 742 * declared in the class represented by this {@code Class}. If there are no 743 * methods or if this {@code Class} represents an array class, a primitive 744 * type or void then an empty array is returned. 745 * 746 * @return an array with the methods declared in the class represented by 747 * this {@code Class}. 748 * @throws SecurityException 749 * if a security manager exists and it does not allow member 750 * access. 751 * @see #getMethods() 752 */ getDeclaredMethods()753 public Method[] getDeclaredMethods() throws SecurityException { 754 checkDeclaredMemberAccess(); 755 756 // Return a copy of the private (to the package) array. 757 Method[] methods = getClassCache().getDeclaredMethods(); 758 return ClassCache.deepCopy(methods); 759 } 760 761 /** 762 * Returns the list of methods without performing any security checks 763 * first. If no methods exist, an empty array is returned. 764 */ getDeclaredMethods(Class<?> clazz, boolean publicOnly)765 static native Method[] getDeclaredMethods(Class<?> clazz, boolean publicOnly); 766 767 /** 768 * Gets the {@link ClassCache} for this instance. 769 * 770 * @return non-null; the cache object 771 */ getClassCache()772 /*package*/ ClassCache<T> getClassCache() { 773 /* 774 * Note: It is innocuous if two threads try to simultaneously 775 * create the cache, so we don't bother protecting against that. 776 */ 777 ClassCache<T> cache = null; 778 779 if (cacheRef != null) { 780 cache = cacheRef.get(); 781 } 782 783 if (cache == null) { 784 cache = new ClassCache<T>(this); 785 cacheRef = new SoftReference<ClassCache<T>>(cache); 786 } 787 788 return cache; 789 } 790 791 /** 792 * Returns the declaring {@code Class} of this {@code Class}. Returns 793 * {@code null} if the class is not a member of another class or if this 794 * {@code Class} represents an array class, a primitive type or void. 795 * 796 * @return the declaring {@code Class} or {@code null}. 797 */ getDeclaringClass()798 native public Class<?> getDeclaringClass(); 799 800 /** 801 * Returns the enclosing {@code Class} of this {@code Class}. If there is no 802 * enclosing class the method returns {@code null}. 803 * 804 * @return the enclosing {@code Class} or {@code null}. 805 */ getEnclosingClass()806 native public Class<?> getEnclosingClass(); 807 808 /** 809 * Gets the enclosing {@code Constructor} of this {@code Class}, if it is an 810 * anonymous or local/automatic class; otherwise {@code null}. 811 * 812 * @return the enclosing {@code Constructor} instance or {@code null}. 813 */ getEnclosingConstructor()814 native public Constructor<?> getEnclosingConstructor(); 815 816 /** 817 * Gets the enclosing {@code Method} of this {@code Class}, if it is an 818 * anonymous or local/automatic class; otherwise {@code null}. 819 * 820 * @return the enclosing {@code Method} instance or {@code null}. 821 */ getEnclosingMethod()822 native public Method getEnclosingMethod(); 823 824 /** 825 * Gets the {@code enum} constants associated with this {@code Class}. 826 * Returns {@code null} if this {@code Class} does not represent an {@code 827 * enum} type. 828 * 829 * @return an array with the {@code enum} constants or {@code null}. 830 */ 831 @SuppressWarnings("unchecked") getEnumConstants()832 public T[] getEnumConstants() { 833 if (isEnum()) { 834 checkPublicMemberAccess(); 835 T[] values = getClassCache().getEnumValuesInOrder(); 836 837 // Copy the private (to the package) array. 838 return (T[]) values.clone(); 839 } 840 841 return null; 842 } 843 844 /** 845 * Returns a {@code Field} object which represents the public field with the 846 * specified name. This method first searches the class C represented by 847 * this {@code Class}, then the interfaces implemented by C and finally the 848 * superclasses of C. 849 * 850 * @param name 851 * the name of the requested field. 852 * @return the public field specified by {@code name}. 853 * @throws NoSuchFieldException 854 * if the field can not be found. 855 * @throws SecurityException 856 * if a security manager exists and it does not allow member 857 * access. 858 * @see #getDeclaredField(String) 859 */ getField(String name)860 public Field getField(String name) throws NoSuchFieldException, SecurityException { 861 checkPublicMemberAccess(); 862 863 Field[] fields = getClassCache().getAllPublicFields(); 864 Field field = findFieldByName(fields, name); 865 866 /* 867 * Make a copy of the private (to the package) object, so that 868 * setAccessible() won't alter the private instance. 869 */ 870 return REFLECT.clone(field); 871 } 872 873 /** 874 * Returns an array containing {@code Field} objects for all public fields 875 * for the class C represented by this {@code Class}. Fields may be declared 876 * in C, the interfaces it implements or in the superclasses of C. The 877 * elements in the returned array are in no particular order. 878 * <p> 879 * If there are no public fields or if this class represents an array class, 880 * a primitive type or {@code void} then an empty array is returned. 881 * </p> 882 * 883 * @return an array with the public fields of the class represented by this 884 * {@code Class}. 885 * @throws SecurityException 886 * if a security manager exists and it does not allow member 887 * access. 888 * @see #getDeclaredFields() 889 */ getFields()890 public Field[] getFields() throws SecurityException { 891 checkPublicMemberAccess(); 892 893 // Return a copy of the private (to the package) array. 894 Field[] fields = getClassCache().getAllPublicFields(); 895 return ClassCache.deepCopy(fields); 896 } 897 898 /** 899 * Gets the {@link Type}s of the interfaces that this {@code Class} directly 900 * implements. If the {@code Class} represents a primitive type or {@code 901 * void} then an empty array is returned. 902 * 903 * @return an array of {@link Type} instances directly implemented by the 904 * class represented by this {@code class}. 905 */ getGenericInterfaces()906 public Type[] getGenericInterfaces() { 907 GenericSignatureParser parser = new GenericSignatureParser(getClassLoader()); 908 parser.parseForClass(this, getSignatureAttribute()); 909 return Types.getClonedTypeArray(parser.interfaceTypes); 910 } 911 912 /** 913 * Gets the {@code Type} that represents the superclass of this {@code 914 * class}. 915 * 916 * @return an instance of {@code Type} representing the superclass. 917 */ getGenericSuperclass()918 public Type getGenericSuperclass() { 919 GenericSignatureParser parser = new GenericSignatureParser(getClassLoader()); 920 parser.parseForClass(this, getSignatureAttribute()); 921 return Types.getType(parser.superclassType); 922 } 923 924 /** 925 * Returns an array of {@code Class} objects that match the interfaces 926 * specified in the {@code implements} declaration of the class represented 927 * by this {@code Class}. The order of the elements in the array is 928 * identical to the order in the original class declaration. If the class 929 * does not implement any interfaces, an empty array is returned. 930 * 931 * @return an array with the interfaces of the class represented by this 932 * class. 933 */ getInterfaces()934 public native Class<?>[] getInterfaces(); 935 936 // Changed to raw type to be closer to the RI 937 /** 938 * Returns a {@code Method} object which represents the public method with 939 * the specified name and parameter types. This method first searches the 940 * class C represented by this {@code Class}, then the superclasses of C and 941 * finally the interfaces implemented by C and finally the superclasses of C 942 * for a method with matching name. 943 * 944 * @param name 945 * the requested method's name. 946 * @param parameterTypes 947 * the parameter types of the requested method. 948 * {@code (Class[]) null} is equivalent to the empty array. 949 * @return the public field specified by {@code name}. 950 * @throws NoSuchMethodException 951 * if the method can not be found. 952 * @throws SecurityException 953 * if a security manager exists and it does not allow member 954 * access. 955 * @see #getDeclaredMethod(String, Class[]) 956 */ getMethod(String name, Class<?>... parameterTypes)957 public Method getMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, 958 SecurityException { 959 checkPublicMemberAccess(); 960 961 Method[] methods = getClassCache().getMethods(); 962 Method method = findMethodByName(methods, name, parameterTypes); 963 964 /* 965 * Make a copy of the private (to the package) object, so that 966 * setAccessible() won't alter the private instance. 967 */ 968 return REFLECT.clone(method); 969 } 970 971 /** 972 * Returns an array containing {@code Method} objects for all public methods 973 * for the class C represented by this {@code Class}. Methods may be 974 * declared in C, the interfaces it implements or in the superclasses of C. 975 * The elements in the returned array are in no particular order. 976 * <p> 977 * If there are no public methods or if this {@code Class} represents a 978 * primitive type or {@code void} then an empty array is returned. 979 * </p> 980 * 981 * @return an array with the methods of the class represented by this 982 * {@code Class}. 983 * @throws SecurityException 984 * if a security manager exists and it does not allow member 985 * access. 986 * @see #getDeclaredMethods() 987 */ getMethods()988 public Method[] getMethods() throws SecurityException { 989 checkPublicMemberAccess(); 990 991 // Return a copy of the private (to the package) array. 992 Method[] methods = getClassCache().getMethods(); 993 return ClassCache.deepCopy(methods); 994 } 995 996 /** 997 * Performs the security checks regarding the access of a public 998 * member of this {@code Class}. 999 * 1000 * <p><b>Note:</b> Because of the {@code getCallingClassLoader2()} 1001 * check, this method must be called exactly one level deep into a 1002 * public method on this instance.</p> 1003 */ checkPublicMemberAccess()1004 /*package*/ void checkPublicMemberAccess() { 1005 SecurityManager smgr = System.getSecurityManager(); 1006 1007 if (smgr != null) { 1008 smgr.checkMemberAccess(this, Member.PUBLIC); 1009 1010 ClassLoader calling = VMStack.getCallingClassLoader2(); 1011 ClassLoader current = getClassLoader(); 1012 1013 if (calling != null && !calling.isAncestorOf(current)) { 1014 smgr.checkPackageAccess(this.getPackage().getName()); 1015 } 1016 } 1017 } 1018 1019 /** 1020 * Performs the security checks regarding the access of a declared 1021 * member of this {@code Class}. 1022 * 1023 * <p><b>Note:</b> Because of the {@code getCallingClassLoader2()} 1024 * check, this method must be called exactly one level deep into a 1025 * public method on this instance.</p> 1026 */ checkDeclaredMemberAccess()1027 private void checkDeclaredMemberAccess() { 1028 SecurityManager smgr = System.getSecurityManager(); 1029 if (smgr != null) { 1030 smgr.checkMemberAccess(this, Member.DECLARED); 1031 1032 ClassLoader calling = VMStack.getCallingClassLoader2(); 1033 ClassLoader current = getClassLoader(); 1034 1035 if (calling != null && !calling.isAncestorOf(current)) { 1036 smgr.checkPackageAccess(this.getPackage().getName()); 1037 } 1038 } 1039 } 1040 1041 /** 1042 * Returns an integer that represents the modifiers of the class represented 1043 * by this {@code Class}. The returned value is a combination of bits 1044 * defined by constants in the {@link Modifier} class. 1045 * 1046 * @return the modifiers of the class represented by this {@code Class}. 1047 */ getModifiers()1048 public int getModifiers() { 1049 return getModifiers(this, false); 1050 } 1051 1052 /* 1053 * Return the modifiers for the given class. 1054 * 1055 * @param clazz the class of interest 1056 * @ignoreInnerClassesAttrib determines whether we look for and use the 1057 * flags from an "inner class" attribute 1058 */ getModifiers(Class<?> clazz, boolean ignoreInnerClassesAttrib)1059 private static native int getModifiers(Class<?> clazz, boolean ignoreInnerClassesAttrib); 1060 1061 /** 1062 * Returns the name of the class represented by this {@code Class}. For a 1063 * description of the format which is used, see the class definition of 1064 * {@link Class}. 1065 * 1066 * @return the name of the class represented by this {@code Class}. 1067 */ getName()1068 public String getName() { 1069 String result = name; 1070 return (result == null) ? (name = getNameNative()) : result; 1071 } 1072 getNameNative()1073 private native String getNameNative(); 1074 1075 /** 1076 * Returns the simple name of the class represented by this {@code Class} as 1077 * defined in the source code. If there is no name (that is, the class is 1078 * anonymous) then an empty string is returned. If the receiver is an array 1079 * then the name of the underlying type with square braces appended (for 1080 * example {@code "Integer[]"}) is returned. 1081 * 1082 * @return the simple name of the class represented by this {@code Class}. 1083 */ getSimpleName()1084 public String getSimpleName() { 1085 if (isArray()) { 1086 return getComponentType().getSimpleName() + "[]"; 1087 } 1088 1089 String name = getName(); 1090 1091 if (isAnonymousClass()) { 1092 return ""; 1093 } 1094 1095 if (isMemberClass() || isLocalClass()) { 1096 return getInnerClassName(); 1097 } 1098 1099 int dot = name.lastIndexOf('.'); 1100 if (dot != -1) { 1101 return name.substring(dot + 1); 1102 } 1103 1104 return name; 1105 } 1106 1107 /* 1108 * Returns the simple name of a member or local class, or null otherwise. 1109 * 1110 * @return The name. 1111 */ getInnerClassName()1112 private native String getInnerClassName(); 1113 1114 /** 1115 * Returns the {@code ProtectionDomain} of the class represented by this 1116 * class. 1117 * <p> 1118 * Note: In order to conserve space in an embedded target like Android, we 1119 * allow this method to return {@code null} for classes in the system 1120 * protection domain (that is, for system classes). System classes are 1121 * always given full permissions (that is, AllPermission). This can not be 1122 * changed through the {@link java.security.Policy} class. 1123 * </p> 1124 * 1125 * @return the {@code ProtectionDomain} of the class represented by this 1126 * class. 1127 * @throws SecurityException 1128 * if a security manager exists and it does not allow member 1129 * access. 1130 */ getProtectionDomain()1131 public ProtectionDomain getProtectionDomain() { 1132 SecurityManager smgr = System.getSecurityManager(); 1133 if (smgr != null) { 1134 // Security check is independent of calling class loader. 1135 smgr.checkPermission(new RuntimePermission("getProtectionDomain")); 1136 } 1137 1138 return pd; 1139 } 1140 1141 /** 1142 * Returns the URL of the resource specified by {@code resName}. The mapping 1143 * between the resource name and the URL is managed by the class' class 1144 * loader. 1145 * 1146 * @param resName 1147 * the name of the resource. 1148 * @return the requested resource's {@code URL} object or {@code null} if 1149 * the resource can not be found. 1150 * @see ClassLoader 1151 */ getResource(String resName)1152 public URL getResource(String resName) { 1153 // Get absolute resource name, but without the leading slash 1154 if (resName.startsWith("/")) { 1155 resName = resName.substring(1); 1156 } else { 1157 String pkg = getName(); 1158 int dot = pkg.lastIndexOf('.'); 1159 if (dot != -1) { 1160 pkg = pkg.substring(0, dot).replace('.', '/'); 1161 } else { 1162 pkg = ""; 1163 } 1164 1165 resName = pkg + "/" + resName; 1166 } 1167 1168 // Delegate to proper class loader 1169 ClassLoader loader = getClassLoader(); 1170 if (loader != null) { 1171 return loader.getResource(resName); 1172 } else { 1173 return ClassLoader.getSystemResource(resName); 1174 } 1175 } 1176 1177 /** 1178 * Returns a read-only stream for the contents of the resource specified by 1179 * {@code resName}. The mapping between the resource name and the stream is 1180 * managed by the class' class loader. 1181 * 1182 * @param resName 1183 * the name of the resource. 1184 * @return a stream for the requested resource or {@code null} if no 1185 * resource with the specified name can be found. 1186 * @see ClassLoader 1187 */ getResourceAsStream(String resName)1188 public InputStream getResourceAsStream(String resName) { 1189 // Get absolute resource name, but without the leading slash 1190 if (resName.startsWith("/")) { 1191 resName = resName.substring(1); 1192 } else { 1193 String pkg = getName(); 1194 int dot = pkg.lastIndexOf('.'); 1195 if (dot != -1) { 1196 pkg = pkg.substring(0, dot).replace('.', '/'); 1197 } else { 1198 pkg = ""; 1199 } 1200 1201 resName = pkg + "/" + resName; 1202 } 1203 1204 // Delegate to proper class loader 1205 ClassLoader loader = getClassLoader(); 1206 if (loader != null) { 1207 return loader.getResourceAsStream(resName); 1208 } else { 1209 return ClassLoader.getSystemResourceAsStream(resName); 1210 } 1211 } 1212 1213 /** 1214 * Returns null. (On Android, a {@code ClassLoader} can load classes from multiple dex files. 1215 * All classes from any given dex file will have the same signers, but different dex 1216 * files may have different signers. This does not fit well with the original 1217 * {@code ClassLoader}-based model of {@code getSigners}.) 1218 * 1219 * @return null. 1220 */ getSigners()1221 public Object[] getSigners() { 1222 // See http://code.google.com/p/android/issues/detail?id=1766. 1223 return null; 1224 } 1225 1226 /** 1227 * Returns the {@code Class} object which represents the superclass of the 1228 * class represented by this {@code Class}. If this {@code Class} represents 1229 * the {@code Object} class, a primitive type, an interface or void then the 1230 * method returns {@code null}. If this {@code Class} represents an array 1231 * class then the {@code Object} class is returned. 1232 * 1233 * @return the superclass of the class represented by this {@code Class}. 1234 */ getSuperclass()1235 public native Class<? super T> getSuperclass(); 1236 1237 /** 1238 * Returns an array containing {@code TypeVariable} objects for type 1239 * variables declared by the generic class represented by this {@code 1240 * Class}. Returns an empty array if the class is not generic. 1241 * 1242 * @return an array with the type variables of the class represented by this 1243 * class. 1244 */ 1245 @SuppressWarnings("unchecked") getTypeParameters()1246 public synchronized TypeVariable<Class<T>>[] getTypeParameters() { 1247 GenericSignatureParser parser = new GenericSignatureParser(getClassLoader()); 1248 parser.parseForClass(this, getSignatureAttribute()); 1249 return parser.formalTypeParameters.clone(); 1250 } 1251 1252 /** 1253 * Indicates whether this {@code Class} represents an annotation class. 1254 * 1255 * @return {@code true} if this {@code Class} represents an annotation 1256 * class; {@code false} otherwise. 1257 */ isAnnotation()1258 public boolean isAnnotation() { 1259 final int ACC_ANNOTATION = 0x2000; // not public in reflect.Modifiers 1260 int mod = getModifiers(this, true); 1261 return (mod & ACC_ANNOTATION) != 0; 1262 } 1263 1264 /** 1265 * Indicates whether the specified annotation is present for the class 1266 * represented by this {@code Class}. 1267 * 1268 * @param annotationClass 1269 * the annotation to look for. 1270 * @return {@code true} if the class represented by this {@code Class} is 1271 * annotated with {@code annotationClass}; {@code false} otherwise. 1272 */ isAnnotationPresent(Class<? extends Annotation> annotationClass)1273 public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) { 1274 return getAnnotation(annotationClass) != null; 1275 } 1276 1277 /** 1278 * Indicates whether the class represented by this {@code Class} is 1279 * anonymously declared. 1280 * 1281 * @return {@code true} if the class represented by this {@code Class} is 1282 * anonymous; {@code false} otherwise. 1283 */ isAnonymousClass()1284 native public boolean isAnonymousClass(); 1285 1286 /** 1287 * Indicates whether the class represented by this {@code Class} is an array 1288 * class. 1289 * 1290 * @return {@code true} if the class represented by this {@code Class} is an 1291 * array class; {@code false} otherwise. 1292 */ isArray()1293 public boolean isArray() { 1294 return getComponentType() != null; 1295 } 1296 1297 /** 1298 * Indicates whether the specified class type can be converted to the class 1299 * represented by this {@code Class}. Conversion may be done via an identity 1300 * conversion or a widening reference conversion (if either the receiver or 1301 * the argument represent primitive types, only the identity conversion 1302 * applies). 1303 * 1304 * @param cls 1305 * the class to check. 1306 * @return {@code true} if {@code cls} can be converted to the class 1307 * represented by this {@code Class}; {@code false} otherwise. 1308 * @throws NullPointerException 1309 * if {@code cls} is {@code null}. 1310 */ isAssignableFrom(Class<?> cls)1311 public native boolean isAssignableFrom(Class<?> cls); 1312 1313 /** 1314 * Indicates whether the class represented by this {@code Class} is an 1315 * {@code enum}. 1316 * 1317 * @return {@code true} if the class represented by this {@code Class} is an 1318 * {@code enum}; {@code false} otherwise. 1319 */ isEnum()1320 public boolean isEnum() { 1321 return ((getModifiers() & 0x4000) != 0) && (getSuperclass() == Enum.class); 1322 } 1323 1324 /** 1325 * Indicates whether the specified object can be cast to the class 1326 * represented by this {@code Class}. This is the runtime version of the 1327 * {@code instanceof} operator. 1328 * 1329 * @param object 1330 * the object to check. 1331 * @return {@code true} if {@code object} can be cast to the type 1332 * represented by this {@code Class}; {@code false} if {@code 1333 * object} is {@code null} or cannot be cast. 1334 */ isInstance(Object object)1335 public native boolean isInstance(Object object); 1336 1337 /** 1338 * Indicates whether this {@code Class} represents an interface. 1339 * 1340 * @return {@code true} if this {@code Class} represents an interface; 1341 * {@code false} otherwise. 1342 */ isInterface()1343 public native boolean isInterface(); 1344 1345 /** 1346 * Indicates whether the class represented by this {@code Class} is defined 1347 * locally. 1348 * 1349 * @return {@code true} if the class represented by this {@code Class} is 1350 * defined locally; {@code false} otherwise. 1351 */ isLocalClass()1352 public boolean isLocalClass() { 1353 boolean enclosed = (getEnclosingMethod() != null || 1354 getEnclosingConstructor() != null); 1355 return enclosed && !isAnonymousClass(); 1356 } 1357 1358 /** 1359 * Indicates whether the class represented by this {@code Class} is a member 1360 * class. 1361 * 1362 * @return {@code true} if the class represented by this {@code Class} is a 1363 * member class; {@code false} otherwise. 1364 */ isMemberClass()1365 public boolean isMemberClass() { 1366 return getDeclaringClass() != null; 1367 } 1368 1369 /** 1370 * Indicates whether this {@code Class} represents a primitive type. 1371 * 1372 * @return {@code true} if this {@code Class} represents a primitive type; 1373 * {@code false} otherwise. 1374 */ isPrimitive()1375 public native boolean isPrimitive(); 1376 1377 /** 1378 * Indicates whether this {@code Class} represents a synthetic type. 1379 * 1380 * @return {@code true} if this {@code Class} represents a synthetic type; 1381 * {@code false} otherwise. 1382 */ isSynthetic()1383 public boolean isSynthetic() { 1384 final int ACC_SYNTHETIC = 0x1000; // not public in reflect.Modifiers 1385 int mod = getModifiers(this, true); 1386 return (mod & ACC_SYNTHETIC) != 0; 1387 } 1388 1389 /** 1390 * Returns a new instance of the class represented by this {@code Class}, 1391 * created by invoking the default (that is, zero-argument) constructor. If 1392 * there is no such constructor, or if the creation fails (either because of 1393 * a lack of available memory or because an exception is thrown by the 1394 * constructor), an {@code InstantiationException} is thrown. If the default 1395 * constructor exists but is not accessible from the context where this 1396 * method is invoked, an {@code IllegalAccessException} is thrown. 1397 * 1398 * @return a new instance of the class represented by this {@code Class}. 1399 * @throws IllegalAccessException 1400 * if the default constructor is not visible. 1401 * @throws InstantiationException 1402 * if the instance can not be created. 1403 * @throws SecurityException 1404 * if a security manager exists and it does not allow creating 1405 * new instances. 1406 */ newInstance()1407 public T newInstance() throws InstantiationException, IllegalAccessException { 1408 checkPublicMemberAccess(); 1409 return newInstanceImpl(); 1410 } 1411 newInstanceImpl()1412 private native T newInstanceImpl() throws IllegalAccessException, 1413 InstantiationException; 1414 1415 @Override toString()1416 public String toString() { 1417 if (isPrimitive()) { 1418 return getSimpleName().toLowerCase(); 1419 } else { 1420 return (isInterface() ? "interface " : "class ") + getName(); 1421 } 1422 } 1423 1424 /** 1425 * Returns the {@code Package} of which the class represented by this 1426 * {@code Class} is a member. Returns {@code null} if no {@code Package} 1427 * object was created by the class loader of the class. 1428 * 1429 * @return Package the {@code Package} of which this {@code Class} is a 1430 * member or {@code null}. 1431 */ getPackage()1432 public Package getPackage() { 1433 // TODO This might be a hack, but the VM doesn't have the necessary info. 1434 ClassLoader loader = getClassLoader(); 1435 if (loader != null) { 1436 String name = getName(); 1437 int dot = name.lastIndexOf('.'); 1438 return (dot != -1 ? ClassLoader.getPackage(loader, name.substring(0, dot)) : null); 1439 } 1440 1441 return null; 1442 } 1443 1444 /** 1445 * Returns the assertion status for the class represented by this {@code 1446 * Class}. Assertion is enabled / disabled based on the class loader, 1447 * package or class default at runtime. 1448 * 1449 * @return the assertion status for the class represented by this {@code 1450 * Class}. 1451 */ desiredAssertionStatus()1452 public native boolean desiredAssertionStatus(); 1453 1454 /** 1455 * Casts this {@code Class} to represent a subclass of the specified class. 1456 * If successful, this {@code Class} is returned; otherwise a {@code 1457 * ClassCastException} is thrown. 1458 * 1459 * @param clazz 1460 * the required type. 1461 * @return this {@code Class} cast as a subclass of the given type. 1462 * @throws ClassCastException 1463 * if this {@code Class} cannot be cast to the specified type. 1464 */ 1465 @SuppressWarnings("unchecked") asSubclass(Class<U> clazz)1466 public <U> Class<? extends U> asSubclass(Class<U> clazz) { 1467 if (clazz.isAssignableFrom(this)) { 1468 return (Class<? extends U>)this; 1469 } 1470 throw new ClassCastException(); 1471 } 1472 1473 /** 1474 * Casts the specified object to the type represented by this {@code Class}. 1475 * If the object is {@code null} then the result is also {@code null}. 1476 * 1477 * @param obj 1478 * the object to cast. 1479 * @return the object that has been cast. 1480 * @throws ClassCastException 1481 * if the object cannot be cast to the specified type. 1482 */ 1483 @SuppressWarnings("unchecked") cast(Object obj)1484 public T cast(Object obj) { 1485 if (obj == null) { 1486 return null; 1487 } else if (this.isInstance(obj)) { 1488 return (T)obj; 1489 } 1490 throw new ClassCastException(); 1491 } 1492 1493 /** 1494 * Set the "accessible" flag of the given object, without doing any 1495 * access checks. 1496 * 1497 * <p><b>Note:</b> This method is implemented in native code, and, 1498 * as such, is less efficient than using {@link ClassCache#REFLECT} 1499 * to achieve the same goal. This method exists solely to help 1500 * bootstrap the reflection bridge.</p> 1501 * 1502 * @param ao non-null; the object to modify 1503 * @param flag the new value for the accessible flag 1504 */ setAccessibleNoCheck(AccessibleObject ao, boolean flag)1505 /*package*/ static native void setAccessibleNoCheck(AccessibleObject ao, 1506 boolean flag); 1507 1508 /** 1509 * Copies two arrays into one. Assumes that the destination array is large 1510 * enough. 1511 * 1512 * @param result the destination array 1513 * @param head the first source array 1514 * @param tail the second source array 1515 * @return the destination array, that is, result 1516 */ arraycopy(T[] result, T[] head, T[] tail)1517 private static <T extends Object> T[] arraycopy(T[] result, T[] head, T[] tail) { 1518 System.arraycopy(head, 0, result, 0, head.length); 1519 System.arraycopy(tail, 0, result, head.length, tail.length); 1520 return result; 1521 } 1522 1523 /** 1524 * This must be provided by the vm vendor, as it is used by other provided 1525 * class implementations in this package. This method is used by 1526 * SecurityManager.classDepth(), and getClassContext() which use the 1527 * parameters (-1, false) and SecurityManager.classLoaderDepth(), 1528 * currentClassLoader(), and currentLoadedClass() which use the parameters 1529 * (-1, true). Walk the stack and answer an array containing the maxDepth 1530 * most recent classes on the stack of the calling thread. Starting with the 1531 * caller of the caller of getStackClasses(), return an array of not more 1532 * than maxDepth Classes representing the classes of running methods on the 1533 * stack (including native methods). Frames representing the VM 1534 * implementation of java.lang.reflect are not included in the list. If 1535 * stopAtPrivileged is true, the walk will terminate at any frame running 1536 * one of the following methods: <code><ul> 1537 * <li>java/security/AccessController.doPrivileged(Ljava/security/PrivilegedAction;)Ljava/lang/Object;</li> 1538 * <li>java/security/AccessController.doPrivileged(Ljava/security/PrivilegedExceptionAction;)Ljava/lang/Object;</li> 1539 * <li>java/security/AccessController.doPrivileged(Ljava/security/PrivilegedAction;Ljava/security/AccessControlContext;)Ljava/lang/Object;</li> 1540 * <li>java/security/AccessController.doPrivileged(Ljava/security/PrivilegedExceptionAction;Ljava/security/AccessControlContext;)Ljava/lang/Object;</li> 1541 * </ul></code> If one of the doPrivileged methods is found, the walk terminate 1542 * and that frame is NOT included in the returned array. Notes: 1543 * <ul> 1544 * <li>This method operates on the defining classes of methods on stack. 1545 * NOT the classes of receivers.</li> 1546 * <li>The item at index zero in the result array describes the caller of 1547 * the caller of this method.</li> 1548 * </ul> 1549 * 1550 * @param maxDepth 1551 * maximum depth to walk the stack, -1 for the entire stack 1552 * @param stopAtPrivileged 1553 * stop at privileged classes 1554 * @return the array of the most recent classes on the stack 1555 */ getStackClasses(int maxDepth, boolean stopAtPrivileged)1556 static final Class<?>[] getStackClasses(int maxDepth, boolean stopAtPrivileged) { 1557 return VMStack.getClasses(maxDepth, stopAtPrivileged); 1558 } 1559 1560 } 1561