模块 java.base
包 java.lang

类 Class<T>

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

Class 没有公共构造函数。相反，当通过调用以下方法之一从 class 文件的字节派生类时，Java 虚拟机会自动构造 Class 对象：

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

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

   void printClassName(Object obj) {
     System.out.println("The class of " + obj +
              " is " + obj.getClass().getName());
   }
也可以使用类文字.例如：
System.out.println("The name of class Foo is: "+Foo.class.getName());

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

通过调用 Lookup::defineHiddenClass 创建的类或接口是 hidden 类或接口。各种类，包括枚举类和记录类，都可能是隐藏类；各种接口，包括注解接口，都可能是隐藏接口。 隐藏类或接口的名称 不是 二进制名称 ，这意味着：

隐藏类或接口永远不是数组类，但可能是数组的元素类型。在所有其他方面，隐藏类或接口的事实与类 Class 的方法公开的特征无关。
看Java 语言规范:
15.8.2 类文字
自从：
1.0
参见：

  • 内部类总结

    在接口 java.lang.invoke.TypeDescriptor 中声明的嵌套类/接口

    TypeDescriptor.OfField<F extends TypeDescriptor.OfField<F>>, TypeDescriptor.OfMethod<F extends TypeDescriptor.OfField<F>,M extends TypeDescriptor.OfMethod<F,M>>

  • 方法总结

    修饰符和类型
    方法
    描述
    Set<AccessFlag>
    accessFlags()
    为此类返回一组不可修改的 访问标志，可能为空。
    Class<?>
    arrayType()
    为其组件类型由此 Class 描述的数组类型返回 Class。
    <U> Class<? extends U>
    asSubclass(Class<U> clazz)
    转换此 Class 对象以表示由指定类对象表示的类的子类。
    T
    cast(Object obj)
    将一个对象转换为此 Class 对象表示的类或接口。
    Class<?>
    componentType()
    返回此 Class 的组件类型，如果它描述数组类型，否则返回 null。
    Optional<ClassDesc>
    describeConstable()
    如果可以构造，则返回此实例的标称描述符，如果不能构造，则返回一个空的Optional 。
    String
    descriptorString()
    返回此 Class 对象表示的实体（类、接口、数组类、原始类型或 void ）的描述符字符串。
    boolean
    desiredAssertionStatus()
    如果在调用此方法时初始化此类，则返回将分配给此类的断言状态。
    static Class<?>
    forName(Module module, String name)
    返回给定模块中具有给定 二进制名称 的 Class。
    static Class<?>
    forName(String className)
    返回与具有给定字符串名称的类或接口关联的 Class 对象。
    static Class<?>
    forName(String name, boolean initialize, ClassLoader loader)
    使用给定的类加载器返回与具有给定字符串名称的类或接口关联的 Class 对象。
    AnnotatedType[]
    getAnnotatedInterfaces()
    返回一个 AnnotatedType 对象数组，这些对象表示使用类型来指定此 Class 对象表示的实体的超接口。
    AnnotatedType
    getAnnotatedSuperclass()
    返回一个 AnnotatedType 对象，表示使用类型来指定此 Class 对象表示的实体的超类。
    <A extends Annotation>
    A
    getAnnotation(Class<A> annotationClass)
    如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
    Annotation[]
    getAnnotations()
    返回此元素上的 present 注释。
    <A extends Annotation>
    A[]
    getAnnotationsByType(Class<A> annotationClass)
    返回带有此元素的 associated 注释。
    String
    getCanonicalName()
    返回由定义的基础类的规范名称Java 语言规范.
    Class<?>[]
    getClasses()
    返回一个包含 Class 对象的数组，这些对象表示作为此 Class 对象所表示的类的成员的所有公共类和接口。
    ClassLoader
    getClassLoader()
    返回类的类加载器。
    Class<?>
    getComponentType()
    返回表示数组组件类型的Class。
    Constructor<T>
    getConstructor(Class<?>... parameterTypes)
    返回一个 Constructor 对象，该对象反映此 Class 对象表示的类的指定公共构造函数。
    Constructor<?>[]
    getConstructors()
    返回一个包含 Constructor 对象的数组，这些对象反映了由该 Class 对象表示的类的所有公共构造函数。
    <A extends Annotation>
    A
    getDeclaredAnnotation(Class<A> annotationClass)
    如果此类注解为 directly present ，则返回此元素针对指定类型的注解，否则为 null。
    Annotation[]
    getDeclaredAnnotations()
    返回此元素上的 directly present 注释。
    <A extends Annotation>
    A[]
    getDeclaredAnnotationsByType(Class<A> annotationClass)
    如果此类注解是 directly present 或 indirectly present ，则返回此元素的指定类型的注解。
    Class<?>[]
    getDeclaredClasses()
    返回一个 Class 对象数组，反映声明为此 Class 对象表示的类的成员的所有类和接口。
    Constructor<T>
    getDeclaredConstructor(Class<?>... parameterTypes)
    返回一个 Constructor 对象，该对象反映此 Class 对象表示的类的指定构造函数。
    Constructor<?>[]
    getDeclaredConstructors()
    返回一个 Constructor 对象数组，反映由该 Class 对象表示的类隐式或显式声明的所有构造函数。
    Field
    getDeclaredField(String name)
    返回一个 Field 对象，该对象反映了此 Class 对象表示的类或接口的指定声明字段。
    Field[]
    getDeclaredFields()
    返回一个 Field 对象数组，反映由该 Class 对象表示的类或接口声明的所有字段。
    Method
    getDeclaredMethod(String name, Class<?>... parameterTypes)
    返回一个 Method 对象，该对象反映了此 Class 对象表示的类或接口的指定声明方法。
    Method[]
    getDeclaredMethods()
    返回包含 Method 个对象的数组，这些对象反映了此 Class 对象表示的类或接口的所有已声明方法，包括公共、受保护、默认（包）访问和私有方法，但不包括继承方法。
    Class<?>
    getDeclaringClass()
    如果此 Class 对象表示的类或接口是另一个类的成员，则返回表示声明它的类的 Class 对象。
    Class<?>
    getEnclosingClass()
    返回基础类的直接封闭类。
    Constructor<?>
    getEnclosingConstructor()
    如果此 Class 对象表示构造函数中的本地或匿名类，则返回一个 Constructor 对象，表示基础类的直接封闭构造函数。
    Method
    getEnclosingMethod()
    如果此 Class 对象表示方法中的本地或匿名类，则返回一个 Method 对象表示基础类的直接封闭方法。
    T[]
    getEnumConstants()
    返回此枚举类的元素；如果此 Class 对象不表示枚举类，则返回 null。
    Field
    getField(String name)
    返回一个 Field 对象，该对象反映此 Class 对象表示的类或接口的指定公共成员字段。
    Field[]
    getFields()
    返回包含 Field 对象的数组，这些对象反映了此 Class 对象表示的类或接口的所有可访问公共字段。
    Type[]
    getGenericInterfaces()
    返回代表由该 Class 对象代表的类或接口直接实现的接口的 Type s。
    Type
    getGenericSuperclass()
    返回表示此 Class 对象表示的实体（类、接口、原始类型或 void）的直接超类的 Type。
    Class<?>[]
    getInterfaces()
    返回由此 Class 对象表示的类或接口直接实现的接口。
    Method
    getMethod(String name, Class<?>... parameterTypes)
    返回一个 Method 对象，该对象反映此 Class 对象表示的类或接口的指定公共成员方法。
    Method[]
    getMethods()
    返回一个包含 Method 个对象的数组，这些对象反映了这个 Class 对象所表示的类或接口的所有公共方法，包括类或接口声明的方法以及从超类和超接口继承的方法。
    int
    getModifiers()
    返回此类或接口的 Java 语言修饰符，以整数编码。
    Module
    getModule()
    返回此类或接口所属的模块。
    String
    getName()
    返回此 Class 对象表示的实体名称（类、接口、数组类、原始类型或 void）。
    Class<?>
    getNestHost()
    返回此 Class 对象所表示的类或接口所属的 巢 的嵌套主机。
    Class<?>[]
    getNestMembers()
    返回一个包含 Class 对象的数组，这些对象表示作为此 Class 对象所表示的类或接口所属的嵌套成员的所有类和接口。
    Package
    getPackage()
    获取该类的包。
    String
    getPackageName()
    返回完全限定的包名称。
    Class<?>[]
    getPermittedSubclasses()
    返回一个包含 Class 对象的数组，这些对象表示允许扩展或实现此类或接口（如果它是密封的）的直接子接口或子类。
    ProtectionDomain
    getProtectionDomain()
    返回此类的 ProtectionDomain。
    RecordComponent[]
    getRecordComponents()
    返回代表此记录类的所有记录组件的 RecordComponent 对象数组，如果此类不是记录类，则返回 null。
    URL
    getResource(String name)
    查找具有给定名称的资源。
    InputStream
    getResourceAsStream(String name)
    查找具有给定名称的资源。
    Object[]
    getSigners()
    获取此类的签名者。
    String
    getSimpleName()
    返回源代码中给定的基础类的简单名称。
    Class<? super T>
    getSuperclass()
    返回表示此 Class 表示的实体（类、接口、原始类型或 void）的直接超类的 Class。
    String
    getTypeName()
    返回此类或接口名称的信息字符串。
    TypeVariable<Class<T>>[]
    getTypeParameters()
    返回一个 TypeVariable 对象数组，这些对象表示由此 GenericDeclaration 对象表示的泛型声明所声明的类型变量，按声明顺序排列。
    boolean
    isAnnotation()
    如果此 Class 对象表示注释接口，则返回 true。
    boolean
    isAnnotationPresent(Class<? extends Annotation> annotationClass)
    如果指定类型的注解在此元素上为 present，则返回 true，否则返回 false。
    boolean
    isAnonymousClass()
    当且仅当基础类是匿名类时返回 true。
    boolean
    isArray()
    确定此 Class 对象是否表示数组类。
    boolean
    isAssignableFrom(Class<?> cls)
    确定此 Class 对象表示的类或接口是否与指定的 Class 参数表示的类或接口相同，或者是其超类或超接口。
    boolean
    isEnum()
    当且仅当此类在源代码中被声明为枚举时才返回 true。
    boolean
    isHidden()
    当且仅当基础类是隐藏类时返回 true。
    boolean
    isInstance(Object obj)
    确定指定的 Object 是否与此 Class 表示的对象兼容。
    boolean
    isInterface()
    确定此 Class 对象是否表示接口类型。
    boolean
    isLocalClass()
    当且仅当基础类是本地类时返回 true。
    boolean
    isMemberClass()
    当且仅当基础类是成员类时返回 true。
    boolean
    isNestmateOf(Class<?> c)
    确定给定的 Class 是否是此 Class 对象表示的类或接口的 nestmate。
    boolean
    isPrimitive()
    确定指定的 Class 对象是否表示原始类型。
    boolean
    isRecord()
    当且仅当此类是记录类时返回 true。
    boolean
    isSealed()
    当且仅当此 Class 对象表示密封类或接口时，返回 true。
    boolean
    isSynthetic()
    当且仅当此类设置了合成修饰符位时，才返回 true。
    T
    newInstance()
    已弃用。
    此方法传播 nullary 构造方法抛出的任何异常，包括已检查的异常。
    String
    toGenericString()
    返回描述此 Class 的字符串，包括有关修饰符和类型参数的信息。
    String
    toString()
    将对象转换为字符串。

    在类 java.lang.Object 中声明的方法

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

  • 方法详情

    • toString

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

    • toGenericString

      public String  toGenericString()
      返回描述此 Class 的字符串，包括有关修饰符和类型参数的信息。该字符串被格式化为类型修饰符列表（如果有），后跟类型的种类（基本类型和 class、enum、interface、@interface 或 record 为空字符串，视情况而定），后跟类型名称，再后跟一个类型参数的尖括号逗号分隔列表（如果有），包括类型参数的信息范围（如果有）。空格用于将修饰符彼此分开，并将任何修饰符与类型的种类分开。修饰符按规范顺序出现。如果没有类型参数，则省略类型参数列表。对于数组类型，字符串以类型名称开头，后跟用尖括号括起来的逗号分隔的类型类型参数列表（如果有），后跟一系列 [] 个字符，数组的每个维度一组括号。

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

      返回：
      描述此 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 的类被初始化。

      如果从堆栈上没有调用者框架的上下文调用此方法（例如，当直接从 JNI 附加线程调用时），则使用系统类加载器。

      参数：
      className - 所需类的完全限定名称。
      返回：
      具有指定名称的类的 Class 对象。
      抛出：
      LinkageError - 如果链接失败
      ExceptionInInitializerError - 如果此方法引发的初始化失败
      ClassNotFoundException - 如果找不到类
      看Java 语言规范:
      12.2 加载类和接口
      12.3 类和接口的链接
      12.4 类和接口的初始化

    • forName

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

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

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

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

      Class.forName("Foo")
      相当于：
      Class.forName("Foo", true, this.getClass().getClassLoader())
      请注意，此方法会抛出与加载、链接或初始化相关的错误，如第 12.2、12.3 和 12.4 节中所指定Java 语言规范.请注意，此方法不会检查请求的类是否可供其调用者访问。
      参数：
      name - 所需类的完全限定名称
      initialize - 如果 true 类将被初始化（这意味着链接）。请参阅第 12.4 节Java 语言规范.
      loader - 必须从中加载类的类加载器
      返回：
      表示所需类的类对象
      抛出：
      LinkageError - 如果链接失败
      ExceptionInInitializerError - 如果此方法引发的初始化失败
      ClassNotFoundException - 如果类不能被指定的类加载器定位
      SecurityException - 如果存在安全管理器，并且 loader 是 null，并且调用者的类加载器不是 null，并且调用者没有 RuntimePermission ("getClassLoader")
      看Java 语言规范:
      12.2 加载类和接口
      12.3 类和接口的链接
      12.4 类和接口的初始化
      自从：
      1.2
      参见：

    • forName

      public static Class <?> forName(Module  module, String  name)
      返回给定模块中具有给定 二进制名称 的 Class。

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

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

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

      API 注意：
      此方法在失败时返回 null 而不是抛出 ClassNotFoundException ，就像 forName(String, boolean, ClassLoader) 方法所做的那样。如果调用者加载另一个模块中的类，则安全检查是基于堆栈的权限检查。
      参数：
      module - 一个模块
      name - 类的二进制名称
      返回：
      Class 给定模块中定义的给定名称的对象； null 如果未找到。
      抛出：
      NullPointerException - 如果给定的模块或名称是 null
      LinkageError - 如果链接失败
      SecurityException -
      • 如果调用者不是指定模块并且RuntimePermission("getClassLoader")权限被拒绝；或者
      • 拒绝访问模块内容。例如，当类加载器调用ModuleReader.open(String) 读取模块中类文件的字节时，将执行权限检查。
      看Java 语言规范:
      12.2 加载类和接口
      12.3 类和接口的链接
      自从：
      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；或者如果类没有 nullary 构造函数；或者如果实例化由于其他原因失败。
      ExceptionInInitializerError - 如果此方法引发的初始化失败。
      SecurityException - 如果是安全经理，s, 存在并且调用者的类加载器与当前类的类加载器不同或不是其祖先，调用 s.checkPackageAccess() 拒绝访问此类的包。

    • isInstance

      public boolean isInstance(Object  obj)
      确定指定的 Object 是否与此 Class 表示的对象兼容。此方法是 Java 语言 instanceof 运算符的动态等价物。如果指定的 Object 参数不为空并且可以强制转换为此 Class 对象表示的引用类型而无需引发 ClassCastException.，则该方法返回 true 否则返回 false。

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

      参数：
      obj - 要检查的对象
      返回：
      如果 obj 是此类的实例，则为真
      自从：
      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 - 如果指定的类参数为空。
      自从：
      1.1

    • isInterface

      public boolean isInterface()
      确定此 Class 对象是否表示接口类型。
      返回：
      true 如果这个 Class 对象代表一个接口； false否则。

    • isArray

      public boolean isArray()
      确定此 Class 对象是否表示数组类。
      指定者：
      isArray 在接口 TypeDescriptor.OfField<T> 中
      返回：
      true 如果这个 Class 对象表示一个数组类； false否则。
      自从：
      1.1

    • isPrimitive

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

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

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

      指定者：
      isPrimitive 在接口 TypeDescriptor.OfField<T> 中
      返回：
      当且仅当此类表示原始类型时才为真
      自从：
      1.1
      参见：

    • isAnnotation

      public boolean isAnnotation()
      如果此 Class 对象表示注释接口，则返回 true。请注意，如果此方法返回 true，isInterface() 也会返回 true，因为所有注释接口也是接口。
      返回：
      true 如果这个 Class 对象表示一个注解接口； false否则
      自从：
      1.5

    • isSynthetic

      public boolean isSynthetic()
      当且仅当此类设置了合成修饰符位时，才返回 true。
      返回：
      true 当且仅当此类设置了合成修饰符位
      看Java 语言规范:
      13.1 二进制形式
      看Java 虚拟机规范:
      4.1ClassFile结构
      自从：
      1.5
      参见：

    • getName

      public String  getName()
      返回此 Class 对象表示的实体名称（类、接口、数组类、原始类型或 void）。

      如果这个 Class 对象表示一个类或接口，而不是一个数组类，那么：

      如果此 Class 对象表示数组类，则结果是一个字符串，由一个或多个表示数组嵌套深度的“[”字符组成，后跟使用下表编码的元素类型：

      元素类型和编码
      元素类型 编码
      boolean Z
      byte B
      char C
      二进制名称 的类或接口N L N ;
      double D
      float F
      int I
      long J
      short S

      如果这个 Class 对象表示原始类型或 void ，那么结果是一个字符串，其拼写与对应于原始类型或 void 的 Java 语言关键字相同。

      示例：

       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"
      返回：
      此 Class 对象表示的类、接口或其他实体的名称。
      看Java 语言规范:
      13.1 二进制形式

    • getClassLoader

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

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

      返回：
      加载此 Class 对象表示的类或接口的类加载器。
      抛出：
      SecurityException - 如果存在安全管理器，并且调用者的类加载器不是 null 并且与请求类加载器的类的类加载器不同或不是其祖先，并且调用者没有 RuntimePermission ("getClassLoader")
      参见：

    • getModule

      public Module  getModule()
      返回此类或接口所属的模块。如果此类表示数组类型，则此方法返回元素类型的 Module。如果此类表示原始类型或 void，则返回 java.base 模块的 Module 对象。如果此类在未命名模块中，则返回此类的类加载器的无名 Module。
      返回：
      此类或接口所属的模块
      自从：
      9

    • getTypeParameters

      public TypeVariable <Class <T >>[] getTypeParameters()
      返回一个 TypeVariable 对象数组，这些对象表示由此 GenericDeclaration 对象表示的泛型声明所声明的类型变量，按声明顺序排列。如果基础泛型声明未声明类型变量，则返回长度为 0 的数组。
      指定者：
      getTypeParameters 在接口 GenericDeclaration 中
      返回：
      一个 TypeVariable 对象数组，表示此泛型声明所声明的类型变量
      抛出：
      GenericSignatureFormatError - 如果此通用声明的通用签名不符合 4.7.9 节中指定的格式Java 虚拟机规范
      自从：
      1.5

    • getSuperclass

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

    • getGenericSuperclass

      public Type  getGenericSuperclass()
      返回表示此 Class 对象表示的实体（类、接口、原始类型或 void）的直接超类的 Type。

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

      返回：
      此 Class 对象表示的类的直接超类
      抛出：
      GenericSignatureFormatError - 如果泛型类签名不符合 4.7.9 节中指定的格式Java 虚拟机规范
      TypeNotPresentException - 如果泛型超类引用不存在的类型声明
      MalformedParameterizedTypeException - 如果泛型超类引用一个因任何原因不能被实例化的参数化类型
      自从：
      1.5

    • getPackage

      public 包  getPackage()
      获取该类的包。

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

      返回：
      这个类的包。

    • getPackageName

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

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

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

      如果此类是 本地类 或 匿名类，则此方法等效于在 封装方法 或 封闭构造函数 的 声明类 上调用 getPackageName()。

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

      返回：
      完全合格的包名称
      看Java 语言规范:
      6.7 完全限定名称
      自从：
      9

    • getInterfaces

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

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

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

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

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

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

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

      返回：
      此类直接实现的接口数组

    • getGenericInterfaces

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

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

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

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

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

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

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

      返回：
      此类直接实现的接口数组
      抛出：
      GenericSignatureFormatError - 如果泛型类签名不符合 4.7.9 节中指定的格式Java 虚拟机规范
      TypeNotPresentException - 如果任何通用超接口引用不存在的类型声明
      MalformedParameterizedTypeException - 如果任何通用超接口引用一个参数化类型，但由于任何原因无法实例化
      自从：
      1.5

    • getComponentType

      public Class <?> getComponentType()
      返回表示数组组件类型的Class。如果此类不表示数组类，则此方法返回 null。
      返回：
      如果此类是数组，则 Class 表示此类的组件类型
      自从：
      1.1
      参见：

    • getModifiers

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

      如果底层类是数组类：

      • 它的 public 、 private 和 protected 修饰符与其组件类型的修饰符相同
      • 它的 abstract 和 final 修饰符总是 true
      • 它的接口修饰符总是 false ，即使组件类型是接口
      如果此 Class 对象表示原始类型或 void，则其 public、abstract 和 final 修饰符始终为 true。对于表示 void、基本类型和数组的Class 对象，其他修饰符的值是 false 与上面指定的不同。

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

      返回：
      int 表示此类的修饰符
      看Java 语言规范:
      8.1.1 类修饰符
      9.1.1.界面修饰符
      看Java 虚拟机规范:
      4.1ClassFile结构
      自从：
      1.1
      参见：

    • accessFlags

      public Set <AccessFlag > accessFlags()
      为此类返回一组不可修改的 访问标志，可能为空。

      如果底层类是数组类：

      • 它的 PUBLIC 、 PRIVATE 和 PROTECTED 访问标志与其组件类型的访问标志相同
      • 它的 ABSTRACT 和 FINAL 标志存在
      • 它的 INTERFACE 标志不存在，即使组件类型是接口
      如果此 Class 对象表示原始类型或 void，则标志为 PUBLIC、ABSTRACT 和 FINAL。对于表示 void、原始类型和数组的 Class 对象，除了上面指定的之外，没有访问标志。
      返回：
      此类不可修改的 访问标志 集，可能为空
      看Java 虚拟机规范:
      4.1 类文件结构
      4.7.6 InnerClasses 属性
      自从：
      20
      参见：

    • getSigners

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

    • getEnclosingMethod

      public Method  getEnclosingMethod() throws SecurityException
      如果此 Class 对象表示方法中的本地或匿名类，则返回一个 Method 对象表示基础类的直接封闭方法。否则返回 null。特别是，如果底层类是本地类或匿名类，则此方法返回 null 并立即包含在类或接口声明、实例初始值设定项或静态初始值设定项中。
      返回：
      底层类的直接封闭方法，如果该类是本地类或匿名类；否则 null 。
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且满足以下任何条件：
      • 调用者的类加载器与封闭类的类加载器不同，使用 RuntimePermission("accessDeclaredMembers") 调用 s.checkPermission 方法拒绝访问封闭类中的方法
      • 调用者的类加载器与封闭类的类加载器不同或不是其祖先，调用 s.checkPackageAccess() 拒绝访问封闭类的包
      自从：
      1.5

    • getEnclosingConstructor

      public 构造方法 <?> getEnclosingConstructor() throws SecurityException
      如果此 Class 对象表示构造函数中的本地或匿名类，则返回一个 Constructor 对象，表示基础类的直接封闭构造函数。否则返回 null。特别是，如果底层类是本地类或匿名类，则此方法返回 null 并立即包含在类或接口声明、实例初始值设定项或静态初始值设定项中。
      返回：
      底层类的直接封闭构造函数，如果该类是本地类或匿名类；否则 null 。
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且满足以下任何条件：
      • 调用者的类加载器与封闭类的类加载器不同，使用 RuntimePermission("accessDeclaredMembers") 调用 s.checkPermission 方法会拒绝访问封闭类中的构造函数
      • 调用者的类加载器与封闭类的类加载器不同或不是其祖先，调用 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()
      返回此类或接口名称的信息字符串。
      指定者：
      getTypeName 在接口 Type 中
      返回：
      此类或接口名称的信息字符串
      自从：
      1.8

    • getCanonicalName

      public String  getCanonicalName()
      返回由定义的基础类的规范名称Java 语言规范.如果底层类没有规范名称，则返回 null。没有规范名称的类包括： 原始类的规范名称是相应原始类型的关键字（byte、short、char、int 等）。

      当且仅当其组件类型具有规范名称时，数组类型才具有规范名称。当数组类型具有规范名称时，它等于组件类型的规范名称后跟“[]”。

      返回：
      基础类的规范名称（如果存在），否则为 null。
      看Java 语言规范:
      6.7 完全限定名称和规范名称
      自从：
      1.5

    • isAnonymousClass

      public boolean isAnonymousClass()
      当且仅当基础类是匿名类时返回 true。
      API 注意：
      匿名类不是 隐藏类 。
      返回：
      true 当且仅当此类是匿名类时。
      看Java 语言规范:
      15.9.5 匿名类声明
      自从：
      1.5

    • isLocalClass

      public boolean isLocalClass()
      当且仅当基础类是本地类时返回 true。
      返回：
      true 当且仅当此类是本地类。
      看Java 语言规范:
      14.3 本地类声明
      自从：
      1.5

    • isMemberClass

      public boolean isMemberClass()
      当且仅当基础类是成员类时返回 true。
      返回：
      true当且仅当此类是成员类。
      看Java 语言规范:
      8.5 成员类型声明
      自从：
      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 对象的数组，这些对象反映了此 Class 对象表示的类或接口的所有可访问公共字段。

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

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

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

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

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

      返回：
      表示公共字段的 Field 对象数组
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且调用者的类加载器与当前类的类加载器不同或不是其祖先，调用 s.checkPackageAccess() 拒绝访问此类的包。
      看Java 语言规范:
      8.2 类成员
      8.3 字段声明
      自从：
      1.1

    • getMethods

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

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

      如果此 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 更具体。如果满足以下条件，则 N 比 M 更具体：
        1. N由类声明，M由接口声明；或者
        2. N 和 M 都由类或接口声明，并且 N 的声明类型与 M 的声明类型相同或者是 M 的声明类型的子类型（显然，如果 M 和 N 的声明类型相同，则 M 和 N 是相同的方法） .
      4. 该算法的结果是从步骤 3 中选择的所有方法的联合。
      API 注意：
      一个类中可能有多个具有特定名称和参数类型的方法，因为虽然 Java 语言禁止类声明具有相同签名但返回类型不同的多个方法，但 Java 虚拟机却不允许。虚拟机中这种增加的灵活性可用于实现各种语言功能。例如，可以使用 桥梁方法 实现协变返回；桥接方法和覆盖方法将具有相同的签名但返回类型不同。
      返回：
      代表此类公共方法的 Method 对象数组
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且调用者的类加载器与当前类的类加载器不同或不是其祖先，调用 s.checkPackageAccess() 拒绝访问此类的包。
      看Java 语言规范:
      8.2 类成员
      8.4 方法声明
      自从：
      1.1

    • getConstructors

      public 构造方法 <?>[] getConstructors() throws SecurityException
      返回一个包含 Constructor 对象的数组，这些对象反映了由该 Class 对象表示的类的所有公共构造函数。如果类没有公共构造函数，或者如果类是数组类，或者如果类反映原始类型或 void，则返回长度为 0 的数组。
      API 注意：
      虽然此方法返回一个 Constructor<T> 对象数组（即此类的构造函数数组），但此方法的返回类型可能是 Constructor<?>[] 和 not Constructor<T>[]。这种信息较少的返回类型是必要的，因为从该方法返回后，数组可以修改为保存不同类的 Constructor 对象，这将违反 Constructor<T>[] 的类型保证。
      返回：
      代表此类公共构造函数的 Constructor 对象数组
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且调用者的类加载器与当前类的类加载器不同或不是其祖先，调用 s.checkPackageAccess() 拒绝访问此类的包。
      自从：
      1.1
      参见：

    • getField

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

      要反射的字段由以下算法确定。设 C 为这个 Class 对象表示的类或接口：

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

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

      参数：
      name - 字段名称
      返回：
      name 指定的此类的 Field 对象
      抛出：
      NoSuchFieldException - 如果未找到具有指定名称的字段。
      NullPointerException - 如果 name 是 null
      SecurityException - 如果是安全经理，s, 存在并且调用者的类加载器与当前类的类加载器不同或不是其祖先，调用 s.checkPackageAccess() 拒绝访问此类的包。
      看Java 语言规范:
      8.2 类成员
      8.3 字段声明
      自从：
      1.1

    • getMethod

      public Method  getMethod(String  name, Class <?>... parameterTypes) throws NoSuchMethodException , SecurityException
      返回一个 Method 对象，该对象反映此 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 更具体。如果满足以下条件，则 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 的子类型，由 R.class.isAssignableFrom(java.lang.Class<?>) (S.class) 确定。
      API 注意：
      一个类中可能有多个具有匹配名称和参数类型的方法，因为虽然 Java 语言禁止类声明具有相同签名但返回类型不同的多个方法，但 Java 虚拟机却不允许。虚拟机中这种增加的灵活性可用于实现各种语言功能。例如，可以使用 桥梁方法 实现协变返回；桥接方法和覆盖方法将具有相同的签名但返回类型不同。此方法将返回覆盖方法，因为它具有更具体的返回类型。
      参数：
      name - 方法的名称
      parameterTypes - 参数列表
      返回：
      与指定的 name 和 parameterTypes 匹配的 Method 对象
      抛出：
      NoSuchMethodException - 如果未找到匹配方法或名称为“<init>”或“<clinit>”。
      NullPointerException - 如果 name 是 null
      SecurityException - 如果是安全经理，s, 存在并且调用者的类加载器与当前类的类加载器不同或不是其祖先，调用 s.checkPackageAccess() 拒绝访问此类的包。
      看Java 语言规范:
      8.2 类成员
      8.4 方法声明
      自从：
      1.1

    • getConstructor

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

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

      参数：
      parameterTypes - 参数数组
      返回：
      与指定的 parameterTypes 匹配的公共构造函数的 Constructor 对象
      抛出：
      NoSuchMethodException - 如果未找到匹配的构造函数，包括当此 Class 对象表示接口、基本类型、数组类或 void 时。
      SecurityException - 如果是安全经理，s, 存在并且调用者的类加载器与当前类的类加载器不同或不是其祖先，调用 s.checkPackageAccess() 拒绝访问此类的包。
      自从：
      1.1
      参见：

    • getDeclaredClasses

      public Class <?>[] getDeclaredClasses() throws SecurityException
      返回一个 Class 对象数组，反映声明为此 Class 对象表示的类的成员的所有类和接口。这包括公共类、受保护类、默认（包）访问以及类声明的私有类和接口，但不包括继承的类和接口。如果该类没有将类或接口声明为成员，或者如果此 Class 对象表示基本类型、数组类或 void，则此方法返回一个长度为 0 的数组。
      返回：
      代表该类所有已声明成员的 Class 对象数组
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且满足以下任何条件：
      • 调用者的类加载器与此类的类加载器不同，使用 RuntimePermission("accessDeclaredMembers") 调用 s.checkPermission 方法拒绝访问此类中声明的类
      • 调用者的类加载器与当前类的类加载器或类加载器的祖先不同，s.checkPackageAccess() 的调用拒绝访问此类的包
      看Java 语言规范:
      8.5 成员类型声明
      自从：
      1.1

    • getDeclaredFields

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

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

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

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

      返回：
      Field 对象数组，表示此类的所有已声明字段
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且满足以下任何条件：
      • 调用者的类加载器与此类的类加载器不同，使用 RuntimePermission("accessDeclaredMembers") 调用 s.checkPermission 方法会拒绝访问此类中声明的字段
      • 调用者的类加载器与当前类的类加载器或类加载器的祖先不同，s.checkPackageAccess() 的调用拒绝访问此类的包
      看Java 语言规范:
      8.2 类成员
      8.3 字段声明
      自从：
      1.1

    • getRecordComponents

      public RecordComponent [] getRecordComponents()
      返回代表此记录类的所有记录组件的 RecordComponent 对象数组，如果此类不是记录类，则返回 null。

      组件返回的顺序与它们在记录头中声明的顺序相同。如果此记录类没有组件，则数组为空。如果该类不是记录类，即 isRecord() 返回 false ，则此方法返回 null 。相反，如果 isRecord() 返回 true ，则此方法返回一个非空值。

      API 注意：

      以下方法可用于查找记录规范构造方法：

      
 static <T extends Record> Constructor<T> getCanonicalConstructor(Class<T> cls)
   throws NoSuchMethodException {
  Class<?>[] paramTypes =
   Arrays.stream(cls.getRecordComponents())
      .map(RecordComponent::getType)
      .toArray(Class<?>[]::new);
  return cls.getDeclaredConstructor(paramTypes);
 }
      返回：
      代表该记录类的所有记录组件的 RecordComponent 对象数组，如果此类不是记录类，则为 null
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且满足以下任何条件：
      • 调用者的类加载器与此类的类加载器不同，使用 RuntimePermission("accessDeclaredMembers") 调用 s.checkPermission 方法拒绝访问此类中声明的方法
      • 调用者的类加载器与当前类的类加载器或类加载器的祖先不同，s.checkPackageAccess() 的调用拒绝访问此类的包
      看Java 语言规范:
      8.10 记录类
      自从：
      16

    • getDeclaredMethods

      public Method [] getDeclaredMethods() throws SecurityException
      返回包含 Method 个对象的数组，这些对象反映了此 Class 对象表示的类或接口的所有已声明方法，包括公共、受保护、默认（包）访问和私有方法，但不包括继承方法。声明的方法可能包括类或接口的源代码中的方法not，包括编译器添加的桥梁方法和其他合成的方法。

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

      如果此 Class 对象表示具有类初始化方法 <clinit> 的类或接口，则返回的数组 not 确实具有对应的 Method 对象。

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

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

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

      返回：
      Method 对象数组，表示此类的所有已声明方法
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且满足以下任何条件：
      • 调用者的类加载器与此类的类加载器不同，使用 RuntimePermission("accessDeclaredMembers") 调用 s.checkPermission 方法拒绝访问此类中声明的方法
      • 调用者的类加载器与当前类的类加载器或类加载器的祖先不同，s.checkPackageAccess() 的调用拒绝访问此类的包
      看Java 语言规范:
      8.2 类成员
      8.4 方法声明
      自从：
      1.1
      参见：

    • getDeclaredConstructors

      public 构造方法 <?>[] getDeclaredConstructors() throws SecurityException
      返回一个 Constructor 对象数组，反映由该 Class 对象表示的类隐式或显式声明的所有构造函数。这些是公共、受保护、默认（包）访问和私有构造函数。返回的数组中的元素未排序且未按任何特定顺序排列。如果该类具有默认构造函数 (JLS 8.8.9)，则它包含在返回的数组中。如果记录类具有规范构造函数（JLS 8.10.4.1、8.10.4.2），则它包含在返回的数组中。如果此 Class 对象表示接口、基本类型、数组类或 void，则此方法返回一个长度为 0 的数组。
      返回：
      Constructor 对象数组，表示此类的所有已声明构造函数
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且满足以下任何条件：
      • 调用者的类加载器与此类的类加载器不同，使用 RuntimePermission("accessDeclaredMembers") 调用 s.checkPermission 方法拒绝访问此类中声明的构造函数
      • 调用者的类加载器与当前类的类加载器或类加载器的祖先不同，s.checkPackageAccess() 的调用拒绝访问此类的包
      看Java 语言规范:
      8.8 构造函数声明
      自从：
      1.1
      参见：

    • getDeclaredField

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

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

      参数：
      name - 字段名称
      返回：
      此类中指定字段的 Field 对象
      抛出：
      NoSuchFieldException - 如果未找到具有指定名称的字段。
      NullPointerException - 如果 name 是 null
      SecurityException - 如果是安全经理，s, 存在并且满足以下任何条件：
      • 调用者的类加载器与此类的类加载器不同，使用 RuntimePermission("accessDeclaredMembers") 调用 s.checkPermission 方法拒绝访问声明的字段
      • 调用者的类加载器与当前类的类加载器或类加载器的祖先不同，s.checkPackageAccess() 的调用拒绝访问此类的包
      看Java 语言规范:
      8.2 类成员
      8.3 字段声明
      自从：
      1.1

    • getDeclaredMethod

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

      如果这个Class对象代表一个数组类型，那么这个方法就没有找到clone()方法。

      参数：
      name - 方法的名称
      parameterTypes - 参数数组
      返回：
      匹配指定名称和参数的此类方法的 Method 对象
      抛出：
      NoSuchMethodException - 如果未找到匹配方法。
      NullPointerException - 如果 name 是 null
      SecurityException - 如果是安全经理，s, 存在并且满足以下任何条件：
      • 调用者的类加载器与此类的类加载器不同，使用 RuntimePermission("accessDeclaredMembers") 调用 s.checkPermission 方法拒绝访问声明的方法
      • 调用者的类加载器与当前类的类加载器或类加载器的祖先不同，s.checkPackageAccess() 的调用拒绝访问此类的包
      看Java 语言规范:
      8.2 类成员
      8.4 方法声明
      自从：
      1.1

    • getDeclaredConstructor

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

    • getResourceAsStream

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

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

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

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

      • 如果 name 以 '/' ('\u002f' ) 开头，则资源的绝对名称是 name 中跟在 '/' 之后的部分。
      • 否则，绝对名称具有以下形式：
        modified_package_name/name

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

      参数：
      name - 所需资源的名称
      返回：
      一个InputStream 对象； null 如果未找到具有此名称的资源，则该资源位于至少对调用方模块而言不是 open 的包中，或者安全管理器拒绝访问该资源。
      抛出：
      NullPointerException - 如果 name 是 null
      自从：
      1.1
      参见：

    • getResource

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

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

      否则，如果此类不在命名模块中，则搜索与给定类关联的资源的规则由类的定义 类加载器 实现。此方法委托给此 Class 对象的类加载器。如果这个 Class 对象是由引导类加载器加载的，则该方法委托给 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

    • getProtectionDomain

      public ProtectionDomain  getProtectionDomain()
      返回此类的 ProtectionDomain。如果安装了安全管理器，此方法首先调用安全管理器的 checkPermission 方法，并具有 RuntimePermission("getProtectionDomain") 权限，以确保可以获取 ProtectionDomain 。
      返回：
      此类的 ProtectionDomain
      抛出：
      SecurityException - 如果安全管理器存在且其 checkPermission 方法不允许获取 ProtectionDomain。
      自从：
      1.2
      参见：

    • desiredAssertionStatus

      public boolean desiredAssertionStatus()
      如果在调用此方法时初始化此类，则返回将分配给此类的断言状态。如果此类已设置其断言状态，则将返回最新设置；否则，如果任何包默认断言状态属于此类，则返回最具体的相关包默认断言状态的最新设置；否则，如果此类不是系统类（即，它有一个类加载器），则返回其类加载器的默认断言状态；否则，返回系统类默认断言状态。
      API 注意：
      很少有程序员需要这种方法；它是为了 JDK 本身的利益而提供的。 （它允许类在初始化时确定是否应启用断言。）请注意，此方法不能保证返回实际的断言状态，该断言状态是（或将要）与指定类关联的（或将被）初始化。
      返回：
      指定类的所需断言状态。
      自从：
      1.4
      参见：

    • isEnum

      public boolean isEnum()
      当且仅当此类在源代码中被声明为枚举时才返回 true。请注意，Enum 本身不是一个枚举类。另请注意，如果使用类主体声明枚举常量，则该枚举常量对象的类是匿名类，not 是声明枚举类的类。枚举常量的 Enum.getDeclaringClass() 方法可用于获取声明常量的枚举类的类。
      返回：
      当且仅当此类在源代码中被声明为枚举时才为真
      看Java 语言规范:
      8.9.1 枚举常量
      自从：
      1.5

    • isRecord

      public boolean isRecord()
      当且仅当此类是记录类时返回 true。

      记录类的 直接超类 是 java.lang.Record 。记录类是 final 。记录类具有（可能为零）记录组件； getRecordComponents() 返回一个非空但可能为空的记录值。

      请注意，类 Record 不是记录类，因此在类 Record 上调用此方法会返回 false。

      返回：
      当且仅当此类是记录类时才为真，否则为假
      看Java 语言规范:
      8.10 记录类
      自从：
      16

    • getEnumConstants

      public T [] getEnumConstants()
      返回此枚举类的元素；如果此 Class 对象不表示枚举类，则返回 null。
      返回：
      包含值的数组，该值包含此 Class 对象所表示的枚举类，按照它们声明的顺序排列；如果此 Class 对象不表示枚举类，则为 null
      看Java 语言规范:
      8.9.1 枚举常量
      自从：
      1.5

    • cast

      public T  cast(Object  obj)
      将一个对象转换为此 Class 对象表示的类或接口。
      参数：
      obj - 要投射的对象
      返回：
      转换后的对象，如果 obj 为 null，则为 null
      抛出：
      ClassCastException - 如果对象不为空且不可分配给类型 T。
      自从：
      1.5

    • asSubclass

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

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

      类型参数：
      U - 将此 Class 对象转换为的类型
      参数：
      clazz - 将此 Class 对象转换为的类型的类
      返回：
      this Class 对象，转换为表示指定类对象的子类。
      抛出：
      ClassCastException - 如果这个 Class 对象不代表指定类的子类（这里的“子类”包括类本身）。
      自从：
      1.5

    • getAnnotation

      public <A extends Annotation > A getAnnotation(Class <A> annotationClass)
      如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。

      请注意，此方法返回的任何注解都是声明注解。

      指定者：
      getAnnotation 在接口 AnnotatedElement 中
      类型参数：
      A - 要查询并返回（如果存在）的注释类型
      参数：
      annotationClass——注解类型对应的Class对象
      返回：
      如果此元素上存在此元素的指定注解类型的注解，则为 null
      抛出：
      NullPointerException - 如果给定的注释类为 null
      自从：
      1.5

    • isAnnotationPresent

      public boolean isAnnotationPresent(Class <? extends Annotation > annotationClass)
      如果指定类型的注解在此元素上为 present，则返回 true，否则返回 false。此方法主要是为了方便访问标记注释而设计的。

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

      指定者：
      isAnnotationPresent 在接口 AnnotatedElement 中
      参数：
      annotationClass——注解类型对应的Class对象
      返回：
      如果此元素上存在指定注解类型的注解，则为 true，否则为 false
      抛出：
      NullPointerException - 如果给定的注释类为 null
      自从：
      1.5

    • getAnnotationsByType

      public <A extends Annotation > A[] getAnnotationsByType(Class <A> annotationClass)
      返回带有此元素的 associated 注释。如果这个元素没有注解associated，返回值是一个长度为0的数组。这个方法和AnnotatedElement.getAnnotation(Class) 的区别是这个方法检测它的参数是否是一个repeatable annotation type(JLS 9.6)，如果是，则尝试寻找通过“查看”容器注解来查看该类型的一个或多个注释。该方法的调用者可以自由修改返回的数组；它不会影响返回给其他调用者的数组。

      请注意，此方法返回的任何注释都是声明注解。

      指定者：
      getAnnotationsByType 在接口 AnnotatedElement 中
      类型参数：
      A - 要查询并返回（如果存在）的注释类型
      参数：
      annotationClass——注解类型对应的Class对象
      返回：
      如果与此元素相关联，则为指定注解类型的所有此元素的注释，否则为长度为零的数组
      抛出：
      NullPointerException - 如果给定的注释类为 null
      自从：
      1.8

    • getAnnotations

      public Annotation [] getAnnotations()
      返回此元素上的 present 注释。如果该元素上没有注解present，则返回值为长度为0的数组。该方法的调用者可以自由修改返回的数组；它不会影响返回给其他调用者的数组。

      请注意，此方法返回的任何注释都是声明注解。

      指定者：
      getAnnotations 在接口 AnnotatedElement 中
      返回：
      此元素上的注释
      自从：
      1.5

    • getDeclaredAnnotation

      public <A extends Annotation > A getDeclaredAnnotation(Class <A> annotationClass)
      如果此类注解为 directly present ，则返回此元素针对指定类型的注解，否则为 null。此方法忽略继承的注释。 （如果没有注释直接出现在该元素上，则返回 null。）

      请注意，此方法返回的任何注解都是声明注解。

      指定者：
      getDeclaredAnnotation 在接口 AnnotatedElement 中
      类型参数：
      A - 要查询的注解类型，如果直接存在则返回
      参数：
      annotationClass——注解类型对应的Class对象
      返回：
      如果直接出现在此元素上，则此元素针对指定注解类型的注解，否则为 null
      抛出：
      NullPointerException - 如果给定的注释类为 null
      自从：
      1.8

    • getDeclaredAnnotationsByType

      public <A extends Annotation > A[] getDeclaredAnnotationsByType(Class <A> annotationClass)
      如果此类注解是 directly present 或 indirectly present ，则返回此元素的指定类型的注解。此方法忽略继承的注释。如果没有指定的注解直接或间接出现在这个元素上，返回值是一个长度为0的数组。这个方法和AnnotatedElement.getDeclaredAnnotation(Class) 的区别是这个方法检测它的参数是否是一个repeatable annotation type(JLS 9.6)，如果是，尝试通过“查看”容器注解（如果存在）来查找该类型的一个或多个注释。该方法的调用者可以自由修改返回的数组；它不会影响返回给其他调用者的数组。

      请注意，此方法返回的任何注释都是声明注解。

      指定者：
      getDeclaredAnnotationsByType 在接口 AnnotatedElement 中
      类型参数：
      A - 如果直接或间接存在，要查询并返回的注释类型
      参数：
      annotationClass——注解类型对应的Class对象
      返回：
      如果直接或间接出现在该元素上，则指定注解类型的所有该元素的注释，否则为长度为零的数组
      抛出：
      NullPointerException - 如果给定的注释类为 null
      自从：
      1.8

    • getDeclaredAnnotations

      public Annotation [] getDeclaredAnnotations()
      返回此元素上的 directly present 注释。此方法忽略继承的注释。如果该元素上没有注解directly present，则返回值为长度为0的数组。该方法的调用者可以自由修改返回的数组；它不会影响返回给其他调用者的数组。

      请注意，此方法返回的任何注释都是声明注解。

      指定者：
      getDeclaredAnnotations 在接口 AnnotatedElement 中
      返回：
      注释直接出现在这个元素上
      自从：
      1.5

    • getAnnotatedSuperclass

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

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

      如果此 Class 表示 Object 类、接口类型、数组类型、原始类型或 void，则返回值为 null。

      返回：
      表示超类的对象
      自从：
      1.8

    • getAnnotatedInterfaces

      public AnnotatedType [] getAnnotatedInterfaces()
      返回一个 AnnotatedType 对象数组，这些对象表示使用类型来指定此 Class 对象表示的实体的超接口。 （用于在“...实现 Foo”中指定超接口的 Foo 类型的 use 与接口 Foo 的 declaration 不同。）

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

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

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

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

      返回：
      表示父级接口的数组
      自从：
      1.8

    • getNestHost

      public Class <?> getNestHost()
      返回此 Class 对象所表示的类或接口所属的 巢 的嵌套主机。每个类和接口都属于一个嵌套。如果之前已经确定了此类或接口的嵌套宿主，则此方法返回嵌套宿主。如果这个类或接口的嵌套主机之前没有被确定，那么这个方法使用JVMS 5.4.4的算法确定嵌套主机，并返回它。通常，类或接口属于仅由其自身组成的嵌套，在这种情况下，此方法返回 this 以指示该类或接口是嵌套宿主。

      如果这个Class对象表示原始类型、数组类型或void，则此方法返回this，表示表示的实体属于只由它自己组成的嵌套，是嵌套宿主。

      返回：
      此类或接口的嵌套宿主
      抛出：
      SecurityException - 如果返回的类不是当前类，并且是安全管理器，s存在并且调用者的类加载器与返回类的类加载器不同或不是其祖先，调用 s.checkPackageAccess() 拒绝访问返回类的包
      看Java 虚拟机规范:
      4.7.28NestHost属性
      4.7.29NestMembers属性
      5.4.4 访问控制
      自从：
      11

    • isNestmateOf

      public boolean isNestmateOf(Class <?> c)
      确定给定的 Class 是否是此 Class 对象表示的类或接口的 nestmate。如果两个类或接口具有相同的 巢寄主 ，则它们是 nestmates。
      参数：
      c - 要检查的类
      返回：
      true 如果这个类和 c 是同一个巢的成员；和 false 否则。
      自从：
      11

    • getNestMembers

      public Class <?>[] getNestMembers()
      返回一个包含 Class 对象的数组，这些对象表示作为此 Class 对象所表示的类或接口所属的嵌套成员的所有类和接口。首先，该方法获取该Class对象所表示的类或接口所属的嵌套的巢寄主、H。返回数组的第零个元素是 H 。然后，对于被H记录为其嵌套成员的每个类或接口C，该方法尝试获取C的Class对象（使用当前Class对象的定义类加载器），然后获取嵌套的巢寄主以C 属于哪个。 H 记录为其嵌套成员的类和接口，以及 H 可以确定为其嵌套主机的类和接口，由返回数组的后续元素指示。这些元素的顺序是未指定的。允许重复。

      如果此 Class 对象表示基本类型、数组类型或 void ，则此方法返回包含 this 的单元素数组。

      API 注意：
      返回的数组仅包含记录在 NestMembers 属性中的嵌套成员，而不包含通过 Lookup::defineHiddenClass 添加到嵌套中的任何隐藏类。
      返回：
      与此类或接口位于同一嵌套中的所有类和接口的数组
      抛出：
      SecurityException - 如果任何返回的类不是当前类，并且如果是安全管理器，s, 存在并且调用者的类加载器与该返回类的类加载器不同或它的祖先，并且调用 s.checkPackageAccess() 拒绝访问该返回类的包
      看Java 虚拟机规范:
      4.7.28NestHost属性
      4.7.29NestMembers属性
      自从：
      11
      参见：

    • descriptorString

      public String  descriptorString()
      返回此 Class 对象表示的实体（类、接口、数组类、原始类型或 void ）的描述符字符串。

      如果这个 Class 对象表示一个类或接口，而不是一个数组类，那么：

      • 如果类或接口不是 hidden ，则结果是该类或接口的字段描述符 (JVMS 4.3.2 )。使用结果描述符字符串调用 ClassDesc::ofDescriptor 会生成描述此类或接口的 ClassDesc 。
      • 如果类或接口是 hidden ，则结果是以下形式的字符串：
        "L" + N + "." + <suffix> + ";"
        其中 N 是以传递给 Lookup::defineHiddenClass 的 class 文件指示的内部形式编码的 二进制名称，而 <suffix> 是一个不合格的名称。隐藏类或接口没有 名义描述符 。结果字符串不是类型描述符。

      如果此 Class 对象表示数组类，则结果是一个字符串，由一个或多个“[”字符组成，表示数组嵌套的深度，后跟元素类型的描述符字符串。

      • 如果元素类型不是hidden类或接口，那么这个数组类可以名义上描述。使用结果描述符字符串调用 ClassDesc::ofDescriptor 会生成描述此数组类的 ClassDesc 。
      • 如果元素类型是hidden类或接口，那么这个数组类就不能名义上描述了。结果字符串不是类型描述符。

      如果这个 Class 对象表示原始类型或 void ，那么结果是一个字段描述符字符串，它是对应于原始类型或 void ("B", "C", "D", "F", "I", "J", "S", "Z", "V" ) (JVMS 4.3.2 ) 的单字母代码。

      指定者：
      descriptorString 在接口 TypeDescriptor 中
      API 注意：
      这不是 forName(java.lang.String) 的严格逆；共享通用名称但具有不同类加载器的不同类将具有相同的描述符字符串。
      返回：
      此 Class 对象的描述符字符串
      看Java 虚拟机规范:
      4.3.2 字段描述符
      自从：
      12

    • componentType

      public Class <?> componentType()
      返回此 Class 的组件类型，如果它描述数组类型，否则返回 null。
      指定者：
      componentType 在接口 TypeDescriptor.OfField<T> 中
      实现要求：
      相当于 getComponentType() 。
      返回：
      a Class 描述组件类型，或者 null 如果这个 Class 没有描述数组类型
      自从：
      12

    • arrayType

      public Class <?> arrayType()
      为其组件类型由此 Class 描述的数组类型返回 Class。
      指定者：
      arrayType 在接口 TypeDescriptor.OfField<T> 中
      返回：
      一个 Class 描述数组类型
      抛出：
      UnsupportedOperationException - 如果此组件类型为 void 或生成的数组类型的维数超过 255。
      看Java 虚拟机规范:
      4.3.2 字段描述符
      4.4.1CONSTANT_Class_info结构
      自从：
      12

    • describeConstable

      public Optional <ClassDesc > describeConstable()
      如果可以构造，则返回此实例的标称描述符，如果不能构造，则返回一个空的Optional 。
      指定者：
      describeConstable 在接口 Constable 中
      返回：
      包含生成的标称描述符的 Optional ，或者如果无法构造则为空的 Optional 。
      自从：
      12

    • isHidden

      public boolean isHidden()
      当且仅当基础类是隐藏类时返回 true。
      返回：
      true 当且仅当此类是隐藏类时。
      自从：
      15
      参见：

    • getPermittedSubclasses

      public Class <?>[] getPermittedSubclasses()
      返回一个包含 Class 对象的数组，这些对象表示允许扩展或实现此类或接口（如果它是密封的）的直接子接口或子类。这些元素的顺序是未指定的。如果此密封类或接口没有允许的子类，则该数组为空。如果这个 Class 对象代表一个原始类型， void ，一个数组类型，或者一个非密封的类或接口，即 isSealed() 返回 false ，那么这个方法返回 null 。相反，如果 isSealed() 返回 true ，则此方法返回一个非空值。对于记录为允许的直接子接口或此类或接口的子类的每个类或接口 C，此方法尝试获取 C 的 Class 对象（使用当前 Class 对象的 定义类加载器）。可以获取的Class对象是此类或接口的直接子接口或子类，由返回数组的元素指示。如果无法获得 Class 对象，则会被忽略，并且不会包含在结果数组中。
      返回：
      此类或接口允许的子类的 Class 对象数组，或者 null 如果此类或接口未密封。
      抛出：
      SecurityException - 如果是安全经理，s, 存在并且调用者的类加载器与该返回类的类加载器不同或不是其祖先，调用 s.checkPackageAccess() 拒绝访问返回数组中任何类的包。
      看Java 语言规范:
      8.1 类声明
      9.1 接口声明
      自从：
      17

    • isSealed

      public boolean isSealed()
      当且仅当此 Class 对象表示密封类或接口时，返回 true。如果此 Class 对象表示基本类型 void 或数组类型，则此方法返回 false 。密封类或接口具有（可能为零）允许的子类； getPermittedSubclasses() 为密封类或接口返回一个非空但可能为空的值。
      返回：
      true 当且仅当此 Class 对象表示密封类或接口时。
      看Java 语言规范:
      8.1 类声明
      9.1 接口声明
      自从：
      17