Save This Page
Home » openjdk-7 » java » lang » [javadoc | source]
    1   /*
    2    * Copyright (c) 1994, 2010, 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;
   27   
   28   import java.lang.reflect.Array;
   29   import java.lang.reflect.GenericArrayType;
   30   import java.lang.reflect.Member;
   31   import java.lang.reflect.Field;
   32   import java.lang.reflect.Method;
   33   import java.lang.reflect.Constructor;
   34   import java.lang.reflect.GenericDeclaration;
   35   import java.lang.reflect.Modifier;
   36   import java.lang.reflect.Type;
   37   import java.lang.reflect.TypeVariable;
   38   import java.lang.reflect.InvocationTargetException;
   39   import java.lang.ref.SoftReference;
   40   import java.io.InputStream;
   41   import java.io.ObjectStreamField;
   42   import java.security.AccessController;
   43   import java.security.PrivilegedAction;
   44   import java.util.ArrayList;
   45   import java.util.Arrays;
   46   import java.util.Collection;
   47   import java.util.HashSet;
   48   import java.util.Iterator;
   49   import java.util.List;
   50   import java.util.LinkedList;
   51   import java.util.LinkedHashSet;
   52   import java.util.Set;
   53   import java.util.Map;
   54   import java.util.HashMap;
   55   import sun.misc.Unsafe;
   56   import sun.reflect.ConstantPool;
   57   import sun.reflect.Reflection;
   58   import sun.reflect.ReflectionFactory;
   59   import sun.reflect.SignatureIterator;
   60   import sun.reflect.generics.factory.CoreReflectionFactory;
   61   import sun.reflect.generics.factory.GenericsFactory;
   62   import sun.reflect.generics.repository.ClassRepository;
   63   import sun.reflect.generics.repository.MethodRepository;
   64   import sun.reflect.generics.repository.ConstructorRepository;
   65   import sun.reflect.generics.scope.ClassScope;
   66   import sun.security.util.SecurityConstants;
   67   import java.lang.annotation.Annotation;
   68   import sun.reflect.annotation;
   69   
   70   /**
   71    * Instances of the class {@code Class} represent classes and
   72    * interfaces in a running Java application.  An enum is a kind of
   73    * class and an annotation is a kind of interface.  Every array also
   74    * belongs to a class that is reflected as a {@code Class} object
   75    * that is shared by all arrays with the same element type and number
   76    * of dimensions.  The primitive Java types ({@code boolean},
   77    * {@code byte}, {@code char}, {@code short},
   78    * {@code int}, {@code long}, {@code float}, and
   79    * {@code double}), and the keyword {@code void} are also
   80    * represented as {@code Class} objects.
   81    *
   82    * <p> {@code Class} has no public constructor. Instead {@code Class}
   83    * objects are constructed automatically by the Java Virtual Machine as classes
   84    * are loaded and by calls to the {@code defineClass} method in the class
   85    * loader.
   86    *
   87    * <p> The following example uses a {@code Class} object to print the
   88    * class name of an object:
   89    *
   90    * <p> <blockquote><pre>
   91    *     void printClassName(Object obj) {
   92    *         System.out.println("The class of " + obj +
   93    *                            " is " + obj.getClass().getName());
   94    *     }
   95    * </pre></blockquote>
   96    *
   97    * <p> It is also possible to get the {@code Class} object for a named
   98    * type (or for void) using a class literal.  See Section 15.8.2 of
   99    * <cite>The Java&trade; Language Specification</cite>.
  100    * For example:
  101    *
  102    * <p> <blockquote>
  103    *     {@code System.out.println("The name of class Foo is: "+Foo.class.getName());}
  104    * </blockquote>
  105    *
  106    * @param <T> the type of the class modeled by this {@code Class}
  107    * object.  For example, the type of {@code String.class} is {@code
  108    * Class<String>}.  Use {@code Class<?>} if the class being modeled is
  109    * unknown.
  110    *
  111    * @author  unascribed
  112    * @see     java.lang.ClassLoader#defineClass(byte[], int, int)
  113    * @since   JDK1.0
  114    */
  115   public final
  116       class Class<T> implements java.io.Serializable,
  117                                 java.lang.reflect.GenericDeclaration,
  118                                 java.lang.reflect.Type,
  119                                 java.lang.reflect.AnnotatedElement {
  120       private static final int ANNOTATION= 0x00002000;
  121       private static final int ENUM      = 0x00004000;
  122       private static final int SYNTHETIC = 0x00001000;
  123   
  124       private static native void registerNatives();
  125       static {
  126           registerNatives();
  127       }
  128   
  129       /*
  130        * Constructor. Only the Java Virtual Machine creates Class
  131        * objects.
  132        */
  133       private Class() {}
  134   
  135   
  136       /**
  137        * Converts the object to a string. The string representation is the
  138        * string "class" or "interface", followed by a space, and then by the
  139        * fully qualified name of the class in the format returned by
  140        * {@code getName}.  If this {@code Class} object represents a
  141        * primitive type, this method returns the name of the primitive type.  If
  142        * this {@code Class} object represents void this method returns
  143        * "void".
  144        *
  145        * @return a string representation of this class object.
  146        */
  147       public String toString() {
  148           return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
  149               + getName();
  150       }
  151   
  152   
  153       /**
  154        * Returns the {@code Class} object associated with the class or
  155        * interface with the given string name.  Invoking this method is
  156        * equivalent to:
  157        *
  158        * <blockquote>
  159        *  {@code Class.forName(className, true, currentLoader)}
  160        * </blockquote>
  161        *
  162        * where {@code currentLoader} denotes the defining class loader of
  163        * the current class.
  164        *
  165        * <p> For example, the following code fragment returns the
  166        * runtime {@code Class} descriptor for the class named
  167        * {@code java.lang.Thread}:
  168        *
  169        * <blockquote>
  170        *   {@code Class t = Class.forName("java.lang.Thread")}
  171        * </blockquote>
  172        * <p>
  173        * A call to {@code forName("X")} causes the class named
  174        * {@code X} to be initialized.
  175        *
  176        * @param      className   the fully qualified name of the desired class.
  177        * @return     the {@code Class} object for the class with the
  178        *             specified name.
  179        * @exception LinkageError if the linkage fails
  180        * @exception ExceptionInInitializerError if the initialization provoked
  181        *            by this method fails
  182        * @exception ClassNotFoundException if the class cannot be located
  183        */
  184       public static Class<?> forName(String className)
  185                   throws ClassNotFoundException {
  186           return forName0(className, true, ClassLoader.getCallerClassLoader());
  187       }
  188   
  189   
  190       /**
  191        * Returns the {@code Class} object associated with the class or
  192        * interface with the given string name, using the given class loader.
  193        * Given the fully qualified name for a class or interface (in the same
  194        * format returned by {@code getName}) this method attempts to
  195        * locate, load, and link the class or interface.  The specified class
  196        * loader is used to load the class or interface.  If the parameter
  197        * {@code loader} is null, the class is loaded through the bootstrap
  198        * class loader.  The class is initialized only if the
  199        * {@code initialize} parameter is {@code true} and if it has
  200        * not been initialized earlier.
  201        *
  202        * <p> If {@code name} denotes a primitive type or void, an attempt
  203        * will be made to locate a user-defined class in the unnamed package whose
  204        * name is {@code name}. Therefore, this method cannot be used to
  205        * obtain any of the {@code Class} objects representing primitive
  206        * types or void.
  207        *
  208        * <p> If {@code name} denotes an array class, the component type of
  209        * the array class is loaded but not initialized.
  210        *
  211        * <p> For example, in an instance method the expression:
  212        *
  213        * <blockquote>
  214        *  {@code Class.forName("Foo")}
  215        * </blockquote>
  216        *
  217        * is equivalent to:
  218        *
  219        * <blockquote>
  220        *  {@code Class.forName("Foo", true, this.getClass().getClassLoader())}
  221        * </blockquote>
  222        *
  223        * Note that this method throws errors related to loading, linking or
  224        * initializing as specified in Sections 12.2, 12.3 and 12.4 of <em>The
  225        * Java Language Specification</em>.
  226        * Note that this method does not check whether the requested class
  227        * is accessible to its caller.
  228        *
  229        * <p> If the {@code loader} is {@code null}, and a security
  230        * manager is present, and the caller's class loader is not null, then this
  231        * method calls the security manager's {@code checkPermission} method
  232        * with a {@code RuntimePermission("getClassLoader")} permission to
  233        * ensure it's ok to access the bootstrap class loader.
  234        *
  235        * @param name       fully qualified name of the desired class
  236        * @param initialize whether the class must be initialized
  237        * @param loader     class loader from which the class must be loaded
  238        * @return           class object representing the desired class
  239        *
  240        * @exception LinkageError if the linkage fails
  241        * @exception ExceptionInInitializerError if the initialization provoked
  242        *            by this method fails
  243        * @exception ClassNotFoundException if the class cannot be located by
  244        *            the specified class loader
  245        *
  246        * @see       java.lang.Class#forName(String)
  247        * @see       java.lang.ClassLoader
  248        * @since     1.2
  249        */
  250       public static Class<?> forName(String name, boolean initialize,
  251                                      ClassLoader loader)
  252           throws ClassNotFoundException
  253       {
  254           if (loader == null) {
  255               SecurityManager sm = System.getSecurityManager();
  256               if (sm != null) {
  257                   ClassLoader ccl = ClassLoader.getCallerClassLoader();
  258                   if (ccl != null) {
  259                       sm.checkPermission(
  260                           SecurityConstants.GET_CLASSLOADER_PERMISSION);
  261                   }
  262               }
  263           }
  264           return forName0(name, initialize, loader);
  265       }
  266   
  267       /** Called after security checks have been made. */
  268       private static native Class<?> forName0(String name, boolean initialize,
  269                                               ClassLoader loader)
  270           throws ClassNotFoundException;
  271   
  272       /**
  273        * Creates a new instance of the class represented by this {@code Class}
  274        * object.  The class is instantiated as if by a {@code new}
  275        * expression with an empty argument list.  The class is initialized if it
  276        * has not already been initialized.
  277        *
  278        * <p>Note that this method propagates any exception thrown by the
  279        * nullary constructor, including a checked exception.  Use of
  280        * this method effectively bypasses the compile-time exception
  281        * checking that would otherwise be performed by the compiler.
  282        * The {@link
  283        * java.lang.reflect.Constructor#newInstance(java.lang.Object...)
  284        * Constructor.newInstance} method avoids this problem by wrapping
  285        * any exception thrown by the constructor in a (checked) {@link
  286        * java.lang.reflect.InvocationTargetException}.
  287        *
  288        * @return     a newly allocated instance of the class represented by this
  289        *             object.
  290        * @exception  IllegalAccessException  if the class or its nullary
  291        *               constructor is not accessible.
  292        * @exception  InstantiationException
  293        *               if this {@code Class} represents an abstract class,
  294        *               an interface, an array class, a primitive type, or void;
  295        *               or if the class has no nullary constructor;
  296        *               or if the instantiation fails for some other reason.
  297        * @exception  ExceptionInInitializerError if the initialization
  298        *               provoked by this method fails.
  299        * @exception  SecurityException
  300        *             If a security manager, <i>s</i>, is present and any of the
  301        *             following conditions is met:
  302        *
  303        *             <ul>
  304        *
  305        *             <li> invocation of
  306        *             {@link SecurityManager#checkMemberAccess
  307        *             s.checkMemberAccess(this, Member.PUBLIC)} denies
  308        *             creation of new instances of this class
  309        *
  310        *             <li> the caller's class loader is not the same as or an
  311        *             ancestor of the class loader for the current class and
  312        *             invocation of {@link SecurityManager#checkPackageAccess
  313        *             s.checkPackageAccess()} denies access to the package
  314        *             of this class
  315        *
  316        *             </ul>
  317        *
  318        */
  319       public T newInstance()
  320           throws InstantiationException, IllegalAccessException
  321       {
  322           if (System.getSecurityManager() != null) {
  323               checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
  324           }
  325           return newInstance0();
  326       }
  327   
  328       private T newInstance0()
  329           throws InstantiationException, IllegalAccessException
  330       {
  331           // NOTE: the following code may not be strictly correct under
  332           // the current Java memory model.
  333   
  334           // Constructor lookup
  335           if (cachedConstructor == null) {
  336               if (this == Class.class) {
  337                   throw new IllegalAccessException(
  338                       "Can not call newInstance() on the Class for java.lang.Class"
  339                   );
  340               }
  341               try {
  342                   Class<?>[] empty = {};
  343                   final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
  344                   // Disable accessibility checks on the constructor
  345                   // since we have to do the security check here anyway
  346                   // (the stack depth is wrong for the Constructor's
  347                   // security check to work)
  348                   java.security.AccessController.doPrivileged(
  349                       new java.security.PrivilegedAction<Void>() {
  350                           public Void run() {
  351                                   c.setAccessible(true);
  352                                   return null;
  353                               }
  354                           });
  355                   cachedConstructor = c;
  356               } catch (NoSuchMethodException e) {
  357                   throw new InstantiationException(getName());
  358               }
  359           }
  360           Constructor<T> tmpConstructor = cachedConstructor;
  361           // Security check (same as in java.lang.reflect.Constructor)
  362           int modifiers = tmpConstructor.getModifiers();
  363           if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
  364               Class<?> caller = Reflection.getCallerClass(3);
  365               if (newInstanceCallerCache != caller) {
  366                   Reflection.ensureMemberAccess(caller, this, null, modifiers);
  367                   newInstanceCallerCache = caller;
  368               }
  369           }
  370           // Run constructor
  371           try {
  372               return tmpConstructor.newInstance((Object[])null);
  373           } catch (InvocationTargetException e) {
  374               Unsafe.getUnsafe().throwException(e.getTargetException());
  375               // Not reached
  376               return null;
  377           }
  378       }
  379       private volatile transient Constructor<T> cachedConstructor;
  380       private volatile transient Class<?>       newInstanceCallerCache;
  381   
  382   
  383       /**
  384        * Determines if the specified {@code Object} is assignment-compatible
  385        * with the object represented by this {@code Class}.  This method is
  386        * the dynamic equivalent of the Java language {@code instanceof}
  387        * operator. The method returns {@code true} if the specified
  388        * {@code Object} argument is non-null and can be cast to the
  389        * reference type represented by this {@code Class} object without
  390        * raising a {@code ClassCastException.} It returns {@code false}
  391        * otherwise.
  392        *
  393        * <p> Specifically, if this {@code Class} object represents a
  394        * declared class, this method returns {@code true} if the specified
  395        * {@code Object} argument is an instance of the represented class (or
  396        * of any of its subclasses); it returns {@code false} otherwise. If
  397        * this {@code Class} object represents an array class, this method
  398        * returns {@code true} if the specified {@code Object} argument
  399        * can be converted to an object of the array class by an identity
  400        * conversion or by a widening reference conversion; it returns
  401        * {@code false} otherwise. If this {@code Class} object
  402        * represents an interface, this method returns {@code true} if the
  403        * class or any superclass of the specified {@code Object} argument
  404        * implements this interface; it returns {@code false} otherwise. If
  405        * this {@code Class} object represents a primitive type, this method
  406        * returns {@code false}.
  407        *
  408        * @param   obj the object to check
  409        * @return  true if {@code obj} is an instance of this class
  410        *
  411        * @since JDK1.1
  412        */
  413       public native boolean isInstance(Object obj);
  414   
  415   
  416       /**
  417        * Determines if the class or interface represented by this
  418        * {@code Class} object is either the same as, or is a superclass or
  419        * superinterface of, the class or interface represented by the specified
  420        * {@code Class} parameter. It returns {@code true} if so;
  421        * otherwise it returns {@code false}. If this {@code Class}
  422        * object represents a primitive type, this method returns
  423        * {@code true} if the specified {@code Class} parameter is
  424        * exactly this {@code Class} object; otherwise it returns
  425        * {@code false}.
  426        *
  427        * <p> Specifically, this method tests whether the type represented by the
  428        * specified {@code Class} parameter can be converted to the type
  429        * represented by this {@code Class} object via an identity conversion
  430        * or via a widening reference conversion. See <em>The Java Language
  431        * Specification</em>, sections 5.1.1 and 5.1.4 , for details.
  432        *
  433        * @param cls the {@code Class} object to be checked
  434        * @return the {@code boolean} value indicating whether objects of the
  435        * type {@code cls} can be assigned to objects of this class
  436        * @exception NullPointerException if the specified Class parameter is
  437        *            null.
  438        * @since JDK1.1
  439        */
  440       public native boolean isAssignableFrom(Class<?> cls);
  441   
  442   
  443       /**
  444        * Determines if the specified {@code Class} object represents an
  445        * interface type.
  446        *
  447        * @return  {@code true} if this object represents an interface;
  448        *          {@code false} otherwise.
  449        */
  450       public native boolean isInterface();
  451   
  452   
  453       /**
  454        * Determines if this {@code Class} object represents an array class.
  455        *
  456        * @return  {@code true} if this object represents an array class;
  457        *          {@code false} otherwise.
  458        * @since   JDK1.1
  459        */
  460       public native boolean isArray();
  461   
  462   
  463       /**
  464        * Determines if the specified {@code Class} object represents a
  465        * primitive type.
  466        *
  467        * <p> There are nine predefined {@code Class} objects to represent
  468        * the eight primitive types and void.  These are created by the Java
  469        * Virtual Machine, and have the same names as the primitive types that
  470        * they represent, namely {@code boolean}, {@code byte},
  471        * {@code char}, {@code short}, {@code int},
  472        * {@code long}, {@code float}, and {@code double}.
  473        *
  474        * <p> These objects may only be accessed via the following public static
  475        * final variables, and are the only {@code Class} objects for which
  476        * this method returns {@code true}.
  477        *
  478        * @return true if and only if this class represents a primitive type
  479        *
  480        * @see     java.lang.Boolean#TYPE
  481        * @see     java.lang.Character#TYPE
  482        * @see     java.lang.Byte#TYPE
  483        * @see     java.lang.Short#TYPE
  484        * @see     java.lang.Integer#TYPE
  485        * @see     java.lang.Long#TYPE
  486        * @see     java.lang.Float#TYPE
  487        * @see     java.lang.Double#TYPE
  488        * @see     java.lang.Void#TYPE
  489        * @since JDK1.1
  490        */
  491       public native boolean isPrimitive();
  492   
  493       /**
  494        * Returns true if this {@code Class} object represents an annotation
  495        * type.  Note that if this method returns true, {@link #isInterface()}
  496        * would also return true, as all annotation types are also interfaces.
  497        *
  498        * @return {@code true} if this class object represents an annotation
  499        *      type; {@code false} otherwise
  500        * @since 1.5
  501        */
  502       public boolean isAnnotation() {
  503           return (getModifiers() & ANNOTATION) != 0;
  504       }
  505   
  506       /**
  507        * Returns {@code true} if this class is a synthetic class;
  508        * returns {@code false} otherwise.
  509        * @return {@code true} if and only if this class is a synthetic class as
  510        *         defined by the Java Language Specification.
  511        * @since 1.5
  512        */
  513       public boolean isSynthetic() {
  514           return (getModifiers() & SYNTHETIC) != 0;
  515       }
  516   
  517       /**
  518        * Returns the  name of the entity (class, interface, array class,
  519        * primitive type, or void) represented by this {@code Class} object,
  520        * as a {@code String}.
  521        *
  522        * <p> If this class object represents a reference type that is not an
  523        * array type then the binary name of the class is returned, as specified
  524        * by
  525        * <cite>The Java&trade; Language Specification</cite>.
  526        *
  527        * <p> If this class object represents a primitive type or void, then the
  528        * name returned is a {@code String} equal to the Java language
  529        * keyword corresponding to the primitive type or void.
  530        *
  531        * <p> If this class object represents a class of arrays, then the internal
  532        * form of the name consists of the name of the element type preceded by
  533        * one or more '{@code [}' characters representing the depth of the array
  534        * nesting.  The encoding of element type names is as follows:
  535        *
  536        * <blockquote><table summary="Element types and encodings">
  537        * <tr><th> Element Type <th> &nbsp;&nbsp;&nbsp; <th> Encoding
  538        * <tr><td> boolean      <td> &nbsp;&nbsp;&nbsp; <td align=center> Z
  539        * <tr><td> byte         <td> &nbsp;&nbsp;&nbsp; <td align=center> B
  540        * <tr><td> char         <td> &nbsp;&nbsp;&nbsp; <td align=center> C
  541        * <tr><td> class or interface
  542        *                       <td> &nbsp;&nbsp;&nbsp; <td align=center> L<i>classname</i>;
  543        * <tr><td> double       <td> &nbsp;&nbsp;&nbsp; <td align=center> D
  544        * <tr><td> float        <td> &nbsp;&nbsp;&nbsp; <td align=center> F
  545        * <tr><td> int          <td> &nbsp;&nbsp;&nbsp; <td align=center> I
  546        * <tr><td> long         <td> &nbsp;&nbsp;&nbsp; <td align=center> J
  547        * <tr><td> short        <td> &nbsp;&nbsp;&nbsp; <td align=center> S
  548        * </table></blockquote>
  549        *
  550        * <p> The class or interface name <i>classname</i> is the binary name of
  551        * the class specified above.
  552        *
  553        * <p> Examples:
  554        * <blockquote><pre>
  555        * String.class.getName()
  556        *     returns "java.lang.String"
  557        * byte.class.getName()
  558        *     returns "byte"
  559        * (new Object[3]).getClass().getName()
  560        *     returns "[Ljava.lang.Object;"
  561        * (new int[3][4][5][6][7][8][9]).getClass().getName()
  562        *     returns "[[[[[[[I"
  563        * </pre></blockquote>
  564        *
  565        * @return  the name of the class or interface
  566        *          represented by this object.
  567        */
  568       public String getName() {
  569           String name = this.name;
  570           if (name == null)
  571               this.name = name = getName0();
  572           return name;
  573       }
  574   
  575       // cache the name to reduce the number of calls into the VM
  576       private transient String name;
  577       private native String getName0();
  578   
  579       /**
  580        * Returns the class loader for the class.  Some implementations may use
  581        * null to represent the bootstrap class loader. This method will return
  582        * null in such implementations if this class was loaded by the bootstrap
  583        * class loader.
  584        *
  585        * <p> If a security manager is present, and the caller's class loader is
  586        * not null and the caller's class loader is not the same as or an ancestor of
  587        * the class loader for the class whose class loader is requested, then
  588        * this method calls the security manager's {@code checkPermission}
  589        * method with a {@code RuntimePermission("getClassLoader")}
  590        * permission to ensure it's ok to access the class loader for the class.
  591        *
  592        * <p>If this object
  593        * represents a primitive type or void, null is returned.
  594        *
  595        * @return  the class loader that loaded the class or interface
  596        *          represented by this object.
  597        * @throws SecurityException
  598        *    if a security manager exists and its
  599        *    {@code checkPermission} method denies
  600        *    access to the class loader for the class.
  601        * @see java.lang.ClassLoader
  602        * @see SecurityManager#checkPermission
  603        * @see java.lang.RuntimePermission
  604        */
  605       public ClassLoader getClassLoader() {
  606           ClassLoader cl = getClassLoader0();
  607           if (cl == null)
  608               return null;
  609           SecurityManager sm = System.getSecurityManager();
  610           if (sm != null) {
  611               ClassLoader ccl = ClassLoader.getCallerClassLoader();
  612               if (ccl != null && ccl != cl && !cl.isAncestor(ccl)) {
  613                   sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
  614               }
  615           }
  616           return cl;
  617       }
  618   
  619       // Package-private to allow ClassLoader access
  620       native ClassLoader getClassLoader0();
  621   
  622   
  623       /**
  624        * Returns an array of {@code TypeVariable} objects that represent the
  625        * type variables declared by the generic declaration represented by this
  626        * {@code GenericDeclaration} object, in declaration order.  Returns an
  627        * array of length 0 if the underlying generic declaration declares no type
  628        * variables.
  629        *
  630        * @return an array of {@code TypeVariable} objects that represent
  631        *     the type variables declared by this generic declaration
  632        * @throws java.lang.reflect.GenericSignatureFormatError if the generic
  633        *     signature of this generic declaration does not conform to
  634        *     the format specified in
  635        *     <cite>The Java&trade; Virtual Machine Specification</cite>
  636        * @since 1.5
  637        */
  638       public TypeVariable<Class<T>>[] getTypeParameters() {
  639           if (getGenericSignature() != null)
  640               return (TypeVariable<Class<T>>[])getGenericInfo().getTypeParameters();
  641           else
  642               return (TypeVariable<Class<T>>[])new TypeVariable<?>[0];
  643       }
  644   
  645   
  646       /**
  647        * Returns the {@code Class} representing the superclass of the entity
  648        * (class, interface, primitive type or void) represented by this
  649        * {@code Class}.  If this {@code Class} represents either the
  650        * {@code Object} class, an interface, a primitive type, or void, then
  651        * null is returned.  If this object represents an array class then the
  652        * {@code Class} object representing the {@code Object} class is
  653        * returned.
  654        *
  655        * @return the superclass of the class represented by this object.
  656        */
  657       public native Class<? super T> getSuperclass();
  658   
  659   
  660       /**
  661        * Returns the {@code Type} representing the direct superclass of
  662        * the entity (class, interface, primitive type or void) represented by
  663        * this {@code Class}.
  664        *
  665        * <p>If the superclass is a parameterized type, the {@code Type}
  666        * object returned must accurately reflect the actual type
  667        * parameters used in the source code. The parameterized type
  668        * representing the superclass is created if it had not been
  669        * created before. See the declaration of {@link
  670        * java.lang.reflect.ParameterizedType ParameterizedType} for the
  671        * semantics of the creation process for parameterized types.  If
  672        * this {@code Class} represents either the {@code Object}
  673        * class, an interface, a primitive type, or void, then null is
  674        * returned.  If this object represents an array class then the
  675        * {@code Class} object representing the {@code Object} class is
  676        * returned.
  677        *
  678        * @throws java.lang.reflect.GenericSignatureFormatError if the generic
  679        *     class signature does not conform to the format specified in
  680        *     <cite>The Java&trade; Virtual Machine Specification</cite>
  681        * @throws TypeNotPresentException if the generic superclass
  682        *     refers to a non-existent type declaration
  683        * @throws java.lang.reflect.MalformedParameterizedTypeException if the
  684        *     generic superclass refers to a parameterized type that cannot be
  685        *     instantiated  for any reason
  686        * @return the superclass of the class represented by this object
  687        * @since 1.5
  688        */
  689       public Type getGenericSuperclass() {
  690           if (getGenericSignature() != null) {
  691               // Historical irregularity:
  692               // Generic signature marks interfaces with superclass = Object
  693               // but this API returns null for interfaces
  694               if (isInterface())
  695                   return null;
  696               return getGenericInfo().getSuperclass();
  697           } else
  698               return getSuperclass();
  699       }
  700   
  701       /**
  702        * Gets the package for this class.  The class loader of this class is used
  703        * to find the package.  If the class was loaded by the bootstrap class
  704        * loader the set of packages loaded from CLASSPATH is searched to find the
  705        * package of the class. Null is returned if no package object was created
  706        * by the class loader of this class.
  707        *
  708        * <p> Packages have attributes for versions and specifications only if the
  709        * information was defined in the manifests that accompany the classes, and
  710        * if the class loader created the package instance with the attributes
  711        * from the manifest.
  712        *
  713        * @return the package of the class, or null if no package
  714        *         information is available from the archive or codebase.
  715        */
  716       public Package getPackage() {
  717           return Package.getPackage(this);
  718       }
  719   
  720   
  721       /**
  722        * Determines the interfaces implemented by the class or interface
  723        * represented by this object.
  724        *
  725        * <p> If this object represents a class, the return value is an array
  726        * containing objects representing all interfaces implemented by the
  727        * class. The order of the interface objects in the array corresponds to
  728        * the order of the interface names in the {@code implements} clause
  729        * of the declaration of the class represented by this object. For
  730        * example, given the declaration:
  731        * <blockquote>
  732        * {@code class Shimmer implements FloorWax, DessertTopping { ... }}
  733        * </blockquote>
  734        * suppose the value of {@code s} is an instance of
  735        * {@code Shimmer}; the value of the expression:
  736        * <blockquote>
  737        * {@code s.getClass().getInterfaces()[0]}
  738        * </blockquote>
  739        * is the {@code Class} object that represents interface
  740        * {@code FloorWax}; and the value of:
  741        * <blockquote>
  742        * {@code s.getClass().getInterfaces()[1]}
  743        * </blockquote>
  744        * is the {@code Class} object that represents interface
  745        * {@code DessertTopping}.
  746        *
  747        * <p> If this object represents an interface, the array contains objects
  748        * representing all interfaces extended by the interface. The order of the
  749        * interface objects in the array corresponds to the order of the interface
  750        * names in the {@code extends} clause of the declaration of the
  751        * interface represented by this object.
  752        *
  753        * <p> If this object represents a class or interface that implements no
  754        * interfaces, the method returns an array of length 0.
  755        *
  756        * <p> If this object represents a primitive type or void, the method
  757        * returns an array of length 0.
  758        *
  759        * @return an array of interfaces implemented by this class.
  760        */
  761       public native Class<?>[] getInterfaces();
  762   
  763       /**
  764        * Returns the {@code Type}s representing the interfaces
  765        * directly implemented by the class or interface represented by
  766        * this object.
  767        *
  768        * <p>If a superinterface is a parameterized type, the
  769        * {@code Type} object returned for it must accurately reflect
  770        * the actual type parameters used in the source code. The
  771        * parameterized type representing each superinterface is created
  772        * if it had not been created before. See the declaration of
  773        * {@link java.lang.reflect.ParameterizedType ParameterizedType}
  774        * for the semantics of the creation process for parameterized
  775        * types.
  776        *
  777        * <p> If this object represents a class, the return value is an
  778        * array containing objects representing all interfaces
  779        * implemented by the class. The order of the interface objects in
  780        * the array corresponds to the order of the interface names in
  781        * the {@code implements} clause of the declaration of the class
  782        * represented by this object.  In the case of an array class, the
  783        * interfaces {@code Cloneable} and {@code Serializable} are
  784        * returned in that order.
  785        *
  786        * <p>If this object represents an interface, the array contains
  787        * objects representing all interfaces directly extended by the
  788        * interface.  The order of the interface objects in the array
  789        * corresponds to the order of the interface names in the
  790        * {@code extends} clause of the declaration of the interface
  791        * represented by this object.
  792        *
  793        * <p>If this object represents a class or interface that
  794        * implements no interfaces, the method returns an array of length
  795        * 0.
  796        *
  797        * <p>If this object represents a primitive type or void, the
  798        * method returns an array of length 0.
  799        *
  800        * @throws java.lang.reflect.GenericSignatureFormatError
  801        *     if the generic class signature does not conform to the format
  802        *     specified in
  803        *     <cite>The Java&trade; Virtual Machine Specification</cite>
  804        * @throws TypeNotPresentException if any of the generic
  805        *     superinterfaces refers to a non-existent type declaration
  806        * @throws java.lang.reflect.MalformedParameterizedTypeException
  807        *     if any of the generic superinterfaces refer to a parameterized
  808        *     type that cannot be instantiated for any reason
  809        * @return an array of interfaces implemented by this class
  810        * @since 1.5
  811        */
  812       public Type[] getGenericInterfaces() {
  813           if (getGenericSignature() != null)
  814               return getGenericInfo().getSuperInterfaces();
  815           else
  816               return getInterfaces();
  817       }
  818   
  819   
  820       /**
  821        * Returns the {@code Class} representing the component type of an
  822        * array.  If this class does not represent an array class this method
  823        * returns null.
  824        *
  825        * @return the {@code Class} representing the component type of this
  826        * class if this class is an array
  827        * @see     java.lang.reflect.Array
  828        * @since JDK1.1
  829        */
  830       public native Class<?> getComponentType();
  831   
  832   
  833       /**
  834        * Returns the Java language modifiers for this class or interface, encoded
  835        * in an integer. The modifiers consist of the Java Virtual Machine's
  836        * constants for {@code public}, {@code protected},
  837        * {@code private}, {@code final}, {@code static},
  838        * {@code abstract} and {@code interface}; they should be decoded
  839        * using the methods of class {@code Modifier}.
  840        *
  841        * <p> If the underlying class is an array class, then its
  842        * {@code public}, {@code private} and {@code protected}
  843        * modifiers are the same as those of its component type.  If this
  844        * {@code Class} represents a primitive type or void, its
  845        * {@code public} modifier is always {@code true}, and its
  846        * {@code protected} and {@code private} modifiers are always
  847        * {@code false}. If this object represents an array class, a
  848        * primitive type or void, then its {@code final} modifier is always
  849        * {@code true} and its interface modifier is always
  850        * {@code false}. The values of its other modifiers are not determined
  851        * by this specification.
  852        *
  853        * <p> The modifier encodings are defined in <em>The Java Virtual Machine
  854        * Specification</em>, table 4.1.
  855        *
  856        * @return the {@code int} representing the modifiers for this class
  857        * @see     java.lang.reflect.Modifier
  858        * @since JDK1.1
  859        */
  860       public native int getModifiers();
  861   
  862   
  863       /**
  864        * Gets the signers of this class.
  865        *
  866        * @return  the signers of this class, or null if there are no signers.  In
  867        *          particular, this method returns null if this object represents
  868        *          a primitive type or void.
  869        * @since   JDK1.1
  870        */
  871       public native Object[] getSigners();
  872   
  873   
  874       /**
  875        * Set the signers of this class.
  876        */
  877       native void setSigners(Object[] signers);
  878   
  879   
  880       /**
  881        * If this {@code Class} object represents a local or anonymous
  882        * class within a method, returns a {@link
  883        * java.lang.reflect.Method Method} object representing the
  884        * immediately enclosing method of the underlying class. Returns
  885        * {@code null} otherwise.
  886        *
  887        * In particular, this method returns {@code null} if the underlying
  888        * class is a local or anonymous class immediately enclosed by a type
  889        * declaration, instance initializer or static initializer.
  890        *
  891        * @return the immediately enclosing method of the underlying class, if
  892        *     that class is a local or anonymous class; otherwise {@code null}.
  893        * @since 1.5
  894        */
  895       public Method getEnclosingMethod() {
  896           EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();
  897   
  898           if (enclosingInfo == null)
  899               return null;
  900           else {
  901               if (!enclosingInfo.isMethod())
  902                   return null;
  903   
  904               MethodRepository typeInfo = MethodRepository.make(enclosingInfo.getDescriptor(),
  905                                                                 getFactory());
  906               Class<?>   returnType       = toClass(typeInfo.getReturnType());
  907               Type []    parameterTypes   = typeInfo.getParameterTypes();
  908               Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];
  909   
  910               // Convert Types to Classes; returned types *should*
  911               // be class objects since the methodDescriptor's used
  912               // don't have generics information
  913               for(int i = 0; i < parameterClasses.length; i++)
  914                   parameterClasses[i] = toClass(parameterTypes[i]);
  915   
  916               /*
  917                * Loop over all declared methods; match method name,
  918                * number of and type of parameters, *and* return
  919                * type.  Matching return type is also necessary
  920                * because of covariant returns, etc.
  921                */
  922               for(Method m: enclosingInfo.getEnclosingClass().getDeclaredMethods()) {
  923                   if (m.getName().equals(enclosingInfo.getName()) ) {
  924                       Class<?>[] candidateParamClasses = m.getParameterTypes();
  925                       if (candidateParamClasses.length == parameterClasses.length) {
  926                           boolean matches = true;
  927                           for(int i = 0; i < candidateParamClasses.length; i++) {
  928                               if (!candidateParamClasses[i].equals(parameterClasses[i])) {
  929                                   matches = false;
  930                                   break;
  931                               }
  932                           }
  933   
  934                           if (matches) { // finally, check return type
  935                               if (m.getReturnType().equals(returnType) )
  936                                   return m;
  937                           }
  938                       }
  939                   }
  940               }
  941   
  942               throw new InternalError("Enclosing method not found");
  943           }
  944       }
  945   
  946       private native Object[] getEnclosingMethod0();
  947   
  948       private EnclosingMethodInfo getEnclosingMethodInfo() {
  949           Object[] enclosingInfo = getEnclosingMethod0();
  950           if (enclosingInfo == null)
  951               return null;
  952           else {
  953               return new EnclosingMethodInfo(enclosingInfo);
  954           }
  955       }
  956   
  957       private final static class EnclosingMethodInfo {
  958           private Class<?> enclosingClass;
  959           private String name;
  960           private String descriptor;
  961   
  962           private EnclosingMethodInfo(Object[] enclosingInfo) {
  963               if (enclosingInfo.length != 3)
  964                   throw new InternalError("Malformed enclosing method information");
  965               try {
  966                   // The array is expected to have three elements:
  967   
  968                   // the immediately enclosing class
  969                   enclosingClass = (Class<?>) enclosingInfo[0];
  970                   assert(enclosingClass != null);
  971   
  972                   // the immediately enclosing method or constructor's
  973                   // name (can be null).
  974                   name            = (String)   enclosingInfo[1];
  975   
  976                   // the immediately enclosing method or constructor's
  977                   // descriptor (null iff name is).
  978                   descriptor      = (String)   enclosingInfo[2];
  979                   assert((name != null && descriptor != null) || name == descriptor);
  980               } catch (ClassCastException cce) {
  981                   throw new InternalError("Invalid type in enclosing method information");
  982               }
  983           }
  984   
  985           boolean isPartial() {
  986               return enclosingClass == null || name == null || descriptor == null;
  987           }
  988   
  989           boolean isConstructor() { return !isPartial() && "<init>".equals(name); }
  990   
  991           boolean isMethod() { return !isPartial() && !isConstructor() && !"<clinit>".equals(name); }
  992   
  993           Class<?> getEnclosingClass() { return enclosingClass; }
  994   
  995           String getName() { return name; }
  996   
  997           String getDescriptor() { return descriptor; }
  998   
  999       }
 1000   
 1001       private static Class<?> toClass(Type o) {
 1002           if (o instanceof GenericArrayType)
 1003               return Array.newInstance(toClass(((GenericArrayType)o).getGenericComponentType()),
 1004                                        0)
 1005                   .getClass();
 1006           return (Class<?>)o;
 1007        }
 1008   
 1009       /**
 1010        * If this {@code Class} object represents a local or anonymous
 1011        * class within a constructor, returns a {@link
 1012        * java.lang.reflect.Constructor Constructor} object representing
 1013        * the immediately enclosing constructor of the underlying
 1014        * class. Returns {@code null} otherwise.  In particular, this
 1015        * method returns {@code null} if the underlying class is a local
 1016        * or anonymous class immediately enclosed by a type declaration,
 1017        * instance initializer or static initializer.
 1018        *
 1019        * @return the immediately enclosing constructor of the underlying class, if
 1020        *     that class is a local or anonymous class; otherwise {@code null}.
 1021        * @since 1.5
 1022        */
 1023       public Constructor<?> getEnclosingConstructor() {
 1024           EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();
 1025   
 1026           if (enclosingInfo == null)
 1027               return null;
 1028           else {
 1029               if (!enclosingInfo.isConstructor())
 1030                   return null;
 1031   
 1032               ConstructorRepository typeInfo = ConstructorRepository.make(enclosingInfo.getDescriptor(),
 1033                                                                           getFactory());
 1034               Type []    parameterTypes   = typeInfo.getParameterTypes();
 1035               Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];
 1036   
 1037               // Convert Types to Classes; returned types *should*
 1038               // be class objects since the methodDescriptor's used
 1039               // don't have generics information
 1040               for(int i = 0; i < parameterClasses.length; i++)
 1041                   parameterClasses[i] = toClass(parameterTypes[i]);
 1042   
 1043               /*
 1044                * Loop over all declared constructors; match number
 1045                * of and type of parameters.
 1046                */
 1047               for(Constructor<?> c: enclosingInfo.getEnclosingClass().getDeclaredConstructors()) {
 1048                   Class<?>[] candidateParamClasses = c.getParameterTypes();
 1049                   if (candidateParamClasses.length == parameterClasses.length) {
 1050                       boolean matches = true;
 1051                       for(int i = 0; i < candidateParamClasses.length; i++) {
 1052                           if (!candidateParamClasses[i].equals(parameterClasses[i])) {
 1053                               matches = false;
 1054                               break;
 1055                           }
 1056                       }
 1057   
 1058                       if (matches)
 1059                           return c;
 1060                   }
 1061               }
 1062   
 1063               throw new InternalError("Enclosing constructor not found");
 1064           }
 1065       }
 1066   
 1067   
 1068       /**
 1069        * If the class or interface represented by this {@code Class} object
 1070        * is a member of another class, returns the {@code Class} object
 1071        * representing the class in which it was declared.  This method returns
 1072        * null if this class or interface is not a member of any other class.  If
 1073        * this {@code Class} object represents an array class, a primitive
 1074        * type, or void,then this method returns null.
 1075        *
 1076        * @return the declaring class for this class
 1077        * @since JDK1.1
 1078        */
 1079       public native Class<?> getDeclaringClass();
 1080   
 1081   
 1082       /**
 1083        * Returns the immediately enclosing class of the underlying
 1084        * class.  If the underlying class is a top level class this
 1085        * method returns {@code null}.
 1086        * @return the immediately enclosing class of the underlying class
 1087        * @since 1.5
 1088        */
 1089       public Class<?> getEnclosingClass() {
 1090           // There are five kinds of classes (or interfaces):
 1091           // a) Top level classes
 1092           // b) Nested classes (static member classes)
 1093           // c) Inner classes (non-static member classes)
 1094           // d) Local classes (named classes declared within a method)
 1095           // e) Anonymous classes
 1096   
 1097   
 1098           // JVM Spec 4.8.6: A class must have an EnclosingMethod
 1099           // attribute if and only if it is a local class or an
 1100           // anonymous class.
 1101           EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();
 1102   
 1103           if (enclosingInfo == null) {
 1104               // This is a top level or a nested class or an inner class (a, b, or c)
 1105               return getDeclaringClass();
 1106           } else {
 1107               Class<?> enclosingClass = enclosingInfo.getEnclosingClass();
 1108               // This is a local class or an anonymous class (d or e)
 1109               if (enclosingClass == this || enclosingClass == null)
 1110                   throw new InternalError("Malformed enclosing method information");
 1111               else
 1112                   return enclosingClass;
 1113           }
 1114       }
 1115   
 1116       /**
 1117        * Returns the simple name of the underlying class as given in the
 1118        * source code. Returns an empty string if the underlying class is
 1119        * anonymous.
 1120        *
 1121        * <p>The simple name of an array is the simple name of the
 1122        * component type with "[]" appended.  In particular the simple
 1123        * name of an array whose component type is anonymous is "[]".
 1124        *
 1125        * @return the simple name of the underlying class
 1126        * @since 1.5
 1127        */
 1128       public String getSimpleName() {
 1129           if (isArray())
 1130               return getComponentType().getSimpleName()+"[]";
 1131   
 1132           String simpleName = getSimpleBinaryName();
 1133           if (simpleName == null) { // top level class
 1134               simpleName = getName();
 1135               return simpleName.substring(simpleName.lastIndexOf(".")+1); // strip the package name
 1136           }
 1137           // According to JLS3 "Binary Compatibility" (13.1) the binary
 1138           // name of non-package classes (not top level) is the binary
 1139           // name of the immediately enclosing class followed by a '$' followed by:
 1140           // (for nested and inner classes): the simple name.
 1141           // (for local classes): 1 or more digits followed by the simple name.
 1142           // (for anonymous classes): 1 or more digits.
 1143   
 1144           // Since getSimpleBinaryName() will strip the binary name of
 1145           // the immediatly enclosing class, we are now looking at a
 1146           // string that matches the regular expression "\$[0-9]*"
 1147           // followed by a simple name (considering the simple of an
 1148           // anonymous class to be the empty string).
 1149   
 1150           // Remove leading "\$[0-9]*" from the name
 1151           int length = simpleName.length();
 1152           if (length < 1 || simpleName.charAt(0) != '$')
 1153               throw new InternalError("Malformed class name");
 1154           int index = 1;
 1155           while (index < length && isAsciiDigit(simpleName.charAt(index)))
 1156               index++;
 1157           // Eventually, this is the empty string iff this is an anonymous class
 1158           return simpleName.substring(index);
 1159       }
 1160   
 1161       /**
 1162        * Character.isDigit answers {@code true} to some non-ascii
 1163        * digits.  This one does not.
 1164        */
 1165       private static boolean isAsciiDigit(char c) {
 1166           return '0' <= c && c <= '9';
 1167       }
 1168   
 1169       /**
 1170        * Returns the canonical name of the underlying class as
 1171        * defined by the Java Language Specification.  Returns null if
 1172        * the underlying class does not have a canonical name (i.e., if
 1173        * it is a local or anonymous class or an array whose component
 1174        * type does not have a canonical name).
 1175        * @return the canonical name of the underlying class if it exists, and
 1176        * {@code null} otherwise.
 1177        * @since 1.5
 1178        */
 1179       public String getCanonicalName() {
 1180           if (isArray()) {
 1181               String canonicalName = getComponentType().getCanonicalName();
 1182               if (canonicalName != null)
 1183                   return canonicalName + "[]";
 1184               else
 1185                   return null;
 1186           }
 1187           if (isLocalOrAnonymousClass())
 1188               return null;
 1189           Class<?> enclosingClass = getEnclosingClass();
 1190           if (enclosingClass == null) { // top level class
 1191               return getName();
 1192           } else {
 1193               String enclosingName = enclosingClass.getCanonicalName();
 1194               if (enclosingName == null)
 1195                   return null;
 1196               return enclosingName + "." + getSimpleName();
 1197           }
 1198       }
 1199   
 1200       /**
 1201        * Returns {@code true} if and only if the underlying class
 1202        * is an anonymous class.
 1203        *
 1204        * @return {@code true} if and only if this class is an anonymous class.
 1205        * @since 1.5
 1206        */
 1207       public boolean isAnonymousClass() {
 1208           return "".equals(getSimpleName());
 1209       }
 1210   
 1211       /**
 1212        * Returns {@code true} if and only if the underlying class
 1213        * is a local class.
 1214        *
 1215        * @return {@code true} if and only if this class is a local class.
 1216        * @since 1.5
 1217        */
 1218       public boolean isLocalClass() {
 1219           return isLocalOrAnonymousClass() && !isAnonymousClass();
 1220       }
 1221   
 1222       /**
 1223        * Returns {@code true} if and only if the underlying class
 1224        * is a member class.
 1225        *
 1226        * @return {@code true} if and only if this class is a member class.
 1227        * @since 1.5
 1228        */
 1229       public boolean isMemberClass() {
 1230           return getSimpleBinaryName() != null && !isLocalOrAnonymousClass();
 1231       }
 1232   
 1233       /**
 1234        * Returns the "simple binary name" of the underlying class, i.e.,
 1235        * the binary name without the leading enclosing class name.
 1236        * Returns {@code null} if the underlying class is a top level
 1237        * class.
 1238        */
 1239       private String getSimpleBinaryName() {
 1240           Class<?> enclosingClass = getEnclosingClass();
 1241           if (enclosingClass == null) // top level class
 1242               return null;
 1243           // Otherwise, strip the enclosing class' name
 1244           try {
 1245               return getName().substring(enclosingClass.getName().length());
 1246           } catch (IndexOutOfBoundsException ex) {
 1247               throw new InternalError("Malformed class name");
 1248           }
 1249       }
 1250   
 1251       /**
 1252        * Returns {@code true} if this is a local class or an anonymous
 1253        * class.  Returns {@code false} otherwise.
 1254        */
 1255       private boolean isLocalOrAnonymousClass() {
 1256           // JVM Spec 4.8.6: A class must have an EnclosingMethod
 1257           // attribute if and only if it is a local class or an
 1258           // anonymous class.
 1259           return getEnclosingMethodInfo() != null;
 1260       }
 1261   
 1262       /**
 1263        * Returns an array containing {@code Class} objects representing all
 1264        * the public classes and interfaces that are members of the class
 1265        * represented by this {@code Class} object.  This includes public
 1266        * class and interface members inherited from superclasses and public class
 1267        * and interface members declared by the class.  This method returns an
 1268        * array of length 0 if this {@code Class} object has no public member
 1269        * classes or interfaces.  This method also returns an array of length 0 if
 1270        * this {@code Class} object represents a primitive type, an array
 1271        * class, or void.
 1272        *
 1273        * @return the array of {@code Class} objects representing the public
 1274        * members of this class
 1275        * @exception  SecurityException
 1276        *             If a security manager, <i>s</i>, is present and any of the
 1277        *             following conditions is met:
 1278        *
 1279        *             <ul>
 1280        *
 1281        *             <li> invocation of
 1282        *             {@link SecurityManager#checkMemberAccess
 1283        *             s.checkMemberAccess(this, Member.PUBLIC)} method
 1284        *             denies access to the classes within this class
 1285        *
 1286        *             <li> the caller's class loader is not the same as or an
 1287        *             ancestor of the class loader for the current class and
 1288        *             invocation of {@link SecurityManager#checkPackageAccess
 1289        *             s.checkPackageAccess()} denies access to the package
 1290        *             of this class
 1291        *
 1292        *             </ul>
 1293        *
 1294        * @since JDK1.1
 1295        */
 1296       public Class<?>[] getClasses() {
 1297           // be very careful not to change the stack depth of this
 1298           // checkMemberAccess call for security reasons
 1299           // see java.lang.SecurityManager.checkMemberAccess
 1300           checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
 1301   
 1302           // Privileged so this implementation can look at DECLARED classes,
 1303           // something the caller might not have privilege to do.  The code here
 1304           // is allowed to look at DECLARED classes because (1) it does not hand
 1305           // out anything other than public members and (2) public member access
 1306           // has already been ok'd by the SecurityManager.
 1307   
 1308           return java.security.AccessController.doPrivileged(
 1309               new java.security.PrivilegedAction<Class<?>[]>() {
 1310                   public Class[] run() {
 1311                       List<Class<?>> list = new ArrayList<>();
 1312                       Class<?> currentClass = Class.this;
 1313                       while (currentClass != null) {
 1314                           Class<?>[] members = currentClass.getDeclaredClasses();
 1315                           for (int i = 0; i < members.length; i++) {
 1316                               if (Modifier.isPublic(members[i].getModifiers())) {
 1317                                   list.add(members[i]);
 1318                               }
 1319                           }
 1320                           currentClass = currentClass.getSuperclass();
 1321                       }
 1322                       return list.toArray(new Class[0]);
 1323                   }
 1324               });
 1325       }
 1326   
 1327   
 1328       /**
 1329        * Returns an array containing {@code Field} objects reflecting all
 1330        * the accessible public fields of the class or interface represented by
 1331        * this {@code Class} object.  The elements in the array returned are
 1332        * not sorted and are not in any particular order.  This method returns an
 1333        * array of length 0 if the class or interface has no accessible public
 1334        * fields, or if it represents an array class, a primitive type, or void.
 1335        *
 1336        * <p> Specifically, if this {@code Class} object represents a class,
 1337        * this method returns the public fields of this class and of all its
 1338        * superclasses.  If this {@code Class} object represents an
 1339        * interface, this method returns the fields of this interface and of all
 1340        * its superinterfaces.
 1341        *
 1342        * <p> The implicit length field for array class is not reflected by this
 1343        * method. User code should use the methods of class {@code Array} to
 1344        * manipulate arrays.
 1345        *
 1346        * <p> See <em>The Java Language Specification</em>, sections 8.2 and 8.3.
 1347        *
 1348        * @return the array of {@code Field} objects representing the
 1349        * public fields
 1350        * @exception  SecurityException
 1351        *             If a security manager, <i>s</i>, is present and any of the
 1352        *             following conditions is met:
 1353        *
 1354        *             <ul>
 1355        *
 1356        *             <li> invocation of
 1357        *             {@link SecurityManager#checkMemberAccess
 1358        *             s.checkMemberAccess(this, Member.PUBLIC)} denies
 1359        *             access to the fields within this class
 1360        *
 1361        *             <li> the caller's class loader is not the same as or an
 1362        *             ancestor of the class loader for the current class and
 1363        *             invocation of {@link SecurityManager#checkPackageAccess
 1364        *             s.checkPackageAccess()} denies access to the package
 1365        *             of this class
 1366        *
 1367        *             </ul>
 1368        *
 1369        * @since JDK1.1
 1370        */
 1371       public Field[] getFields() throws SecurityException {
 1372           // be very careful not to change the stack depth of this
 1373           // checkMemberAccess call for security reasons
 1374           // see java.lang.SecurityManager.checkMemberAccess
 1375           checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
 1376           return copyFields(privateGetPublicFields(null));
 1377       }
 1378   
 1379   
 1380       /**
 1381        * Returns an array containing {@code Method} objects reflecting all
 1382        * the public <em>member</em> methods of the class or interface represented
 1383        * by this {@code Class} object, including those declared by the class
 1384        * or interface and those inherited from superclasses and
 1385        * superinterfaces.  Array classes return all the (public) member methods
 1386        * inherited from the {@code Object} class.  The elements in the array
 1387        * returned are not sorted and are not in any particular order.  This
 1388        * method returns an array of length 0 if this {@code Class} object
 1389        * represents a class or interface that has no public member methods, or if
 1390        * this {@code Class} object represents a primitive type or void.
 1391        *
 1392        * <p> The class initialization method {@code <clinit>} is not
 1393        * included in the returned array. If the class declares multiple public
 1394        * member methods with the same parameter types, they are all included in
 1395        * the returned array.
 1396        *
 1397        * <p> See <em>The Java Language Specification</em>, sections 8.2 and 8.4.
 1398        *
 1399        * @return the array of {@code Method} objects representing the
 1400        * public methods of this class
 1401        * @exception  SecurityException
 1402        *             If a security manager, <i>s</i>, is present and any of the
 1403        *             following conditions is met:
 1404        *
 1405        *             <ul>
 1406        *
 1407        *             <li> invocation of
 1408        *             {@link SecurityManager#checkMemberAccess
 1409        *             s.checkMemberAccess(this, Member.PUBLIC)} denies
 1410        *             access to the methods within this class
 1411        *
 1412        *             <li> the caller's class loader is not the same as or an
 1413        *             ancestor of the class loader for the current class and
 1414        *             invocation of {@link SecurityManager#checkPackageAccess
 1415        *             s.checkPackageAccess()} denies access to the package
 1416        *             of this class
 1417        *
 1418        *             </ul>
 1419        *
 1420        * @since JDK1.1
 1421        */
 1422       public Method[] getMethods() throws SecurityException {
 1423           // be very careful not to change the stack depth of this
 1424           // checkMemberAccess call for security reasons
 1425           // see java.lang.SecurityManager.checkMemberAccess
 1426           checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
 1427           return copyMethods(privateGetPublicMethods());
 1428       }
 1429   
 1430   
 1431       /**
 1432        * Returns an array containing {@code Constructor} objects reflecting
 1433        * all the public constructors of the class represented by this
 1434        * {@code Class} object.  An array of length 0 is returned if the
 1435        * class has no public constructors, or if the class is an array class, or
 1436        * if the class reflects a primitive type or void.
 1437        *
 1438        * Note that while this method returns an array of {@code
 1439        * Constructor<T>} objects (that is an array of constructors from
 1440        * this class), the return type of this method is {@code
 1441        * Constructor<?>[]} and <em>not</em> {@code Constructor<T>[]} as
 1442        * might be expected.  This less informative return type is
 1443        * necessary since after being returned from this method, the
 1444        * array could be modified to hold {@code Constructor} objects for
 1445        * different classes, which would violate the type guarantees of
 1446        * {@code Constructor<T>[]}.
 1447        *
 1448        * @return the array of {@code Constructor} objects representing the
 1449        *  public constructors of this class
 1450        * @exception  SecurityException
 1451        *             If a security manager, <i>s</i>, is present and any of the
 1452        *             following conditions is met:
 1453        *
 1454        *             <ul>
 1455        *
 1456        *             <li> invocation of
 1457        *             {@link SecurityManager#checkMemberAccess
 1458        *             s.checkMemberAccess(this, Member.PUBLIC)} denies
 1459        *             access to the constructors within this class
 1460        *
 1461        *             <li> the caller's class loader is not the same as or an
 1462        *             ancestor of the class loader for the current class and
 1463        *             invocation of {@link SecurityManager#checkPackageAccess
 1464        *             s.checkPackageAccess()} denies access to the package
 1465        *             of this class
 1466        *
 1467        *             </ul>
 1468        *
 1469        * @since JDK1.1
 1470        */
 1471       public Constructor<?>[] getConstructors() throws SecurityException {
 1472           // be very careful not to change the stack depth of this
 1473           // checkMemberAccess call for security reasons
 1474           // see java.lang.SecurityManager.checkMemberAccess
 1475           checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
 1476           return copyConstructors(privateGetDeclaredConstructors(true));
 1477       }
 1478   
 1479   
 1480       /**
 1481        * Returns a {@code Field} object that reflects the specified public
 1482        * member field of the class or interface represented by this
 1483        * {@code Class} object. The {@code name} parameter is a
 1484        * {@code String} specifying the simple name of the desired field.
 1485        *
 1486        * <p> The field to be reflected is determined by the algorithm that
 1487        * follows.  Let C be the class represented by this object:
 1488        * <OL>
 1489        * <LI> If C declares a public field with the name specified, that is the
 1490        *      field to be reflected.</LI>
 1491        * <LI> If no field was found in step 1 above, this algorithm is applied
 1492        *      recursively to each direct superinterface of C. The direct
 1493        *      superinterfaces are searched in the order they were declared.</LI>
 1494        * <LI> If no field was found in steps 1 and 2 above, and C has a
 1495        *      superclass S, then this algorithm is invoked recursively upon S.
 1496        *      If C has no superclass, then a {@code NoSuchFieldException}
 1497        *      is thrown.</LI>
 1498        * </OL>
 1499        *
 1500        * <p> See <em>The Java Language Specification</em>, sections 8.2 and 8.3.
 1501        *
 1502        * @param name the field name
 1503        * @return  the {@code Field} object of this class specified by
 1504        * {@code name}
 1505        * @exception NoSuchFieldException if a field with the specified name is
 1506        *              not found.
 1507        * @exception NullPointerException if {@code name} is {@code null}
 1508        * @exception  SecurityException
 1509        *             If a security manager, <i>s</i>, is present and any of the
 1510        *             following conditions is met:
 1511        *
 1512        *             <ul>
 1513        *
 1514        *             <li> invocation of
 1515        *             {@link SecurityManager#checkMemberAccess
 1516        *             s.checkMemberAccess(this, Member.PUBLIC)} denies
 1517        *             access to the field
 1518        *
 1519        *             <li> the caller's class loader is not the same as or an
 1520        *             ancestor of the class loader for the current class and
 1521        *             invocation of {@link SecurityManager#checkPackageAccess
 1522        *             s.checkPackageAccess()} denies access to the package
 1523        *             of this class
 1524        *
 1525        *             </ul>
 1526        *
 1527        * @since JDK1.1
 1528        */
 1529       public Field getField(String name)
 1530           throws NoSuchFieldException, SecurityException {
 1531           // be very careful not to change the stack depth of this
 1532           // checkMemberAccess call for security reasons
 1533           // see java.lang.SecurityManager.checkMemberAccess
 1534           checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
 1535           Field field = getField0(name);
 1536           if (field == null) {
 1537               throw new NoSuchFieldException(name);
 1538           }
 1539           return field;
 1540       }
 1541   
 1542   
 1543       /**
 1544        * Returns a {@code Method} object that reflects the specified public
 1545        * member method of the class or interface represented by this
 1546        * {@code Class} object. The {@code name} parameter is a
 1547        * {@code String} specifying the simple name of the desired method. The
 1548        * {@code parameterTypes} parameter is an array of {@code Class}
 1549        * objects that identify the method's formal parameter types, in declared
 1550        * order. If {@code parameterTypes} is {@code null}, it is
 1551        * treated as if it were an empty array.
 1552        *
 1553        * <p> If the {@code name} is "{@code <init>};"or "{@code <clinit>}" a
 1554        * {@code NoSuchMethodException} is raised. Otherwise, the method to
 1555        * be reflected is determined by the algorithm that follows.  Let C be the
 1556        * class represented by this object:
 1557        * <OL>
 1558        * <LI> C is searched for any <I>matching methods</I>. If no matching
 1559        *      method is found, the algorithm of step 1 is invoked recursively on
 1560        *      the superclass of C.</LI>
 1561        * <LI> If no method was found in step 1 above, the superinterfaces of C
 1562        *      are searched for a matching method. If any such method is found, it
 1563        *      is reflected.</LI>
 1564        * </OL>
 1565        *
 1566        * To find a matching method in a class C:&nbsp; If C declares exactly one
 1567        * public method with the specified name and exactly the same formal
 1568        * parameter types, that is the method reflected. If more than one such
 1569        * method is found in C, and one of these methods has a return type that is
 1570        * more specific than any of the others, that method is reflected;
 1571        * otherwise one of the methods is chosen arbitrarily.
 1572        *
 1573        * <p>Note that there may be more than one matching method in a
 1574        * class because while the Java language forbids a class to
 1575        * declare multiple methods with the same signature but different
 1576        * return types, the Java virtual machine does not.  This
 1577        * increased flexibility in the virtual machine can be used to
 1578        * implement various language features.  For example, covariant
 1579        * returns can be implemented with {@linkplain
 1580        * java.lang.reflect.Method#isBridge bridge methods}; the bridge
 1581        * method and the method being overridden would have the same
 1582        * signature but different return types.
 1583        *
 1584        * <p> See <em>The Java Language Specification</em>, sections 8.2 and 8.4.
 1585        *
 1586        * @param name the name of the method
 1587        * @param parameterTypes the list of parameters
 1588        * @return the {@code Method} object that matches the specified
 1589        * {@code name} and {@code parameterTypes}
 1590        * @exception NoSuchMethodException if a matching method is not found
 1591        *            or if the name is "&lt;init&gt;"or "&lt;clinit&gt;".
 1592        * @exception NullPointerException if {@code name} is {@code null}
 1593        * @exception  SecurityException
 1594        *             If a security manager, <i>s</i>, is present and any of the
 1595        *             following conditions is met:
 1596        *
 1597        *             <ul>
 1598        *
 1599        *             <li> invocation of
 1600        *             {@link SecurityManager#checkMemberAccess
 1601        *             s.checkMemberAccess(this, Member.PUBLIC)} denies
 1602        *             access to the method
 1603        *
 1604        *             <li> the caller's class loader is not the same as or an
 1605        *             ancestor of the class loader for the current class and
 1606        *             invocation of {@link SecurityManager#checkPackageAccess
 1607        *             s.checkPackageAccess()} denies access to the package
 1608        *             of this class
 1609        *
 1610        *             </ul>
 1611        *
 1612        * @since JDK1.1
 1613        */
 1614       public Method getMethod(String name, Class<?>... parameterTypes)
 1615           throws NoSuchMethodException, SecurityException {
 1616           // be very careful not to change the stack depth of this
 1617           // checkMemberAccess call for security reasons
 1618           // see java.lang.SecurityManager.checkMemberAccess
 1619           checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
 1620           Method method = getMethod0(name, parameterTypes);
 1621           if (method == null) {
 1622               throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
 1623           }
 1624           return method;
 1625       }
 1626   
 1627   
 1628       /**
 1629        * Returns a {@code Constructor} object that reflects the specified
 1630        * public constructor of the class represented by this {@code Class}
 1631        * object. The {@code parameterTypes} parameter is an array of
 1632        * {@code Class} objects that identify the constructor's formal
 1633        * parameter types, in declared order.
 1634        *
 1635        * If this {@code Class} object represents an inner class
 1636        * declared in a non-static context, the formal parameter types
 1637        * include the explicit enclosing instance as the first parameter.
 1638        *
 1639        * <p> The constructor to reflect is the public constructor of the class
 1640        * represented by this {@code Class} object whose formal parameter
 1641        * types match those specified by {@code parameterTypes}.
 1642        *
 1643        * @param parameterTypes the parameter array
 1644        * @return the {@code Constructor} object of the public constructor that
 1645        * matches the specified {@code parameterTypes}
 1646        * @exception NoSuchMethodException if a matching method is not found.
 1647        * @exception  SecurityException
 1648        *             If a security manager, <i>s</i>, is present and any of the
 1649        *             following conditions is met:
 1650        *
 1651        *             <ul>
 1652        *
 1653        *             <li> invocation of
 1654        *             {@link SecurityManager#checkMemberAccess
 1655        *             s.checkMemberAccess(this, Member.PUBLIC)} denies
 1656        *             access to the constructor
 1657        *
 1658        *             <li> the caller's class loader is not the same as or an
 1659        *             ancestor of the class loader for the current class and
 1660        *             invocation of {@link SecurityManager#checkPackageAccess
 1661        *             s.checkPackageAccess()} denies access to the package
 1662        *             of this class
 1663        *
 1664        *             </ul>
 1665        *
 1666        * @since JDK1.1
 1667        */
 1668       public Constructor<T> getConstructor(Class<?>... parameterTypes)
 1669           throws NoSuchMethodException, SecurityException {
 1670           // be very careful not to change the stack depth of this
 1671           // checkMemberAccess call for security reasons
 1672           // see java.lang.SecurityManager.checkMemberAccess
 1673           checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
 1674           return getConstructor0(parameterTypes, Member.PUBLIC);
 1675       }
 1676   
 1677   
 1678       /**
 1679        * Returns an array of {@code Class} objects reflecting all the
 1680        * classes and interfaces declared as members of the class represented by
 1681        * this {@code Class} object. This includes public, protected, default
 1682        * (package) access, and private classes and interfaces declared by the
 1683        * class, but excludes inherited classes and interfaces.  This method
 1684        * returns an array of length 0 if the class declares no classes or
 1685        * interfaces as members, or if this {@code Class} object represents a
 1686        * primitive type, an array class, or void.
 1687        *
 1688        * @return the array of {@code Class} objects representing all the
 1689        * declared members of this class
 1690        * @exception  SecurityException
 1691        *             If a security manager, <i>s</i>, is present and any of the
 1692        *             following conditions is met:
 1693        *
 1694        *             <ul>
 1695        *
 1696        *             <li> invocation of
 1697        *             {@link SecurityManager#checkMemberAccess
 1698        *             s.checkMemberAccess(this, Member.DECLARED)} denies
 1699        *             access to the declared classes within this class
 1700        *
 1701        *             <li> the caller's class loader is not the same as or an
 1702        *             ancestor of the class loader for the current class and
 1703        *             invocation of {@link SecurityManager#checkPackageAccess
 1704        *             s.checkPackageAccess()} denies access to the package
 1705        *             of this class
 1706        *
 1707        *             </ul>
 1708        *
 1709        * @since JDK1.1
 1710        */
 1711       public Class<?>[] getDeclaredClasses() throws SecurityException {
 1712           // be very careful not to change the stack depth of this
 1713           // checkMemberAccess call for security reasons
 1714           // see java.lang.SecurityManager.checkMemberAccess
 1715           checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
 1716           return getDeclaredClasses0();
 1717       }
 1718   
 1719   
 1720       /**
 1721        * Returns an array of {@code Field} objects reflecting all the fields
 1722        * declared by the class or interface represented by this
 1723        * {@code Class} object. This includes public, protected, default
 1724        * (package) access, and private fields, but excludes inherited fields.
 1725        * The elements in the array returned are not sorted and are not in any
 1726        * particular order.  This method returns an array of length 0 if the class
 1727        * or interface declares no fields, or if this {@code Class} object
 1728        * represents a primitive type, an array class, or void.
 1729        *
 1730        * <p> See <em>The Java Language Specification</em>, sections 8.2 and 8.3.
 1731        *
 1732        * @return    the array of {@code Field} objects representing all the
 1733        * declared fields of this class
 1734        * @exception  SecurityException
 1735        *             If a security manager, <i>s</i>, is present and any of the
 1736        *             following conditions is met:
 1737        *
 1738        *             <ul>
 1739        *
 1740        *             <li> invocation of
 1741        *             {@link SecurityManager#checkMemberAccess
 1742        *             s.checkMemberAccess(this, Member.DECLARED)} denies
 1743        *             access to the declared fields within this class
 1744        *
 1745        *             <li> the caller's class loader is not the same as or an
 1746        *             ancestor of the class loader for the current class and
 1747        *             invocation of {@link SecurityManager#checkPackageAccess
 1748        *             s.checkPackageAccess()} denies access to the package
 1749        *             of this class
 1750        *
 1751        *             </ul>
 1752        *
 1753        * @since JDK1.1
 1754        */
 1755       public Field[] getDeclaredFields() throws SecurityException {
 1756           // be very careful not to change the stack depth of this
 1757           // checkMemberAccess call for security reasons
 1758           // see java.lang.SecurityManager.checkMemberAccess
 1759           checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
 1760           return copyFields(privateGetDeclaredFields(false));
 1761       }
 1762   
 1763   
 1764       /**
 1765        * Returns an array of {@code Method} objects reflecting all the
 1766        * methods declared by the class or interface represented by this
 1767        * {@code Class} object. This includes public, protected, default
 1768        * (package) access, and private methods, but excludes inherited methods.
 1769        * The elements in the array returned are not sorted and are not in any
 1770        * particular order.  This method returns an array of length 0 if the class
 1771        * or interface declares no methods, or if this {@code Class} object
 1772        * represents a primitive type, an array class, or void.  The class
 1773        * initialization method {@code <clinit>} is not included in the
 1774        * returned array. If the class declares multiple public member methods
 1775        * with the same parameter types, they are all included in the returned
 1776        * array.
 1777        *
 1778        * <p> See <em>The Java Language Specification</em>, section 8.2.
 1779        *
 1780        * @return    the array of {@code Method} objects representing all the
 1781        * declared methods of this class
 1782        * @exception  SecurityException
 1783        *             If a security manager, <i>s</i>, is present and any of the
 1784        *             following conditions is met:
 1785        *
 1786        *             <ul>
 1787        *
 1788        *             <li> invocation of
 1789        *             {@link SecurityManager#checkMemberAccess
 1790        *             s.checkMemberAccess(this, Member.DECLARED)} denies
 1791        *             access to the declared methods within this class
 1792        *
 1793        *             <li> the caller's class loader is not the same as or an
 1794        *             ancestor of the class loader for the current class and
 1795        *             invocation of {@link SecurityManager#checkPackageAccess
 1796        *             s.checkPackageAccess()} denies access to the package
 1797        *             of this class
 1798        *
 1799        *             </ul>
 1800        *
 1801        * @since JDK1.1
 1802        */
 1803       public Method[] getDeclaredMethods() throws SecurityException {
 1804           // be very careful not to change the stack depth of this
 1805           // checkMemberAccess call for security reasons
 1806           // see java.lang.SecurityManager.checkMemberAccess
 1807           checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
 1808           return copyMethods(privateGetDeclaredMethods(false));
 1809       }
 1810   
 1811   
 1812       /**
 1813        * Returns an array of {@code Constructor} objects reflecting all the
 1814        * constructors declared by the class represented by this
 1815        * {@code Class} object. These are public, protected, default
 1816        * (package) access, and private constructors.  The elements in the array
 1817        * returned are not sorted and are not in any particular order.  If the
 1818        * class has a default constructor, it is included in the returned array.
 1819        * This method returns an array of length 0 if this {@code Class}
 1820        * object represents an interface, a primitive type, an array class, or
 1821        * void.
 1822        *
 1823        * <p> See <em>The Java Language Specification</em>, section 8.2.
 1824        *
 1825        * @return    the array of {@code Constructor} objects representing all the
 1826        * declared constructors of this class
 1827        * @exception  SecurityException
 1828        *             If a security manager, <i>s</i>, is present and any of the
 1829        *             following conditions is met:
 1830        *
 1831        *             <ul>
 1832        *
 1833        *             <li> invocation of
 1834        *             {@link SecurityManager#checkMemberAccess
 1835        *             s.checkMemberAccess(this, Member.DECLARED)} denies
 1836        *             access to the declared constructors within this class
 1837        *
 1838        *             <li> the caller's class loader is not the same as or an
 1839        *             ancestor of the class loader for the current class and
 1840        *             invocation of {@link SecurityManager#checkPackageAccess
 1841        *             s.checkPackageAccess()} denies access to the package
 1842        *             of this class
 1843        *
 1844        *             </ul>
 1845        *
 1846        * @since JDK1.1
 1847        */
 1848       public Constructor<?>[] getDeclaredConstructors() throws SecurityException {
 1849           // be very careful not to change the stack depth of this
 1850           // checkMemberAccess call for security reasons
 1851           // see java.lang.SecurityManager.checkMemberAccess
 1852           checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
 1853           return copyConstructors(privateGetDeclaredConstructors(false));
 1854       }
 1855   
 1856   
 1857       /**
 1858        * Returns a {@code Field} object that reflects the specified declared
 1859        * field of the class or interface represented by this {@code Class}
 1860        * object. The {@code name} parameter is a {@code String} that
 1861        * specifies the simple name of the desired field.  Note that this method
 1862        * will not reflect the {@code length} field of an array class.
 1863        *
 1864        * @param name the name of the field
 1865        * @return the {@code Field} object for the specified field in this
 1866        * class
 1867        * @exception NoSuchFieldException if a field with the specified name is
 1868        *              not found.
 1869        * @exception NullPointerException if {@code name} is {@code null}
 1870        * @exception  SecurityException
 1871        *             If a security manager, <i>s</i>, is present and any of the
 1872        *             following conditions is met:
 1873        *
 1874        *             <ul>
 1875        *
 1876        *             <li> invocation of
 1877        *             {@link SecurityManager#checkMemberAccess
 1878        *             s.checkMemberAccess(this, Member.DECLARED)} denies
 1879        *             access to the declared field
 1880        *
 1881        *             <li> the caller's class loader is not the same as or an
 1882        *             ancestor of the class loader for the current class and
 1883        *             invocation of {@link SecurityManager#checkPackageAccess
 1884        *             s.checkPackageAccess()} denies access to the package
 1885        *             of this class
 1886        *
 1887        *             </ul>
 1888        *
 1889        * @since JDK1.1
 1890        */
 1891       public Field getDeclaredField(String name)
 1892           throws NoSuchFieldException, SecurityException {
 1893           // be very careful not to change the stack depth of this
 1894           // checkMemberAccess call for security reasons
 1895           // see java.lang.SecurityManager.checkMemberAccess
 1896           checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
 1897           Field field = searchFields(privateGetDeclaredFields(false), name);
 1898           if (field == null) {
 1899               throw new NoSuchFieldException(name);
 1900           }
 1901           return field;
 1902       }
 1903   
 1904   
 1905       /**
 1906        * Returns a {@code Method} object that reflects the specified
 1907        * declared method of the class or interface represented by this
 1908        * {@code Class} object. The {@code name} parameter is a
 1909        * {@code String} that specifies the simple name of the desired
 1910        * method, and the {@code parameterTypes} parameter is an array of
 1911        * {@code Class} objects that identify the method's formal parameter
 1912        * types, in declared order.  If more than one method with the same
 1913        * parameter types is declared in a class, and one of these methods has a
 1914        * return type that is more specific than any of the others, that method is
 1915        * returned; otherwise one of the methods is chosen arbitrarily.  If the
 1916        * name is "&lt;init&gt;"or "&lt;clinit&gt;" a {@code NoSuchMethodException}
 1917        * is raised.
 1918        *
 1919        * @param name the name of the method
 1920        * @param parameterTypes the parameter array
 1921        * @return    the {@code Method} object for the method of this class
 1922        * matching the specified name and parameters
 1923        * @exception NoSuchMethodException if a matching method is not found.
 1924        * @exception NullPointerException if {@code name} is {@code null}
 1925        * @exception  SecurityException
 1926        *             If a security manager, <i>s</i>, is present and any of the
 1927        *             following conditions is met:
 1928        *
 1929        *             <ul>
 1930        *
 1931        *             <li> invocation of
 1932        *             {@link SecurityManager#checkMemberAccess
 1933        *             s.checkMemberAccess(this, Member.DECLARED)} denies
 1934        *             access to the declared method
 1935        *
 1936        *             <li> the caller's class loader is not the same as or an
 1937        *             ancestor of the class loader for the current class and
 1938        *             invocation of {@link SecurityManager#checkPackageAccess
 1939        *             s.checkPackageAccess()} denies access to the package
 1940        *             of this class
 1941        *
 1942        *             </ul>
 1943        *
 1944        * @since JDK1.1
 1945        */
 1946       public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
 1947           throws NoSuchMethodException, SecurityException {
 1948           // be very careful not to change the stack depth of this
 1949           // checkMemberAccess call for security reasons
 1950           // see java.lang.SecurityManager.checkMemberAccess
 1951           checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
 1952           Method method = searchMethods(privateGetDeclaredMethods(false), name, parameterTypes);
 1953           if (method == null) {
 1954               throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
 1955           }
 1956           return method;
 1957       }
 1958   
 1959   
 1960       /**
 1961        * Returns a {@code Constructor} object that reflects the specified
 1962        * constructor of the class or interface represented by this
 1963        * {@code Class} object.  The {@code parameterTypes} parameter is
 1964        * an array of {@code Class} objects that identify the constructor's
 1965        * formal parameter types, in declared order.
 1966        *
 1967        * If this {@code Class} object represents an inner class
 1968        * declared in a non-static context, the formal parameter types
 1969        * include the explicit enclosing instance as the first parameter.
 1970        *
 1971        * @param parameterTypes the parameter array
 1972        * @return    The {@code Constructor} object for the constructor with the
 1973        * specified parameter list
 1974        * @exception NoSuchMethodException if a matching method is not found.
 1975        * @exception  SecurityException
 1976        *             If a security manager, <i>s</i>, is present and any of the
 1977        *             following conditions is met:
 1978        *
 1979        *             <ul>
 1980        *
 1981        *             <li> invocation of
 1982        *             {@link SecurityManager#checkMemberAccess
 1983        *             s.checkMemberAccess(this, Member.DECLARED)} denies
 1984        *             access to the declared constructor
 1985        *
 1986        *             <li> the caller's class loader is not the same as or an
 1987        *             ancestor of the class loader for the current class and
 1988        *             invocation of {@link SecurityManager#checkPackageAccess
 1989        *             s.checkPackageAccess()} denies access to the package
 1990        *             of this class
 1991        *
 1992        *             </ul>
 1993        *
 1994        * @since JDK1.1
 1995        */
 1996       public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
 1997           throws NoSuchMethodException, SecurityException {
 1998           // be very careful not to change the stack depth of this
 1999           // checkMemberAccess call for security reasons
 2000           // see java.lang.SecurityManager.checkMemberAccess
 2001           checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
 2002           return getConstructor0(parameterTypes, Member.DECLARED);
 2003       }
 2004   
 2005       /**
 2006        * Finds a resource with a given name.  The rules for searching resources
 2007        * associated with a given class are implemented by the defining
 2008        * {@linkplain ClassLoader class loader} of the class.  This method
 2009        * delegates to this object's class loader.  If this object was loaded by
 2010        * the bootstrap class loader, the method delegates to {@link
 2011        * ClassLoader#getSystemResourceAsStream}.
 2012        *
 2013        * <p> Before delegation, an absolute resource name is constructed from the
 2014        * given resource name using this algorithm:
 2015        *
 2016        * <ul>
 2017        *
 2018        * <li> If the {@code name} begins with a {@code '/'}
 2019        * (<tt>'&#92;u002f'</tt>), then the absolute name of the resource is the
 2020        * portion of the {@code name} following the {@code '/'}.
 2021        *
 2022        * <li> Otherwise, the absolute name is of the following form:
 2023        *
 2024        * <blockquote>
 2025        *   {@code modified_package_name/name}
 2026        * </blockquote>
 2027        *
 2028        * <p> Where the {@code modified_package_name} is the package name of this
 2029        * object with {@code '/'} substituted for {@code '.'}
 2030        * (<tt>'&#92;u002e'</tt>).
 2031        *
 2032        * </ul>
 2033        *
 2034        * @param  name name of the desired resource
 2035        * @return      A {@link java.io.InputStream} object or {@code null} if
 2036        *              no resource with this name is found
 2037        * @throws  NullPointerException If {@code name} is {@code null}
 2038        * @since  JDK1.1
 2039        */
 2040        public InputStream getResourceAsStream(String name) {
 2041           name = resolveName(name);
 2042           ClassLoader cl = getClassLoader0();
 2043           if (cl==null) {
 2044               // A system class.
 2045               return ClassLoader.getSystemResourceAsStream(name);
 2046           }
 2047           return cl.getResourceAsStream(name);
 2048       }
 2049   
 2050       /**
 2051        * Finds a resource with a given name.  The rules for searching resources
 2052        * associated with a given class are implemented by the defining
 2053        * {@linkplain ClassLoader class loader} of the class.  This method
 2054        * delegates to this object's class loader.  If this object was loaded by
 2055        * the bootstrap class loader, the method delegates to {@link
 2056        * ClassLoader#getSystemResource}.
 2057        *
 2058        * <p> Before delegation, an absolute resource name is constructed from the
 2059        * given resource name using this algorithm:
 2060        *
 2061        * <ul>
 2062        *
 2063        * <li> If the {@code name} begins with a {@code '/'}
 2064        * (<tt>'&#92;u002f'</tt>), then the absolute name of the resource is the
 2065        * portion of the {@code name} following the {@code '/'}.
 2066        *
 2067        * <li> Otherwise, the absolute name is of the following form:
 2068        *
 2069        * <blockquote>
 2070        *   {@code modified_package_name/name}
 2071        * </blockquote>
 2072        *
 2073        * <p> Where the {@code modified_package_name} is the package name of this
 2074        * object with {@code '/'} substituted for {@code '.'}
 2075        * (<tt>'&#92;u002e'</tt>).
 2076        *
 2077        * </ul>
 2078        *
 2079        * @param  name name of the desired resource
 2080        * @return      A  {@link java.net.URL} object or {@code null} if no
 2081        *              resource with this name is found
 2082        * @since  JDK1.1
 2083        */
 2084       public java.net.URL getResource(String name) {
 2085           name = resolveName(name);
 2086           ClassLoader cl = getClassLoader0();
 2087           if (cl==null) {
 2088               // A system class.
 2089               return ClassLoader.getSystemResource(name);
 2090           }
 2091           return cl.getResource(name);
 2092       }
 2093   
 2094   
 2095   
 2096       /** protection domain returned when the internal domain is null */
 2097       private static java.security.ProtectionDomain allPermDomain;
 2098   
 2099   
 2100       /**
 2101        * Returns the {@code ProtectionDomain} of this class.  If there is a
 2102        * security manager installed, this method first calls the security
 2103        * manager's {@code checkPermission} method with a
 2104        * {@code RuntimePermission("getProtectionDomain")} permission to
 2105        * ensure it's ok to get the
 2106        * {@code ProtectionDomain}.
 2107        *
 2108        * @return the ProtectionDomain of this class
 2109        *
 2110        * @throws SecurityException
 2111        *        if a security manager exists and its
 2112        *        {@code checkPermission} method doesn't allow
 2113        *        getting the ProtectionDomain.
 2114        *
 2115        * @see java.security.ProtectionDomain
 2116        * @see SecurityManager#checkPermission
 2117        * @see java.lang.RuntimePermission
 2118        * @since 1.2
 2119        */
 2120       public java.security.ProtectionDomain getProtectionDomain() {
 2121           SecurityManager sm = System.getSecurityManager();
 2122           if (sm != null) {
 2123               sm.checkPermission(SecurityConstants.GET_PD_PERMISSION);
 2124           }
 2125           java.security.ProtectionDomain pd = getProtectionDomain0();
 2126           if (pd == null) {
 2127               if (allPermDomain == null) {
 2128                   java.security.Permissions perms =
 2129                       new java.security.Permissions();
 2130                   perms.add(SecurityConstants.ALL_PERMISSION);
 2131                   allPermDomain =
 2132                       new java.security.ProtectionDomain(null, perms);
 2133               }
 2134               pd = allPermDomain;
 2135           }
 2136           return pd;
 2137       }
 2138   
 2139   
 2140       /**
 2141        * Returns the ProtectionDomain of this class.
 2142        */
 2143       private native java.security.ProtectionDomain getProtectionDomain0();
 2144   
 2145   
 2146       /**
 2147        * Set the ProtectionDomain for this class. Called by
 2148        * ClassLoader.defineClass.
 2149        */
 2150       native void setProtectionDomain0(java.security.ProtectionDomain pd);
 2151   
 2152   
 2153       /*
 2154        * Return the Virtual Machine's Class object for the named
 2155        * primitive type.
 2156        */
 2157       static native Class getPrimitiveClass(String name);
 2158   
 2159   
 2160       /*
 2161        * Check if client is allowed to access members.  If access is denied,
 2162        * throw a SecurityException.
 2163        *
 2164        * Be very careful not to change the stack depth of this checkMemberAccess
 2165        * call for security reasons.
 2166        * See java.lang.SecurityManager.checkMemberAccess.
 2167        *
 2168        * <p> Default policy: allow all clients access with normal Java access
 2169        * control.
 2170        */
 2171       private void checkMemberAccess(int which, ClassLoader ccl) {
 2172           SecurityManager s = System.getSecurityManager();
 2173           if (s != null) {
 2174               s.checkMemberAccess(this, which);
 2175               ClassLoader cl = getClassLoader0();
 2176               if ((ccl != null) && (ccl != cl) &&
 2177                     ((cl == null) || !cl.isAncestor(ccl))) {
 2178                   String name = this.getName();
 2179                   int i = name.lastIndexOf('.');
 2180                   if (i != -1) {
 2181                       s.checkPackageAccess(name.substring(0, i));
 2182                   }
 2183               }
 2184           }
 2185       }
 2186   
 2187       /**
 2188        * Add a package name prefix if the name is not absolute Remove leading "/"
 2189        * if name is absolute
 2190        */
 2191       private String resolveName(String name) {
 2192           if (name == null) {
 2193               return name;
 2194           }
 2195           if (!name.startsWith("/")) {
 2196               Class<?> c = this;
 2197               while (c.isArray()) {
 2198                   c = c.getComponentType();
 2199               }
 2200               String baseName = c.getName();
 2201               int index = baseName.lastIndexOf('.');
 2202               if (index != -1) {
 2203                   name = baseName.substring(0, index).replace('.', '/')
 2204                       +"/"+name;
 2205               }
 2206           } else {
 2207               name = name.substring(1);
 2208           }
 2209           return name;
 2210       }
 2211   
 2212       /**
 2213        * Reflection support.
 2214        */
 2215   
 2216       // Caches for certain reflective results
 2217       private static boolean useCaches = true;
 2218       private volatile transient SoftReference<Field[]> declaredFields;
 2219       private volatile transient SoftReference<Field[]> publicFields;
 2220       private volatile transient SoftReference<Method[]> declaredMethods;
 2221       private volatile transient SoftReference<Method[]> publicMethods;
 2222       private volatile transient SoftReference<Constructor<T>[]> declaredConstructors;
 2223       private volatile transient SoftReference<Constructor<T>[]> publicConstructors;
 2224       // Intermediate results for getFields and getMethods
 2225       private volatile transient SoftReference<Field[]> declaredPublicFields;
 2226       private volatile transient SoftReference<Method[]> declaredPublicMethods;
 2227   
 2228       // Incremented by the VM on each call to JVM TI RedefineClasses()
 2229       // that redefines this class or a superclass.
 2230       private volatile transient int classRedefinedCount = 0;
 2231   
 2232       // Value of classRedefinedCount when we last cleared the cached values
 2233       // that are sensitive to class redefinition.
 2234       private volatile transient int lastRedefinedCount = 0;
 2235   
 2236       // Clears cached values that might possibly have been obsoleted by
 2237       // a class redefinition.
 2238       private void clearCachesOnClassRedefinition() {
 2239           if (lastRedefinedCount != classRedefinedCount) {
 2240               declaredFields = publicFields = declaredPublicFields = null;
 2241               declaredMethods = publicMethods = declaredPublicMethods = null;
 2242               declaredConstructors = publicConstructors = null;
 2243               annotations = declaredAnnotations = null;
 2244   
 2245               // Use of "volatile" (and synchronization by caller in the case
 2246               // of annotations) ensures that no thread sees the update to
 2247               // lastRedefinedCount before seeing the caches cleared.
 2248               // We do not guard against brief windows during which multiple
 2249               // threads might redundantly work to fill an empty cache.
 2250               lastRedefinedCount = classRedefinedCount;
 2251           }
 2252       }
 2253   
 2254       // Generic signature handling
 2255       private native String getGenericSignature();
 2256   
 2257       // Generic info repository; lazily initialized
 2258       private transient ClassRepository genericInfo;
 2259   
 2260       // accessor for factory
 2261       private GenericsFactory getFactory() {
 2262           // create scope and factory
 2263           return CoreReflectionFactory.make(this, ClassScope.make(this));
 2264       }
 2265   
 2266       // accessor for generic info repository
 2267       private ClassRepository getGenericInfo() {
 2268           // lazily initialize repository if necessary
 2269           if (genericInfo == null) {
 2270               // create and cache generic info repository
 2271               genericInfo = ClassRepository.make(getGenericSignature(),
 2272                                                  getFactory());
 2273           }
 2274           return genericInfo; //return cached repository
 2275       }
 2276   
 2277       // Annotations handling
 2278       private native byte[] getRawAnnotations();
 2279   
 2280       native ConstantPool getConstantPool();
 2281   
 2282       //
 2283       //
 2284       // java.lang.reflect.Field handling
 2285       //
 2286       //
 2287   
 2288       // Returns an array of "root" fields. These Field objects must NOT
 2289       // be propagated to the outside world, but must instead be copied
 2290       // via ReflectionFactory.copyField.
 2291       private Field[] privateGetDeclaredFields(boolean publicOnly) {
 2292           checkInitted();
 2293           Field[] res = null;
 2294           if (useCaches) {
 2295               clearCachesOnClassRedefinition();
 2296               if (publicOnly) {
 2297                   if (declaredPublicFields != null) {
 2298                       res = declaredPublicFields.get();
 2299                   }
 2300               } else {
 2301                   if (declaredFields != null) {
 2302                       res = declaredFields.get();
 2303                   }
 2304               }
 2305               if (res != null) return res;
 2306           }
 2307           // No cached value available; request value from VM
 2308           res = Reflection.filterFields(this, getDeclaredFields0(publicOnly));
 2309           if (useCaches) {
 2310               if (publicOnly) {
 2311                   declaredPublicFields = new SoftReference<>(res);
 2312               } else {
 2313                   declaredFields = new SoftReference<>(res);
 2314               }
 2315           }
 2316           return res;
 2317       }
 2318   
 2319       // Returns an array of "root" fields. These Field objects must NOT
 2320       // be propagated to the outside world, but must instead be copied
 2321       // via ReflectionFactory.copyField.
 2322       private Field[] privateGetPublicFields(Set<Class<?>> traversedInterfaces) {
 2323           checkInitted();
 2324           Field[] res = null;
 2325           if (useCaches) {
 2326               clearCachesOnClassRedefinition();
 2327               if (publicFields != null) {
 2328                   res = publicFields.get();
 2329               }
 2330               if (res != null) return res;
 2331           }
 2332   
 2333           // No cached value available; compute value recursively.
 2334           // Traverse in correct order for getField().
 2335           List<Field> fields = new ArrayList<>();
 2336           if (traversedInterfaces == null) {
 2337               traversedInterfaces = new HashSet<>();
 2338           }
 2339   
 2340           // Local fields
 2341           Field[] tmp = privateGetDeclaredFields(true);
 2342           addAll(fields, tmp);
 2343   
 2344           // Direct superinterfaces, recursively
 2345           for (Class<?> c : getInterfaces()) {
 2346               if (!traversedInterfaces.contains(c)) {
 2347                   traversedInterfaces.add(c);
 2348                   addAll(fields, c.privateGetPublicFields(traversedInterfaces));
 2349               }
 2350           }
 2351   
 2352           // Direct superclass, recursively
 2353           if (!isInterface()) {
 2354               Class<?> c = getSuperclass();
 2355               if (c != null) {
 2356                   addAll(fields, c.privateGetPublicFields(traversedInterfaces));
 2357               }
 2358           }
 2359   
 2360           res = new Field[fields.size()];
 2361           fields.toArray(res);
 2362           if (useCaches) {
 2363               publicFields = new SoftReference<>(res);
 2364           }
 2365           return res;
 2366       }
 2367   
 2368       private static void addAll(Collection<Field> c, Field[] o) {
 2369           for (int i = 0; i < o.length; i++) {
 2370               c.add(o[i]);
 2371           }
 2372       }
 2373   
 2374   
 2375       //
 2376       //
 2377       // java.lang.reflect.Constructor handling
 2378       //
 2379       //
 2380   
 2381       // Returns an array of "root" constructors. These Constructor
 2382       // objects must NOT be propagated to the outside world, but must
 2383       // instead be copied via ReflectionFactory.copyConstructor.
 2384       private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
 2385           checkInitted();
 2386           Constructor<T>[] res = null;
 2387           if (useCaches) {
 2388               clearCachesOnClassRedefinition();
 2389               if (publicOnly) {
 2390                   if (publicConstructors != null) {
 2391                       res = publicConstructors.get();
 2392                   }
 2393               } else {
 2394                   if (declaredConstructors != null) {
 2395                       res = declaredConstructors.get();
 2396                   }
 2397               }
 2398               if (res != null) return res;
 2399           }
 2400           // No cached value available; request value from VM
 2401           if (isInterface()) {
 2402               res = new Constructor[0];
 2403           } else {
 2404               res = getDeclaredConstructors0(publicOnly);
 2405           }
 2406           if (useCaches) {
 2407               if (publicOnly) {
 2408                   publicConstructors = new SoftReference<>(res);
 2409               } else {
 2410                   declaredConstructors = new SoftReference<>(res);
 2411               }
 2412           }
 2413           return res;
 2414       }
 2415   
 2416       //
 2417       //
 2418       // java.lang.reflect.Method handling
 2419       //
 2420       //
 2421   
 2422       // Returns an array of "root" methods. These Method objects must NOT
 2423       // be propagated to the outside world, but must instead be copied
 2424       // via ReflectionFactory.copyMethod.
 2425       private Method[] privateGetDeclaredMethods(boolean publicOnly) {
 2426           checkInitted();
 2427           Method[] res = null;
 2428           if (useCaches) {
 2429               clearCachesOnClassRedefinition();
 2430               if (publicOnly) {
 2431                   if (declaredPublicMethods != null) {
 2432                       res = declaredPublicMethods.get();
 2433                   }
 2434               } else {
 2435                   if (declaredMethods != null) {
 2436                       res = declaredMethods.get();
 2437                   }
 2438               }
 2439               if (res != null) return res;
 2440           }
 2441           // No cached value available; request value from VM
 2442           res = Reflection.filterMethods(this, getDeclaredMethods0(publicOnly));
 2443           if (useCaches) {
 2444               if (publicOnly) {
 2445                   declaredPublicMethods = new SoftReference<>(res);
 2446               } else {
 2447                   declaredMethods = new SoftReference<>(res);
 2448               }
 2449           }
 2450           return res;
 2451       }
 2452   
 2453       static class MethodArray {
 2454           private Method[] methods;
 2455           private int length;
 2456   
 2457           MethodArray() {
 2458               methods = new Method[20];
 2459               length = 0;
 2460           }
 2461   
 2462           void add(Method m) {
 2463               if (length == methods.length) {
 2464                   methods = Arrays.copyOf(methods, 2 * methods.length);
 2465               }
 2466               methods[length++] = m;
 2467           }
 2468   
 2469           void addAll(Method[] ma) {
 2470               for (int i = 0; i < ma.length; i++) {
 2471                   add(ma[i]);
 2472               }
 2473           }
 2474   
 2475           void addAll(MethodArray ma) {
 2476               for (int i = 0; i < ma.length(); i++) {
 2477                   add(ma.get(i));
 2478               }
 2479           }
 2480   
 2481           void addIfNotPresent(Method newMethod) {
 2482               for (int i = 0; i < length; i++) {
 2483                   Method m = methods[i];
 2484                   if (m == newMethod || (m != null && m.equals(newMethod))) {
 2485                       return;
 2486                   }
 2487               }
 2488               add(newMethod);
 2489           }
 2490   
 2491           void addAllIfNotPresent(MethodArray newMethods) {
 2492               for (int i = 0; i < newMethods.length(); i++) {
 2493                   Method m = newMethods.get(i);
 2494                   if (m != null) {
 2495                       addIfNotPresent(m);
 2496                   }
 2497               }
 2498           }
 2499   
 2500           int length() {
 2501               return length;
 2502           }
 2503   
 2504           Method get(int i) {
 2505               return methods[i];
 2506           }
 2507   
 2508           void removeByNameAndSignature(Method toRemove) {
 2509               for (int i = 0; i < length; i++) {
 2510                   Method m = methods[i];
 2511                   if (m != null &&
 2512                       m.getReturnType() == toRemove.getReturnType() &&
 2513                       m.getName() == toRemove.getName() &&
 2514                       arrayContentsEq(m.getParameterTypes(),
 2515                                       toRemove.getParameterTypes())) {
 2516                       methods[i] = null;
 2517                   }
 2518               }
 2519           }
 2520   
 2521           void compactAndTrim() {
 2522               int newPos = 0;
 2523               // Get rid of null slots
 2524               for (int pos = 0; pos < length; pos++) {
 2525                   Method m = methods[pos];
 2526                   if (m != null) {
 2527                       if (pos != newPos) {
 2528                           methods[newPos] = m;
 2529                       }
 2530                       newPos++;
 2531                   }
 2532               }
 2533               if (newPos != methods.length) {
 2534                   methods = Arrays.copyOf(methods, newPos);
 2535               }
 2536           }
 2537   
 2538           Method[] getArray() {
 2539               return methods;
 2540           }
 2541       }
 2542   
 2543   
 2544       // Returns an array of "root" methods. These Method objects must NOT
 2545       // be propagated to the outside world, but must instead be copied
 2546       // via ReflectionFactory.copyMethod.
 2547       private Method[] privateGetPublicMethods() {
 2548           checkInitted();
 2549           Method[] res = null;
 2550           if (useCaches) {
 2551               clearCachesOnClassRedefinition();
 2552               if (publicMethods != null) {
 2553                   res = publicMethods.get();
 2554               }
 2555               if (res != null) return res;
 2556           }
 2557   
 2558           // No cached value available; compute value recursively.
 2559           // Start by fetching public declared methods
 2560           MethodArray methods = new MethodArray();
 2561           {
 2562               Method[] tmp = privateGetDeclaredMethods(true);
 2563               methods.addAll(tmp);
 2564           }
 2565           // Now recur over superclass and direct superinterfaces.
 2566           // Go over superinterfaces first so we can more easily filter
 2567           // out concrete implementations inherited from superclasses at
 2568           // the end.
 2569           MethodArray inheritedMethods = new MethodArray();
 2570           Class<?>[] interfaces = getInterfaces();
 2571           for (int i = 0; i < interfaces.length; i++) {
 2572               inheritedMethods.addAll(interfaces[i].privateGetPublicMethods());
 2573           }
 2574           if (!isInterface()) {
 2575               Class<?> c = getSuperclass();
 2576               if (c != null) {
 2577                   MethodArray supers = new MethodArray();
 2578                   supers.addAll(c.privateGetPublicMethods());
 2579                   // Filter out concrete implementations of any
 2580                   // interface methods
 2581                   for (int i = 0; i < supers.length(); i++) {
 2582                       Method m = supers.get(i);
 2583                       if (m != null && !Modifier.isAbstract(m.getModifiers())) {
 2584                           inheritedMethods.removeByNameAndSignature(m);
 2585                       }
 2586                   }
 2587                   // Insert superclass's inherited methods before
 2588                   // superinterfaces' to satisfy getMethod's search
 2589                   // order
 2590                   supers.addAll(inheritedMethods);
 2591                   inheritedMethods = supers;
 2592               }
 2593           }
 2594           // Filter out all local methods from inherited ones
 2595           for (int i = 0; i < methods.length(); i++) {
 2596               Method m = methods.get(i);
 2597               inheritedMethods.removeByNameAndSignature(m);
 2598           }
 2599           methods.addAllIfNotPresent(inheritedMethods);
 2600           methods.compactAndTrim();
 2601           res = methods.getArray();
 2602           if (useCaches) {
 2603               publicMethods = new SoftReference<>(res);
 2604           }
 2605           return res;
 2606       }
 2607   
 2608   
 2609       //
 2610       // Helpers for fetchers of one field, method, or constructor
 2611       //
 2612   
 2613       private Field searchFields(Field[] fields, String name) {
 2614           String internedName = name.intern();
 2615           for (int i = 0; i < fields.length; i++) {
 2616               if (fields[i].getName() == internedName) {
 2617                   return getReflectionFactory().copyField(fields[i]);
 2618               }
 2619           }
 2620           return null;
 2621       }
 2622   
 2623       private Field getField0(String name) throws NoSuchFieldException {
 2624           // Note: the intent is that the search algorithm this routine
 2625           // uses be equivalent to the ordering imposed by
 2626           // privateGetPublicFields(). It fetches only the declared
 2627           // public fields for each class, however, to reduce the number
 2628           // of Field objects which have to be created for the common
 2629           // case where the field being requested is declared in the
 2630           // class which is being queried.
 2631           Field res = null;
 2632           // Search declared public fields
 2633           if ((res = searchFields(privateGetDeclaredFields(true), name)) != null) {
 2634               return res;
 2635           }
 2636           // Direct superinterfaces, recursively
 2637           Class<?>[] interfaces = getInterfaces();
 2638           for (int i = 0; i < interfaces.length; i++) {
 2639               Class<?> c = interfaces[i];
 2640               if ((res = c.getField0(name)) != null) {
 2641                   return res;
 2642               }
 2643           }
 2644           // Direct superclass, recursively
 2645           if (!isInterface()) {
 2646               Class<?> c = getSuperclass();
 2647               if (c != null) {
 2648                   if ((res = c.getField0(name)) != null) {
 2649                       return res;
 2650                   }
 2651               }
 2652           }
 2653           return null;
 2654       }
 2655   
 2656       private static Method searchMethods(Method[] methods,
 2657                                           String name,
 2658                                           Class<?>[] parameterTypes)
 2659       {
 2660           Method res = null;
 2661           String internedName = name.intern();
 2662           for (int i = 0; i < methods.length; i++) {
 2663               Method m = methods[i];
 2664               if (m.getName() == internedName
 2665                   && arrayContentsEq(parameterTypes, m.getParameterTypes())
 2666                   && (res == null
 2667                       || res.getReturnType().isAssignableFrom(m.getReturnType())))
 2668                   res = m;
 2669           }
 2670   
 2671           return (res == null ? res : getReflectionFactory().copyMethod(res));
 2672       }
 2673   
 2674   
 2675       private Method getMethod0(String name, Class<?>[] parameterTypes) {
 2676           // Note: the intent is that the search algorithm this routine
 2677           // uses be equivalent to the ordering imposed by
 2678           // privateGetPublicMethods(). It fetches only the declared
 2679           // public methods for each class, however, to reduce the
 2680           // number of Method objects which have to be created for the
 2681           // common case where the method being requested is declared in
 2682           // the class which is being queried.
 2683           Method res = null;
 2684           // Search declared public methods
 2685           if ((res = searchMethods(privateGetDeclaredMethods(true),
 2686                                    name,
 2687                                    parameterTypes)) != null) {
 2688               return res;
 2689           }
 2690           // Search superclass's methods
 2691           if (!isInterface()) {
 2692               Class<? super T> c = getSuperclass();
 2693               if (c != null) {
 2694                   if ((res = c.getMethod0(name, parameterTypes)) != null) {
 2695                       return res;
 2696                   }
 2697               }
 2698           }
 2699           // Search superinterfaces' methods
 2700           Class<?>[] interfaces = getInterfaces();
 2701           for (int i = 0; i < interfaces.length; i++) {
 2702               Class<?> c = interfaces[i];
 2703               if ((res = c.getMethod0(name, parameterTypes)) != null) {
 2704                   return res;
 2705               }
 2706           }
 2707           // Not found
 2708           return null;
 2709       }
 2710   
 2711       private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
 2712                                           int which) throws NoSuchMethodException
 2713       {
 2714           Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
 2715           for (Constructor<T> constructor : constructors) {
 2716               if (arrayContentsEq(parameterTypes,
 2717                                   constructor.getParameterTypes())) {
 2718                   return getReflectionFactory().copyConstructor(constructor);
 2719               }
 2720           }
 2721           throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));
 2722       }
 2723   
 2724       //
 2725       // Other helpers and base implementation
 2726       //
 2727   
 2728       private static boolean arrayContentsEq(Object[] a1, Object[] a2) {
 2729           if (a1 == null) {
 2730               return a2 == null || a2.length == 0;
 2731           }
 2732   
 2733           if (a2 == null) {
 2734               return a1.length == 0;
 2735           }
 2736   
 2737           if (a1.length != a2.length) {
 2738               return false;
 2739           }
 2740   
 2741           for (int i = 0; i < a1.length; i++) {
 2742               if (a1[i] != a2[i]) {
 2743                   return false;
 2744               }
 2745           }
 2746   
 2747           return true;
 2748       }
 2749   
 2750       private static Field[] copyFields(Field[] arg) {
 2751           Field[] out = new Field[arg.length];
 2752           ReflectionFactory fact = getReflectionFactory();
 2753           for (int i = 0; i < arg.length; i++) {
 2754               out[i] = fact.copyField(arg[i]);
 2755           }
 2756           return out;
 2757       }
 2758   
 2759       private static Method[] copyMethods(Method[] arg) {
 2760           Method[] out = new Method[arg.length];
 2761           ReflectionFactory fact = getReflectionFactory();
 2762           for (int i = 0; i < arg.length; i++) {
 2763               out[i] = fact.copyMethod(arg[i]);
 2764           }
 2765           return out;
 2766       }
 2767   
 2768       private static <U> Constructor<U>[] copyConstructors(Constructor<U>[] arg) {
 2769           Constructor<U>[] out = arg.clone();
 2770           ReflectionFactory fact = getReflectionFactory();
 2771           for (int i = 0; i < out.length; i++) {
 2772               out[i] = fact.copyConstructor(out[i]);
 2773           }
 2774           return out;
 2775       }
 2776   
 2777       private native Field[]       getDeclaredFields0(boolean publicOnly);
 2778       private native Method[]      getDeclaredMethods0(boolean publicOnly);
 2779       private native Constructor<T>[] getDeclaredConstructors0(boolean publicOnly);
 2780       private native Class<?>[]   getDeclaredClasses0();
 2781   
 2782       private static String        argumentTypesToString(Class<?>[] argTypes) {
 2783           StringBuilder buf = new StringBuilder();
 2784           buf.append("(");
 2785           if (argTypes != null) {
 2786               for (int i = 0; i < argTypes.length; i++) {
 2787                   if (i > 0) {
 2788                       buf.append(", ");
 2789                   }
 2790                   Class<?> c = argTypes[i];
 2791                   buf.append((c == null) ? "null" : c.getName());
 2792               }
 2793           }
 2794           buf.append(")");
 2795           return buf.toString();
 2796       }
 2797   
 2798       /** use serialVersionUID from JDK 1.1 for interoperability */
 2799       private static final long serialVersionUID = 3206093459760846163L;
 2800   
 2801   
 2802       /**
 2803        * Class Class is special cased within the Serialization Stream Protocol.
 2804        *
 2805        * A Class instance is written initially into an ObjectOutputStream in the
 2806        * following format:
 2807        * <pre>
 2808        *      {@code TC_CLASS} ClassDescriptor
 2809        *      A ClassDescriptor is a special cased serialization of
 2810        *      a {@code java.io.ObjectStreamClass} instance.
 2811        * </pre>
 2812        * A new handle is generated for the initial time the class descriptor
 2813        * is written into the stream. Future references to the class descriptor
 2814        * are written as references to the initial class descriptor instance.
 2815        *
 2816        * @see java.io.ObjectStreamClass
 2817        */
 2818       private static final ObjectStreamField[] serialPersistentFields =
 2819           new ObjectStreamField[0];
 2820   
 2821   
 2822       /**
 2823        * Returns the assertion status that would be assigned to this
 2824        * class if it were to be initialized at the time this method is invoked.
 2825        * If this class has had its assertion status set, the most recent
 2826        * setting will be returned; otherwise, if any package default assertion
 2827        * status pertains to this class, the most recent setting for the most
 2828        * specific pertinent package default assertion status is returned;
 2829        * otherwise, if this class is not a system class (i.e., it has a
 2830        * class loader) its class loader's default assertion status is returned;
 2831        * otherwise, the system class default assertion status is returned.
 2832        * <p>
 2833        * Few programmers will have any need for this method; it is provided
 2834        * for the benefit of the JRE itself.  (It allows a class to determine at
 2835        * the time that it is initialized whether assertions should be enabled.)
 2836        * Note that this method is not guaranteed to return the actual
 2837        * assertion status that was (or will be) associated with the specified
 2838        * class when it was (or will be) initialized.
 2839        *
 2840        * @return the desired assertion status of the specified class.
 2841        * @see    java.lang.ClassLoader#setClassAssertionStatus
 2842        * @see    java.lang.ClassLoader#setPackageAssertionStatus
 2843        * @see    java.lang.ClassLoader#setDefaultAssertionStatus
 2844        * @since  1.4
 2845        */
 2846       public boolean desiredAssertionStatus() {
 2847           ClassLoader loader = getClassLoader();
 2848           // If the loader is null this is a system class, so ask the VM
 2849           if (loader == null)
 2850               return desiredAssertionStatus0(this);
 2851   
 2852           // If the classloader has been initialized with the assertion
 2853           // directives, ask it. Otherwise, ask the VM.
 2854           synchronized(loader.assertionLock) {
 2855               if (loader.classAssertionStatus != null) {
 2856                   return loader.desiredAssertionStatus(getName());
 2857               }
 2858           }
 2859           return desiredAssertionStatus0(this);
 2860       }
 2861   
 2862       // Retrieves the desired assertion status of this class from the VM
 2863       private static native boolean desiredAssertionStatus0(Class<?> clazz);
 2864   
 2865       /**
 2866        * Returns true if and only if this class was declared as an enum in the
 2867        * source code.
 2868        *
 2869        * @return true if and only if this class was declared as an enum in the
 2870        *     source code
 2871        * @since 1.5
 2872        */
 2873       public boolean isEnum() {
 2874           // An enum must both directly extend java.lang.Enum and have
 2875           // the ENUM bit set; classes for specialized enum constants
 2876           // don't do the former.
 2877           return (this.getModifiers() & ENUM) != 0 &&
 2878           this.getSuperclass() == java.lang.Enum.class;
 2879       }
 2880   
 2881       // Fetches the factory for reflective objects
 2882       private static ReflectionFactory getReflectionFactory() {
 2883           if (reflectionFactory == null) {
 2884               reflectionFactory =
 2885                   java.security.AccessController.doPrivileged
 2886                       (new sun.reflect.ReflectionFactory.GetReflectionFactoryAction());
 2887           }
 2888           return reflectionFactory;
 2889       }
 2890       private static ReflectionFactory reflectionFactory;
 2891   
 2892       // To be able to query system properties as soon as they're available
 2893       private static boolean initted = false;
 2894       private static void checkInitted() {
 2895           if (initted) return;
 2896           AccessController.doPrivileged(new PrivilegedAction<Void>() {
 2897                   public Void run() {
 2898                       // Tests to ensure the system properties table is fully
 2899                       // initialized. This is needed because reflection code is
 2900                       // called very early in the initialization process (before
 2901                       // command-line arguments have been parsed and therefore
 2902                       // these user-settable properties installed.) We assume that
 2903                       // if System.out is non-null then the System class has been
 2904                       // fully initialized and that the bulk of the startup code
 2905                       // has been run.
 2906   
 2907                       if (System.out == null) {
 2908                           // java.lang.System not yet fully initialized
 2909                           return null;
 2910                       }
 2911   
 2912                       String val =
 2913                           System.getProperty("sun.reflect.noCaches");
 2914                       if (val != null && val.equals("true")) {
 2915                           useCaches = false;
 2916                       }
 2917   
 2918                       initted = true;
 2919                       return null;
 2920                   }
 2921               });
 2922       }
 2923   
 2924       /**
 2925        * Returns the elements of this enum class or null if this
 2926        * Class object does not represent an enum type.
 2927        *
 2928        * @return an array containing the values comprising the enum class
 2929        *     represented by this Class object in the order they're
 2930        *     declared, or null if this Class object does not
 2931        *     represent an enum type
 2932        * @since 1.5
 2933        */
 2934       public T[] getEnumConstants() {
 2935           T[] values = getEnumConstantsShared();
 2936           return (values != null) ? values.clone() : null;
 2937       }
 2938   
 2939       /**
 2940        * Returns the elements of this enum class or null if this
 2941        * Class object does not represent an enum type;
 2942        * identical to getEnumConstants except that the result is
 2943        * uncloned, cached, and shared by all callers.
 2944        */
 2945       T[] getEnumConstantsShared() {
 2946           if (enumConstants == null) {
 2947               if (!isEnum()) return null;
 2948               try {
 2949                   final Method values = getMethod("values");
 2950                   java.security.AccessController.doPrivileged(
 2951                       new java.security.PrivilegedAction<Void>() {
 2952                           public Void run() {
 2953                                   values.setAccessible(true);
 2954                                   return null;
 2955                               }
 2956                           });
 2957                   enumConstants = (T[])values.invoke(null);
 2958               }
 2959               // These can happen when users concoct enum-like classes
 2960               // that don't comply with the enum spec.
 2961               catch (InvocationTargetException ex) { return null; }
 2962               catch (NoSuchMethodException ex) { return null; }
 2963               catch (IllegalAccessException ex) { return null; }
 2964           }
 2965           return enumConstants;
 2966       }
 2967       private volatile transient T[] enumConstants = null;
 2968   
 2969       /**
 2970        * Returns a map from simple name to enum constant.  This package-private
 2971        * method is used internally by Enum to implement
 2972        *     public static <T extends Enum<T>> T valueOf(Class<T>, String)
 2973        * efficiently.  Note that the map is returned by this method is
 2974        * created lazily on first use.  Typically it won't ever get created.
 2975        */
 2976       Map<String, T> enumConstantDirectory() {
 2977           if (enumConstantDirectory == null) {
 2978               T[] universe = getEnumConstantsShared();
 2979               if (universe == null)
 2980                   throw new IllegalArgumentException(
 2981                       getName() + " is not an enum type");
 2982               Map<String, T> m = new HashMap<>(2 * universe.length);
 2983               for (T constant : universe)
 2984                   m.put(((Enum<?>)constant).name(), constant);
 2985               enumConstantDirectory = m;
 2986           }
 2987           return enumConstantDirectory;
 2988       }
 2989       private volatile transient Map<String, T> enumConstantDirectory = null;
 2990   
 2991       /**
 2992        * Casts an object to the class or interface represented
 2993        * by this {@code Class} object.
 2994        *
 2995        * @param obj the object to be cast
 2996        * @return the object after casting, or null if obj is null
 2997        *
 2998        * @throws ClassCastException if the object is not
 2999        * null and is not assignable to the type T.
 3000        *
 3001        * @since 1.5
 3002        */
 3003       public T cast(Object obj) {
 3004           if (obj != null && !isInstance(obj))
 3005               throw new ClassCastException(cannotCastMsg(obj));
 3006           return (T) obj;
 3007       }
 3008   
 3009       private String cannotCastMsg(Object obj) {
 3010           return "Cannot cast " + obj.getClass().getName() + " to " + getName();
 3011       }
 3012   
 3013       /**
 3014        * Casts this {@code Class} object to represent a subclass of the class
 3015        * represented by the specified class object.  Checks that that the cast
 3016        * is valid, and throws a {@code ClassCastException} if it is not.  If
 3017        * this method succeeds, it always returns a reference to this class object.
 3018        *
 3019        * <p>This method is useful when a client needs to "narrow" the type of
 3020        * a {@code Class} object to pass it to an API that restricts the
 3021        * {@code Class} objects that it is willing to accept.  A cast would
 3022        * generate a compile-time warning, as the correctness of the cast
 3023        * could not be checked at runtime (because generic types are implemented
 3024        * by erasure).
 3025        *
 3026        * @return this {@code Class} object, cast to represent a subclass of
 3027        *    the specified class object.
 3028        * @throws ClassCastException if this {@code Class} object does not
 3029        *    represent a subclass of the specified class (here "subclass" includes
 3030        *    the class itself).
 3031        * @since 1.5
 3032        */
 3033       public <U> Class<? extends U> asSubclass(Class<U> clazz) {
 3034           if (clazz.isAssignableFrom(this))
 3035               return (Class<? extends U>) this;
 3036           else
 3037               throw new ClassCastException(this.toString());
 3038       }
 3039   
 3040       /**
 3041        * @throws NullPointerException {@inheritDoc}
 3042        * @since 1.5
 3043        */
 3044       public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
 3045           if (annotationClass == null)
 3046               throw new NullPointerException();
 3047   
 3048           initAnnotationsIfNecessary();
 3049           return (A) annotations.get(annotationClass);
 3050       }
 3051   
 3052       /**
 3053        * @throws NullPointerException {@inheritDoc}
 3054        * @since 1.5
 3055        */
 3056       public boolean isAnnotationPresent(
 3057           Class<? extends Annotation> annotationClass) {
 3058           if (annotationClass == null)
 3059               throw new NullPointerException();
 3060   
 3061           return getAnnotation(annotationClass) != null;
 3062       }
 3063   
 3064   
 3065       /**
 3066        * @since 1.5
 3067        */
 3068       public Annotation[] getAnnotations() {
 3069           initAnnotationsIfNecessary();
 3070           return AnnotationParser.toArray(annotations);
 3071       }
 3072   
 3073       /**
 3074        * @since 1.5
 3075        */
 3076       public Annotation[] getDeclaredAnnotations()  {
 3077           initAnnotationsIfNecessary();
 3078           return AnnotationParser.toArray(declaredAnnotations);
 3079       }
 3080   
 3081       // Annotations cache
 3082       private transient Map<Class<? extends Annotation>, Annotation> annotations;
 3083       private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
 3084   
 3085       private synchronized void initAnnotationsIfNecessary() {
 3086           clearCachesOnClassRedefinition();
 3087           if (annotations != null)
 3088               return;
 3089           declaredAnnotations = AnnotationParser.parseAnnotations(
 3090               getRawAnnotations(), getConstantPool(), this);
 3091           Class<?> superClass = getSuperclass();
 3092           if (superClass == null) {
 3093               annotations = declaredAnnotations;
 3094           } else {
 3095               annotations = new HashMap<>();
 3096               superClass.initAnnotationsIfNecessary();
 3097               for (Map.Entry<Class<? extends Annotation>, Annotation> e : superClass.annotations.entrySet()) {
 3098                   Class<? extends Annotation> annotationClass = e.getKey();
 3099                   if (AnnotationType.getInstance(annotationClass).isInherited())
 3100                       annotations.put(annotationClass, e.getValue());
 3101               }
 3102               annotations.putAll(declaredAnnotations);
 3103           }
 3104       }
 3105   
 3106       // Annotation types cache their internal (AnnotationType) form
 3107   
 3108       private AnnotationType annotationType;
 3109   
 3110       void setAnnotationType(AnnotationType type) {
 3111           annotationType = type;
 3112       }
 3113   
 3114       AnnotationType getAnnotationType() {
 3115           return annotationType;
 3116       }
 3117   }

Save This Page
Home » openjdk-7 » java » lang » [javadoc | source]