您的位置: 首页  >  技术问答  >  关于Java的Class类

关于Java的Class类

分类: 技术问答 • 2022-03-17 17:48:14

关于Java的Class类

问题描述：

本人初学Java，孤身奋战，经常被自己搞的头破血流，现有一问题，想与各位高人讨论讨论

我百度了很多关于Class类的文章，看了很多，感觉好像明白了一点，但是又不敢确定，我把我的认识写下来，请各位评价评价。
Class类是一个很特殊的类，在Java源文件编译完成生成的每个class文件中，都有一个Class对象，或者说跟Class这个类有关的一点东西，当JVM加载这个类(记做A)的时候，这个类(A)本身并不参与到JVM中，而是那个跟Class类有关的东西生成了一个Class的对象，这个对象包括了A的所有信息，而也可以说，这个Class对象就是一个包装了类A，让类A来了个改头换面后的一个类A的副本对象。
我的理解就是这样，不知道事实是不是这样，大家认为我理解不对请指出来吧！本来是打算问老师的，可是上次问了他一个超级简单的swing的问题，他支支吾吾硬是没回答我（我目前所出的学校是个专科院校），我觉着还是算了，另外，大家有时间的话，请告诉我一些学Java的途径，我现在老是自己一个人自学，感觉没什么进步，经常性的 :cry: :cry: :cry: ……

答

Class类就是你new出来的那个对象的模版 你这么想就ok了 Class会记录你new的那个对象的元数据，包括 方法信息 属性信息 实现的接口信息等等等等 虚拟机装载的就是这个Class对象 而你new的东西就是实际对象属性值的集合 看看inside jvm这书很有帮助

难得lz能这么好学 这样的人不多了 加油吧

答

[color=blue][b]
我是这样理解的：

每一个类被JVM加载后，在内存中生成一个对应的class对象，该class对象是 编译后的class文件，在JVM中的存在方式。[/b][/color]

答

我这样理解的:
首先,每一个JAVA类会编译成一个class文件,当一个JAVA类被加载到JVM中也,也就是加载对应的class文件了.
然后,Class类的对象是用于包装加载到JVM中的class文件的.它里面的一些成员变量,会记录此class文件,也就是此JAVA类的相关信息.
再次,Class无构造方法,我们无法自已生成一个Class对象，Class对象的生成都是ＪＶＭ来生成的．
最后:
给你Class的原代码.
[code="java"]/*

  • @(#)Class.java 1.187 04/07/12 *
  • Copyright 2004 Sun Microsystems, Inc. All rights reserved.
  • SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */

package java.lang;

import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Member;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
import java.lang.reflect.GenericDeclaration;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.InvocationTargetException;
import java.lang.ref.SoftReference;
import java.io.InputStream;
import java.io.ObjectStreamClass;
import java.io.ObjectStreamField;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.LinkedList;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.Map;
import java.util.HashMap;
import sun.misc.Unsafe;
import sun.reflect.ConstantPool;
import sun.reflect.Reflection;
import sun.reflect.ReflectionFactory;
import sun.reflect.SignatureIterator;
import sun.reflect.generics.factory.CoreReflectionFactory;
import sun.reflect.generics.factory.GenericsFactory;
import sun.reflect.generics.repository.ClassRepository;
import sun.reflect.generics.repository.MethodRepository;
import sun.reflect.generics.repository.ConstructorRepository;
import sun.reflect.generics.scope.ClassScope;
import sun.security.util.SecurityConstants;
import java.lang.annotation.Annotation;
import sun.reflect.annotation.*;

/**

  • Instances of the class Class represent classes and
  • interfaces in a running Java application. An enum is a kind of
  • class and an annotation is a kind of interface. Every array also
  • belongs to a class that is reflected as a Class object
  • that is shared by all arrays with the same element type and number
  • of dimensions. The primitive Java types (boolean,
  • byte, char, short,
  • int, long, float, and
  • double), and the keyword void are also
  • represented as Class objects. *

  • Class has no public constructor. Instead Class

  • objects are constructed automatically by the Java Virtual Machine as classes
  • are loaded and by calls to the defineClass method in the class
  • loader. *

  • The following example uses a 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 Class object for a named
    • 

  • type (or for void) using a class literal 
    • 

  • (JLS Section 15.8.2). 
    • 

  • For example:
*
    • 

  • 

     
    

    

    • 

  •     System.out.println("The name of class Foo is: "+Foo.class.getName());
    • 

  • 
*
    • 

  • @author  unascribed
    • 

  • @version 1.135, 05/25/01
    • 

  • @see     java.lang.ClassLoader#defineClass(byte[], int, int)
    • 

  • 

    @since   JDK1.0
    
*/
    
public final
    
class Class implements java.io.Serializable, 
    
              java.lang.reflect.GenericDeclaration, 
    
              java.lang.reflect.Type,
    
                          java.lang.reflect.AnnotatedElement {
    
private static final int ANNOTATION= 0x00002000;
    
private static final int ENUM      = 0x00004000;
    
private static final int SYNTHETIC = 0x00001000;
    


    private static native void registerNatives();
    
static {
    
    registerNatives();
    
}
    


    /*
    


      

    • Constructor. Only the Java Virtual Machine creates Class
      • 

    • objects.
*/
private Class() {}
      • 

    

    /**
    


      

    • Converts the object to a string. The string representation is the
      • 

    • string "class" or "interface", followed by a space, and then by the
      • 

    • fully qualified name of the class in the format returned by
      • 

    • 
getName.  If this Class object represents a
      • 

    • primitive type, this method returns the name of the primitive type.  If
      • 

    • this Class object represents void this method returns
      • 

    • "void".
*
      • 

    • @return a string representation of this class object.
*/
public String toString() {
return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
    + getName();
}
      • 

    

    /**
    


      

    • Returns the Class object associated with the class or
      • 

    • interface with the given string name.  Invoking this method is
      • 

    • equivalent to:
*
      • 

      • 

    •  Class.forName(className, true, currentLoader)
      • 

    • 
*
      • 

    • where currentLoader denotes the defining class loader of
      • 

    • the current class.
*
      • 

    •  For example, the following code fragment returns the
      • 

    • runtime Class descriptor for the class named
      • 

    • 
java.lang.Thread:
*
      • 

      • 

    •   Class t = Class.forName("java.lang.Thread")
      • 

    • 

      • 

      • 

    • A call to forName("X") causes the class named 
      • 

    • 
X to be initialized.
*
      • 

    • @param      className   the fully qualified name of the desired class.
      • 

    • @return     the 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
*/
public static Class<?> forName(String className) 
        throws ClassNotFoundException {
return forName0(className, true, ClassLoader.getCallerClassLoader());
}
      • 

    

    /**
    


      

    • Returns the 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 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
      • 

    • 
loader is null, the class is loaded through the bootstrap
      • 

    • class loader.  The class is initialized only if the
      • 

    • 
initialize parameter is true and if it has
      • 

    • not been initialized earlier.
*
      • 

    •  If 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 name. Therefore, this method cannot be used to
      • 

    • obtain any of the Class objects representing primitive
      • 

    • types or void.
*
      • 

    •  If 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:
*
      • 

      • 

    •  Class.forName("Foo")
      • 

    • 
*
      • 

    • is equivalent to:
*
      • 

      • 

    •  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 loader is null, and a security
      • 

    • manager is present, and the caller's class loader is not null, then this
      • 

    • method calls the security manager's checkPermission method
      • 

    • with a 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 whether the class must be initialized
      • 

    • @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
*/
public static Class<?> forName(String name, boolean initialize,
           ClassLoader loader)
throws ClassNotFoundException
{
if (loader == null) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader ccl = ClassLoader.getCallerClassLoader();
if (ccl != null) {
    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 Class

      • 

    • object.  The class is instantiated as if by a 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.
      • 

    • @exception  IllegalAccessException  if the class or its nullary 
      • 

    •               constructor is not accessible.
      • 

    • @exception  InstantiationException 
      • 

    •               if this 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.
      • 

    • @exception  ExceptionInInitializerError if the initialization
      • 

    •               provoked by this method fails.
      • 

    • @exception  SecurityException
      • 

    •             If a security manager, s, is present and any of the
      • 

    •             following conditions is met:
*
      • 

    •             
        
*
      

      • 

    •             
      • 

    •  invocation of 
      • 

    •             {@link SecurityManager#checkMemberAccess

      • 

    •             s.checkMemberAccess(this, Member.PUBLIC)} denies
      • 

    •             creation of new instances of this class
*
      • 

    •             
      • 

    •  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
*
      • 

    •             
      • 

    
*
*/
public T newInstance() 
throws InstantiationException, IllegalAccessException
{
if (System.getSecurityManager() != null) {
checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
}
return newInstance0();
}
    • 



private T newInstance0()

    throws InstantiationException, IllegalAccessException

{

    // 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<T> c = getConstructor0(empty, Member.DECLARED);
        // Disable accessibility checks on the constructor
        // since we have to do the security check here anyway
        // (the stack depth is wrong for the Constructor's
        // security check to work)
        java.security.AccessController.doPrivileged
            (new java.security.PrivilegedAction() {
                    public Object run() {
                        c.setAccessible(true);
                        return null;
                    }
                });
        cachedConstructor = c;
    } catch (NoSuchMethodException e) {
        throw new InstantiationException(getName());
    }
}
Constructor<T> tmpConstructor = cachedConstructor;
// Security check (same as in java.lang.reflect.Constructor)
int modifiers = tmpConstructor.getModifiers();
if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
    Class caller = Reflection.getCallerClass(3);
    if (newInstanceCallerCache != caller) {
        Reflection.ensureMemberAccess(caller, this, null, modifiers);
        newInstanceCallerCache = caller;
    }
}
// Run constructor
try {
    return tmpConstructor.newInstance((Object[])null);
} catch (InvocationTargetException e) {
    Unsafe.getUnsafe().throwException(e.getTargetException());
    // Not reached
    return null;
}




}

private volatile transient Constructor cachedConstructor;

private volatile transient Class       newInstanceCallerCache;



/**



    

  • Determines if the specified Object is assignment-compatible
    • 

  • with the object represented by this Class.  This method is
    • 

  • the dynamic equivalent of the Java language instanceof

    • 

  • operator. The method returns true if the specified
    • 

  • 
Object argument is non-null and can be cast to the
    • 

  • reference type represented by this Class object without
    • 

  • raising a ClassCastException. It returns false

    • 

  • otherwise.
*
    • 

  •  Specifically, if this Class object represents a
    • 

  • declared class, this method returns true if the specified
    • 

  • 
Object argument is an instance of the represented class (or
    • 

  • of any of its subclasses); it returns false otherwise. If
    • 

  • this Class object represents an array class, this method
    • 

  • returns true if the specified Object argument
    • 

  • can be converted to an object of the array class by an identity
    • 

  • conversion or by a widening reference conversion; it returns
    • 

  • 
false otherwise. If this Class object
    • 

  • represents an interface, this method returns true if the
    • 

  • class or any superclass of the specified Object argument
    • 

  • implements this interface; it returns false otherwise. If
    • 

  • this Class object represents a primitive type, this method
    • 

  • returns false.
*
    • 

  • @param   obj the object to check
    • 

  • @return  true if 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
    • 

  • 
Class object is either the same as, or is a superclass or
    • 

  • superinterface of, the class or interface represented by the specified
    • 

  • 
Class parameter. It returns true if so;
    • 

  • otherwise it returns false. If this Class

    • 

  • object represents a primitive type, this method returns
    • 

  • 
true if the specified Class parameter is
    • 

  • exactly this Class object; otherwise it returns
    • 

  • 
false.
*
    • 

  •  Specifically, this method tests whether the type represented by the
    • 

  • specified Class parameter can be converted to the type
    • 

  • represented by this 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 Class object to be checked
    • 

  • @return the boolean value indicating whether objects of the
    • 

  • type 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 Class object represents an
    • 

  • interface type.
*
    • 

  • @return  true if this object represents an interface;
    • 

  •          false otherwise.
*/
public native boolean isInterface();
    • 



/**



    

  • Determines if this Class object represents an array class.
*
    • 

  • @return  true if this object represents an array class;
    • 

  •          false otherwise.
    • 

  • @since   JDK1.1
*/
public native boolean isArray();
    • 



/**



    

  • Determines if the specified Class object represents a
    • 

  • primitive type.
*
    • 

  •  There are nine predefined 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 boolean, byte,
    • 

  • 
char, short, int,
    • 

  • 
long, float, and double.
*
    • 

  •  These objects may only be accessed via the following public static
    • 

  • final variables, and are the only Class objects for which
    • 

  • this method returns 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 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 true if this class object represents an annotation
    • 

  •      type; false otherwise
    • 

  • @since 1.5
*/
public boolean isAnnotation() {
return (getModifiers() & ANNOTATION) != 0;
}
    • 



/**



    

  • Returns true if this class is a synthetic class;
    • 

  • returns false otherwise.
    • 

  • @return true if and only if this class is a synthetic class as
    • 

  •         defined by the Java Language Specification.
    • 

  • @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 Class object,
    • 

  • as a 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, Second Edition.
*
    • 

  •  If this class object represents a primitive type or void, then the
    • 

  • name returned is a 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 '[' 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"
    • 

  • 
*
    • 

  • @return  the name of the class or interface
    • 

  •          represented by this object.
*/
public String getName() {
if (name == null)
name = getName0();
return name;
}
    • 



// cache the name to reduce the number of calls into the VM

private transient String name;

private native String getName0();



/**



    

  • Returns the class loader for the class.  Some implementations may use
    • 

  • null to represent the bootstrap class loader. This method will return
    • 

  • null in such implementations if this class was loaded by the bootstrap
    • 

  • class loader.
*
    • 

  •  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 checkPermission 
    • 

  • method with a 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 
    • 

  •    checkPermission method denies
    • 

  •    access to the class loader for the class.
    • 

  • @see java.lang.ClassLoader
    • 

  • @see SecurityManager#checkPermission
    • 

  • @see java.lang.RuntimePermission
*/
public ClassLoader getClassLoader() {
ClassLoader cl = getClassLoader0();
if (cl == null)
    return null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
    ClassLoader ccl = ClassLoader.getCallerClassLoader();
    if (ccl != null && ccl != cl && !cl.isAncestor(ccl)) {
        sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
    }
}
return cl;
}
    • 



// Package-private to allow ClassLoader access

native ClassLoader getClassLoader0();



/**



    

  • Returns an array of TypeVariable objects that represent the
    • 

  • type variables declared by the generic declaration represented by this
    • 

  • 
GenericDeclaration object, in declaration order.  Returns an
    • 

  • array of length 0 if the underlying generic declaration declares no type
    • 

  • variables.
*
    • 

  • @return an array of TypeVariable objects that represent
    • 

  •     the type variables declared by this generic declaration
    • 

  • @throws GenericSignatureFormatError if the generic
    • 

  •     signature of this generic declaration does not conform to
    • 

  •     the format specified in the Java Virtual Machine Specification,
    • 

  •     3rd edition
    • 

  • @since 1.5
*/
public TypeVariable>[] getTypeParameters() {
if (getGenericSignature() != null) 
return (TypeVariable>[])getGenericInfo().getTypeParameters();
else
return (TypeVariable>[])new TypeVariable[0];
}
    • 



/**



    

  • Returns the Class representing the superclass of the entity
    • 

  • (class, interface, primitive type or void) represented by this
    • 

  • 
Class.  If this Class represents either the
    • 

  • 
Object class, an interface, a primitive type, or void, then
    • 

  • null is returned.  If this object represents an array class then the
    • 

  • 
Class object representing the Object class is
    • 

  • returned.
*
    • 

  • @return the superclass of the class represented by this object.
*/
public native Class<? super T> getSuperclass();
    • 



/**



    

  • Returns the Type representing the direct superclass of
    • 

  • the entity (class, interface, primitive type or void) represented by
    • 

  • this Class.
    • 

  • 

    • 

  • If the superclass is a parameterized type, the 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 Class represents either the Object

    • 

  • class, an interface, a primitive type, or void, then null is
    • 

  • returned.  If this object represents an array class then the
    • 

  • 
Class object representing the Object class is
    • 

  • returned.
*
    • 

  • @throws GenericSignatureFormatError if the generic
    • 

  •     class signature does not conform to the format specified in the
    • 

  •     Java Virtual Machine Specification, 3rd edition
    • 

  • @throws TypeNotPresentException if the generic superclass
    • 

  •     refers to a non-existent type declaration
    • 

  • @throws 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() {
if (getGenericSignature() != null) {
// Historical irregularity:
// Generic signature marks interfaces with superclass = Object
// but this API returns null for interfaces
if (isInterface())
return null;
return getGenericInfo().getSuperclass();
} else
return 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 implements clause
    • 

  • of the declaration of the class represented by this object. For 
    • 

  • example, given the declaration:
    • 

    • 

  • class Shimmer implements FloorWax, DessertTopping { ... }
    • 

  • 

    • 

  • suppose the value of s is an instance of 
    • 

  • 
Shimmer; the value of the expression:
    • 

    • 

  • s.getClass().getInterfaces()[0]
    • 

  • 

    • 

  • is the Class object that represents interface 
    • 

  • 
FloorWax; and the value of:
    • 

    • 

  • s.getClass().getInterfaces()[1]
    • 

  • 

    • 

  • is the Class object that represents interface 
    • 

  • 
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 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.
*
    • 

  • @return an array of interfaces implemented by this class.
*/
public native Class[] getInterfaces();
    • 



/**



    

  • Returns the Types representing the interfaces 
    • 

  • directly implemented by the class or interface represented by
    • 

  • this object.
*
    • 

  • If a superinterface is a parameterized type, the
    • 

  • 
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 implements clause of the declaration of the class
    • 

  • represented by this object.  In the case of an array class, the
    • 

  • interfaces Cloneable and 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
    • 

  • 
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 GenericSignatureFormatError
    • 

  •     if the generic class signature does not conform to the format
    • 

  •     specified in the Java Virtual Machine Specification, 3rd edition
    • 

  • @throws TypeNotPresentException if any of the generic
    • 

  •     superinterfaces refers to a non-existent type declaration
    • 

  • @throws 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() {
if (getGenericSignature() != null)
return getGenericInfo().getSuperInterfaces();
else
return getInterfaces();
}
    • 



/**



    

  • Returns the Class representing the component type of an
    • 

  • array.  If this class does not represent an array class this method
    • 

  • returns null.
*
    • 

  • @return the 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 public, protected,
    • 

  • 
private, final, static,
    • 

  • 
abstract and interface; they should be decoded
    • 

  • using the methods of class Modifier.
*
    • 

  •  If the underlying class is an array class, then its
    • 

  • 
public, private and protected

    • 

  • modifiers are the same as those of its component type.  If this
    • 

  • 
Class represents a primitive type or void, its
    • 

  • 
public modifier is always true, and its
    • 

  • 
protected and private modifiers are always
    • 

  • 
false. If this object represents an array class, a
    • 

  • primitive type or void, then its final modifier is always
    • 

  • 
true and its interface modifier is always
    • 

  • 
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 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 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
    • 

  • 
null otherwise.
*
    • 

  • In particular, this method returns 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 null.
    • 

  • @since 1.5
*/
public Method getEnclosingMethod() {
EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();
    • 



if (enclosingInfo == null)

    return null;

else {

    if (!enclosingInfo.isMethod())

    return null;



MethodRepository typeInfo = MethodRepository.make(enclosingInfo.getDescriptor(), 
                          getFactory());
Class      returnType       = toClass(typeInfo.getReturnType());
Type []    parameterTypes   = typeInfo.getParameterTypes();
Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];

// Convert Types to Classes; returned types *should*
// be class objects since the methodDescriptor's used
// don't have generics information
for(int i = 0; i < parameterClasses.length; i++)
parameterClasses[i] = toClass(parameterTypes[i]);

/*
 * Loop over all declared methods; match method name,
 * number of and type of parameters, *and* return
 * type.  Matching return type is also necessary
 * because of covariant returns, etc.
 */
for(Method m: enclosingInfo.getEnclosingClass().getDeclaredMethods()) {
if (m.getName().equals(enclosingInfo.getName()) ) {
    Class<?>[] candidateParamClasses = m.getParameterTypes();
    if (candidateParamClasses.length == parameterClasses.length) {
    boolean matches = true;
    for(int i = 0; i < candidateParamClasses.length; i++) {
        if (!candidateParamClasses[i].equals(parameterClasses[i])) {
        matches = false;
        break;
        }
    }

    if (matches) { // finally, check return type
        if (m.getReturnType().equals(returnType) )
        return m;
    }
    }
}
}

throw new InternalError("Enclosing method not found");




}

}



private native Object[] getEnclosingMethod0();



private EnclosingMethodInfo getEnclosingMethodInfo() {

if (isPrimitive())

    return null;

Object[] enclosingInfo = getEnclosingMethod0();

if (enclosingInfo == null)

    return null;

else {

    return new EnclosingMethodInfo(enclosingInfo);

}

}



private final static class EnclosingMethodInfo {

private Class<?> enclosingClass;

private String name;

private String descriptor;



private EnclosingMethodInfo(Object[] enclosingInfo) {

    if (enclosingInfo.length != 3)

    throw new InternalError("Malformed enclosing method information");

    try {

    // The array is expected to have three elements:



// the immediately enclosing class
enclosingClass = (Class<?>) enclosingInfo[0];
assert(enclosingClass != null);

// the immediately enclosing method or constructor's
// name (can be null).
name        = (String)   enclosingInfo[1]; 

// the immediately enclosing method or constructor's
// descriptor (null iff name is).
descriptor  = (String)   enclosingInfo[2];
assert((name != null && descriptor != null) || name == descriptor);
} catch (ClassCastException cce) {
throw new InternalError("Invalid type in enclosing method information");
}




}



boolean isPartial() {

    return enclosingClass == null || name == null || descriptor == null;

}



boolean isConstructor() { return !isPartial() && "".equals(name); }



boolean isMethod() { return !isPartial() && !isConstructor() && !"".equals(name); }



Class<?> getEnclosingClass() { return enclosingClass; }



String getName() { return name; }



String getDescriptor() { return descriptor; }



}



private static Class toClass(Type o) {

if (o instanceof GenericArrayType)

    return Array.newInstance(toClass(((GenericArrayType)o).getGenericComponentType()),

                 0)

    .getClass();

return (Class)o;

 }



/**



    

  • If this Class object represents a local or anonymous
    • 

  • class within a constructor, returns a {@link
    • 

  • java.lang.reflect.Constructor Constructor} object representing
    • 

  • the immediately enclosing constructor of the underlying
    • 

  • class. Returns null otherwise.  In particular, this
    • 

  • method returns 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 constructor of the underlying class, if
    • 

  •     that class is a local or anonymous class; otherwise null.
    • 

  • @since 1.5
*/
public Constructor<?> getEnclosingConstructor() {
EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();
    • 



if (enclosingInfo == null)

    return null;

else {

    if (!enclosingInfo.isConstructor())

    return null;



ConstructorRepository typeInfo = ConstructorRepository.make(enclosingInfo.getDescriptor(), 
                            getFactory());
Type []    parameterTypes   = typeInfo.getParameterTypes();
Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];

// Convert Types to Classes; returned types *should*
// be class objects since the methodDescriptor's used
// don't have generics information
for(int i = 0; i < parameterClasses.length; i++)
parameterClasses[i] = toClass(parameterTypes[i]);

/*
 * Loop over all declared constructors; match number
 * of and type of parameters.
 */
for(Constructor c: enclosingInfo.getEnclosingClass().getDeclaredConstructors()) {
Class<?>[] candidateParamClasses = c.getParameterTypes();
if (candidateParamClasses.length == parameterClasses.length) {
    boolean matches = true;
    for(int i = 0; i < candidateParamClasses.length; i++) {
    if (!candidateParamClasses[i].equals(parameterClasses[i])) {
        matches = false;
        break;
    }
    }

    if (matches)
    return c;
}
}

throw new InternalError("Enclosing constructor not found");




}

}



/**



    

  • If the class or interface represented by this Class object
    • 

  • is a member of another class, returns the Class object
    • 

  • representing the class in which it was declared.  This method returns
    • 

  • null if this class or interface is not a member of any other class.  If
    • 

  • this Class object represents an array class, a primitive
    • 

  • type, or void,then this method returns null.
*
    • 

  • @return the declaring class for this class
    • 

  • @since JDK1.1
*/
public native Class<?> getDeclaringClass();
    • 



/**



    

  • Returns the immediately enclosing class of the underlying
    • 

  • class.  If the underlying class is a top level class this
    • 

  • method returns null.
    • 

  • @return the immediately enclosing class of the underlying class
    • 

  • @since 1.5
*/
public Class<?> getEnclosingClass() {
// There are five kinds of classes (or interfaces):
// a) Top level classes
// b) Nested classes (static member classes)
// c) Inner classes (non-static member classes)
// d) Local classes (named classes declared within a method)
// e) Anonymous classes
    • 



// 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.

EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();



if (enclosingInfo == null) {

    // This is a top level or a nested class or an inner class (a, b, or c)

    return getDeclaringClass();

} else {

    Class<?> enclosingClass = enclosingInfo.getEnclosingClass();

    // This is a local class or an anonymous class (d or e)

    if (enclosingClass == this || enclosingClass == null)

    throw new InternalError("Malformed enclosing method information");

    else

    return enclosingClass;

}

}



/**



    

  • Returns the simple name of the underlying class as given in the
    • 

  • source code. Returns an empty string if the underlying class is
    • 

  • anonymous.
*
    • 

  • 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);

}



/**



    

  • Character.isDigit answers 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 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
    • 

  • 
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 true if and only if the underlying class
    • 

  • is an anonymous class.
*
    • 

  • @return true if and only if this class is an anonymous class.
    • 

  • @since 1.5
*/
public boolean isAnonymousClass() {
return "".equals(getSimpleName());
}
    • 



/**



    

  • Returns true if and only if the underlying class
    • 

  • is a local class.
*
    • 

  • @return true if and only if this class is a local class.
    • 

  • @since 1.5
*/
public boolean isLocalClass() {
return isLocalOrAnonymousClass() && !isAnonymousClass();
}
    • 



/**



    

  • Returns true if and only if the underlying class
    • 

  • is a member class.
*
    • 

  • @return 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 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");
}
}
    • 



/**



    

  • Returns true if this is a local class or an anonymous
    • 

  • class.  Returns 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 Class objects representing all
    • 

  • the public classes and interfaces that are members of the class
    • 

  • represented by this 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 Class object has no public member
    • 

  • classes or interfaces.  This method also returns an array of length 0 if
    • 

  • this Class object represents a primitive type, an array
    • 

  • class, or void.
    • 

  • 

    • 

  • @return the array of Class objects representing the public
    • 

  • members of this class
    • 

  • @exception  SecurityException
    • 

  •             If a security manager, s, is present and any of the
    • 

  •             following conditions is met:
*
    • 

  •             
      
*
    

    • 

  •             
    • 

  •  invocation of 
    • 

  •             {@link SecurityManager#checkMemberAccess

    • 

  •             s.checkMemberAccess(this, Member.PUBLIC)} method
    • 

  •             denies access to the classes within this class
*
    • 

  •             
    • 

  •  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
*/
public Class[] getClasses() {
// be very careful not to change the stack depth of this
// checkMemberAccess call for security reasons 
// see java.lang.SecurityManager.checkMemberAccess
checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());



// 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.



Class[] result = (Class[]) java.security.AccessController.doPrivileged

    (new java.security.PrivilegedAction() {

        public Object run() {

        java.util.List list = new java.util.ArrayList();

        Class currentClass = Class.this;

        while (currentClass != null) {

        Class[] members = currentClass.getDeclaredClasses();

        for (int i = 0; i < members.length; i++) {

            if (Modifier.isPublic(members[i].getModifiers())) {

            list.add(members[i]);

            }

        }

        currentClass = currentClass.getSuperclass();

        }

        Class[] empty = {};

        return list.toArray(empty);

    }

    });



return result;




}



/**



    

  • Returns an array containing Field objects reflecting all
    • 

  • the accessible public fields of the class or interface represented by
    • 

  • this Class object.  The elements in the array returned are
    • 

  • not sorted and are not in any particular order.  This method returns an
    • 

  • array of length 0 if the class or interface has no accessible public
    • 

  • fields, or if it represents an array class, a primitive type, or void.
*
    • 

  •  Specifically, if this Class object represents a class,
    • 

  • this method returns the public fields of this class and of all its
    • 

  • superclasses.  If this Class object represents an
    • 

  • interface, this method returns the fields of this interface and of all
    • 

  • its superinterfaces.
*
    • 

  •  The implicit length field for array class is not reflected by this
    • 

  • method. User code should use the methods of class Array to
    • 

  • manipulate arrays.
*
    • 

  •  See The Java Language Specification, sections 8.2 and 8.3.
*
    • 

  • @return the array of Field objects representing the
    • 

  • public fields
    • 

  • @exception  SecurityException
    • 

  •             If a security manager, s, is present and any of the
    • 

  •             following conditions is met:
*
    • 

  •             
      
*
    

    • 

  •             
    • 

  •  invocation of 
    • 

  •             {@link SecurityManager#checkMemberAccess

    • 

  •             s.checkMemberAccess(this, Member.PUBLIC)} denies
    • 

  •             access to the fields within this class
*
    • 

  •             
    • 

  •  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
*/
public Field[] getFields() throws SecurityException {
// be very careful not to change the stack depth of this
// checkMemberAccess call for security reasons 
// see java.lang.SecurityManager.checkMemberAccess
checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
return copyFields(privateGetPublicFields(null));
}



/**



    

  • Returns an array containing Method objects reflecting all
    • 

  • the public member methods of the class or interface represented
    • 

  • by this Class object, including those declared by the class
    • 

  • or interface and those inherited from superclasses and
    • 

  • superinterfaces.  Array classes return all the (public) member methods 
    • 

  • inherited from the Object class.  The elements in the array 
    • 

  • returned are not sorted and are not in any particular order.  This 
    • 

  • method returns an array of length 0 if this Class object
    • 

  • represents a class or interface that has no public member methods, or if
    • 

  • this Class object represents a primitive type or void.
*
    • 

  •  The class initialization method <clinit> is not
    • 

  • included in the returned array. If the class declares multiple public
    • 

  • member methods with the same parameter types, they are all included in
    • 

  • the returned array.
*
    • 

  •  See The Java Language Specification, sections 8.2 and 8.4.
*
    • 

  • @return the array of Method objects representing the
    • 

  • public methods of this class
    • 

  • @exception  SecurityException
    • 

  •             If a security manager, s, is present and any of the
    • 

  •             following conditions is met:
*
    • 

  •             
      
*
    

    • 

  •             
    • 

  •  invocation of 
    • 

  •             {@link SecurityManager#checkMemberAccess

    • 

  •             s.checkMemberAccess(this, Member.PUBLIC)} denies
    • 

  •             access to the methods within this class
*
    • 

  •             
    • 

  •  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
*/
public Method[] getMethods() throws SecurityException {
// be very careful not to change the stack depth of this
// checkMemberAccess call for security reasons 
// see java.lang.SecurityManager.checkMemberAccess
checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
return copyMethods(privateGetPublicMethods());
}



/**



    

  • Returns an array containing Constructor objects reflecting
    • 

  • all the public constructors of the class represented by this
    • 

  • 
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.
*
    • 

  • @return the array containing Method objects for all the
    • 

  • declared public constructors of this class matches the specified
    • 

  • parameterTypes
    • 

  • @exception  SecurityException
    • 

  •             If a security manager, s, is present and any of the
    • 

  •             following conditions is met:
*
    • 

  •             
      
*
    

    • 

  •             
    • 

  •  invocation of 
    • 

  •             {@link SecurityManager#checkMemberAccess

    • 

  •             s.checkMemberAccess(this, Member.PUBLIC)} denies
    • 

  •             access to the constructors within this class
*
    • 

  •             
    • 

  •  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
*/
public Constructor[] getConstructors() throws SecurityException {
// be very careful not to change the stack depth of this
// checkMemberAccess call for security reasons 
// see java.lang.SecurityManager.checkMemberAccess
checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
return copyConstructors(privateGetDeclaredConstructors(true));
}



/**



    

  • Returns a Field object that reflects the specified public
    • 

  • member field of the class or interface represented by this
    • 

  • 
Class object. The name parameter is a
    • 

  • 
String specifying the simple name of the desired field.
*
    • 

  •  The field to be reflected is determined by the algorithm that
    • 

  • follows.  Let C be the class represented by this object:
    • 

      1. 

    1. 

      2. 

    2.  If C declares a public field with the name specified, that is the
      3. 

    3.      field to be reflected.
      4. 

    4. 

      5. 

    5.  If no field was found in step 1 above, this algorithm is applied
      6. 

    6.      recursively to each direct superinterface of C. The direct
      7. 

    7.      superinterfaces are searched in the order they were declared.
      8. 

    8. 

      9. 

    9.  If no field was found in steps 1 and 2 above, and C has a
      10. 

    10.      superclass S, then this algorithm is invoked recursively upon S.
      11. 

    11.      If C has no superclass, then a NoSuchFieldException

      12. 

    12.      is thrown.
      13. 

    13. 
*
      14. 

    14.  See The Java Language Specification, sections 8.2 and 8.3.
      15. 

    15. 

      16. 

    16. @param name the field name
      17. 

    17. @return  the Field object of this class specified by 
      18. 

    18. name
      19. 

    19. @exception NoSuchFieldException if a field with the specified name is
      20. 

    20.              not found.
      21. 

    21. @exception NullPointerException if name is null

      22. 

    22. @exception  SecurityException
      23. 

    23.             If a security manager, s, is present and any of the
      24. 

    24.             following conditions is met:
*
      25. 

    25.             
        
*
      

      26. 

    26.             
      27. 

    27.  invocation of 
      28. 

    28.             {@link SecurityManager#checkMemberAccess

      29. 

    29.             s.checkMemberAccess(this, Member.PUBLIC)} denies
      30. 

    30.             access to the field
*
      31. 

    31.             
      32. 

    32.  the caller's class loader is not the same as or an
      33. 

    33.             ancestor of the class loader for the current class and
      34. 

    34.             invocation of {@link SecurityManager#checkPackageAccess

      35. 

    35.             s.checkPackageAccess()} denies access to the package
      36. 

    36.             of this class
*
      37. 

    37.             
      38. 

    
*
@since JDK1.1
*/
public Field getField(String name)
throws NoSuchFieldException, SecurityException {
// be very careful not to change the stack depth of this
// checkMemberAccess call for security reasons 
// see java.lang.SecurityManager.checkMemberAccess
checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
Field field = getField0(name);
if (field == null) {
    throw new NoSuchFieldException(name);
}
return field;
}



    /**
    


      

    • Returns a Method object that reflects the specified public
      • 

    • member method of the class or interface represented by this
      • 

    • 
Class object. The name parameter is a
      • 

    • 
String specifying the simple name the desired method. The
      • 

    • 
parameterTypes parameter is an array of Class

      • 

    • objects that identify the method's formal parameter types, in declared
      • 

    • order. If parameterTypes is null, it is 
      • 

    • treated as if it were an empty array.
*
      • 

    •  If the name is "<init>"or "<clinit>" a
      • 

    • 
NoSuchMethodException is raised. Otherwise, the method to
      • 

    • be reflected is determined by the algorithm that follows.  Let C be the
      • 

    • class represented by this object:
      • 

        1. 

      1. 

        2. 

      2.  C is searched for any matching methods. If no matching
        3. 

      3.      method is found, the algorithm of step 1 is invoked recursively on
        4. 

      4.      the superclass of C.
        5. 

      5. 

        6. 

      6.  If no method was found in step 1 above, the superinterfaces of C
        7. 

      7.      are searched for a matching method. If any such method is found, it
        8. 

      8.      is reflected.
        9. 

      9. 
*
        10. 

      10. To find a matching method in a class C:  If C declares exactly one
        11. 

      11. public method with the specified name and exactly the same formal
        12. 

      12. parameter types, that is the method reflected. If more than one such
        13. 

      13. method is found in C, and one of these methods has a return type that is
        14. 

      14. more specific than any of the others, that method is reflected;
        15. 

      15. otherwise one of the methods is chosen arbitrarily.
*
        16. 

      16.  See The Java Language Specification, sections 8.2 and 8.4.
*
        17. 

      17. @param name the name of the method
        18. 

      18. @param parameterTypes the list of parameters
        19. 

      19. @return the Method object that matches the specified
        20. 

      20. 
name and parameterTypes

        21. 

      21. @exception NoSuchMethodException if a matching method is not found
        22. 

      22.            or if the name
        23. 

      

          
        										
      
									
      
								
      
																
      
									
      
										
											答										
										
      
											
      

      [color=blue][b]
      
给你推荐2本书：
      


      《Java深度历险》（看看第1、2、5三章） 
      


      《 java reflection in action 》（有一定基础再看）[/b][/color]
      

          
        										
      
									
      
								
      
																
      
									
      
										
											答										
										
      
											
      

      [quote]另外，大家有时间的话，请告诉我一些学Java的途径，我现在老是自己一个人自学，感觉没什么进步[/quote]
      


      [size=large][color=red]我觉得,你可以下载尚学堂的马老师的Java基础视平,看一下看,边看,边动手练习.
      


      我给我一点我的个人建议:
      
第一,不语言要记一定的东西,基础的语法;关键字;语言固定的代码格式;
      
    比如,你要记class类杂个定义,方法杂个定义,怎么创建新对象;
      
第二,在基本语言理解的情况下,要多写小程序;来加强对语言的熟悉与亲切感;以前我在看到抛出一大堆异常后,心里就很不爽,现在喜欢上异常了,因为她会帮助我找到错误的代码行;
      
第三,其实也还是第二点;做项目.小一点的,可以使用java有main的方法的小程序;J2EE方向的,可以使用jsp,jdbc做些信息系统;
      


      总之,要明确理论的重要性与实践的不可或缺!!!![/size]
      


      希望对你有帮助....[/color]
      

          
        										
      
									
      
								
      
																
      
									
      
										
											答										
										
      
											
      逛逛...
          
        										
      
									
      
								
      
																
      
									
      
										
											答										
										
      
											
      我觉得Class不是像Double这样包装double的类，从感性认识可知它包含某个类的信息（如:字段、属性、方法、构造函数），还可以知道它可以用来实例化该类的对象。
      
但是，我们每次调用它的newInstance方法后都能得到一个全新的对象。
      
虽然我们可以这样认为：它面里是直接用对应的对象的类来new出来的。但是，事实上不是这样的。
      
我的猜想如下：它是通过一个字节数组来定义出来的，这个字节数组就是JVM在加载某个.class文件之后得到的[color=red]一段[/color]字节。事实上，我们也可以通过ClassLoader来手动创建Class对象，每一个Class对象里面都有一个ClassLoader，奥秘就在这个ClassLoader里面，它读取.class文件后调用jdk一系列的本地方法来构造一个Class，这个Class就包含.class的全部数据以供他用。
          
        										
      
									
      
								
      
																							
      
																					
      
								
      
									相关推荐