Module java.base
Package java.lang

Class 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(obj + "的类是" + obj.getClass().getName());
}
也可以使用类文字获取命名类或接口（或void）的Class对象。例如： 
System.out.println("类Foo的名称是：" + Foo.class.getName());

Class类的一些方法公开了一个类或接口在Java源代码中是否被封装的声明。其他方法描述了类或接口在一个嵌套中的位置。一个嵌套是一组类和接口，位于同一运行时包中，允许彼此访问其private成员。这些类和接口被称为嵌套成员。一个嵌套成员充当嵌套主机，并列出属于嵌套的其他嵌套成员；每个嵌套成员又将其记录为嵌套主机。属于嵌套的类和接口，包括其主机，在生成class文件时确定，例如，Java编译器通常将顶级类记录为嵌套的主机，其中其他成员是其声明封装在顶级类声明内部的类和接口。

隐藏类

通过调用Lookup::defineHiddenClass创建的类或接口是隐藏类或接口。所有类的种类，包括枚举类和记录类，都可以是隐藏类；所有接口的种类，包括注解接口，都可以是隐藏接口。隐藏类或接口的名称不是二进制名称，这意味着以下内容： 隐藏类或接口永远不是数组类，但可以是数组的元素类型。在其他方面，类或接口是隐藏的这一事实对Class类的方法公开的特征没有影响。

未命名类

由Java编译器从未命名类的源文件生成的未命名类预览的class文件是顶级的、合成的和final的。虽然未命名类在其Java源形式中没有名称，但java.lang.Class的几个与名称相关的方法对表示未命名类的Class对象返回非空结果。通常，Java编译器从未命名类的源文件开始，例如HelloWorld.java，创建一个同名的class文件，HelloWorld.class，其中存储在该class文件中的类命名为"HelloWorld"，与源文件和class文件的基本名称匹配。对于未命名类HelloWorld的Class对象，获取名称和类型名称的方法返回结果等于"HelloWorld"。这种未命名类的简单名称为空字符串，规范名称为null。
参见Java语言规范：
15.8.2 类文字
自：
1.0
另请参见：

  • Method Details

    • toString

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

    • toGenericString

      public String toGenericString()
      返回描述此Class的字符串，包括有关修饰符和类型参数的信息。字符串格式为类型修饰符列表（如果有），后跟类型的类型（原始类型和class、enum、interface、@interface或record），后跟类型的名称，后跟尖括号分隔的逗号分隔的类型参数列表（如果有），包括类型参数的信息性边界（如果有）。修饰符之间用空格分隔，修饰符与类型之间用空格分隔。修饰符按规范顺序出现。如果没有类型参数，则省略类型参数列表。对于数组类型，字符串以类型名称开头，后跟尖括号分隔的逗号分隔的类型参数列表（如果有），后跟一系列[]字符，每个数组维度一个括号集。

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

      返回值:
      一个描述此Class的字符串，包括有关修饰符和类型参数的信息
      自JDK版本:
      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对象，使用给定的类加载器。根据类或接口的二进制名称，此方法尝试定位和加载类或接口。指定的类加载器用于加载类或接口。如果参数loader为null，则通过引导类加载器加载类。仅当initialize参数为true且尚未初始化类时，才会初始化类。

      此方法不能用于获取表示原始类型或void的任何Class对象，隐藏的类或接口，或其元素类型为隐藏的类或接口的数组类。例如，如果name表示原始类型或void，例如I，则会尝试定位未命名包中名称为I的用户定义类。

      要获取与数组类关联的Class对象，名称由一个或多个表示数组嵌套深度的'['字符组成，后跟Class.getName()中指定的编码的元素类型。

      示例：

      Class<?> threadClass = Class.forName("java.lang.Thread", false, currentLoader);
Class<?> stringArrayClass = Class.forName("[Ljava.lang.String;", false, currentLoader);
Class<?> intArrayClass = Class.forName("[[[I", false, currentLoader);   // int[][][]的类
Class<?> nestedClass = Class.forName("java.lang.Character$UnicodeBlock", false, currentLoader);
Class<?> fooClass = Class.forName("Foo", true, currentLoader);

      从forName(N)返回的Class对象调用getName()将返回N。

      调用forName("[LN;")将加载元素类型为N的类，但不会初始化，无论initialize参数的值如何。

      API注释:
      此方法会抛出与Java语言规范中第12.2、12.3和12.4节中指定的加载、链接或初始化相关的错误。此外，此方法不检查请求的类是否对其调用者可访问。
      参数:
      name - 类的二进制名称或表示数组类的字符串
      initialize - 如果为true，则将初始化类（这意味着链接）。请参阅Java语言规范中的第12.4节。
      loader - 必须加载类的类加载器
      返回值:
      表示所需类的类对象
      异常:
      LinkageError - 如果链接失败
      ExceptionInInitializerError - 如果此方法引发的初始化失败
      ClassNotFoundException - 如果指定的类加载器无法找到类
      SecurityException - 如果存在安全管理器，并且loader为null，并且调用者的类加载器不为null，并且调用者没有RuntimePermission("getClassLoader")
      参见 Java语言规范:
      12.2 类和接口的加载
      12.3 类和接口的链接
      12.4 类和接口的初始化
      13.1 二进制形式
      自JDK版本:
      1.2
      参见:

    • forName

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

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

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

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

      API注释:
      与forName(String, boolean, ClassLoader)不同，此方法不支持加载数组类型。类名必须是二进制名称。此方法在失败时返回null，而不像forName(String, boolean, ClassLoader)方法那样抛出ClassNotFoundException。如果调用者加载另一个模块中的类，则安全检查是基于堆栈的权限检查。
      参数:
      module - 一个模块
      name - 类的二进制名称
      返回值:
      给定模块中定义的给定名称的Class对象；如果未找到，则返回null。
      异常:
      NullPointerException - 如果给定模块或名称为null
      LinkageError - 如果链接失败
      SecurityException -
      • 如果调用者不是指定的模块，并且拒绝RuntimePermission("getClassLoader")权限；或
      • 拒绝访问模块内容。例如，当类加载器调用ModuleReader.open(String)读取模块中类文件的字节时，将执行权限检查。
      参见 Java语言规范:
      12.2 类和接口的加载
      12.3 类和接口的链接
      自JDK版本:
      9

    • newInstance

      @Deprecated(since="9") public T newInstance() throws InstantiationException, IllegalAccessException
      Deprecated.
      This method propagates any exception thrown by the nullary constructor, including a checked exception. Use of this method effectively bypasses the compile-time exception checking that would otherwise be performed by the compiler. The Constructor.newInstance method avoids this problem by wrapping any exception thrown by the constructor in a (checked) InvocationTargetException.

      The call

      clazz.newInstance()
      can be replaced by 
      clazz.getDeclaredConstructor().newInstance()
      The latter sequence of calls is inferred to be able to throw the additional exception types InvocationTargetException and NoSuchMethodException. Both of these exception types are subclasses of ReflectiveOperationException.
      创建由此Class对象表示的类的新实例。该类的实例化方式类似于使用空参数列表的new表达式。如果尚未初始化类，则将初始化类。
      返回:
      由此对象表示的类的新分配实例。
      抛出:
      IllegalAccessException - 如果类或其无参构造函数不可访问。
      InstantiationException - 如果此Class表示一个抽象类、一个接口、一个数组类、一个基本类型或void；或者如果类没有无参构造函数；或者由于其他原因实例化失败。
      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是此类的实例，则返回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对象
      返回:
      表示对象的类型cls是否可以分配给此类的对象的boolean值
      抛出:
      NullPointerException - 如果指定的Class参数为null。
      自:
      1.1

    • isInterface

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

    • isArray

      public boolean isArray()
      确定此Class对象是否表示一个数组类。
      指定者:
      isArray 在接口 TypeDescriptor.OfField<T>中
      返回:
      如果此Class对象表示一个数组类，则返回true；否则返回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>中
      返回:
      如果此类表示一个基本类型，则返回true
      自:
      1.1
      参见:

    • isAnnotation

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

    • isSynthetic

      public boolean isSynthetic()
      如果此类具有合成修饰符位设置，则返回true。
      返回:
      如果此类具有合成修饰符位设置，则返回true
      参见Java语言规范:
      13.1 二进制形式
      参见Java虚拟机规范:
      4.1 ClassFile结构
      自:
      1.5
      参见:

    • getName

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

      如果此Class对象表示的是类或接口，而不是数组类，则：

      如果此Class对象表示数组类，则结果是一个字符串，其中包含一个或多个'['字符，表示数组嵌套的深度，后跟使用以下表格编码的元素类型：

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

      如果此Class对象表示原始类型或void，则结果是与Java语言关键字拼写相同的字符串，该关键字对应于原始类型或void。

      示例：

       String.class.getName()
     返回 "java.lang.String"
 Character.UnicodeBlock.class.getName()
     返回 "java.lang.Character$UnicodeBlock"
 byte.class.getName()
     返回 "byte"
 (new Object[3]).getClass().getName()
     返回 "[Ljava.lang.Object;"
 (new int[3][4][5][6][7][8][9]).getClass().getName()
     返回 "[[[[[[[I"
      API注释：
      不同的类对象可以具有相同的名称，但具有不同的类加载器。
      返回：
      此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。
      返回：
      此类或接口所属的模块
      自JDK版本：
      9

    • getTypeParameters

      public TypeVariable<Class<T>>[] getTypeParameters()
      返回由此GenericDeclaration对象表示的泛型声明声明的类型变量的TypeVariable对象数组，按声明顺序返回。如果基础泛型声明未声明类型变量，则返回长度为0的数组。
      指定者：
      getTypeParameters 在接口 GenericDeclaration中
      返回：
      表示此泛型声明声明的类型变量的TypeVariable对象数组
      抛出：
      GenericSignatureFormatError - 如果此泛型声明的泛型签名不符合Java虚拟机规范第4.7.9节中指定的格式
      自JDK版本：
      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 - 如果泛型类签名不符合Java虚拟机规范第4.7.9节中指定的格式
      TypeNotPresentException - 如果泛型超类引用不存在的类型声明
      MalformedParameterizedTypeException - 如果泛型超类引用由于任何原因无法实例化的参数化类型
      自JDK版本：
      1.5

    • getPackage

      public Package getPackage()
      获取此类的包。

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

      返回：
      此类的包。

    • getPackageName

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

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

      如果此类是成员类，则此方法等效于在封闭类上调用getPackageName()。

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

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

      返回：
      完全限定的包名称
      参见Java语言规范：
      6.7 完全限定名称
      自JDK版本：
      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对象。

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

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

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

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

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

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

      返回：
      由此类直接实现的接口的数组
      抛出：
      GenericSignatureFormatError - 如果通用类签名不符合The Java Virtual Machine Specification第4.7.9节中指定的格式
      TypeNotPresentException - 如果任何通用超级接口引用不存在的类型声明
      MalformedParameterizedTypeException - 如果任何通用超级接口引用由于任何原因无法实例化的参数化类型
      自：
      1.5

    • getComponentType

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

    • getModifiers

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

      如果底层类是数组类：

      • 其public、private和protected修饰符与其组件类型的相同
      • 其abstract和final修饰符始终为true
      • 其接口修饰符始终为false，即使组件类型是接口
      如果此Class对象表示原始类型或void，则其public、abstract和final修饰符始终为true。对于表示void、原始类型和数组的Class对象，除了上述规定的修饰符值为false外，其他修饰符的值均为false。

      修饰符编码在The Java Virtual Machine Specification的第4.1节中定义。

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

    • accessFlags

      public Set<AccessFlag> accessFlags()
      返回此类的access flags的不可修改集合，可能为空。

      如果底层类是数组类：

      • 其PUBLIC、PRIVATE和PROTECTED访问标志与其组件类型的相同
      • 其ABSTRACT和FINAL标志存在
      • 其INTERFACE标志不存在，即使组件类型是接口
      如果此Class对象表示原始类型或void，则标志为PUBLIC、ABSTRACT和FINAL。对于表示void、原始类型和数组的Class对象，除了上述规定的访问标志存在外，其他访问标志均不存在。
      返回：
      此类的access flags的不可修改集合，可能为空
      参见Java虚拟机规范：
      4.1 The ClassFile Structure
      4.7.6 The InnerClasses Attribute
      自：
      20
      参见：

    • getSigners

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

    • getEnclosingMethod

      public Method getEnclosingMethod() throws SecurityException
      如果此Class对象表示方法内的本地类或匿名类，则返回表示底层类的立即封闭方法的Method对象。否则返回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，并且满足以下任一条件之一：
      • 调用者的类加载器与封闭类的类加载器不同，并且使用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

    • isUnnamedClass

      public boolean isUnnamedClass()
      isUnnamedClass是Java平台的反射预览API。
      预览功能可能在将来的版本中被移除，或升级为Java平台的永久功能。
      如果基础类是未命名类，则返回true。
      API注释：
      未命名类不是匿名类。
      返回：
      如果基础类是未命名类，则返回true
      参见Java语言规范：
      7.3 编译单元
      自：
      21

    • 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
      返回一个包含反映由此Class对象表示的类或接口的所有可访问公共字段的Field对象的数组。

      如果此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对象表示数组类型，则返回的数组对应于从Object继承的数组类型的每个公共方法都有一个Method对象。它不包含clone()的Method对象。

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

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

      返回的数组中的元素未排序，也没有特定顺序。

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

      1. 方法的并集由以下组成：
        1. 由getDeclaredMethods()返回的C的声明的公共实例和静态方法，并进行过滤以仅包括公共方法。
        2. 如果C是除Object之外的类，则递归调用此算法在C的超类上。
        3. 包括递归调用此算法在C的所有直接超接口上的结果，但仅包括实例方法。
      2. 来自步骤1的并集被划分为具有相同签名（名称、参数类型）和返回类型的方法子集。
      3. 在每个这样的子集中，只选择最具体的方法。设方法M是具有相同签名和返回类型的方法集中的方法。如果不存在不同于M的方法N != M，使得N比M更具体，则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 Constructor<?>[] getConstructors() throws SecurityException
      返回一个包含Constructor对象的数组，反映了由此Class对象表示的类的所有公共构造函数。如果类没有公共构造函数，或者类是数组类，或者类反映原始类型或void，则返回长度为0的数组。
      API 注释:
      虽然此方法返回一个 Constructor<T>对象数组（即来自此类的构造函数数组），但此方法的返回类型是 Constructor<?>[]，而不是可能预期的Constructor<T>[]。这种信息较少的返回类型是必要的，因为从此方法返回后，数组可能被修改以保存不同类的Constructor对象，这将违反Constructor<T>[]的类型保证。
      返回值:
      表示此类的公共构造函数的Constructor对象数组
      抛出:
      SecurityException - 如果存在安全管理器s，并且调用者的类加载器与当前类的类加载器不同或不是当前类加载器的祖先，并且调用s.checkPackageAccess()拒绝访问此类的包。
      自版本:
      1.1
      参见:

    • getField

      public Field getField(String name) throws NoSuchFieldException, SecurityException
      返回一个反映由此Class对象表示的类或接口的指定公共成员字段的Field对象。 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来自同一集合，使得N比M更具体，则M是最具体的。 如果：
        1. N由类声明，M由接口声明；或
        2. N和M都由类或接口声明，并且N的声明类型与M的声明类型相同或是M的声明类型的子类型（显然，如果M和N的声明类型是相同类型，则M和N是相同方法）。
      4. 从步骤3中选择的所有选定方法中具有最具体返回类型的方法将任意选择为此算法的结果。 让R是来自步骤3中所有选定方法集合的方法M的返回类型。 如果没有这样的方法N != M来自同一集合，具有返回类型S != R，使得S是由R.class.isAssignableFrom(java.lang.Class<?>)(S.class)确定的R的子类型，则M是具有最具体返回类型的方法。
      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 Constructor<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，并且满足以下任一条件之一：
      • 调用者的类加载器与此类的类加载器不同，并且调用s.checkPermission方法使用RuntimePermission("accessDeclaredMembers")拒绝访问此类中声明的类
      • 调用者的类加载器与当前类的类加载器不同，或者调用s.checkPackageAccess()拒绝访问此类的包
      参见Java语言规范：
      8.5 成员类型声明
      自：
      1.1

    • getDeclaredFields

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

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

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

      返回数组中的元素未排序，也没有特定顺序。

      返回：
      表示此类所有声明字段的Field对象数组
      抛出：
      SecurityException - 如果存在安全管理器s，并且满足以下任一条件之一：
      • 调用者的类加载器与此类的类加载器不同，并且调用s.checkPermission方法使用RuntimePermission("accessDeclaredMembers")拒绝访问此类中声明的字段
      • 调用者的类加载器与当前类的类加载器不同，或者调用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")权限调用 方法拒绝访问此类中声明的方法
      • 调用者的类加载器与当前类的类加载器不同或不是当前类加载器的祖先，并且使用 方法拒绝访问此类的包
      参见 Java 语言规范:
      8.10 记录类
      自版本:
      16

    • getDeclaredMethods

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

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

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

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

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

      返回的数组中的元素未排序，也没有特定顺序。

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

    • getDeclaredConstructors

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

    • getDeclaredField

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

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

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

    • getDeclaredMethod

      public Method getDeclaredMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException
      返回反映由此Class对象表示的类或接口的指定已声明方法的Method对象。 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 Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException
      返回一个反映由此Class对象表示的类的指定构造函数的Constructor对象。 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。
      抛出:
      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对象；如果找不到具有此名称的资源，无法通过URL找到资源，资源位于至少对调用者模块开放的包中，或者安全管理器拒绝访问资源，则返回null。
      抛出:
      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 本身不是枚举类。还请注意，如果枚举常量使用类体声明，则该枚举常量对象的类是匿名类，而不是声明枚举类的类。枚举常量的 Enum.getDeclaringClass() 方法可用于获取声明常量的枚举类的类。
      返回:
      如果此类在源代码中被声明为枚举，则返回true
      参见 Java语言规范:
      8.9.1 枚举常量
      自版本:
      1.5

    • isRecord

      public boolean isRecord()
      如果此类是记录类，则返回true。

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

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

      返回:
      如果此类是记录类，则返回true，否则返回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 - 如果对象不为 null 且不可分配给类型 T。
      自版本:
      1.5

    • asSubclass

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

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

      类型参数:
      U - 要将此 Class 对象转换为的类型
      参数:
      clazz - 要将此 Class 对象转换为其子类的类
      返回:
      将此 Class 对象转换为表示指定类对象的子类。
      抛出:
      ClassCastException - 如果此 Class 对象不表示指定类的子类（此处“子类”包括类本身）。
      自版本:
      1.5

    • getAnnotation

      public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
      如果此元素的指定类型的注释存在，则返回该注释，否则返回 null。

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

      指定者:
      getAnnotation 在接口 AnnotatedElement 中
      类型参数:
      A - 要查询并返回的注释类型
      参数:
      annotationClass - 对应于注释类型的 Class 对象
      返回:
      如果此元素上存在指定注释类型的注释，则返回该元素的指定注释，否则返回 null
      抛出:
      NullPointerException - 如果给定的注释类为 null
      自版本:
      1.5

    • isAnnotationPresent

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

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

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

    • getAnnotationsByType

      public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationClass)
      返回与此元素关联的注释。如果此元素没有与之关联的注释，则返回值为长度为 0 的数组。此方法与 AnnotatedElement.getAnnotation(Class) 的区别在于，此方法检测其参数是否为可重复注释类型（JLS 9.6），如果是，则尝试通过“查找”容器注释来查找一个或多个该类型的注释。调用此方法的调用者可以修改返回的数组；这不会影响返回给其他调用者的数组。

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

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

    • getAnnotations

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

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

      指定者:
      getAnnotations 在接口 AnnotatedElement 中
      返回:
      此元素上存在的注释
      自版本:
      1.5

    • getDeclaredAnnotation

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

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

      指定者:
      getDeclaredAnnotation 在接口 AnnotatedElement 中
      类型参数:
      A - 要查询并返回的直接存在的注释类型
      参数:
      annotationClass - 对应于注释类型的 Class 对象
      返回:
      如果此元素上直接存在指定注释类型的注释，则返回该元素的指定注释，否则返回 null
      抛出:
      NullPointerException - 如果给定的注释类为 null
      自版本:
      1.8

    • getDeclaredAnnotationsByType

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

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

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

    • getDeclaredAnnotations

      public Annotation[] getDeclaredAnnotations()
      返回此元素上直接存在的注解。此方法忽略继承的注解。如果此元素上没有直接存在的注解，则返回值是长度为0的数组。调用此方法的对象可以修改返回的数组；这不会影响返回给其他调用者的数组。

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

      指定者:
      getDeclaredAnnotations 在接口 AnnotatedElement
      返回:
      此元素上直接存在的注解
      自从:
      1.5

    • getAnnotatedSuperclass

      public AnnotatedType getAnnotatedSuperclass()
      返回一个AnnotatedType对象，表示用于指定由此Class对象表示的实体的超类的类型。（在“... extends Foo”中使用类型Foo指定超类的“使用”与类Foo的“声明”是不同的。）

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

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

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

    • getAnnotatedInterfaces

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

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

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

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

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

      返回:
      表示超接口的数组
      自从:
      1.8

    • getNestHost

      public Class<?> getNestHost()
      返回Class对象的巢群宿主，该对象表示此Class对象所属的nest。每个类和接口都属于一个巢群。如果此类或接口的巢群宿主先前已确定，则此方法返回该巢群宿主。如果此类或接口的巢群宿主先前未确定，则此方法使用JVMS 5.4.4的算法确定巢群宿主，并返回它。通常，一个类或接口属于一个仅包含自身的巢群，此时此方法返回this以指示该类或接口是巢群宿主。

      如果此Class对象表示基本类型、数组类型或void，则此方法返回this，表示表示的实体属于仅包含自身的巢群，并且是巢群宿主。

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

    • isNestmateOf

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

    • getNestMembers

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

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

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

    • descriptorString

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

      如果此Class对象表示的是类或接口而不是数组类，则：

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

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

      • 如果元素类型不是隐藏的类或接口，则此数组类可以被名义描述。使用结果描述符字符串调用ClassDesc::ofDescriptor将产生描述此数组类的ClassDesc。
      • 如果元素类型是隐藏的类或接口，则此数组类无法被名义描述。结果字符串不是类型描述符。

      如果此Class对象表示原始类型或void，则结果是一个字段描述符字符串，该字符串是与原始类型或void对应的一个字母代码（"B"，"C"，"D"，"F"，"I"，"J"，"S"，"Z"，"V"）（JVMS 4.3.2）。

      指定者：
      descriptorString 在接口 TypeDescriptor
      返回：
      此Class对象的描述符字符串
      参见Java虚拟机规范：
      4.3.2 字段描述符
      自：
      12

    • componentType

      public Class<?> componentType()
      如果描述一个数组类型，则返回此Class的组件类型；否则返回null。
      指定者：
      componentType 在接口 TypeDescriptor.OfField<T>
      实现要求：
      等效于getComponentType()。
      返回：
      描述组件类型的Class，如果此Class不描述数组类型，则返回null
      自：
      12

    • arrayType

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

    • describeConstable

      public Optional<ClassDesc> describeConstable()
      返回此实例的名义描述符，如果可以构造一个，则返回一个包含结果名义描述符的空Optional；如果无法构造，则返回一个空的Optional。
      指定者：
      describeConstable 在接口 Constable
      返回：
      包含结果名义描述符的Optional，如果无法构造，则返回一个空的Optional
      自：
      12

    • isHidden

      public boolean isHidden()
      如果底层类是隐藏类，则返回true。
      返回：
      如果此类是隐藏类，则返回true。
      自：
      15
      参见：

    • getPermittedSubclasses

      public Class<?>[] getPermittedSubclasses()
      如果此Class对象表示一个密封类或接口，则返回一个包含代表允许扩展或实现此类或接口的直接子接口或子类的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()返回一个非空但可能为空的值。
      返回：
      如果此Class对象表示一个密封类或接口，则返回true。
      参见Java语言规范：
      8.1 类声明
      9.1 接口声明
      自：
      17