{@code Class} has no public constructor. Instead {@code Class} * objects are constructed automatically by the Java Virtual Machine as classes * are loaded and by calls to the {@code defineClass} method in the class * loader. * *
The following example uses a {@code Class} object to print the * class name of an object: * *
* void printClassName(Object obj) {
* System.out.println("The class of " + obj +
* " is " + obj.getClass().getName());
* }
* It is also possible to get the {@code Class} object for a named * type (or for void) using a class literal. See Section 15.8.2 of * The Java™ Language Specification. * For example: * *
* {@code System.out.println("The name of class Foo is: "+Foo.class.getName());} ** * @param
@{@code interface}, as appropriate), followed
* by the type's name, followed by an angle-bracketed
* comma-separated list of the type's type parameters, if any.
*
* A space is used to separate modifiers from one another and to
* separate any modifiers from the kind of type. The modifiers
* occur in canonical order. If there are no type parameters, the
* type parameter list is elided.
*
* Note that since information about the runtime representation * of a type is being generated, modifiers not present on the * originating source code or illegal on the originating source * code may be present. * * @return a string describing this {@code Class}, including * information about modifiers and type parameters * * @since 1.8 */ public String toGenericString() { if (isPrimitive()) { return toString(); } else { StringBuilder sb = new StringBuilder(); // Class modifiers are a superset of interface modifiers int modifiers = getModifiers() & Modifier.classModifiers(); if (modifiers != 0) { sb.append(Modifier.toString(modifiers)); sb.append(' '); } if (isAnnotation()) { sb.append('@'); } if (isInterface()) { // Note: all annotation types are interfaces sb.append("interface"); } else { if (isEnum()) sb.append("enum"); else sb.append("class"); } sb.append(' '); sb.append(getName()); TypeVariable[] typeparms = getTypeParameters(); if (typeparms.length > 0) { boolean first = true; sb.append('<'); for(TypeVariable typeparm: typeparms) { if (!first) sb.append(','); sb.append(typeparm.getTypeName()); first = false; } sb.append('>'); } return sb.toString(); } } /** * Returns the {@code Class} object associated with the class or * interface with the given string name. Invoking this method is * equivalent to: * *
* {@code Class.forName(className, true, currentLoader)} ** * where {@code currentLoader} denotes the defining class loader of * the current class. * *
For example, the following code fragment returns the * runtime {@code Class} descriptor for the class named * {@code java.lang.Thread}: * *
* {@code Class t = Class.forName("java.lang.Thread")} **
* A call to {@code forName("X")} causes the class named * {@code X} to be initialized. * * @param className the fully qualified name of the desired class. * @return the {@code Class} object for the class with the * specified name. * @exception LinkageError if the linkage fails * @exception ExceptionInInitializerError if the initialization provoked * by this method fails * @exception ClassNotFoundException if the class cannot be located */ @CallerSensitive public static Class forName(String className) throws ClassNotFoundException { return forName0(className, true, ClassLoader.getClassLoader(Reflection.getCallerClass())); } /** * Returns the {@code Class} object associated with the class or * interface with the given string name, using the given class loader. * Given the fully qualified name for a class or interface (in the same * format returned by {@code getName}) this method attempts to * locate, load, and link the class or interface. The specified class * loader is used to load the class or interface. If the parameter * {@code loader} is null, the class is loaded through the bootstrap * class loader. The class is initialized only if the * {@code initialize} parameter is {@code true} and if it has * not been initialized earlier. * *
If {@code name} denotes a primitive type or void, an attempt * will be made to locate a user-defined class in the unnamed package whose * name is {@code name}. Therefore, this method cannot be used to * obtain any of the {@code Class} objects representing primitive * types or void. * *
If {@code name} denotes an array class, the component type of * the array class is loaded but not initialized. * *
For example, in an instance method the expression: * *
* {@code Class.forName("Foo")} ** * is equivalent to: * *
* {@code Class.forName("Foo", true, this.getClass().getClassLoader())} ** * Note that this method throws errors related to loading, linking or * initializing as specified in Sections 12.2, 12.3 and 12.4 of The * Java Language Specification. * Note that this method does not check whether the requested class * is accessible to its caller. * *
If the {@code loader} is {@code null}, and a security * manager is present, and the caller's class loader is not null, then this * method calls the security manager's {@code checkPermission} method * with a {@code RuntimePermission("getClassLoader")} permission to * ensure it's ok to access the bootstrap class loader. * * @param name fully qualified name of the desired class * @param initialize if {@code true} the class will be initialized. * See Section 12.4 of The Java Language Specification. * @param loader class loader from which the class must be loaded * @return class object representing the desired class * * @exception LinkageError if the linkage fails * @exception ExceptionInInitializerError if the initialization provoked * by this method fails * @exception ClassNotFoundException if the class cannot be located by * the specified class loader * * @see java.lang.Class#forName(String) * @see java.lang.ClassLoader * @since 1.2 */ @CallerSensitive public static Class forName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException { if (sun.misc.VM.isSystemDomainLoader(loader)) { SecurityManager sm = System.getSecurityManager(); if (sm != null) { ClassLoader ccl = ClassLoader.getClassLoader(Reflection.getCallerClass()); if (!sun.misc.VM.isSystemDomainLoader(ccl)) { sm.checkPermission( SecurityConstants.GET_CLASSLOADER_PERMISSION); } } } return forName0(name, initialize, loader); } /** Called after security checks have been made. */ private static native Class forName0(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException; /** * Creates a new instance of the class represented by this {@code Class} * object. The class is instantiated as if by a {@code new} * expression with an empty argument list. The class is initialized if it * has not already been initialized. * *
Note that this method propagates any exception thrown by the
* nullary constructor, including a checked exception. Use of
* this method effectively bypasses the compile-time exception
* checking that would otherwise be performed by the compiler.
* The {@link
* java.lang.reflect.Constructor#newInstance(java.lang.Object...)
* Constructor.newInstance} method avoids this problem by wrapping
* any exception thrown by the constructor in a (checked) {@link
* java.lang.reflect.InvocationTargetException}.
*
* @return a newly allocated instance of the class represented by this
* object.
* @throws IllegalAccessException if the class or its nullary
* constructor is not accessible.
* @throws InstantiationException
* if this {@code Class} represents an abstract class,
* an interface, an array class, a primitive type, or void;
* or if the class has no nullary constructor;
* or if the instantiation fails for some other reason.
* @throws ExceptionInInitializerError if the initialization
* provoked by this method fails.
* @throws SecurityException
* If a security manager, s, is present and
* the caller's class loader is not the same as or an
* ancestor of the class loader for the current class and
* invocation of {@link SecurityManager#checkPackageAccess
* s.checkPackageAccess()} denies access to the package
* of this class.
*/
@CallerSensitive
public T newInstance()
throws InstantiationException, IllegalAccessException
{
if (System.getSecurityManager() != null) {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
}
// NOTE: the following code may not be strictly correct under
// the current Java memory model.
// Constructor lookup
if (cachedConstructor == null) {
if (this == Class.class) {
throw new IllegalAccessException(
"Can not call newInstance() on the Class for java.lang.Class"
);
}
try {
Class[] empty = {};
final Constructor
Specifically, if this {@code Class} object represents a * declared class, this method returns {@code true} if the specified * {@code Object} argument is an instance of the represented class (or * of any of its subclasses); it returns {@code false} otherwise. If * this {@code Class} object represents an array class, this method * returns {@code true} if the specified {@code Object} argument * can be converted to an object of the array class by an identity * conversion or by a widening reference conversion; it returns * {@code false} otherwise. If this {@code Class} object * represents an interface, this method returns {@code true} if the * class or any superclass of the specified {@code Object} argument * implements this interface; it returns {@code false} otherwise. If * this {@code Class} object represents a primitive type, this method * returns {@code false}. * * @param obj the object to check * @return true if {@code obj} is an instance of this class * * @since JDK1.1 */ public native boolean isInstance(Object obj); /** * Determines if the class or interface represented by this * {@code Class} object is either the same as, or is a superclass or * superinterface of, the class or interface represented by the specified * {@code Class} parameter. It returns {@code true} if so; * otherwise it returns {@code false}. If this {@code Class} * object represents a primitive type, this method returns * {@code true} if the specified {@code Class} parameter is * exactly this {@code Class} object; otherwise it returns * {@code false}. * *
Specifically, this method tests whether the type represented by the * specified {@code Class} parameter can be converted to the type * represented by this {@code Class} object via an identity conversion * or via a widening reference conversion. See The Java Language * Specification, sections 5.1.1 and 5.1.4 , for details. * * @param cls the {@code Class} object to be checked * @return the {@code boolean} value indicating whether objects of the * type {@code cls} can be assigned to objects of this class * @exception NullPointerException if the specified Class parameter is * null. * @since JDK1.1 */ public native boolean isAssignableFrom(Class cls); /** * Determines if the specified {@code Class} object represents an * interface type. * * @return {@code true} if this object represents an interface; * {@code false} otherwise. */ public native boolean isInterface(); /** * Determines if this {@code Class} object represents an array class. * * @return {@code true} if this object represents an array class; * {@code false} otherwise. * @since JDK1.1 */ public native boolean isArray(); /** * Determines if the specified {@code Class} object represents a * primitive type. * *
There are nine predefined {@code Class} objects to represent * the eight primitive types and void. These are created by the Java * Virtual Machine, and have the same names as the primitive types that * they represent, namely {@code boolean}, {@code byte}, * {@code char}, {@code short}, {@code int}, * {@code long}, {@code float}, and {@code double}. * *
These objects may only be accessed via the following public static * final variables, and are the only {@code Class} objects for which * this method returns {@code true}. * * @return true if and only if this class represents a primitive type * * @see java.lang.Boolean#TYPE * @see java.lang.Character#TYPE * @see java.lang.Byte#TYPE * @see java.lang.Short#TYPE * @see java.lang.Integer#TYPE * @see java.lang.Long#TYPE * @see java.lang.Float#TYPE * @see java.lang.Double#TYPE * @see java.lang.Void#TYPE * @since JDK1.1 */ public native boolean isPrimitive(); /** * Returns true if this {@code Class} object represents an annotation * type. Note that if this method returns true, {@link #isInterface()} * would also return true, as all annotation types are also interfaces. * * @return {@code true} if this class object represents an annotation * type; {@code false} otherwise * @since 1.5 */ public boolean isAnnotation() { return (getModifiers() & ANNOTATION) != 0; } /** * Returns {@code true} if this class is a synthetic class; * returns {@code false} otherwise. * @return {@code true} if and only if this class is a synthetic class as * defined by the Java Language Specification. * @jls 13.1 The Form of a Binary * @since 1.5 */ public boolean isSynthetic() { return (getModifiers() & SYNTHETIC) != 0; } /** * Returns the name of the entity (class, interface, array class, * primitive type, or void) represented by this {@code Class} object, * as a {@code String}. * *
If this class object represents a reference type that is not an * array type then the binary name of the class is returned, as specified * by * The Java™ Language Specification. * *
If this class object represents a primitive type or void, then the * name returned is a {@code String} equal to the Java language * keyword corresponding to the primitive type or void. * *
If this class object represents a class of arrays, then the internal * form of the name consists of the name of the element type preceded by * one or more '{@code [}' characters representing the depth of the array * nesting. The encoding of element type names is as follows: * *
** *
Element Type Encoding * boolean Z * byte B * char C * class or interface * Lclassname; * double D * float F * int I * long J * short S *
The class or interface name classname is the binary name of * the class specified above. * *
Examples: *
* String.class.getName()
* returns "java.lang.String"
* byte.class.getName()
* returns "byte"
* (new Object[3]).getClass().getName()
* returns "[Ljava.lang.Object;"
* (new int[3][4][5][6][7][8][9]).getClass().getName()
* returns "[[[[[[[I"
* If a security manager is present, and the caller's class loader is * not null and the caller's class loader is not the same as or an ancestor of * the class loader for the class whose class loader is requested, then * this method calls the security manager's {@code checkPermission} * method with a {@code RuntimePermission("getClassLoader")} * permission to ensure it's ok to access the class loader for the class. * *
If this object
* represents a primitive type or void, null is returned.
*
* @return the class loader that loaded the class or interface
* represented by this object.
* @throws SecurityException
* if a security manager exists and its
* {@code checkPermission} method denies
* access to the class loader for the class.
* @see java.lang.ClassLoader
* @see SecurityManager#checkPermission
* @see java.lang.RuntimePermission
*/
@CallerSensitive
public ClassLoader getClassLoader() {
ClassLoader cl = getClassLoader0();
if (cl == null)
return null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass());
}
return cl;
}
// Package-private to allow ClassLoader access
native ClassLoader getClassLoader0();
/**
* Returns an array of {@code TypeVariable} objects that represent the
* type variables declared by the generic declaration represented by this
* {@code GenericDeclaration} object, in declaration order. Returns an
* array of length 0 if the underlying generic declaration declares no type
* variables.
*
* @return an array of {@code TypeVariable} objects that represent
* the type variables declared by this generic declaration
* @throws java.lang.reflect.GenericSignatureFormatError if the generic
* signature of this generic declaration does not conform to
* the format specified in
* The Java™ Virtual Machine Specification
* @since 1.5
*/
@SuppressWarnings("unchecked")
public TypeVariable
If the superclass is a parameterized type, the {@code Type} * object returned must accurately reflect the actual type * parameters used in the source code. The parameterized type * representing the superclass is created if it had not been * created before. See the declaration of {@link * java.lang.reflect.ParameterizedType ParameterizedType} for the * semantics of the creation process for parameterized types. If * this {@code Class} represents either the {@code Object} * class, an interface, a primitive type, or void, then null is * returned. If this object represents an array class then the * {@code Class} object representing the {@code Object} class is * returned. * * @throws java.lang.reflect.GenericSignatureFormatError if the generic * class signature does not conform to the format specified in * The Java™ Virtual Machine Specification * @throws TypeNotPresentException if the generic superclass * refers to a non-existent type declaration * @throws java.lang.reflect.MalformedParameterizedTypeException if the * generic superclass refers to a parameterized type that cannot be * instantiated for any reason * @return the superclass of the class represented by this object * @since 1.5 */ public Type getGenericSuperclass() { ClassRepository info = getGenericInfo(); if (info == null) { return getSuperclass(); } // Historical irregularity: // Generic signature marks interfaces with superclass = Object // but this API returns null for interfaces if (isInterface()) { return null; } return info.getSuperclass(); } /** * Gets the package for this class. The class loader of this class is used * to find the package. If the class was loaded by the bootstrap class * loader the set of packages loaded from CLASSPATH is searched to find the * package of the class. Null is returned if no package object was created * by the class loader of this class. * *
Packages have attributes for versions and specifications only if the * information was defined in the manifests that accompany the classes, and * if the class loader created the package instance with the attributes * from the manifest. * * @return the package of the class, or null if no package * information is available from the archive or codebase. */ public Package getPackage() { return Package.getPackage(this); } /** * Determines the interfaces implemented by the class or interface * represented by this object. * *
If this object represents a class, the return value is an array * containing objects representing all interfaces implemented by the * class. The order of the interface objects in the array corresponds to * the order of the interface names in the {@code implements} clause * of the declaration of the class represented by this object. For * example, given the declaration: *
* {@code class Shimmer implements FloorWax, DessertTopping { ... }} ** suppose the value of {@code s} is an instance of * {@code Shimmer}; the value of the expression: *
* {@code s.getClass().getInterfaces()[0]} ** is the {@code Class} object that represents interface * {@code FloorWax}; and the value of: *
* {@code s.getClass().getInterfaces()[1]} ** is the {@code Class} object that represents interface * {@code DessertTopping}. * *
If this object represents an interface, the array contains objects * representing all interfaces extended by the interface. The order of the * interface objects in the array corresponds to the order of the interface * names in the {@code extends} clause of the declaration of the * interface represented by this object. * *
If this object represents a class or interface that implements no * interfaces, the method returns an array of length 0. * *
If this object represents a primitive type or void, the method * returns an array of length 0. * *
If this {@code Class} object represents an array type, the
* interfaces {@code Cloneable} and {@code java.io.Serializable} are
* returned in that order.
*
* @return an array of interfaces implemented by this class.
*/
public Class[] getInterfaces() {
ReflectionData
If a superinterface is a parameterized type, the * {@code Type} object returned for it must accurately reflect * the actual type parameters used in the source code. The * parameterized type representing each superinterface is created * if it had not been created before. See the declaration of * {@link java.lang.reflect.ParameterizedType ParameterizedType} * for the semantics of the creation process for parameterized * types. * *
If this object represents a class, the return value is an * array containing objects representing all interfaces * implemented by the class. The order of the interface objects in * the array corresponds to the order of the interface names in * the {@code implements} clause of the declaration of the class * represented by this object. In the case of an array class, the * interfaces {@code Cloneable} and {@code Serializable} are * returned in that order. * *
If this object represents an interface, the array contains * objects representing all interfaces directly extended by the * interface. The order of the interface objects in the array * corresponds to the order of the interface names in the * {@code extends} clause of the declaration of the interface * represented by this object. * *
If this object represents a class or interface that * implements no interfaces, the method returns an array of length * 0. * *
If this object represents a primitive type or void, the * method returns an array of length 0. * * @throws java.lang.reflect.GenericSignatureFormatError * if the generic class signature does not conform to the format * specified in * The Java™ Virtual Machine Specification * @throws TypeNotPresentException if any of the generic * superinterfaces refers to a non-existent type declaration * @throws java.lang.reflect.MalformedParameterizedTypeException * if any of the generic superinterfaces refer to a parameterized * type that cannot be instantiated for any reason * @return an array of interfaces implemented by this class * @since 1.5 */ public Type[] getGenericInterfaces() { ClassRepository info = getGenericInfo(); return (info == null) ? getInterfaces() : info.getSuperInterfaces(); } /** * Returns the {@code Class} representing the component type of an * array. If this class does not represent an array class this method * returns null. * * @return the {@code Class} representing the component type of this * class if this class is an array * @see java.lang.reflect.Array * @since JDK1.1 */ public native Class getComponentType(); /** * Returns the Java language modifiers for this class or interface, encoded * in an integer. The modifiers consist of the Java Virtual Machine's * constants for {@code public}, {@code protected}, * {@code private}, {@code final}, {@code static}, * {@code abstract} and {@code interface}; they should be decoded * using the methods of class {@code Modifier}. * *
If the underlying class is an array class, then its * {@code public}, {@code private} and {@code protected} * modifiers are the same as those of its component type. If this * {@code Class} represents a primitive type or void, its * {@code public} modifier is always {@code true}, and its * {@code protected} and {@code private} modifiers are always * {@code false}. If this object represents an array class, a * primitive type or void, then its {@code final} modifier is always * {@code true} and its interface modifier is always * {@code false}. The values of its other modifiers are not determined * by this specification. * *
The modifier encodings are defined in The Java Virtual Machine * Specification, table 4.1. * * @return the {@code int} representing the modifiers for this class * @see java.lang.reflect.Modifier * @since JDK1.1 */ public native int getModifiers(); /** * Gets the signers of this class. * * @return the signers of this class, or null if there are no signers. In * particular, this method returns null if this object represents * a primitive type or void. * @since JDK1.1 */ public native Object[] getSigners(); /** * Set the signers of this class. */ native void setSigners(Object[] signers); /** * If this {@code Class} object represents a local or anonymous * class within a method, returns a {@link * java.lang.reflect.Method Method} object representing the * immediately enclosing method of the underlying class. Returns * {@code null} otherwise. * * In particular, this method returns {@code null} if the underlying * class is a local or anonymous class immediately enclosed by a type * declaration, instance initializer or static initializer. * * @return the immediately enclosing method of the underlying class, if * that class is a local or anonymous class; otherwise {@code null}. * * @throws SecurityException * If a security manager, s, is present and any of the * following conditions is met: * *
The simple name of an array is the simple name of the
* component type with "[]" appended. In particular the simple
* name of an array whose component type is anonymous is "[]".
*
* @return the simple name of the underlying class
* @since 1.5
*/
public String getSimpleName() {
if (isArray())
return getComponentType().getSimpleName()+"[]";
String simpleName = getSimpleBinaryName();
if (simpleName == null) { // top level class
simpleName = getName();
return simpleName.substring(simpleName.lastIndexOf(".")+1); // strip the package name
}
// According to JLS3 "Binary Compatibility" (13.1) the binary
// name of non-package classes (not top level) is the binary
// name of the immediately enclosing class followed by a '$' followed by:
// (for nested and inner classes): the simple name.
// (for local classes): 1 or more digits followed by the simple name.
// (for anonymous classes): 1 or more digits.
// Since getSimpleBinaryName() will strip the binary name of
// the immediatly enclosing class, we are now looking at a
// string that matches the regular expression "\$[0-9]*"
// followed by a simple name (considering the simple of an
// anonymous class to be the empty string).
// Remove leading "\$[0-9]*" from the name
int length = simpleName.length();
if (length < 1 || simpleName.charAt(0) != '$')
throw new InternalError("Malformed class name");
int index = 1;
while (index < length && isAsciiDigit(simpleName.charAt(index)))
index++;
// Eventually, this is the empty string iff this is an anonymous class
return simpleName.substring(index);
}
/**
* Return an informative string for the name of this type.
*
* @return an informative string for the name of this type
* @since 1.8
*/
public String getTypeName() {
if (isArray()) {
try {
Class cl = this;
int dimensions = 0;
while (cl.isArray()) {
dimensions++;
cl = cl.getComponentType();
}
StringBuilder sb = new StringBuilder();
sb.append(cl.getName());
for (int i = 0; i < dimensions; i++) {
sb.append("[]");
}
return sb.toString();
} catch (Throwable e) { /*FALLTHRU*/ }
}
return getName();
}
/**
* Character.isDigit answers {@code true} to some non-ascii
* digits. This one does not.
*/
private static boolean isAsciiDigit(char c) {
return '0' <= c && c <= '9';
}
/**
* Returns the canonical name of the underlying class as
* defined by the Java Language Specification. Returns null if
* the underlying class does not have a canonical name (i.e., if
* it is a local or anonymous class or an array whose component
* type does not have a canonical name).
* @return the canonical name of the underlying class if it exists, and
* {@code null} otherwise.
* @since 1.5
*/
public String getCanonicalName() {
if (isArray()) {
String canonicalName = getComponentType().getCanonicalName();
if (canonicalName != null)
return canonicalName + "[]";
else
return null;
}
if (isLocalOrAnonymousClass())
return null;
Class enclosingClass = getEnclosingClass();
if (enclosingClass == null) { // top level class
return getName();
} else {
String enclosingName = enclosingClass.getCanonicalName();
if (enclosingName == null)
return null;
return enclosingName + "." + getSimpleName();
}
}
/**
* Returns {@code true} if and only if the underlying class
* is an anonymous class.
*
* @return {@code true} if and only if this class is an anonymous class.
* @since 1.5
*/
public boolean isAnonymousClass() {
return "".equals(getSimpleName());
}
/**
* Returns {@code true} if and only if the underlying class
* is a local class.
*
* @return {@code true} if and only if this class is a local class.
* @since 1.5
*/
public boolean isLocalClass() {
return isLocalOrAnonymousClass() && !isAnonymousClass();
}
/**
* Returns {@code true} if and only if the underlying class
* is a member class.
*
* @return {@code true} if and only if this class is a member class.
* @since 1.5
*/
public boolean isMemberClass() {
return getSimpleBinaryName() != null && !isLocalOrAnonymousClass();
}
/**
* Returns the "simple binary name" of the underlying class, i.e.,
* the binary name without the leading enclosing class name.
* Returns {@code null} if the underlying class is a top level
* class.
*/
private String getSimpleBinaryName() {
Class enclosingClass = getEnclosingClass();
if (enclosingClass == null) // top level class
return null;
// Otherwise, strip the enclosing class' name
try {
return getName().substring(enclosingClass.getName().length());
} catch (IndexOutOfBoundsException ex) {
throw new InternalError("Malformed class name", ex);
}
}
/**
* Returns {@code true} if this is a local class or an anonymous
* class. Returns {@code false} otherwise.
*/
private boolean isLocalOrAnonymousClass() {
// JVM Spec 4.8.6: A class must have an EnclosingMethod
// attribute if and only if it is a local class or an
// anonymous class.
return getEnclosingMethodInfo() != null;
}
/**
* Returns an array containing {@code Class} objects representing all
* the public classes and interfaces that are members of the class
* represented by this {@code Class} object. This includes public
* class and interface members inherited from superclasses and public class
* and interface members declared by the class. This method returns an
* array of length 0 if this {@code Class} object has no public member
* classes or interfaces. This method also returns an array of length 0 if
* this {@code Class} object represents a primitive type, an array
* class, or void.
*
* @return the array of {@code Class} objects representing the public
* members of this class
* @throws SecurityException
* If a security manager, s, is present and
* the caller's class loader is not the same as or an
* ancestor of the class loader for the current class and
* invocation of {@link SecurityManager#checkPackageAccess
* s.checkPackageAccess()} denies access to the package
* of this class.
*
* @since JDK1.1
*/
@CallerSensitive
public Class[] getClasses() {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
// Privileged so this implementation can look at DECLARED classes,
// something the caller might not have privilege to do. The code here
// is allowed to look at DECLARED classes because (1) it does not hand
// out anything other than public members and (2) public member access
// has already been ok'd by the SecurityManager.
return java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction
If this {@code Class} object represents a class or interface with no * no accessible public fields, then this method returns an array of length * 0. * *
If this {@code Class} object represents a class, then this method * returns the public fields of the class and of all its superclasses. * *
If this {@code Class} object represents an interface, then this * method returns the fields of the interface and of all its * superinterfaces. * *
If this {@code Class} object represents an array type, a primitive * type, or void, then this method returns an array of length 0. * *
The elements in the returned array are not sorted and are not in any * particular order. * * @return the array of {@code Field} objects representing the * public fields * @throws SecurityException * If a security manager, s, is present and * the caller's class loader is not the same as or an * ancestor of the class loader for the current class and * invocation of {@link SecurityManager#checkPackageAccess * s.checkPackageAccess()} denies access to the package * of this class. * * @since JDK1.1 * @jls 8.2 Class Members * @jls 8.3 Field Declarations */ @CallerSensitive public Field[] getFields() throws SecurityException { checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true); return copyFields(privateGetPublicFields(null)); } /** * Returns an array containing {@code Method} objects reflecting all the * public methods of the class or interface represented by this {@code * Class} object, including those declared by the class or interface and * those inherited from superclasses and superinterfaces. * *
If this {@code Class} object represents a type that has multiple * public methods with the same name and parameter types, but different * return types, then the returned array has a {@code Method} object for * each such method. * *
If this {@code Class} object represents a type with a class
* initialization method {@code
If this {@code Class} object represents an array type, then the * returned array has a {@code Method} object for each of the public * methods inherited by the array type from {@code Object}. It does not * contain a {@code Method} object for {@code clone()}. * *
If this {@code Class} object represents an interface then the * returned array does not contain any implicitly declared methods from * {@code Object}. Therefore, if no methods are explicitly declared in * this interface or any of its superinterfaces then the returned array * has length 0. (Note that a {@code Class} object which represents a class * always has public methods, inherited from {@code Object}.) * *
If this {@code Class} object represents a primitive type or void, * then the returned array has length 0. * *
Static methods declared in superinterfaces of the class or interface * represented by this {@code Class} object are not considered members of * the class or interface. * *
The elements in the returned array are not sorted and are not in any
* particular order.
*
* @return the array of {@code Method} objects representing the
* public methods of this class
* @throws SecurityException
* If a security manager, s, is present and
* the caller's class loader is not the same as or an
* ancestor of the class loader for the current class and
* invocation of {@link SecurityManager#checkPackageAccess
* s.checkPackageAccess()} denies access to the package
* of this class.
*
* @jls 8.2 Class Members
* @jls 8.4 Method Declarations
* @since JDK1.1
*/
@CallerSensitive
public Method[] getMethods() throws SecurityException {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
return copyMethods(privateGetPublicMethods());
}
/**
* Returns an array containing {@code Constructor} objects reflecting
* all the public constructors of the class represented by this
* {@code Class} object. An array of length 0 is returned if the
* class has no public constructors, or if the class is an array class, or
* if the class reflects a primitive type or void.
*
* Note that while this method returns an array of {@code
* Constructor
The field to be reflected is determined by the algorithm that * follows. Let C be the class or interface represented by this object: * *
If this {@code Class} object represents an array type, then this * method does not find the {@code length} field of the array type. * * @param name the field name * @return the {@code Field} object of this class specified by * {@code name} * @throws NoSuchFieldException if a field with the specified name is * not found. * @throws NullPointerException if {@code name} is {@code null} * @throws SecurityException * If a security manager, s, is present and * the caller's class loader is not the same as or an * ancestor of the class loader for the current class and * invocation of {@link SecurityManager#checkPackageAccess * s.checkPackageAccess()} denies access to the package * of this class. * * @since JDK1.1 * @jls 8.2 Class Members * @jls 8.3 Field Declarations */ @CallerSensitive public Field getField(String name) throws NoSuchFieldException, SecurityException { checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true); Field field = getField0(name); if (field == null) { throw new NoSuchFieldException(name); } return field; } /** * Returns a {@code Method} object that reflects the specified public * member method of the class or interface represented by this * {@code Class} object. The {@code name} parameter is a * {@code String} specifying the simple name of the desired method. The * {@code parameterTypes} parameter is an array of {@code Class} * objects that identify the method's formal parameter types, in declared * order. If {@code parameterTypes} is {@code null}, it is * treated as if it were an empty array. * *
If the {@code name} is "{@code
To find a matching method in a class or interface C: If C * declares exactly one public method with the specified name and exactly * the same formal parameter types, that is the method reflected. If more * than one such method is found in C, and one of these methods has a * return type that is more specific than any of the others, that method is * reflected; otherwise one of the methods is chosen arbitrarily. * *
Note that there may be more than one matching method in a * class because while the Java language forbids a class to * declare multiple methods with the same signature but different * return types, the Java virtual machine does not. This * increased flexibility in the virtual machine can be used to * implement various language features. For example, covariant * returns can be implemented with {@linkplain * java.lang.reflect.Method#isBridge bridge methods}; the bridge * method and the method being overridden would have the same * signature but different return types. * *
If this {@code Class} object represents an array type, then this * method does not find the {@code clone()} method. * *
Static methods declared in superinterfaces of the class or interface * represented by this {@code Class} object are not considered members of * the class or interface. * * @param name the name of the method * @param parameterTypes the list of parameters * @return the {@code Method} object that matches the specified * {@code name} and {@code parameterTypes} * @throws NoSuchMethodException if a matching method is not found * or if the name is "<init>"or "<clinit>". * @throws NullPointerException if {@code name} is {@code null} * @throws SecurityException * If a security manager, s, is present and * the caller's class loader is not the same as or an * ancestor of the class loader for the current class and * invocation of {@link SecurityManager#checkPackageAccess * s.checkPackageAccess()} denies access to the package * of this class. * * @jls 8.2 Class Members * @jls 8.4 Method Declarations * @since JDK1.1 */ @CallerSensitive public Method getMethod(String name, Class... parameterTypes) throws NoSuchMethodException, SecurityException { checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true); Method method = getMethod0(name, parameterTypes, true); if (method == null) { throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes)); } return method; } /** * Returns a {@code Constructor} object that reflects the specified * public constructor of the class represented by this {@code Class} * object. The {@code parameterTypes} parameter is an array of * {@code Class} objects that identify the constructor's formal * parameter types, in declared order. * * If this {@code Class} object represents an inner class * declared in a non-static context, the formal parameter types * include the explicit enclosing instance as the first parameter. * *
The constructor to reflect is the public constructor of the class
* represented by this {@code Class} object whose formal parameter
* types match those specified by {@code parameterTypes}.
*
* @param parameterTypes the parameter array
* @return the {@code Constructor} object of the public constructor that
* matches the specified {@code parameterTypes}
* @throws NoSuchMethodException if a matching method is not found.
* @throws SecurityException
* If a security manager, s, is present and
* the caller's class loader is not the same as or an
* ancestor of the class loader for the current class and
* invocation of {@link SecurityManager#checkPackageAccess
* s.checkPackageAccess()} denies access to the package
* of this class.
*
* @since JDK1.1
*/
@CallerSensitive
public Constructor
If this {@code Class} object represents a class or interface with no * declared fields, then this method returns an array of length 0. * *
If this {@code Class} object represents an array type, a primitive * type, or void, then this method returns an array of length 0. * *
The elements in the returned array are not sorted and are not in any * particular order. * * @return the array of {@code Field} objects representing all the * declared fields of this class * @throws SecurityException * If a security manager, s, is present and any of the * following conditions is met: * *
If this {@code Class} object represents a type that has multiple * declared methods with the same name and parameter types, but different * return types, then the returned array has a {@code Method} object for * each such method. * *
If this {@code Class} object represents a type that has a class
* initialization method {@code
If this {@code Class} object represents a class or interface with no * declared methods, then the returned array has length 0. * *
If this {@code Class} object represents an array type, a primitive * type, or void, then the returned array has length 0. * *
The elements in the returned array are not sorted and are not in any * particular order. * * @return the array of {@code Method} objects representing all the * declared methods of this class * @throws SecurityException * If a security manager, s, is present and any of the * following conditions is met: * *
See The Java Language Specification, section 8.2. * * @return the array of {@code Constructor} objects representing all the * declared constructors of this class * @throws SecurityException * If a security manager, s, is present and any of the * following conditions is met: * *
If this {@code Class} object represents an array type, then this * method does not find the {@code length} field of the array type. * * @param name the name of the field * @return the {@code Field} object for the specified field in this * class * @throws NoSuchFieldException if a field with the specified name is * not found. * @throws NullPointerException if {@code name} is {@code null} * @throws SecurityException * If a security manager, s, is present and any of the * following conditions is met: * *
If this {@code Class} object represents an array type, then this * method does not find the {@code clone()} method. * * @param name the name of the method * @param parameterTypes the parameter array * @return the {@code Method} object for the method of this class * matching the specified name and parameters * @throws NoSuchMethodException if a matching method is not found. * @throws NullPointerException if {@code name} is {@code null} * @throws SecurityException * If a security manager, s, is present and any of the * following conditions is met: * *
Before delegation, an absolute resource name is constructed from the * given resource name using this algorithm: * *
* {@code modified_package_name/name} ** *
Where the {@code modified_package_name} is the package name of this * object with {@code '/'} substituted for {@code '.'} * ('\u002e'). * *
Before delegation, an absolute resource name is constructed from the * given resource name using this algorithm: * *
* {@code modified_package_name/name} ** *
Where the {@code modified_package_name} is the package name of this * object with {@code '/'} substituted for {@code '.'} * ('\u002e'). * *
Default policy: allow all clients access with normal Java access
* control.
*/
private void checkMemberAccess(int which, Class caller, boolean checkProxyInterfaces) {
final SecurityManager s = System.getSecurityManager();
if (s != null) {
/* Default policy allows access to all {@link Member#PUBLIC} members,
* as well as access to classes that have the same class loader as the caller.
* In all other cases, it requires RuntimePermission("accessDeclaredMembers")
* permission.
*/
final ClassLoader ccl = ClassLoader.getClassLoader(caller);
final ClassLoader cl = getClassLoader0();
if (which != Member.PUBLIC) {
if (ccl != cl) {
s.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
}
}
this.checkPackageAccess(ccl, checkProxyInterfaces);
}
}
/*
* Checks if a client loaded in ClassLoader ccl is allowed to access this
* class under the current package access policy. If access is denied,
* throw a SecurityException.
*/
private void checkPackageAccess(final ClassLoader ccl, boolean checkProxyInterfaces) {
final SecurityManager s = System.getSecurityManager();
if (s != null) {
final ClassLoader cl = getClassLoader0();
if (ReflectUtil.needsPackageAccessCheck(ccl, cl)) {
String name = this.getName();
int i = name.lastIndexOf('.');
if (i != -1) {
// skip the package access check on a proxy class in default proxy package
String pkg = name.substring(0, i);
if (!Proxy.isProxyClass(this) || ReflectUtil.isNonPublicProxyClass(this)) {
s.checkPackageAccess(pkg);
}
}
}
// check package access on the proxy interfaces
if (checkProxyInterfaces && Proxy.isProxyClass(this)) {
ReflectUtil.checkProxyPackageAccess(ccl, this.getInterfaces());
}
}
}
/**
* Add a package name prefix if the name is not absolute Remove leading "/"
* if name is absolute
*/
private String resolveName(String name) {
if (name == null) {
return name;
}
if (!name.startsWith("/")) {
Class c = this;
while (c.isArray()) {
c = c.getComponentType();
}
String baseName = c.getName();
int index = baseName.lastIndexOf('.');
if (index != -1) {
name = baseName.substring(0, index).replace('.', '/')
+"/"+name;
}
} else {
name = name.substring(1);
}
return name;
}
/**
* Atomic operations support.
*/
private static class Atomic {
// initialize Unsafe machinery here, since we need to call Class.class instance method
// and have to avoid calling it in the static initializer of the Class class...
private static final Unsafe unsafe = Unsafe.getUnsafe();
// offset of Class.reflectionData instance field
private static final long reflectionDataOffset;
// offset of Class.annotationType instance field
private static final long annotationTypeOffset;
// offset of Class.annotationData instance field
private static final long annotationDataOffset;
static {
Field[] fields = Class.class.getDeclaredFields0(false); // bypass caches
reflectionDataOffset = objectFieldOffset(fields, "reflectionData");
annotationTypeOffset = objectFieldOffset(fields, "annotationType");
annotationDataOffset = objectFieldOffset(fields, "annotationData");
}
private static long objectFieldOffset(Field[] fields, String fieldName) {
Field field = searchFields(fields, fieldName);
if (field == null) {
throw new Error("No " + fieldName + " field found in java.lang.Class");
}
return unsafe.objectFieldOffset(field);
}
static
* {@code TC_CLASS} ClassDescriptor
* A ClassDescriptor is a special cased serialization of
* a {@code java.io.ObjectStreamClass} instance.
*
* A new handle is generated for the initial time the class descriptor
* is written into the stream. Future references to the class descriptor
* are written as references to the initial class descriptor instance.
*
* @see java.io.ObjectStreamClass
*/
private static final ObjectStreamField[] serialPersistentFields =
new ObjectStreamField[0];
/**
* Returns the assertion status that would be assigned to this
* class if it were to be initialized at the time this method is invoked.
* If this class has had its assertion status set, the most recent
* setting will be returned; otherwise, if any package default assertion
* status pertains to this class, the most recent setting for the most
* specific pertinent package default assertion status is returned;
* otherwise, if this class is not a system class (i.e., it has a
* class loader) its class loader's default assertion status is returned;
* otherwise, the system class default assertion status is returned.
*
* Few programmers will have any need for this method; it is provided
* for the benefit of the JRE itself. (It allows a class to determine at
* the time that it is initialized whether assertions should be enabled.)
* Note that this method is not guaranteed to return the actual
* assertion status that was (or will be) associated with the specified
* class when it was (or will be) initialized.
*
* @return the desired assertion status of the specified class.
* @see java.lang.ClassLoader#setClassAssertionStatus
* @see java.lang.ClassLoader#setPackageAssertionStatus
* @see java.lang.ClassLoader#setDefaultAssertionStatus
* @since 1.4
*/
public boolean desiredAssertionStatus() {
ClassLoader loader = getClassLoader();
// If the loader is null this is a system class, so ask the VM
if (loader == null)
return desiredAssertionStatus0(this);
// If the classloader has been initialized with the assertion
// directives, ask it. Otherwise, ask the VM.
synchronized(loader.assertionLock) {
if (loader.classAssertionStatus != null) {
return loader.desiredAssertionStatus(getName());
}
}
return desiredAssertionStatus0(this);
}
// Retrieves the desired assertion status of this class from the VM
private static native boolean desiredAssertionStatus0(Class clazz);
/**
* Returns true if and only if this class was declared as an enum in the
* source code.
*
* @return true if and only if this class was declared as an enum in the
* source code
* @since 1.5
*/
public boolean isEnum() {
// An enum must both directly extend java.lang.Enum and have
// the ENUM bit set; classes for specialized enum constants
// don't do the former.
return (this.getModifiers() & ENUM) != 0 &&
this.getSuperclass() == java.lang.Enum.class;
}
// Fetches the factory for reflective objects
private static ReflectionFactory getReflectionFactory() {
if (reflectionFactory == null) {
reflectionFactory =
java.security.AccessController.doPrivileged
(new sun.reflect.ReflectionFactory.GetReflectionFactoryAction());
}
return reflectionFactory;
}
private static ReflectionFactory reflectionFactory;
// To be able to query system properties as soon as they're available
private static boolean initted = false;
private static void checkInitted() {
if (initted) return;
AccessController.doPrivileged(new PrivilegedAction
This method is useful when a client needs to "narrow" the type of
* a {@code Class} object to pass it to an API that restricts the
* {@code Class} objects that it is willing to accept. A cast would
* generate a compile-time warning, as the correctness of the cast
* could not be checked at runtime (because generic types are implemented
* by erasure).
*
* @param the type to cast this class object to
* @param clazz the class of the type to cast this class object to
* @return this {@code Class} object, cast to represent a subclass of
* the specified class object.
* @throws ClassCastException if this {@code Class} object does not
* represent a subclass of the specified class (here "subclass" includes
* the class itself).
* @since 1.5
*/
@SuppressWarnings("unchecked")
public Class asSubclass(Class clazz) {
if (clazz.isAssignableFrom(this))
return (Class) this;
else
throw new ClassCastException(this.toString());
}
/**
* @throws NullPointerException {@inheritDoc}
* @since 1.5
*/
@SuppressWarnings("unchecked")
public A getAnnotation(Class annotationClass) {
Objects.requireNonNull(annotationClass);
return (A) annotationData().annotations.get(annotationClass);
}
/**
* {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @since 1.5
*/
@Override
public boolean isAnnotationPresent(Class annotationClass) {
return GenericDeclaration.super.isAnnotationPresent(annotationClass);
}
/**
* @throws NullPointerException {@inheritDoc}
* @since 1.8
*/
@Override
public A[] getAnnotationsByType(Class annotationClass) {
Objects.requireNonNull(annotationClass);
AnnotationData annotationData = annotationData();
return AnnotationSupport.getAssociatedAnnotations(annotationData.declaredAnnotations,
this,
annotationClass);
}
/**
* @since 1.5
*/
public Annotation[] getAnnotations() {
return AnnotationParser.toArray(annotationData().annotations);
}
/**
* @throws NullPointerException {@inheritDoc}
* @since 1.8
*/
@Override
@SuppressWarnings("unchecked")
public A getDeclaredAnnotation(Class annotationClass) {
Objects.requireNonNull(annotationClass);
return (A) annotationData().declaredAnnotations.get(annotationClass);
}
/**
* @throws NullPointerException {@inheritDoc}
* @since 1.8
*/
@Override
public A[] getDeclaredAnnotationsByType(Class annotationClass) {
Objects.requireNonNull(annotationClass);
return AnnotationSupport.getDirectlyAndIndirectlyPresent(annotationData().declaredAnnotations,
annotationClass);
}
/**
* @since 1.5
*/
public Annotation[] getDeclaredAnnotations() {
return AnnotationParser.toArray(annotationData().declaredAnnotations);
}
// annotation data that might get invalidated when JVM TI RedefineClasses() is called
private static class AnnotationData {
final Map