模块  java.base
软件包  java.lang

Class Class<T>

  • 参数类型
    T - 此类对象建模的类的类型。 例如， String.class的类型是Class<String> 。 如果正在建模的类未知，请使用Class<?> 。
    实现的所有接口
    Serializable ， AnnotatedElement ， GenericDeclaration ， Type 
    public final class Class<T>
extends Object
implements Serializable, GenericDeclaration, Type, AnnotatedElement
    类类实例表示正在运行的Java应用程序中的类和接口。 枚举类型是一种类，注释类型是一种接口。 每个数组也属于一个类，该类反映为类对象，由具有相同元素类型和维数的所有数组共享。 原始Java类型（ boolean ， byte ， char ， short ， int ， long ， float ，和double ），以及关键字void也表示为类对象。

    类没有公共构造函数。 而是当类加载器调用defineClass方法之一并传递class文件的字节时，Java虚拟机会自动构造类对象。

    类类的方法暴露了类或接口的许多特征。 大多数特性派生自类加载器传递给Java虚拟机的class文件。 一些特性由运行时的类加载环境决定，例如getModule()返回的模块。

    类类某些方法公开Java源代码中的类或接口的声明是否包含在另一个声明中。 其他方法描述了类或接口如何位于嵌套中 。 nest是一组类和接口，在同一运行时包中，允许相互访问其private成员。 类和接口称为nestmates 。 一个巢穴充当巢主 ，并列举属于巢的其他巢穴; 它们中的每一个又将其记录为嵌套主机。 属于嵌套的类（包括其主机）的类和接口是在生成class文件时确定的，例如，Java编译器通常会将顶级类记录为嵌套的主机，其中其他成员是类，声明包含在顶级类声明中的接口。

    以下示例使用类对象来打印对象的类名： 

         void printClassName(Object obj) {
         System.out.println("The class of " + obj +
                            " is " + obj.getClass().getName());
     }

    也可以使用类文字为指定类型（或void）获取类对象。 参见The Java™ Language Specification的第15.8.2节。 例如：

    System.out.println("The name of class Foo is: "+Foo.class.getName());
    从以下版本开始：
    1.0
    另请参见：
    ClassLoader.defineClass(byte[], int, int) ， Serialized Form

    • 方法摘要

      所有方法  静态方法  实例方法 具体的方法  弃用的方法 
      变量和类型 方法 描述
      <U> 类<? extends U> asSubclass​(类<U> clazz)
      转换此 类对象以表示由指定的类对象表示的类的子类。
      T cast​(Object obj)
      将对象 类为此 类对象表示的类或接口。
      boolean desiredAssertionStatus()
      如果要在调用此方法时初始化，则返回将分配给此类的断言状态。
      static 类<?> forName​(模块 module, String name)
      返回 类给定 binary name给定的模块中。
      static 类<?> forName​(String className)
      返回与具有给定字符串名称的类或接口关联的 类对象。
      static 类<?> forName​(String name, boolean initialize, ClassLoader loader)
      使用给定的类加载器返回与具有给定字符串名称的类或接口关联的 类对象。
      AnnotatedType[] getAnnotatedInterfaces()
      返回 AnnotatedType对象的数组， AnnotatedType对象表示使用类型来指定此 类对象所表示的实体的超 类 。
      AnnotatedType getAnnotatedSuperclass()
      返回一个 AnnotatedType对象，该对象表示使用类型来指定此 类对象所表示的实体的超类。
      <A extends Annotation>
      A      		 getAnnotation​(类<A> annotationClass)
      返回该元素的，如果这样的注释 ，否则返回null指定类型的注释。
      Annotation[] getAnnotations()
      返回此元素上 存在的注释。
      <A extends Annotation>
      A[]      		 getAnnotationsByType​(类<A> annotationClass)
      返回与此元素 关联的注释。
      String getCanonicalName()
      返回Java语言规范定义的基础类的规范名称。
      类<?>[] getClasses()
      返回一个包含 类对象的数组， 类对象表示作为此 类对象所表示的类的成员的所有公共类和接口。
      ClassLoader getClassLoader()
      返回类的类加载器。
      类<?> getComponentType()
      返回表示数组的组件类型的 类 。
      构造器<T> getConstructor​(类<?>... parameterTypes)
      返回一个 构造器对象，该对象反映此 类对象所表示的类的指定公共构造函数。
      构造器<?>[] getConstructors()
      返回一个包含 构造器对象的数组， 构造器对象反映了此 类对象所表示的类的所有公共构造函数。
      <A extends Annotation>
      A      		 getDeclaredAnnotation​(类<A> annotationClass)
      如果 直接存在这样的注释，则返回指定类型的此元素的注释，否则返回null。
      Annotation[] getDeclaredAnnotations()
      返回 直接出现在此元素上的注释。
      <A extends Annotation>
      A[]      		 getDeclaredAnnotationsByType​(类<A> annotationClass)
      如果此类注释 直接存在或 间接存在 ，则返回指定类型的此元素的注释。
      类<?>[] getDeclaredClasses()
      返回 类对象的数组， 类对象反映声明为此 类对象所表示的类的成员的所有类和接口。
      构造器<T> getDeclaredConstructor​(类<?>... parameterTypes)
      返回一个 构造器对象，该对象反映此 类对象所表示的类或接口的指定构造函数。
      构造器<?>[] getDeclaredConstructors()
      返回 构造器对象的数组， 构造器对象反映由此 类对象表示的类声明的所有构造函数。
      字段 getDeclaredField​(String name)
      返回 字段对象，该对象反映此 类对象表示的类或接口的指定声明字段。
      字段[] getDeclaredFields()
      返回 字段对象的数组， 字段对象反映由此 类对象表示的类或接口声明的所有字段。
      方法 getDeclaredMethod​(String name, 类<?>... parameterTypes)
      返回 方法对象，该对象反映此 类对象表示的类或接口的指定声明方法。
      方法[] getDeclaredMethods()
      返回一个包含 方法对象的数组， 方法对象反映此 类对象表示的类或接口的所有已声明方法，包括public，protected，default（package）访问和私有方法，但不包括继承的方法。
      类<?> getDeclaringClass()
      如果此 类对象表示的类或接口是另一个类的成员，则返回表示声明它的类的 类对象。
      类<?> getEnclosingClass()
      返回基础类的直接封闭类。
      构造器<?> getEnclosingConstructor()
      如果此类对象表示构造函数中的本地或匿名类，则返回表示基础类的直接封闭构造函数的构造器对象。
      方法 getEnclosingMethod()
      如果此类对象表示方法中的本地或匿名类，则返回方法对象，该对象表示基础类的直接封闭方法。
      T[] getEnumConstants()
      返回此枚举类的元素，如果此Class对象不表示枚举类型，则返回null。
      字段 getField​(String name)
      返回 字段对象，该对象反映此 类对象表示的类或接口的指定公共成员字段。
      字段[] getFields()
      返回一个包含 字段对象的数组， 字段对象反映此 类对象所表示的类或接口的所有可访问公共字段。
      Type[] getGenericInterfaces()
      返回表示由此对象表示的类或接口直接实现的接口的 Type 。
      Type getGenericSuperclass()
      返回 Type表示此所表示的实体（类，接口，基本类型或void）的直接超类 类 。
      类<?>[] getInterfaces()
      返回由此对象表示的类或接口直接实现的接口。
      方法 getMethod​(String name, 类<?>... parameterTypes)
      返回 方法对象，该对象反映此 类对象表示的类或接口的指定公共成员方法。
      方法[] getMethods()
      返回一个包含 方法对象的数组， 方法对象反映此 类对象所表示的类或接口的所有公共方法，包括由类或接口声明的那些以及从超类和超接口继承的那些。
      int getModifiers()
      返回此类或接口的Java语言修饰符，以整数编码。
      模块 getModule()
      返回此类或接口所属的模块。
      String getName()
      返回此 类对象表示的实体名称（类，接口，数组类，基本类型或void），作为 String 。
      类<?> getNestHost()
      返回 类对象所代表的类或接口所属的 nest的嵌套主机。
      类<?>[] getNestMembers()
      返回一个包含 类对象的数组， 类对象表示作为此 类对象所代表的类或接口所属的嵌套成员的所有类和接口。
      软件包 getPackage()
      获取此类的包。
      String getPackageName()
      返回完全限定的包名称。
      ProtectionDomain getProtectionDomain()
      返回 ProtectionDomain 。
      URL getResource​(String name)
      查找具有给定名称的资源。
      InputStream getResourceAsStream​(String name)
      查找具有给定名称的资源。
      Object[] getSigners()
      获取此类的签名者。
      String getSimpleName()
      返回源代码中给出的基础类的简单名称。
      类<? super T> getSuperclass()
      返回 类表示此所表示的实体（类，接口，基本类型或void）的直接超类 类 。
      String getTypeName()
      返回此类型名称的信息字符串。
      TypeVariable<类<T>>[] getTypeParameters()
      返回的数组 TypeVariable对象表示通过此表示的一般声明声明的类型变量 GenericDeclaration目的，在声明的顺序。
      boolean isAnnotation()
      如果此 类对象表示注释类型，则返回true。
      boolean isAnnotationPresent​(类<? extends Annotation> annotationClass)
      如果此元素上 存在指定类型的注释，则返回true，否则返回false。
      boolean isAnonymousClass()
      当且仅当基础类是匿名类时，返回 true 。
      boolean isArray()
      确定此 类对象是否表示数组类。
      boolean isAssignableFrom​(类<?> cls)
      确定此 类对象表示的类或接口是否与指定的 类参数表示的类或接口相同，或者是它的超类或超接口。
      boolean isEnum()
      当且仅当此类在源代码中声明为枚举时返回true。
      boolean isInstance​(Object obj)
      确定指定的 Object是否与此 类表示的对象分配兼容。
      boolean isInterface()
      确定指定的 类对象是否表示接口类型。
      boolean isLocalClass()
      当且仅当底层类是本地类时，返回 true 。
      boolean isMemberClass()
      当且仅当基础类是成员类时，返回 true 。
      boolean isNestmateOf​(类<?> c)
      确定给定的 类是否是此 类对象所表示的类或接口的 类 。
      boolean isPrimitive()
      确定指定的 类对象是否表示基本类型。
      boolean isSynthetic()
      如果此类是合成类，则返回true ; 否则返回false 。
      T newInstance()
      已过时。
      此方法传播由Nullary构造函数抛出的任何异常，包括已检查的异常。
      String toGenericString()
      返回描述此 类的字符串，包括有关修饰符和类型参数的信息。
      String toString()
      将对象转换为字符串。

    • 方法详细信息

      • toString

        public String toString()
        将对象转换为字符串。 字符串表示形式是字符串“class”或“interface”，后跟一个空格，然后是getName返回的格式的类的完全限定名。 如果此类对象表示基本类型，则此方法返回基本类型的名称。 如果此类对象表示void，则此方法返回“void”。 如果此类对象表示数组类型，则此方法返回“class”，后跟getName 。
        重写：
        toString在 Object类
        结果
        此类对象的字符串表示形式。

      • toGenericString

        public String toGenericString()
        返回描述此类的字符串，包括有关修饰符和类型参数的信息。 该字符串格式类型修饰符列表，如果有的话，后面的那种类型（基本类型和空字符串class ， 枚举 ， interface ，或@ interface ，如适用），其次是类型的名称，然后是angle-bracketed逗号分隔的类型类型参数列表（如果有）。 空格用于将修饰符彼此分开，并将任何修饰符与类型类型分开。 修饰符以规范顺序出现。 如果没有类型参数，则省略类型参数列表。 对于数组类型，字符串以类型名称开头，后跟以角度括起来的逗号分隔的类型参数列表（如果有），后跟[]字符序列，每个数组维度一组括号。

        注意，由于正在生成关于类型的运行时表示的信息，因此可能存在不在源代码上存在或在源代码上非法的修饰符。

        结果
        描述此 类的字符串，包括有关修饰符和类型参数的信息
        从以下版本开始：
        1.8

      • forName

        public static 类<?> forName​(String className)
                        throws ClassNotFoundException
        返回与具有给定字符串名称的类或接口关联的类对象。 调用此方法相当于：
        Class.forName(className, true, currentLoader)
        其中currentLoader表示当前类的定义类加载器。

        例如，以下代码片段返回名为java.lang.Thread的类的运行时类描述符：

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

        调用forName("X")会导致名为X的类被初始化。

        参数
        className - 所需类的完全限定名称。
        结果
        具有指定名称的类的 类对象。
        异常
        LinkageError - 如果链接失败
        ExceptionInInitializerError - 如果此方法引发的初始化失败
        ClassNotFoundException - 如果无法找到班级

      • forName

        public static 类<?> forName​(String name,
                               boolean initialize,
                               ClassLoader loader)
                        throws ClassNotFoundException
        使用给定的类加载器返回与具有给定字符串名称的类或接口关联的类对象。 给定类或接口的完全限定名称（采用getName返回的相同格式），此方法尝试查找，加载和链接类或接口。 指定的类加载器用于加载类或接口。 如果参数loader为null，则通过引导类加载器加载该类。 仅当initialize参数为true并且之前尚未初始化时，才会初始化true 。

        如果name表示基本类型或void，则将尝试在未命名的包中找到用户定义的类，其名称为name 。 因此，此方法不能用于获取表示基本类型或void的任何类对象。

        如果name表示数组类，则加载数组类的组件类型但不进行初始化。

        例如，在实例方法中，表达式为：

        Class.forName("Foo")
        相当于：
        Class.forName("Foo", true, this.getClass().getClassLoader())
        请注意，此方法会抛出与Java语言规范的第12.2节，第12.3节和第12.4节中指定的加载，链接或初始化相关的错误。 请注意，此方法不会检查其调用者是否可以访问所请求的类。
        参数
        name - 所需类的完全限定名称
        initialize - 如果true该类将被初始化。 请参见Java语言规范的第12.4节。
        loader - 必须从中加载类的类加载器
        结果
        表示所需类的类对象
        异常
        LinkageError - 如果链接失败
        ExceptionInInitializerError - 如果此方法引发的初始化失败
        ClassNotFoundException - 如果指定的类加载器无法找到该类
        SecurityException - 如果存在安全管理器，并且loader是null ，并且调用者的类加载器不是null ，并且调用者没有RuntimePermission ("getClassLoader")
        从以下版本开始：
        1.2
        另请参见：
        forName(String) ， ClassLoader

      • forName

        public static 类<?> forName​(模块 module,
                               String name)
        返回类给定binary name给定的模块中。

        此方法尝试定位，加载和链接类或接口。 它不运行类初始化程序。 如果找不到该类，则此方法返回null 。

        如果给定模块的类加载器定义了其他模块，并且给定名称是在不同模块中定义的类，则此方法在加载类后返回null 。

        此方法不检查其调用者是否可以访问所请求的类。

        API Note:
        此方法在失败时返回null而不是抛出ClassNotFoundException ，如forName(String, boolean, ClassLoader)方法所做的那样 。 如果调用者在另一个模块中加载一个类，则安全检查是基于堆栈的权限检查。
        参数
        模块 - 模块
        name - 该 课程的binary name
        结果
        类给定模块中定义的给定名称的对象; null如果找不到。
        异常
        NullPointerException - 如果给定的模块或名称是 null
        LinkageError - 如果链接失败
        SecurityException -
        • 如果调用者不是指定的模块，则拒绝RuntimePermission("getClassLoader")权限; 要么
        • 访问模块内容被拒绝。 例如，当类加载器调用ModuleReader.open(String)以读取模块中类文件的字节时，将执行权限检查。
        从以下版本开始：
        9

      • newInstance

        @Deprecated(since="9")
public T newInstance()
              throws InstantiationException,
                     IllegalAccessException
        Deprecated.
        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 Constructor.newInstance method avoids this problem by wrapping any exception thrown by the constructor in a (checked) InvocationTargetException.

        The call 

        
 clazz.newInstance()
        can be replaced by 
        
 clazz.getDeclaredConstructor().newInstance()
        The latter sequence of calls is inferred to be able to throw the additional exception types InvocationTargetException and NoSuchMethodException. Both of these exception types are subclasses of ReflectiveOperationException.
        创建此类对象表示的类的新实例。 该类实例化为new带有空参数列表的表达式。 如果尚未初始化，则初始化该类。
        结果
        由此对象表示的类的新分配实例。
        异常
        IllegalAccessException - 如果无法访问该类或其无效构造函数。
        InstantiationException - 如果此类表示抽象类，接口，数组类，基元类型或void; 或者如果该类没有无效的构造函数; 或者如果实例化由于其他原因而失败。
        ExceptionInInitializerError - 如果此方法引发的初始化失败。
        SecurityException - 如果存在安全管理器 s ，并且调用者的类加载器与当前类的类加载器不同或是其祖先，则调用 s.checkPackageAccess()将拒绝访问此类的包。

      • isInstance

        public boolean isInstance​(Object obj)
        确定指定的Object是否与此类表示的对象分配兼容。 此方法是Java语言instanceof运算符的动态等效项。 该方法返回true如果指定Object参数为非空并且可以转换为通过此表示的引用类型类对象不提高一个ClassCastException.它返回false否则。

        具体来说，如果此类对象表示声明的类，如果指定的Object参数是所表示的类（或其任何子类）的实例，则此方法返回true ; 否则返回false 。 如果此类对象表示数组类，如果指定的Object参数可以通过标识转换或扩展引用转换转换为数组类的对象，则此方法返回true ; 否则返回false 。 如果此类对象表示接口，则如果指定的Object参数的类或任何超类实现此接口，则此方法返回true ; 否则返回false 。 如果此类对象表示基本类型，则此方法返回false 。

        参数
        obj - 要检查的对象
        结果
        如果 obj是 obj的实例， obj true
        从以下版本开始：
        1.1

      • isAssignableFrom

        public boolean isAssignableFrom​(类<?> cls)
        确定此类对象表示的类或接口是否与指定的类参数表示的类或接口相同，或者是它的超类或超接口。 如果是这样，它返回true ; 否则返回false 。 如果此类对象表示基本类型，如果指定的类参数恰好是此类对象，则此方法返回true ; 否则返回false 。

        具体来说，此方法测试是否可以通过标识转换或扩展引用转换将指定的类参数表示的类型转换为此类对象表示的类型。 有关详细信息 ，请参阅Java语言规范 ，第5.1.1和5.1.4节。

        参数
        cls - 要检查的 类对象
        结果
        boolean值，指示是否可以将类型为 cls对象分配给此类的对象
        异常
        NullPointerException - 如果指定的Class参数为null。
        从以下版本开始：
        1.1

      • isInterface

        public boolean isInterface()
        确定指定的 类对象是否表示接口类型。
        结果
        true如果此对象表示接口; 否则为false 。

      • isArray

        public boolean isArray()
        确定此 类对象是否表示数组类。
        结果
        true如果此对象表示数组类; 否则为false 。
        从以下版本开始：
        1.1

      • isPrimitive

        public boolean isPrimitive()
        确定指定的类对象是否表示基本类型。

        有九个预定义的类对象来表示八种基本类型和void。 这些是由Java虚拟机创建，并且具有相同的名称为他们所代表的基本类型，即boolean ， byte ， char ， short ， int ， long ， float和double 。

        这些对象只能通过以下公共静态最终变量访问，并且是此方法返回true的唯一类对象。

        结果
        当且仅当此类表示基本类型时才返回true
        从以下版本开始：
        1.1
        另请参见：
        Boolean.TYPE ， Character.TYPE ， Byte.TYPE ， Short.TYPE ， Integer.TYPE ， Long.TYPE ， Float.TYPE ， Double.TYPE ， Void.TYPE

      • isAnnotation

        public boolean isAnnotation()
        如果此类对象表示注释类型，则返回true。 请注意，如果此方法返回true，则isInterface()也将返回true，因为所有注释类型也是接口。
        结果
        true如果此类对象表示注释类型; 否则为false
        从以下版本开始：
        1.5

      • isSynthetic

        public boolean isSynthetic()
        如果此类是合成类，则返回true ; 否则返回false 。
        结果
        true当且仅当此类是Java语言规范定义的合成类时。
        从以下版本开始：
        1.5
        See The Java™ Language Specification:
        13.1二进制形式

      • getName

        public String getName()
        返回此类对象表示的实体名称（类，接口，数组类，基本类型或void），作为String 。

        如果此类对象表示不是数组类型的引用类型，则返回该类的二进制名称，如The Java™ Language Specification所指定。

        如果此类对象表示基本类型或void，则返回的名称是String等于与基本类型或void对应的Java语言关键字。

        如果此类对象表示一个数组类，则该名称的内部形式由元素类型的名称组成，前面是一个或多个表示数组嵌套深度的“ [ ”字符。 元素类型名称的编码如下：

        Element types and encodings
        Element Type Encoding
        boolean Z
        byte B
        char C
        class or interface Lclassname;
        double D
        float F
        int I
        long J
        short S

        类或接口名称classname是上面指定的类的二进制名称。

        例子： 

         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"
        结果
        此对象表示的类或接口的名称。

      • getClassLoader

        public ClassLoader getClassLoader()
        返回类的类加载器。 某些实现可能使用null来表示引导类加载器。 如果此类由引导类加载器加载，则此方法将在此类实现中返回null。

        如果此对象表示基本类型或void，则返回null。

        结果
        加载此对象表示的类或接口的类加载器。
        异常
        SecurityException - 如果存在安全管理器，并且调用者的类加载器不是null ，并且与请求类加载器的类的类加载器的祖先不同，并且调用者没有RuntimePermission ("getClassLoader")
        另请参见：
        ClassLoader ， SecurityManager.checkPermission(java.security.Permission) ， RuntimePermission

      • getModule

        public 模块 getModule()
        返回此类或接口所属的模块。 如果此类表示数组类型，则此方法返回元素类型的模块 。 如果此类表示基本类型或void，则返回java.base模块的模块对象。 如果此类位于未命名的模块中，则返回 模块的类加载器的unnamed 模块 。
        结果
        此类或接口所属的模块
        从以下版本开始：
        9

      • getTypeParameters

        public TypeVariable<类<T>>[] getTypeParameters()
        返回的数组TypeVariable对象表示通过此表示的一般声明声明的类型变量GenericDeclaration目的，在声明的顺序。 如果基础泛型声明未声明类型变量，则返回长度为0的数组。
        Specified by:
        getTypeParameters在接口 GenericDeclaration
        结果
        一个 TypeVariable对象的数组，表示此泛型声明声明的类型变量
        异常
        GenericSignatureFormatError - 如果此通用声明的通用签名不符合 The Java™ Virtual Machine Specification中指定的格式
        从以下版本开始：
        1.5

      • getSuperclass

        public 类<? super T> getSuperclass()
        返回表示此类表示的实体的直接超类（类，接口，基本类型或void）的类 。 如果此类表示Object类，接口，基本类型或void，则返回null。 如果此对象表示数组类，则返回表示Object类的类对象。
        结果
        此对象表示的类的直接超类

      • getGenericSuperclass

        public Type getGenericSuperclass()
        返回Type表示此所表示的实体（类，接口，基本类型或void）的直接超类类 。

        如果超类是参数化类型，则返回的Type对象必须准确反映源代码中使用的实际类型参数。 如果之前尚未创建超类，则创建表示超类的参数化类型。 有关参数化类型的创建过程的语义，请参阅ParameterizedType的声明。 如果此类表示Object类，接口，基本类型或void，则返回null。 如果此对象表示数组类，则返回表示Object类的类对象。

        结果
        此对象表示的类的直接超类
        异常
        GenericSignatureFormatError - 如果泛型类签名不符合 The Java™ Virtual Machine Specification中指定的格式
        TypeNotPresentException - 如果泛型超类引用不存在的类型声明
        MalformedParameterizedTypeException - 如果泛型超类引用无法以任何原因实例化的参数化类型
        从以下版本开始：
        1.5

      • getPackage

        public 软件包 getPackage()
        获取此类的包。

        如果此类表示数组类型，基本类型或void，则此方法返回null 。

        结果
        这个类的包。

      • getPackageName

        public String getPackageName()
        返回完全限定的包名称。

        如果此类是顶级类，则此方法返回该类所属的包的完全限定名称，如果该类位于未命名的包中，则返回空字符串。

        如果该类是一个成员的类，则此方法等效于调用getPackageName()上enclosing class 。

        如果该类是local class或anonymous class ，则此方法等效于调用getPackageName()上declaring class的的enclosing method或enclosing constructor 。

        如果此类表示数组类型，则此方法返回元素类型的包名称。 如果此类表示基本类型或void，则返回包名“ java.lang ”。

        结果
        完全限定的包名称
        从以下版本开始：
        9
        See The Java™ Language Specification:
        6.7完全合格的名称

      • getInterfaces

        public 类<?>[] getInterfaces()
        返回由此对象表示的类或接口直接实现的接口。

        如果此对象表示类，则返回值是一个数组，其中包含表示该类直接实现的所有接口的对象。 数组中接口对象的顺序对应于此对象所表示的类的声明的implements子句中的接口名称的顺序。 例如，鉴于声明：

        class Shimmer implements FloorWax, DessertTopping { ... }
        假设的值s是实例Shimmer ; 表达式的值：
        s.getClass().getInterfaces()[0]
        是类对象，表示接口FloorWax ; 和价值：
        s.getClass().getInterfaces()[1]
        是类对象，表示接口DessertTopping 。

        如果此对象表示接口，则该数组包含表示由接口直接扩展的所有接口的对象。 数组中接口对象的顺序对应于此对象表示的接口声明的extends子句中接口名称的顺序。

        如果此对象表示不实现接口的类或接口，则该方法返回长度为0的数组。

        如果此对象表示基本类型或void，则该方法返回长度为0的数组。

        如果此类对象表示阵列类型， Cloneable顺序返回接口Cloneable和java.io.Serializable 。

        结果
        由此类直接实现的接口数组

      • getGenericInterfaces

        public Type[] getGenericInterfaces()
        返回表示由此对象表示的类或接口直接实现的接口的Type 。

        如果超接口是参数化类型，则Type返回的Type对象必须准确反映源代码中使用的实际类型参数。 如果之前尚未创建，则创建表示每个超级接口的参数化类型。 有关参数化类型的创建过程的语义，请参阅ParameterizedType的声明。

        如果此对象表示类，则返回值是一个数组，其中包含表示该类直接实现的所有接口的对象。 数组中接口对象的顺序对应于此对象所表示的类的声明的implements子句中的接口名称的顺序。

        如果此对象表示接口，则该数组包含表示由接口直接扩展的所有接口的对象。 数组中接口对象的顺序对应于此对象表示的接口声明的extends子句中接口名称的顺序。

        如果此对象表示不实现接口的类或接口，则该方法返回长度为0的数组。

        如果此对象表示基本类型或void，则该方法返回长度为0的数组。

        如果此类对象表示阵列类型， Cloneable顺序返回接口Cloneable和java.io.Serializable 。

        结果
        由此类直接实现的接口数组
        异常
        GenericSignatureFormatError - 如果泛型类签名不符合 The Java™ Virtual Machine Specification中指定的格式
        TypeNotPresentException - 如果任何通用超接口引用了不存在的类型声明
        MalformedParameterizedTypeException - 如果任何通用超接口引用无法以任何原因实例化的参数化类型
        从以下版本开始：
        1.5

      • getComponentType

        public 类<?> getComponentType()
        返回表示数组的组件类型的类 。 如果此类不表示数组类，则此方法返回null。
        结果
        类表示 类的组件类型（如果此类是数组）
        从以下版本开始：
        1.1
        另请参见：
        Array

      • getModifiers

        public int getModifiers()
        返回此类或接口的Java语言修饰符，以整数编码。 修饰符由Java虚拟机的常数为public ， protected ， private ， final ， static ， abstract和interface ; 它们应该使用Modifier类的方法解码。

        如果底层类是一个数组类，则其public ， private和protected改性剂是相同的组分的类型。 如果此类表示基本类型或void，则其public修饰符始终为true ，其protected和private修饰符始终为false 。 如果此对象表示数组类，基本类型或void，则其final修饰符始终为true ，其界面修饰符始终为false 。 其他修饰符的值不是由本规范确定的。

        修饰符编码在Java虚拟机规范表4.1中定义。

        结果
        int表示 int的修饰符
        从以下版本开始：
        1.1
        另请参见：
        Modifier

      • getSigners

        public Object[] getSigners()
        获取此类的签名者。
        结果
        此类的签名者，如果没有签名者则为null。 特别是，如果此对象表示基本类型或void，则此方法返回null。
        从以下版本开始：
        1.1

      • getEnclosingMethod

        public 方法 getEnclosingMethod()
                          throws SecurityException
        如果此类对象表示方法中的本地或匿名类，则返回方法对象，该对象表示基础类的直接封闭方法。 否则返回null 。 特别是，如果基础类是由类型声明，实例初始化程序或静态初始化程序直接包含的本地或匿名类，则此方法返回null 。
        结果
        如果该类是本地或匿名类，则为基础类的直接封闭方法; 否则null 。
        异常
        SecurityException - 如果存在安全管理器s且满足以下任一条件：
        • 调用者的类加载器与封闭类的类加载器不同，并且调用s.checkPermission方法和RuntimePermission("accessDeclaredMembers")拒绝访问封闭类中的方法
        • 调用者的类加载器与封闭类的类加载器不同或是祖先，并且s.checkPackageAccess()的调用拒绝访问封闭类的包
        从以下版本开始：
        1.5

      • getEnclosingConstructor

        public 构造器<?> getEnclosingConstructor()
                                       throws SecurityException
        如果此类对象表示构造函数中的本地或匿名类，则返回构造器对象，该对象表示基础类的直接封闭构造函数。 否则返回null 。 特别是，如果基础类是由类型声明，实例初始化程序或静态初始化程序直接包含的本地或匿名类，则此方法返回null 。
        结果
        如果该类是本地或匿名类，则为基础类的直接封闭构造函数; 否则null 。
        异常
        SecurityException - 如果存在安全管理器s且满足以下任一条件：
        • 调用者的类加载器与封闭类的类加载器不同，并且调用s.checkPermission方法， RuntimePermission("accessDeclaredMembers")拒绝访问封闭类中的构造函数
        • 调用者的类加载器与封闭类的类加载器不同或是祖先，并且s.checkPackageAccess()的调用拒绝访问封闭类的包
        从以下版本开始：
        1.5

      • getDeclaringClass

        public 类<?> getDeclaringClass()
                           throws SecurityException
        如果此类对象表示的类或接口是另一个类的成员，则返回表示声明它的类的类对象。 如果此类或接口不是任何其他类的成员，则此方法返回null。 如果此类对象表示数组类，基本类型或void，则此方法返回null。
        结果
        这个类的声明类
        异常
        SecurityException - 如果存在安全管理器 s ，并且调用者的类加载器与声明类的类加载器不同或者是祖先，并且 s.checkPackageAccess()的调用拒绝访问声明类的包
        从以下版本开始：
        1.1

      • getEnclosingClass

        public 类<?> getEnclosingClass()
                           throws SecurityException
        返回基础类的直接封闭类。 如果底层类是顶级类，则此方法返回null 。
        结果
        基础类的直接封闭类
        异常
        SecurityException - 如果存在安全管理器 s ，并且调用者的类加载器与封闭类的类加载器不同或者是祖先，并且调用 s.checkPackageAccess()拒绝访问封闭类的包
        从以下版本开始：
        1.5

      • getSimpleName

        public String getSimpleName()
        返回源代码中给出的基础类的简单名称。 如果基础类是匿名的，则返回空字符串。

        数组的简单名称是附加了“[]”的组件类型的简单名称。 特别是组件类型为匿名的数组的简单名称是“[]”。

        结果
        底层类的简单名称
        从以下版本开始：
        1.5

      • getTypeName

        public String getTypeName()
        返回此类型名称的信息字符串。
        Specified by:
        getTypeName在接口 Type
        结果
        这种类型名称的信息字符串
        从以下版本开始：
        1.8

      • getCanonicalName

        public String getCanonicalName()
        返回Java语言规范定义的基础类的规范名称。 如果基础类没有规范名称（即，如果它是本地或匿名类或其组件类型没有规范名称的数组），则返回null。
        结果
        基础类的规范名称（如果存在），否则为 null 。
        从以下版本开始：
        1.5

      • isAnonymousClass

        public boolean isAnonymousClass()
        当且仅当基础类是匿名类时，返回 true 。
        结果
        true当且仅当此类是匿名类时。
        从以下版本开始：
        1.5

      • isLocalClass

        public boolean isLocalClass()
        当且仅当基础类是本地类时，返回 true 。
        结果
        true当且仅当此类是本地类时。
        从以下版本开始：
        1.5

      • isMemberClass

        public boolean isMemberClass()
        当且仅当基础类是成员类时，返回 true 。
        结果
        true当且仅当此类是成员类时。
        从以下版本开始：
        1.5

      • getClasses

        public 类<?>[] getClasses()
        返回一个数组，其中包含类对象，这些对象表示作为此类对象所表示的类的成员的所有公共类和接口。 这包括从超类继承的公共类和接口成员，以及由类声明的公共类和接口成员。 如果此类对象没有公共成员类或接口，则此方法返回长度为0的数组。 如果此类对象表示基本类型，数组类或void，则此方法还返回长度为0的数组。
        结果
        类对象的数组，表示 类的公共成员
        异常
        SecurityException - 如果存在安全管理器 s ，并且调用者的类加载器与当前类的类加载器不同或是其祖先，则调用 s.checkPackageAccess()将拒绝访问此类的包。
        从以下版本开始：
        1.1

      • getFields

        public 字段[] getFields()
                  throws SecurityException
        返回一个包含字段对象的数组， 字段对象反映此类对象所表示的类或接口的所有可访问公共字段。

        如果此类对象表示没有可访问的公共字段的类或接口，则此方法返回长度为0的数组。

        如果此类对象表示一个类，则此方法返回该类及其所有超类和超接口的公共字段。

        如果此类对象表示接口，则此方法返回接口及其所有超接口的字段。

        如果此类对象表示数组类型，基本类型或void，则此方法返回长度为0的数组。

        返回数组中的元素未排序，并且不按任何特定顺序排列。

        结果
        表示公共字段的 字段对象的数组
        异常
        SecurityException - 如果存在安全管理器 s ，并且调用者的类加载器与当前类的类加载器不同或是其祖先，则调用 s.checkPackageAccess()将拒绝访问此类的包。
        从以下版本开始：
        1.1
        See The Java™ Language Specification:
        8.2集体成员，8.3现场声明

      • getMethods

        public 方法[] getMethods()
                    throws SecurityException
        返回一个包含方法对象的数组， 方法对象反映此类对象所表示的类或接口的所有公共方法，包括由类或接口声明的那些以及从超类和超接口继承的那些。

        如果此类对象表示一个数组类型，则返回的阵列具有方法对于每个由阵列类型从继承的公共方法对象Object 。 它不包含方法对象为clone() 。

        如果此类对象表示接口，则返回的数组不包含Object任何隐式声明的方法。 因此，如果在此接口或其任何超接口中未显式声明任何方法，则返回的数组的长度为0.（请注意，表示类的类对象始终具有公共方法，继承自Object ）

        返回的数组永远不包含名称为“ <init> ”或“ <clinit> ”的方法。

        返回数组中的元素未排序，并且不按任何特定顺序排列。

        通常，结果按照以下4步算法计算。 设C是此类对象表示的类或接口：

        1. 方法联合包括：
          1. C声明了getDeclaredMethods()返回的公共实例和静态方法，并过滤为仅包含公共方法。
          2. 如果C是Object以外的类，则包括在C的超类上递归调用此算法的结果。
          3. 包括在C的所有直接超接口上递归调用此算法的结果，但仅包括实例方法。
        2. 来自步骤1的联合被划分为具有相同签名（名称，参数类型）和返回类型的方法的子集。
        3. 在每个这样的子集内，仅选择最具体的方法。 设方法M是来自具有相同签名和返回类型的一组方法的方法。 如果在同一组中没有这样的方法N！= M，则M是最具体的，使得N比M更具特异性.N如果出现以下情况，则N比M更具体：
          1. N由类声明，M由接口声明; 要么
          2. N和M都是由类或两者通过接口声明的，并且N的声明类型与M的声明类型相同或者是M的声明类型的子类型（显然，如果M和N的声明类型是相同类型，则M和N是相同的方法） 。
        4. 该算法的结果是来自步骤3的所有选定方法的并集。
        API Note:
        在类中可能有多个具有特定名称和参数类型的方法，因为虽然Java语言禁止类声明具有相同签名但返回类型不同的多个方法，但Java虚拟机却没有。 虚拟机中增加的灵活性可用于实现各种语言功能。 例如，协变返回可以用bridge methods实现; 桥接方法和重写方法将具有相同的签名但返回类型不同。
        结果
        方法对象的数组，表示 方法的公共方法
        异常
        SecurityException - 如果存在安全管理器 s ，并且调用者的类加载器与当前类的类加载器不同或是其祖先，则调用 s.checkPackageAccess()将拒绝访问此类的包。
        从以下版本开始：
        1.1
        See The Java™ Language Specification:
        8.2类成员，8.4方法声明

      • getConstructors

        public 构造器<?>[] getConstructors()
                                 throws SecurityException
        返回一个包含构造器对象的数组， 构造器对象反映了此类对象所表示的类的所有公共构造函数。 如果类没有公共构造函数，或者类是数组类，或者类反映了基本类型或void，则返回长度为0的数组。 请注意，虽然此方法返回Constructor<T>对象的数组（此类中的构造函数数组），但此方法的返回类型为Constructor<?>[]而不是预期的Constructor<T>[] 。 这个信息量较少的返回类型是必要的，因为从此方法返回后，可以修改数组以保存不同类的构造器对象，这将违反Constructor<T>[]的类型保证。
        结果
        构造器对象的数组，表示 构造器的公共构造函数
        异常
        SecurityException - 如果存在安全管理器 s ，并且调用者的类加载器与当前类的类加载器不同或是其祖先，则调用 s.checkPackageAccess()将拒绝访问此类的包。
        从以下版本开始：
        1.1

      • getField

        public 字段 getField​(String name)
               throws NoSuchFieldException,
                      SecurityException
        返回字段对象，该对象反映此类对象表示的类或接口的指定公共成员字段。 name参数是String指定所需字段的简单名称。

        要反映的字段由下面的算法确定。 设C为此对象表示的类或接口：

        1. 如果C声明一个具有指定名称的公共字段，那就是要反映的字段。
        2. 如果在上面的步骤1中没有找到字段，则该算法递归地应用于C的每个直接超接口。直接超接口按它们被声明的顺序搜索。
        3. 如果在上面的步骤1和2中没有找到字段，并且C具有超类S，则在S上递归调用该算法。如果C没有超类，则抛出NoSuchFieldException 。

        如果此类对象表示数组类型，则此方法找不到数组类型的length字段。

        参数
        name - 字段名称
        结果
        由 name指定的 name的 字段对象
        异常
        NoSuchFieldException - 如果找不到具有指定名称的字段。
        NullPointerException - 如果 name是 null
        SecurityException - 如果存在安全管理器 s ，并且调用者的类加载器与当前类的类加载器不同或是其祖先，则调用 s.checkPackageAccess()将拒绝访问此类的包。
        从以下版本开始：
        1.1
        See The Java™ Language Specification:
        8.2集体成员，8.3现场声明

      • getMethod

        public 方法 getMethod​(String name,
                        类<?>... parameterTypes)
                 throws NoSuchMethodException,
                        SecurityException
        返回一个方法对象，该对象反映此类对象所表示的类或接口的指定公共成员方法。 name参数是String指定所需方法的简单名称。 parameterTypes参数是一个类对象的数组，以声明的顺序标识方法的形式参数类型。 如果parameterTypes是null ，则将其视为空数组。

        如果此类对象表示数组类型，则该方法找到以阵列型从继承的任何公有方法Object除了方法clone() 。

        如果此类对象表示接口，则此方法未找到Object任何隐式声明的方法。 因此，如果在此接口或其任何超接口中未显式声明任何方法，则此方法找不到任何方法。

        此方法未找到名称为“ <init> ”或“ <clinit> ”的任何方法。

        通常，要反映的方法由随后的4步算法确定。 设C为此类对象表示的类或接口：

        1. 方法联合包括：
          1. C声明了getDeclaredMethods()返回的公共实例和静态方法，并过滤为仅包含与给定name和parameterTypes匹配的公共方法
          2. 如果C是Object以外的类，则包括在C的超类上递归调用此算法的结果。
          3. 包括在C的所有直接超接口上递归调用此算法的结果，但仅包括实例方法。
        2. 此联合被分区为具有相同返回类型的方法子集（步骤1中的方法选择也保证它们具有相同的方法名称和参数类型）。
        3. 在每个这样的子集内，仅选择最具体的方法。 设方法M是来自具有相同VM签名（返回类型，名称，参数类型）的一组方法的方法。 如果在同一组中没有这样的方法N！= M，则M是最具体的，使得N比M更具特异性.N如果出现以下情况，则N比M更具体：
          1. N由类声明，M由接口声明; 要么
          2. N和M都是由类或两者通过接口声明的，并且N的声明类型与M的声明类型相同或者是M的声明类型的子类型（显然，如果M和N的声明类型是相同类型，则M和N是相同的方法） 。
        4. 该算法的结果是从步骤3中所有选定方法中具有最特定返回类型的方法中任意选择的。设R是来自步骤3中所有选定方法的集合的方法M的返回类型.M是一种方法最具体的返回类型，如果没有这样的方法N！= M来自同一组，具有返回类型S！= R，使得S是由R.class确定的R的子类型。 isAssignableFrom(java.lang.Class<?>) （S.class）。
        API Note:
        在类中可能有多个匹配名称和参数类型的方法，因为虽然Java语言禁止类声明具有相同签名但返回类型不同的多个方法，但Java虚拟机却没有。 虚拟机中增加的灵活性可用于实现各种语言功能。 例如，协变返回可以用bridge methods实现; 桥接方法和重写方法将具有相同的签名但返回类型不同。 此方法将返回覆盖方法，因为它具有更具体的返回类型。
        参数
        name - 方法的名称
        parameterTypes - 参数列表
        结果
        与指定的 name和 parameterTypes匹配的 方法对象
        异常
        NoSuchMethodException - 如果未找到匹配方法或名称为“<init>”或“<clinit>”。
        NullPointerException - 如果 name是 null
        SecurityException - 如果存在安全管理器 s ，并且调用者的类加载器与当前类的类加载器不同或是其祖先，则调用 s.checkPackageAccess()将拒绝访问此类的包。
        从以下版本开始：
        1.1
        See The Java™ Language Specification:
        8.2类成员，8.4方法声明

      • getConstructor

        public 构造器<T> getConstructor​(类<?>... parameterTypes)
                              throws NoSuchMethodException,
                                     SecurityException
        返回一个构造器对象，该对象反映此类对象所表示的类的指定公共构造函数。 parameterTypes参数是一个类对象的数组，它按声明的顺序标识构造函数的形式参数类型。 如果此类对象表示在非静态上下文中声明的内部类，则形式参数类型包括显式封闭实例作为第一个参数。

        要反映的构造函数是此类对象所表示的类的公共构造函数，其形式参数类型与parameterTypes指定的类型相匹配。

        参数
        parameterTypes - 参数数组
        结果
        与指定的 parameterTypes匹配的公共构造函数的 构造器对象
        异常
        NoSuchMethodException - 如果找不到匹配的方法。
        SecurityException - 如果存在安全管理器 s且调用者的类加载器与当前类的类加载器的不同或类型的祖先相同，则调用 s.checkPackageAccess()将拒绝访问此类的包。
        从以下版本开始：
        1.1

      • getDeclaredClasses

        public 类<?>[] getDeclaredClasses()
                              throws SecurityException
        返回类对象的数组， 类对象反映声明为此类对象所表示的类的成员的所有类和接口。 这包括公共，受保护，默认（包）访问以及类声明的私有类和接口，但不包括继承的类和接口。 如果类声明没有类或接口作为成员，或者此类对象表示基本类型，数组类或void，则此方法返回长度为0的数组。
        结果
        类对象的数组，表示 类所有已声明成员
        异常
        SecurityException - 如果存在安全管理器s且满足以下任一条件：
        • 调用者的类加载器与此类的类加载器不同，并且调用s.checkPermission方法和RuntimePermission("accessDeclaredMembers")拒绝访问RuntimePermission("accessDeclaredMembers")中的声明类
        • 调用者的类加载器与当前类的类加载器不同或是祖先，并且s.checkPackageAccess()的调用拒绝访问此类的包
        从以下版本开始：
        1.1

      • getDeclaredFields

        public 字段[] getDeclaredFields()
                          throws SecurityException
        返回字段对象的数组， 字段对象反映由此类对象表示的类或接口声明的所有字段。 这包括公共，受保护，默认（包）访问和私有字段，但不包括继承的字段。

        如果此类对象表示没有声明字段的类或接口，则此方法返回长度为0的数组。

        如果此类对象表示数组类型，基本类型或void，则此方法返回长度为0的数组。

        返回数组中的元素未排序，并且不按任何特定顺序排列。

        结果
        字段对象的数组，表示 字段所有声明字段
        异常
        SecurityException - 如果存在安全管理器s且满足以下任一条件：
        • 调用者的类加载器与此类的类加载器不同，并且调用s.checkPermission方法和RuntimePermission("accessDeclaredMembers")拒绝访问RuntimePermission("accessDeclaredMembers")中的声明字段
        • 调用者的类加载器与当前类的类加载器不同或是祖先，并且s.checkPackageAccess()的调用拒绝访问此类的包
        从以下版本开始：
        1.1
        See The Java™ Language Specification:
        8.2集体成员，8.3现场声明

      • getDeclaredMethods

        public 方法[] getDeclaredMethods()
                            throws SecurityException
        返回一个包含方法对象的数组， 方法对象反映此类对象表示的类或接口的所有已声明方法，包括公共，受保护，默认（包）访问和私有方法，但不包括继承的方法。

        如果此类对象表示具有多个具有相同名称和参数类型但返回类型不同的声明方法的类型，则返回的数组对于每个此类方法都有一个方法对象。

        如果此类对象表示具有类初始化方法的类型<clinit> ，则返回的阵列不具有相应的方法对象。

        如果此类对象表示没有声明方法的类或接口，则返回的数组的长度为0。

        如果此类对象表示数组类型，基本类型或void，则返回的数组的长度为0。

        返回数组中的元素未排序，并且不按任何特定顺序排列。

        结果
        方法对象的数组，表示 方法所有已声明方法
        异常
        SecurityException - 如果存在安全管理器s且满足以下任一条件：
        • 调用者的类加载器与此类的类加载器不同，并且调用s.checkPermission方法， RuntimePermission("accessDeclaredMembers")拒绝访问RuntimePermission("accessDeclaredMembers")中的声明方法
        • 调用者的类加载器与当前类的类加载器的不同或者是祖先，并且s.checkPackageAccess()的调用拒绝访问此类的包
        从以下版本开始：
        1.1
        See The Java™ Language Specification:
        8.2类成员，8.4方法声明

      • getDeclaredConstructors

        public 构造器<?>[] getDeclaredConstructors()
                                         throws SecurityException
        返回构造器对象的数组， 构造器对象反映由此类对象表示的类声明的所有构造函数。 这些是公共，受保护，默认（包）访问和私有构造函数。 返回的数组中的元素没有排序，也没有任何特定的顺序。 如果类具有默认构造函数，则它包含在返回的数组中。 如果此类对象表示接口，基本类型，数组类或void，则此方法返回长度为0的数组。

        请参阅Java语言规范 ，第8.2节。

        结果
        构造器对象的数组，表示 构造器所有声明的构造函数
        异常
        SecurityException - 如果存在安全管理器s且满足以下任一条件：
        • 调用者的类加载器与此类的类加载器不同，并且调用s.checkPermission方法和RuntimePermission("accessDeclaredMembers")拒绝访问RuntimePermission("accessDeclaredMembers")中的已声明构造函数
        • 调用者的类加载器与当前类的类加载器或祖先不同，并且调用s.checkPackageAccess()拒绝访问此类的包
        从以下版本开始：
        1.1

      • getDeclaredField

        public 字段 getDeclaredField​(String name)
                       throws NoSuchFieldException,
                              SecurityException
        返回字段对象，该对象反映此类对象表示的类或接口的指定声明字段。 name参数是String ，它指定所需字段的简单名称。

        如果此类对象表示数组类型，则此方法找不到数组类型的length字段。

        参数
        name - 字段的名称
        结果
        字段中指定字段的 字段对象
        异常
        NoSuchFieldException - 如果找不到具有指定名称的字段。
        NullPointerException - 如果 name是 null
        SecurityException - 如果存在安全管理器s且满足以下任一条件：
        • 调用者的类加载器与此类的类加载器不同，并且调用s.checkPermission方法， RuntimePermission("accessDeclaredMembers")拒绝访问声明的字段
        • 调用者的类加载器与当前类的类加载器的不同或者是祖先，并且s.checkPackageAccess()的调用拒绝访问此类的包
        从以下版本开始：
        1.1
        See The Java™ Language Specification:
        8.2集体成员，8.3现场声明

      • getDeclaredMethod

        public 方法 getDeclaredMethod​(String name,
                                类<?>... parameterTypes)
                         throws NoSuchMethodException,
                                SecurityException
        返回方法对象，该对象反映此类对象所表示的类或接口的指定声明方法。 name参数是String ，它指定所需方法的简单名称， parameterTypes参数是类对象的数组， 类对象按声明的顺序标识方法的形式参数类型。 如果在类中声明了多个具有相同参数类型的方法，并且其中一个方法的返回类型比任何其他方法更具体，则返回该方法; 否则任意选择其中一种方法。 如果名称为“<init>”或“<clinit>”，则引发NoSuchMethodException 。

        如果此类对象表示数组类型，则此方法找不到clone()方法。

        参数
        name - 方法的名称
        parameterTypes - 参数数组
        结果
        方法对象为此类的方法匹配指定的名称和参数
        异常
        NoSuchMethodException - 如果找不到匹配的方法。
        NullPointerException - 如果 name是 null
        SecurityException - 如果存在安全管理器s且满足以下任一条件：
        • 调用者的类加载器与此类的类加载器不同，并且s.checkPermission方法的调用RuntimePermission("accessDeclaredMembers")拒绝访问声明的方法
        • 调用者的类加载器与当前类的类加载器不同或是祖先，并且s.checkPackageAccess()的调用拒绝访问此类的包
        从以下版本开始：
        1.1
        See The Java™ Language Specification:
        8.2类成员，8.4方法声明

      • getDeclaredConstructor

        public 构造器<T> getDeclaredConstructor​(类<?>... parameterTypes)
                                      throws NoSuchMethodException,
                                             SecurityException
        返回一个构造器对象，该对象反映此类对象所表示的类或接口的指定构造函数。 parameterTypes参数是一个类对象的数组，它按声明的顺序标识构造函数的形式参数类型。 如果此类对象表示在非静态上下文中声明的内部类，则形式参数类型包括显式封闭实例作为第一个参数。
        参数
        parameterTypes - 参数数组
        结果
        具有指定参数列表的构造函数的 构造器对象
        异常
        NoSuchMethodException - 如果找不到匹配的方法。
        SecurityException - 如果存在安全管理器s且满足以下任一条件：
        • 调用者的类加载器与此类的类加载器不同，并且调用s.checkPermission方法和RuntimePermission("accessDeclaredMembers")拒绝访问声明的构造函数
        • 调用者的类加载器与当前类的类加载器不同或是祖先，并且s.checkPackageAccess()的调用拒绝访问此类的包
        从以下版本开始：
        1.1

      • getResourceAsStream

        public InputStream getResourceAsStream​(String name)
        查找具有给定名称的资源。

        如果此类位于命名的模块中，则此方法将尝试在模块中查找资源。 这是通过委托模块的类加载器findResource(String,String)方法完成的，使用模块名称和资源的绝对名称调用它。 命名模块中的资源受模块 getResourceAsStream方法中指定的封装规则的模块 ，因此当资源是未对调用方模块打开的包中的非“ .class ”资源时，此方法返回null 。

        否则，如果此类不在命名模块中，则用于搜索与给定类关联的资源的规则由类的定义class loader实现。 此方法委托给该对象的类加载器。 如果此对象由引导类加载器加载，则该方法委托给ClassLoader.getSystemResourceAsStream(java.lang.String) 。

        在委派之前，使用此算法从给定资源名称构造绝对资源名称：

        • 如果name以'/' （ '\u002f' ）开头，那么资源的绝对名称是name之后的'/' 。
        • 否则，绝对名称具有以下形式：
          modified_package_name/name

          其中modified_package_name是此对象的包名称， '/'替换为'.' （ '\u002e' ）。

        参数
        name - 所需资源的名称
        结果
        A InputStream对象; null如果未找到具有此名称的资源，则资源位于至少为调用方模块的open的程序包中，或者安全管理器拒绝对该资源的访问。
        异常
        NullPointerException - 如果 name是 null
        从以下版本开始：
        1.1
        另请参见：
        Module.getResourceAsStream(String)

      • getResource

        public URL getResource​(String name)
        查找具有给定名称的资源。

        如果此类位于命名的模块中，则此方法将尝试在模块中查找资源。 这是通过委托模块的类加载器findResource(String,String)方法完成的，使用模块名称和资源的绝对名称调用它。 命名模块中的资源受模块 getResourceAsStream方法中指定的封装规则的模块 ，因此当资源是未对调用方模块打开的包中的非“ .class ”资源时，此方法返回null 。

        否则，如果此类不在命名模块中，则用于搜索与给定类关联的资源的规则由类的定义class loader实现。 此方法委托给该对象的类加载器。 如果此对象由引导类加载器加载，则该方法委托给ClassLoader.getSystemResource(java.lang.String) 。

        在委派之前，使用此算法从给定资源名称构造绝对资源名称：

        • 如果name以'/' （ '\u002f' ）开头，那么资源的绝对名称是name之后的'/' 。
        • 否则，绝对名称具有以下形式：
          modified_package_name/name

          其中modified_package_name是此对象的包名称， '/'替换为'.' （ '\u002e' ）。

        参数
        name - 所需资源的名称
        结果
        A URL对象; null如果找不到具有此名称的资源，则无法通过URL找到该资源，该资源位于至少为调用方模块的open的包中，或者安全管理器拒绝对该资源的访问。
        异常
        NullPointerException - 如果 name是 null
        从以下版本开始：
        1.1

      • desiredAssertionStatus

        public boolean desiredAssertionStatus()
        如果要在调用此方法时初始化，则返回将分配给此类的断言状态。 如果此类已设置其断言状态，则将返回最新的设置; 否则，如果任何包默认断言状态属于此类，则返回最具体的相关包默认断言状态的最新设置; 否则，如果此类不是系统类（即，它具有类加载器），则返回其类加载器的默认断言状态; 否则，返回系统类的默认断言状态。

        很少有程序员需要这种方法; 它是为了JRE本身的利益而提供的。 （它允许类在初始化时确定是否应该启用断言。）请注意，此方法不保证返回与指定类关联的（或将要）关联的实际断言状态（或将被初始化。

        结果
        指定类的所需断言状态。
        从以下版本开始：
        1.4
        另请参见：
        ClassLoader.setClassAssertionStatus(java.lang.String, boolean) ， ClassLoader.setPackageAssertionStatus(java.lang.String, boolean) ， ClassLoader.setDefaultAssertionStatus(boolean)

      • isEnum

        public boolean isEnum()
        当且仅当此类在源代码中声明为枚举时返回true。
        结果
        当且仅当此类在源代码中声明为枚举时才返回true
        从以下版本开始：
        1.5

      • getEnumConstants

        public T[] getEnumConstants()
        返回此枚举类的元素，如果此Class对象不表示枚举类型，则返回null。
        结果
        包含由此Class对象按其声明的顺序表示的枚举类的值的数组，如果此Class对象不表示枚举类型，则返回null
        从以下版本开始：
        1.5

      • cast

        public T cast​(Object obj)
        将对象 类为此 类对象表示的类或接口。
        参数
        obj - 要转换的对象
        结果
        转换后的对象，如果obj为null，则返回null
        异常
        ClassCastException - 如果对象不为null且不能分配给类型T.
        从以下版本开始：
        1.5

      • asSubclass

        public <U> 类<? extends U> asSubclass​(类<U> clazz)
        转换此类对象以表示由指定的类对象表示的类的子类。 检查ClassCastException是否有效，如果不是，则抛出ClassCastException 。 如果此方法成功，则它始终返回对此类对象的引用。

        当客户端需要“缩小” 类对象的类型以将其传递给限制其愿意接受的类对象的API时，此方法很有用。 强制转换将生成编译时警告，因为无法在运行时检查强制转换的正确性（因为泛型类型是通过擦除实现的）。

        参数类型
        U - 要将此类对象 U为的类型
        参数
        clazz - 要将此类对象 clazz为的类的类
        结果
        这个 类对象， 类为表示指定类对象的子类。
        异常
        ClassCastException - 如果此 类对象不表示指定类的子类（此处“子类”包括类本身）。
        从以下版本开始：
        1.5

      • getAnnotation

        public <A extends Annotation> A getAnnotation​(类<A> annotationClass)
        从界面复制的说明： AnnotatedElement
        返回该元素的，如果这样的注释 ，否则返回null指定类型的注释。
        Specified by:
        getAnnotation在接口 AnnotatedElement
        参数类型
        A - 要查询的注释的类型，如果存在则返回
        参数
        annotationClass - 与注释类型对应的Class对象
        结果
        如果此元素上存在指定注释类型，则此元素的注释，否则为null
        异常
        NullPointerException - 如果给定的注释类为null
        从以下版本开始：
        1.5

      • isAnnotationPresent

        public boolean isAnnotationPresent​(类<? extends Annotation> annotationClass)
        如果此元素上存在指定类型的注释，则返回true，否则返回false。 此方法主要用于方便地访问标记注释。

        此方法返回的真值等价于： getAnnotation(annotationClass) != null

        默认方法的主体被指定为上面的代码。

        Specified by:
        isAnnotationPresent在接口 AnnotatedElement
        参数
        annotationClass - 与注释类型对应的Class对象
        结果
        如果此元素上存在指定注释类型的注释，则返回true，否则返回false
        异常
        NullPointerException - 如果给定的注释类为null
        从以下版本开始：
        1.5

      • getAnnotationsByType

        public <A extends Annotation> A[] getAnnotationsByType​(类<A> annotationClass)
        从界面复制的说明： AnnotatedElement
        返回与此元素关联的注释。 如果没有与此元素关联的注释，则返回值是长度为0的数组。此方法与AnnotatedElement.getAnnotation(Class)之间的区别在于此方法检测其参数是否为可重复注释类型 （JLS 9.6），如果是，则尝试通过“查看”容器注释来查找该类型的一个或多个注释。 此方法的调用者可以自由修改返回的数组; 它对返回给其他调用者的数组没有影响。
        Specified by:
        getAnnotationsByType在接口 AnnotatedElement
        参数类型
        A - 要查询的注释的类型，如果存在则返回
        参数
        annotationClass - 与注释类型对应的Class对象
        结果
        如果与此元素关联，则指定注释类型的所有此元素的注释，否则为长度为零的数组
        异常
        NullPointerException - 如果给定的注释类为null
        从以下版本开始：
        1.8

      • getAnnotations

        public Annotation[] getAnnotations()
        从界面复制的说明： AnnotatedElement
        返回此元素上存在的注释。 如果没有存在于此元素上注解，返回值是长度为0这种方法的调用者可以随意修改返回的数组的数组; 它对返回给其他调用者的数组没有影响。
        Specified by:
        getAnnotations ，界面 AnnotatedElement
        结果
        此元素上的注释
        从以下版本开始：
        1.5

      • getDeclaredAnnotation

        public <A extends Annotation> A getDeclaredAnnotation​(类<A> annotationClass)
        从界面复制的说明： AnnotatedElement
        如果直接存在这样的注释，则返回指定类型的此元素的注释，否则返回null。 此方法忽略继承的注释。 （如果此元素上没有直接出现注释，则返回null。）
        Specified by:
        getDeclaredAnnotation在界面 AnnotatedElement
        参数类型
        A - 要查询的注释的类型，如果直接存在则返回
        参数
        annotationClass - 与注释类型对应的Class对象
        结果
        如果直接出现在此元素上，则此元素的指定注释类型的注释，否则为null
        异常
        NullPointerException - 如果给定的注释类为null
        从以下版本开始：
        1.8

      • getDeclaredAnnotationsByType

        public <A extends Annotation> A[] getDeclaredAnnotationsByType​(类<A> annotationClass)
        从界面复制的说明： AnnotatedElement
        如果此类注释直接存在或间接存在 ，则返回指定类型的此元素的注释。 此方法忽略继承的注释。 如果此元素上没有直接或间接存在的指定注释，则返回值为长度为0的数组。此方法与AnnotatedElement.getDeclaredAnnotation(Class)之间的区别在于此方法检测其参数是否为可重复注释类型 （JLS 9.6），并且如果是，则尝试通过“查看”容器注释（例如，如果存在）来查找该类型的一个或多个注释。 此方法的调用者可以自由修改返回的数组; 它对返回给其他调用者的数组没有影响。
        Specified by:
        getDeclaredAnnotationsByType在界面 AnnotatedElement
        参数类型
        A - 要查询的注释的类型，如果直接或间接存在则返回
        参数
        annotationClass - 与注释类型对应的Class对象
        结果
        如果直接或间接出现在此元素上，则指定注释类型的所有此元素的注释，否则为长度为零的数组
        异常
        NullPointerException - 如果给定的注释类为null
        从以下版本开始：
        1.8

      • getDeclaredAnnotations

        public Annotation[] getDeclaredAnnotations()
        从界面复制的说明： AnnotatedElement
        返回直接出现在此元素上的注释。 此方法忽略继承的注释。 如果此元素上没有直接存在注释，则返回值为长度为0的数组。此方法的调用者可以自由修改返回的数组; 它对返回给其他调用者的数组没有影响。
        Specified by:
        getDeclaredAnnotations在接口 AnnotatedElement
        结果
        注释直接出现在此元素上
        从以下版本开始：
        1.5

      • getAnnotatedSuperclass

        public AnnotatedType getAnnotatedSuperclass()
        返回一个AnnotatedType对象，该对象表示使用类型来指定此类对象所表示的实体的超类。 （ 使用类型Foo来指定'... extends Foo'中的超类与Foo类型的声明不同。）

        如果此类对象表示其声明未明确指示带注释的超类的类型，则返回值是表示没有注释的元素的AnnotatedType对象。

        如果此类表示Object类，接口类型，数组类型，基元类型或void，则返回值为null 。

        结果
        表示超类的对象
        从以下版本开始：
        1.8

      • getAnnotatedInterfaces

        public AnnotatedType[] getAnnotatedInterfaces()
        返回AnnotatedType对象的数组， AnnotatedType对象表示使用类型来指定此类对象所表示的实体的超类 。 （ 使用类型Foo在'... implements Foo'中指定超接口与Foo类型的声明不同。）

        如果此类对象表示类，则返回值是一个数组，其中包含表示接口类型用于指定类实现的接口的对象。 数组中对象的顺序对应于此类对象的声明的“implements”子句中使用的接口类型的顺序。

        如果此类对象表示接口，则返回值是一个数组，其中包含表示接口类型用途的对象，以指定由接口直接扩展的接口。 数组中对象的顺序对应于此类对象的声明的“extends”子句中使用的接口类型的顺序。

        如果此类对象表示其声明未明确指示任何带注释的超接口的类或接口，则返回值为长度为0的数组。

        如果此类对象表示Object类，数组类型，基本类型或void，则返回值是长度为0的数组。

        结果
        表示超接口的数组
        从以下版本开始：
        1.8

      • getNestHost

        public 类<?> getNestHost()
        返回此类对象所代表的类或接口所属的nest的嵌套主机。 每个类和接口都是一个嵌套的成员。 未记录为属于嵌套的类或接口属于仅由其自身组成的嵌套，并且是嵌套主机。

        表示数组类型，基元类型和void的类对象中的每一个返回this以指示所表示的实体属于仅this自身组成的嵌套，并且是嵌套主机。

        如果存在访问嵌套主机的linkage error ，或者嵌套主机未将此类或接口枚举为嵌套成员，则认为它属于自己的嵌套，并且this作为主机返回。

        API Note:
        版本55.0或更高版本的class可以使用NestHost属性（JVMS 4.7.28）记录它所属的嵌套的主机。 或者，版本55.0或更高版本的class文件可以通过使用NestMembers属性（JVMS 4.7.29）枚举嵌套的其他成员来充当嵌套主机。 版本54.0或更低版本的class文件不使用这些属性。
        结果
        此类或接口的嵌套主机
        异常
        SecurityException - 如果返回的类不是当前类，并且存在安全管理器 s ，并且调用者的类加载器与返回类的类加载器不同或是祖先，并且调用 s.checkPackageAccess()拒绝访问返回类的包
        从以下版本开始：
        11
        See The Java™ Virtual Machine Specification:
        4.7.28和4.7.29 NestHost和NestMembers属性，5.4.4访问控制

      • isNestmateOf

        public boolean isNestmateOf​(类<?> c)
        确定给定的类是否是此类对象所表示的类或接口的类 。 如果两个类或接口具有相同的nest host，则它们是嵌套的 。
        参数
        c - 要检查的类
        结果
        true如果此类和c是同一个嵌套的成员; 和false 。
        从以下版本开始：
        11

      • getNestMembers

        public 类<?>[] getNestMembers()
        返回一个数组，其中包含类对象，这些对象表示作为此类对象所表示的类或接口所属的嵌套成员的所有类和接口。 该嵌套的nest host是数组的第0个元素。 后续元素表示由嵌套主机记录为嵌套成员的任何类或接口; 这些元素的顺序是未指定的。 允许重复。 如果该嵌套的嵌套主机未枚举任何成员，则该数组具有包含this的单个元素。

        表示数组类型，基元类型和void每个类对象void返回仅包含this的数组。

        此方法验证，对于由嵌套主机记录为嵌套成员的每个类或接口，该类或接口将自身记录为同一嵌套的成员。 此验证期间发生的任何异常都会被此方法重新抛出。

        结果
        与此类位于同一个嵌套中的所有类和接口的数组
        异常
        LinkageError - 如果加载或验证嵌套成员或其嵌套主机有任何问题
        SecurityException - 如果任何返回的类不是当前类，并且存在安全管理器 s ，并且调用者的类加载器与该返回类的类加载器不同或是其祖先，并且调用 s.checkPackageAccess()拒绝访问返回类的包
        从以下版本开始：
        11
        另请参见：
        getNestHost()