Module  java.base
软件包  java.lang

Class Class<T>

  • 参数类型
    T - 由此Class对象建模的类的类型。 例如， String.class的类型是Class<String> 。 如果被建模的类是未知的，请使用Class<?> 。
    All Implemented Interfaces:
    Serializable ， AnnotatedElement ， GenericDeclaration ， Type 

    public final class Class<T>
extends Object
implements Serializable, GenericDeclaration, Type, AnnotatedElement
    Class类的实例表示正在运行的Java应用程序中的类和接口。 枚举是一种类，一个注释是一种界面。 每个数组也属于一个类，它被反映为具有相同元素类型和维数的所有数组共享的Class对象。 原始Java类型（ boolean ， byte ， char ， short ， int ， long ， float ，和double ），以及关键字void也表示为Class对象。

    Class没有公共建设者。 相反， Class对象由Java虚拟机自动构建，因为类已加载，并通过调用类加载器中的defineClass方法。

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

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

    也可以使用类文字获取Class对象作为命名类型（或为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

    • 方法摘要

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

      电话 

         clazz.newInstance()
      可以替换 
         clazz.getDeclaredConstructor().newInstance()
      后一个调用序列被推断为能够抛出额外的异常类型InvocationTargetException和NoSuchMethodException 。 这两种异常类型都是ReflectiveOperationException的子类。
      String toGenericString​()
      返回描述此 Class的字符串，包括有关修饰符和类型参数的信息。
      String toString​()
      将对象转换为字符串。

    • 方法详细信息

      • toString

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

      • toGenericString

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

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

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

      • forName

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

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

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

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

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

      • forName

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

        如果name表示原始类型或空白，将尝试在名称为name的未命名包中定位用户定义的类。 因此，该方法不能用于获取表示原始类型或空白的任何Class对象。

        如果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 Class<?> forName​(Module module,
                               String name)
        返回Class给定binary name给定的模块中。

        此方法尝试查找，加载和链接类或接口。 它不运行类初始化器。 如果没有找到该类，该方法返回null 。

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

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

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

      • newInstance

        @Deprecated(since="9")
public T newInstance​()
              throws InstantiationException,
                     IllegalAccessException
        已过时。 此方法传播由nullary构造函数抛出的任何异常，包括已检查的异常。 使用此方法有效地绕过编译器异常检查，否则将由编译器执行。 Constructor.newInstance方法通过在（检查的） InvocationTargetException中包含构造函数抛出的任何异常来避免此问题。

        电话 

           clazz.newInstance()
        可以替换 
           clazz.getDeclaredConstructor().newInstance()
        推断后一个调用序列能够抛出额外的异常类型InvocationTargetException和NoSuchMethodException 。 这两个异常类型都是ReflectiveOperationException的子类。
        创建由该Class对象表示的类的新实例。 该类被实例化为一个具有空参数列表的new表达式。 如果类尚未初始化，则初始化该类。
        结果
        由该对象表示的新分配的类的实例。
        异常
        IllegalAccessException - 如果类或其nullary构造函数不可访问。
        InstantiationException - 如果这个Class表示抽象类，接口，数组类，基元类型或void; 或者类没有空值构造函数; 或者由于某种其他原因，实例化失败。
        ExceptionInInitializerError - 如果由此方法引发的初始化失败。
        SecurityException -如果安全管理器 ，S存在，并且调用者的类加载器是不一样或类加载器的当前类和调用的祖先 s.checkPackageAccess()拒绝访问包这个类的。

      • isInstance

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

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

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

      • isAssignableFrom

        public boolean isAssignableFrom​(Class<?> cls)
        确定由此Class对象表示的类或接口是否与由指定的Class参数表示的类或接口相同，或者是超类或超级接口。 如果是，则返回true ; 否则返回false 。 如果此Class对象表示原始类型，则如果指定的Class参数正好是Class对象，则此方法返回true ; 否则返回false 。

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

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

      • isInterface

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

      • isArray

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

      • isPrimitive

        public boolean isPrimitive​()
        确定指定的Class对象是否表示原始类型。

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

        这些对象只能通过以下公共静态最终变量访问，并且是该方法返回的唯一的Class对象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​()
        如果此Class对象表示注释类型，则返回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​()
        返回由该Class对象表示的实体（类，接口，数组类，原始类型或无效）的Class ，作为String 。

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

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

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

        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。

        如果此对象表示原始类型或空值，则返回null。

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

      • getModule

        public Module getModule​()
        返回此类或接口所属的模块。 如果此类表示数组类型，则此方法将返回元素类型的Module 。 如果此类表示原始类型或空值，则返回java.base模块的Module对象。 如果这个类是一个未命名的模块，那么返回这个类的类加载器的unnamed Module 。
        结果
        该类或接口是其成员的模块
        从以下版本开始：
        9

      • getTypeParameters

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

      • getSuperclass

        public Class<? super T> getSuperclass​()
        返回表示由Class表示的实体的直接超类（类，接口，原始类型或空白）的Class 。 如果这个Class表示Object类，一个接口，一个原始类型或者Object ，那么返回null。 如果此对象表示数组类，则返回表示Object类的Class对象。
        结果
        由该对象表示的类的直接超类

      • getGenericSuperclass

        public Type getGenericSuperclass​()
        返回表示由Type表示的实体的直接超类（类，接口，原语类型或void）的Class 。

        如果超类是参数化类型，则返回的Type对象必须准确反映源代码中使用的实际类型参数。 如果以前没有创建表示超类的参数化类型。 有关参数化类型创建过程的语义，请参见ParameterizedType的声明。 如果这个Class代表Object类，接口，原始类型或void，则返回null。 如果此对象表示数组类，则返回表示Object类的Class对象。

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

      • getPackage

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

        如果此类表示数组类型， null原始类型或void，此方法返回null 。

        结果
        这个类的包。

      • getPackageName

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

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

        如果这个类是一个成员类，那么这个方法相当于在getPackageName()上调用getPackageName() 。

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

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

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

      • getInterfaces

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

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

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

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

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

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

        如果此Class对象表示数组类型，则按照该顺序返回接口Cloneable和java.io.Serializable 。

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

      • getGenericInterfaces

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

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

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

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

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

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

        如果此Class对象表示数组类型，则按照该顺序返回接口Cloneable和java.io.Serializable 。

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

      • getComponentType

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

      • getModifiers

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

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

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

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

      • getSigners

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

      • getEnclosingMethod

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

      • getEnclosingConstructor

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

      • getDeclaringClass

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

      • getEnclosingClass

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

      • getFields

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

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

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

        如果这个Class对象表示一个接口，那么这个方法返回接口和其所有超级接口的字段。

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

        返回的数组中的元素不会被排序，并且不是以任何特定的顺序。

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

      • getMethods

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

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

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

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

        返回的数组中的元素不会被排序，并且不是以任何特定的顺序。

        通常，结果与以下4步算法一样计算。 让C是由这个Class对象表示的类或接口：

        1. 方法联合组成：
          1. C所声明的公共实例和静态方法由getDeclaredMethods()返回， 并被过滤以仅包括公共方法。
          2. 如果C是一个不是Object的类，那么包括在C的超类上递归调用这个算法的结果。
          3. 包括在C的所有直接超级接口上递归调用该算法的结果，但仅包括实例方法。
        2. 来自步骤1的联盟被划分为具有相同签名（名称，参数类型）和返回类型的方法的子集。
        3. 在每个这样的子集中，仅选择最具体的方法。 让方法M是一组具有相同签名和返回类型的方法的方法。 如果没有相同集合的这种方法N！= M，则M是最具体的，使得N比M更具体。如果：
          1. N由一个类声明，M由一个接口声明; 要么
          2. N和M都由类或两者通过接口声明，N的声明类型与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 Constructor<?>[] getConstructors​()
                                 throws SecurityException
        返回一个包含Constructor对象的数组， Constructor对象反映由该Class对象表示的类的所有公共构造函数。 如果类没有公共构造函数，或者类是数组类，或类反映原始类型或void时，返回长度为0的数组。 请注意，虽然此方法返回一个Constructor<T>对象（这是该类的构造函数数组）的数组，但此方法的返回类型为Constructor<?>[]而不是 Constructor<T>[] 。 这种信息较少的返回类型是必需的，因为从该方法返回后，可以修改数组以容纳不同类的Constructor对象，这将违反Constructor<T>[]的类型保证。
        结果
        表示 Constructor的公共构造函数的 Constructor对象的数组
        异常
        SecurityException -如果安全管理器 ，S存在，并且调用者的类加载器是不一样或类加载器的当前类和调用的祖先 s.checkPackageAccess()拒绝访问包这个类的。
        从以下版本开始：
        1.1

      • getField

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

        要反映的字段由以下算法确定。 让C成为由该对象表示的类或接口：

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

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

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

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

        如果这个Class对象表示一个接口，那么这个方法没有从Object找到任何隐式声明的方法。 因此，如果在此接口或其任何超级接口中没有显式声明方法，则此方法不会找到任何方法。

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

        一般来说，要反映的方法由以下4步算法确定。 让C是由这个Class对象表示的类或接口：

        1. 方法联合组成：
          1. C所声明的公共实例和静态方法由getDeclaredMethods()返回， 并被过滤以仅包括匹配给予的公共方法name和parameterTypes
          2. 如果C是一个不是Object的类，那么包含在C的超类上递归调用这个算法的结果。
          3. 包括在C的所有直接超级接口上递归调用该算法的结果，但仅包括实例方法。
        2. 该联合被分割成具有相同返回类型的方法子集（步骤1中的方法选择也保证它们具有相同的方法名称和参数类型）。
        3. 在每个这样的子集中，仅选择最具体的方法。 让方法M是一组具有相同VM签名（返回类型，名称，参数类型）的方法。 如果没有相同集合的这种方法N！= M，则M是最具体的，使得N比M更具体。如果：
          1. N由一个类声明，M由一个接口声明; 要么
          2. N和M都由类或两者通过接口声明，N的声明类型与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 Constructor<T> getConstructor​(Class<?>... parameterTypes)
                              throws NoSuchMethodException,
                                     SecurityException
        返回一个Constructor对象，该对象反映由此Class对象表示的类的指定公共构造函数。 parameterTypes参数是以声明顺序标识构造函数的形式参数类型的Class对象的数组。 如果此Class对象表示在非静态上下文中声明的内部类，则形式参数类型将显式包围实例作为第一个参数。

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

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

      • getDeclaredClasses

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

      • getDeclaredFields

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

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

        如果这个Class对象表示一个数组类型，一个原始类型或者void，那么这个方法返回一个长度为0的数组。

        返回的数组中的元素不会被排序，并且不是以任何特定的顺序。

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

      • getDeclaredMethods

        public 方法[] getDeclaredMethods​()
                            throws SecurityException
        返回一个包含方法对象的数组， 方法对象反映由Class对象表示的类或接口的所有声明的方法，包括public，protected，default（package）访问和私有方法，但不包括继承方法。

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

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

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

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

        返回的数组中的元素不会被排序，并且不是以任何特定的顺序。

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

      • getDeclaredConstructors

        public Constructor<?>[] getDeclaredConstructors​()
                                         throws SecurityException
        返回一个Constructor对象的数组，反映由该Class对象表示的类声明的所有构造函数。 这些是public，protected，default（package）访问和私有构造函数。 返回的数组中的元素不会排序，并且不是任何特定的顺序。 如果类有一个默认构造函数，它将包含在返回的数组中。 此方法返回一个长度为0的数组，如果该对象表示一个接口，一个原始类型，一个数组类或者Class 。

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

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

      • getDeclaredField

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

        如果这个Class对象代表一个数组类型，那么这个方法找不到数组类型的length字段。

        参数
        name - 字段的名称
        结果
        Field中指定字段的对象为 Field
        异常
        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,
                                Class<?>... parameterTypes)
                         throws NoSuchMethodException,
                                SecurityException
        返回一个方法对象，该对象反映由此Class对象表示的类或接口的指定声明方法。 name参数是一个String ，它指定了所需方法的简单名称， parameterTypes参数是一个Class对象的数组，以声明顺序标识方法的形式参数类型。 如果在一个类中声明具有相同参数类型的多个方法，并且其中一个方法的返回类型比其他任何方法更具体，返回该方法; 否则其中一种方法是任意选择的。 如果名字是“<init>”或“<clinit>”， NoSuchMethodException一个NoSuchMethodException 。

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

      • getResourceAsStream

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

        如果这个类名为Module，则该方法将尝试在模块中查找资源。 这是通过委托给模块的类加载器findResource(String,String)方法，使用模块名称和资源的绝对名称进行调用来完成的。 命名模块中的资源受到Module getResourceAsStream方法中指定的封装规则的Module ，因此，当资源是未对调用者模块打开的软件包中的非“ .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)
        查找具有给定名称的资源。

        如果这个类名为Module，那么这个方法将尝试在模块中找到资源。 这是通过委托给模块的类加载器findResource(String,String)方法，使用模块名称和资源的绝对名称进行调用。 命名模块中的资源受到Module getResourceAsStream方法中指定的封装规则的Module ，因此，当资源为未对调用方模块开放的软件包中的非“ .class ”资源时，此方法返回null 。

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

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

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

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

        参数
        name - 所需资源的名称
        结果
        一个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。
        结果
        当且仅当该类在源代码中被声明为枚举时才为真
        从以下版本开始：
        1.5

      • getEnumConstants

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

      • cast

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

      • asSubclass

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

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

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

      • getAnnotation

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

      • isAnnotationPresent

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

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

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

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

      • getAnnotationsByType

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

      • getAnnotations

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

      • getDeclaredAnnotation

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

      • getDeclaredAnnotationsByType

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

      • getDeclaredAnnotations

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

      • getAnnotatedSuperclass

        public AnnotatedType getAnnotatedSuperclass​()
        返回一个AnnotatedType对象，表示使用类型来指定由该Class对象表示的实体的超类。 （ 使用 Foo类型指定“...扩展Foo”中的超类与Foo类型的声明不同）

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

        如果这个Class表示Object类，接口类型，数组类型，基元类型或空值，则返回值为null 。

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

      • getAnnotatedInterfaces

        public AnnotatedType[] getAnnotatedInterfaces​()
        返回一个AnnotatedType对象的数组，表示使用类型指定由该Class对象表示的实体的超Class 。 （在“...实现Foo”中使用 Foo类型指定一个超级接口与Foo类型的声明不同）

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

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

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

        如果此Class对象表示Object类，数组类型，原始类型或空值，则返回值为长度为0的数组。

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