类的用途
java.lang.Class

使用 Class 的包

包	描述
com.sun.java.accessibility.util	提供组成 Java 辅助功能实用程序的接口和类的集合。
com.sun.source.tree	提供将源代码表示为抽象语法树 (AST) 的接口。
java.awt	包含用于创建用户界面以及绘制图形和图像的所有类。
java.awt.datatransfer	提供用于在应用程序之间和应用程序内传输数据的接口和类。
java.awt.dnd	拖放是一种在许多图形用户界面系统中发现的直接操作手势，它提供了一种机制，可以在逻辑上与 GUI 中的表示元素相关联的两个实体之间传输信息。
java.awt.image.renderable	提供用于生成与渲染无关的图像的类和接口。
java.beans	包含与开发 beans 相关的类——基于 JavaBeans 体系结构的组件。
java.beans.beancontext	提供与 bean 上下文相关的类和接口。
java.io	通过数据流、序列化和文件系统提供系统输入和输出。
java.lang	提供对 Java 编程语言的设计至关重要的类。
java.lang.annotation	为 Java 编程语言注解工具提供库支持。
java.lang.foreign	提供对 Java 运行时之外的内存和函数的低级访问。
java.lang.instrument	提供允许 Java 编程语言代理检测在 JVM 上运行的程序的服务。
java.lang.invoke	java.lang.invoke 包提供用于与 Java 虚拟机交互的低级原语。
java.lang.management	提供Java运行时Java虚拟机和其他组件的监控和管理的管理接口。
java.lang.reflect	提供用于获取有关类和对象的反射信息的类和接口。
java.lang.runtime	java.lang.runtime 包为 Java 语言提供低级运行时支持。
java.net	提供用于实现网络应用程序的类。
java.nio.file	定义Java虚拟机访问文件、文件属性和文件系统的接口和类。
java.nio.file.spi	java.nio.file 包的服务提供商类。
java.rmi.server	提供用于支持 RMI 服务端的类和接口。
java.security	为安全框架提供类和接口。
java.sql	提供使用 Java 编程语言访问和处理存储在数据源（通常是关系数据库）中的数据的 API。
java.util	包含集合框架、一些国际化支持类、服务加载器、属性、随机数生成、字符串解析和扫描类、base64 编码和解码、位数组和几个杂项实用程序类。
java.util.concurrent.atomic	支持对单个变量进行无锁线程安全编程的小型类工具包。
java.util.prefs	这个包允许应用程序存储和检索用户和系统首选项和配置数据。
javax.annotation.processing	用于声明注解处理器和允许注解处理器与注释处理工具环境进行通信的工具。
javax.crypto	提供用于加密操作的类和接口。
javax.imageio.metadata	处理读取和写入元数据的 Java Image I/O API 包。
javax.imageio.spi	Java 图像 I/O API 的一个包，其中包含用于读取器、写入器、转码器和流的插件接口，以及一个运行时注册表。
javax.lang.model	包的类型和层次结构包含 Java 语言模型、Java 编程语言的声明和类型模型。
javax.lang.model.element	用于对 Java 编程语言的元素建模的接口。
javax.lang.model.type	用于对 Java 编程语言类型建模的接口。
javax.management	为 Java 管理扩展提供核心类。
javax.management.loading	提供实现高级动态加载的类。
javax.management.openmbean	提供开放数据类型和 Open MBean 描述符类。
javax.naming.spi	通过 javax.naming 和相关包提供动态插入支持访问命名和目录服务的方法。
javax.print	为 Java 打印服务 API 提供主要类和接口。
javax.print.attribute	提供描述 Java Print Service 属性类型以及如何将它们收集到属性集中的类和接口。
javax.print.attribute.standard	包 javax.print.attribute.standard 包含特定打印属性的类。
javax.script	脚本 API 由定义 Java 脚本引擎的接口和类组成，并为它们在 Java 应用程序中的使用提供框架。
javax.security.auth	这个包提供了一个用于身份验证和授权的框架。
javax.sound.midi	为 MIDI（乐器数字接口）数据的 I/O、排序和合成提供接口和类。
javax.sound.sampled	提供用于捕获、处理和播放采样音频数据的接口和类。
javax.sql	提供用于从 Java 编程语言访问和处理服务端数据源的 API。
javax.sql.rowset	JDBC RowSet 实现的标准接口和基类。
javax.sql.rowset.serial	提供实用程序类以允许在 Java 编程语言中的 SQL 类型和数据类型之间进行可序列化映射。
javax.swing	提供一组“轻量级”（全 Java 语言）组件，尽可能在所有平台上以相同的方式工作。
javax.swing.event	提供由 Swing 组件触发的事件。
javax.swing.plaf.synth	Synth 是一种可换肤的外观和感觉，其中所有绘画都是委托的。
javax.swing.table	提供用于处理 javax.swing.JTable 的类和接口。
javax.swing.text	提供处理可编辑和不可编辑文本组件的类和接口。
javax.swing.tree	提供用于处理 javax.swing.JTree 的类和接口。
javax.tools	为可以从程序中调用的工具提供接口，例如编译器。
javax.xml.xpath	提供一个 object-model neutral API，用于评估 XPath 表达式和访问评估环境。
jdk.dynalink.beans	包含普通 Java 对象的链接器。
jdk.dynalink.linker	包含语言运行时所需的接口和类，以实现它们自己的特定于语言的对象模型和类型转换。
jdk.dynalink.linker.support	包含的类通过提供某些类的基本实现以及各种实用程序，使语言运行时更方便地实现自己的特定于语言的对象模型和类型转换。
jdk.incubator.vector	孵化功能。 将在未来的版本中删除。
jdk.jfr	这个包提供类来创建事件和控制飞行记录器。
jdk.jfr.consumer	此包包含用于使用 Flight Recorder 数据的类。
jdk.jshell.execution	为构建 JShell 执行引擎提供实现支持。
jdk.net	java.net 和 java.nio.channels 套接字类的平台特定套接字选项。

Class 在 com.sun.java.accessibility.util 中的用法

com.sun.java.accessibility.util 中返回 Class 的方法

修饰符和类型	方法	描述
protected static Class<?>	Translator.getTranslatorClass(Class<?> c)	为这门课找一个翻译。

com.sun.java.accessibility.util 中的方法，参数类型为 Class

修饰符和类型	方法	描述
void	AccessibilityListenerList.add(Class<? extends EventListener> t, EventListener l)	将监听添加为指定类型的监听。
int	AccessibilityListenerList.getListenerCount(Class<? extends EventListener> t)	返回此监听列表所提供类型的监听总数。
protected static Class<?>	Translator.getTranslatorClass(Class<?> c)	为这门课找一个翻译。
void	AccessibilityListenerList.remove(Class<? extends EventListener> t, EventListener l)	作为指定类型的监听删除监听。

Class 在 com.sun.source.tree 中的用法

com.sun.source.tree 中返回 Class 的方法

修饰符和类型	方法	描述
Class<? extends Tree>	Tree.Kind.asInterface()	返回使用此类的关联接口类型。

Class 在 java.awt 中的用法

java.awt 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T extends DragGestureRecognizer> T	Toolkit.createDragGestureRecognizer(Class<T> abstractRecognizerClass, DragSource ds, Component c, int srcActions, DragGestureListener dgl)	创建请求的抽象 DragGestureRecognizer 类的具体的、平台相关的子类，并将其与指定的 DragSource、Component 和 DragGestureListener 相关联。
static <T extends EventListener> T[]	AWTEventMulticaster.getListeners(EventListener l, Class<T> listenerType)	返回由指定的 java.util.EventListener 链接为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	Button.getListeners(Class<T> listenerType)	返回当前在此 Button 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	Checkbox.getListeners(Class<T> listenerType)	返回当前在此 Checkbox 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	CheckboxMenuItem.getListeners(Class<T> listenerType)	返回当前在此 CheckboxMenuItem 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	Choice.getListeners(Class<T> listenerType)	返回当前在此 Choice 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	Component.getListeners(Class<T> listenerType)	返回当前在此 Component 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	Container.getListeners(Class<T> listenerType)	返回当前在此 Container 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	List.getListeners(Class<T> listenerType)	返回当前在此 List 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	MenuItem.getListeners(Class<T> listenerType)	返回当前在此 MenuItem 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	Scrollbar.getListeners(Class<T> listenerType)	返回当前在此 Scrollbar 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	TextComponent.getListeners(Class<T> listenerType)	返回当前在此 TextComponent 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	TextField.getListeners(Class<T> listenerType)	返回当前在此 TextField 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	Window.getListeners(Class<T> listenerType)	返回当前在此 Window 上注册为 FooListener 的所有对象的数组。
protected static void	AWTKeyStroke.registerSubclass(Class<?> subclass)	已弃用。

Class 在 java.awt.datatransfer 中的用法

java.awt.datatransfer 中返回 Class 的方法

修饰符和类型	方法	描述
final Class<?>	DataFlavor.getDefaultRepresentationClass()	返回默认表示类。
Class<?>	DataFlavor.getRepresentationClass()	返回 Class 支持此 DataFlavor 的对象将在请求此 DataFlavor 时返回。
protected static final Class<?>	DataFlavor.tryToLoadClass(String className, ClassLoader fallback)	尝试从以下位置加载一个类：引导加载程序、系统加载程序、上下文加载程序（如果存在）和最后指定的加载程序。

java.awt.datatransfer 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	DataFlavor(Class<?> representationClass, String humanPresentableName)	构造一个代表 Java 类的 DataFlavor。

Class 在 java.awt.dnd 中的用法

java.awt.dnd 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T extends DragGestureRecognizer> T	DragSource.createDragGestureRecognizer(Class<T> recognizerAbstractClass, Component c, int actions, DragGestureListener dgl)	创建一个新的 DragGestureRecognizer 实现 DragGestureRecognizer 的指定抽象子类，并在新创建的对象上设置指定的 Component 和 DragGestureListener。
<T extends EventListener> T[]	DragSource.getListeners(Class<T> listenerType)	获取当前在此 DragSource 上注册为 FooListener 的所有对象。

Class 在 java.awt.image.renderable 中的用法

java.awt.image.renderable 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>[]	ParameterBlock.getParamClasses()	返回描述参数类型的 Class 对象数组。

Class 在 java.beans 中的用法

java.beans 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	BeanDescriptor.getBeanClass()	获取 bean 的 Class 对象。
Class<?>	BeanDescriptor.getCustomizerClass()	为 bean 的定制器获取 Class 对象。
Class<?>	IndexedPropertyDescriptor.getIndexedPropertyType()	返回索引属性的 Java 类型信息。
Class<?>	EventSetDescriptor.getListenerType()	获取目标接口的 Class 对象。
Class<?>	PropertyDescriptor.getPropertyEditorClass()	获取已为此属性注册的任何显式 PropertyEditor 类。
Class<?>	PropertyDescriptor.getPropertyType()	返回属性的 Java 类型信息。

java.beans 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static <T> T	EventHandler.create(Class<T> listenerInterface, Object target, String action)	创建 listenerInterface 的实现，其中监听器接口中的 all 方法将处理程序的 action 应用到 target 。
static <T> T	EventHandler.create(Class<T> listenerInterface, Object target, String action, String eventPropertyName)	/** 创建 listenerInterface 的实现，其中 all 方法将事件表达式 eventPropertyName 的值传递给语句中的最终方法 action，该方法应用于 target。
static <T> T	EventHandler.create(Class<T> listenerInterface, Object target, String action, String eventPropertyName, String listenerMethodName)	创建 listenerInterface 的实现，其中名为 listenerMethodName 的方法将事件表达式 eventPropertyName 的值传递给语句中的最终方法 action，该方法应用于 target。
static PropertyEditor	PropertyEditorManager.findEditor(Class<?> targetType)	找到给定目标类型的值编辑器。
static void	Introspector.flushFromCaches(Class<?> clz)	刷新给定类的内省器的内部缓存信息。
static BeanInfo	Introspector.getBeanInfo(Class<?> beanClass)	内省 Java Bean 并了解其所有属性、公开的方法和事件。
static BeanInfo	Introspector.getBeanInfo(Class<?> beanClass, int flags)	内省 Java bean 并了解其所有属性、公开的方法和事件，受某些控制标志的约束。
static BeanInfo	Introspector.getBeanInfo(Class<?> beanClass, Class<?> stopClass)	内省 Java bean 并在给定的“停止”点以下了解其所有属性、公开的方法。
static BeanInfo	Introspector.getBeanInfo(Class<?> beanClass, Class<?> stopClass, int flags)	内省 Java Bean 并了解它的所有属性、公开的方法和事件，在给定的 stopClass 点下受一些控制 flags 。
static Object	Beans.getInstanceOf(Object bean, Class<?> targetType)	从给定的 bean 中，获取表示该源对象的指定类型视图的对象。
PersistenceDelegate	Encoder.getPersistenceDelegate(Class<?> type)	返回给定类型的持久性委托。
protected void	DefaultPersistenceDelegate.initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out)	initialize 方法的这个默认实现假定保存在这种类型的对象中的所有状态都按照内省器返回的顺序通过匹配的“setter”和“getter”方法对公开。
protected void	PersistenceDelegate.initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out)	生成一系列对 newInstance 有副作用的语句，以便新实例变为 equivalent 到 oldInstance。
static boolean	Beans.isInstanceOf(Object bean, Class<?> targetType)	检查一个 bean 是否可以被视为给定的目标类型。
static void	PropertyEditorManager.registerEditor(Class<?> targetType, Class<?> editorClass)	注册一个编辑器类来编辑给定目标类的值。
void	Encoder.setPersistenceDelegate(Class<?> type, PersistenceDelegate delegate)	将指定的持久性委托与给定类型相关联。
void	PropertyDescriptor.setPropertyEditorClass(Class<?> propertyEditorClass)	通常使用 PropertyEditorManager 可以找到 PropertyEditors。

java.beans 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	BeanDescriptor(Class<?> beanClass)	为没有定制器的 bean 创建 BeanDescriptor。
	BeanDescriptor(Class<?> beanClass, Class<?> customizerClass)	为具有定制器的 bean 创建 BeanDescriptor。
	EventSetDescriptor(Class<?> sourceClass, String eventSetName, Class<?> listenerType, String listenerMethodName)	创建一个 EventSetDescriptor 假设您遵循最简单的标准设计模式，其中命名事件“fred”是 (1) 作为对接口 FredListener 的单个方法的调用传递的，(2) 具有 FredEvent 类型的单个参数，并且 ( 3) 其中 FredListener 可以通过对源组件的 addFredListener 方法的调用进行注册，并通过对 removeFredListener 方法的调用进行删除。
	EventSetDescriptor(Class<?> sourceClass, String eventSetName, Class<?> listenerType, String[] listenerMethodNames, String addListenerMethodName, String removeListenerMethodName)	使用字符串名称从头开始创建 EventSetDescriptor。
	EventSetDescriptor(Class<?> sourceClass, String eventSetName, Class<?> listenerType, String[] listenerMethodNames, String addListenerMethodName, String removeListenerMethodName, String getListenerMethodName)	此构造方法使用字符串名称从头开始创建一个 EventSetDescriptor。
	EventSetDescriptor(String eventSetName, Class<?> listenerType, MethodDescriptor[] listenerMethodDescriptors, Method addListenerMethod, Method removeListenerMethod)	使用 java.lang.reflect.MethodDescriptor 和 java.lang.Class 对象从头开始创建 EventSetDescriptor。
	EventSetDescriptor(String eventSetName, Class<?> listenerType, Method[] listenerMethods, Method addListenerMethod, Method removeListenerMethod)	使用 java.lang.reflect.Method 和 java.lang.Class 对象从头开始创建 EventSetDescriptor。
	EventSetDescriptor(String eventSetName, Class<?> listenerType, Method[] listenerMethods, Method addListenerMethod, Method removeListenerMethod, Method getListenerMethod)	此构造方法使用 java.lang.reflect.Method 和 java.lang.Class 对象从头开始创建 EventSetDescriptor。
	IndexedPropertyDescriptor(String propertyName, Class<?> beanClass)	此构造方法为属性构造一个 IndexedPropertyDescriptor，该属性通过具有 getFoo 和 setFoo 访问器方法来遵循标准 Java 约定，用于索引访问和数组访问。
	IndexedPropertyDescriptor(String propertyName, Class<?> beanClass, String readMethodName, String writeMethodName, String indexedReadMethodName, String indexedWriteMethodName)	此构造方法采用简单属性的名称，以及用于读取和写入属性的方法名称，包括索引和非索引。
	PropertyDescriptor(String propertyName, Class<?> beanClass)	通过具有 getFoo 和 setFoo 访问器方法，为遵循标准 Java 约定的属性构造一个 PropertyDescriptor。
	PropertyDescriptor(String propertyName, Class<?> beanClass, String readMethodName, String writeMethodName)	此构造方法采用简单属性的名称以及用于读取和写入属性的方法名称。

Class 在 java.beans.beancontext 中的用法

java.beans.beancontext 中的字段声明为 Class

修饰符和类型	Field	描述
protected Class<?>	BeanContextServiceAvailableEvent.serviceClass	对新可用服务的 Class 引用
protected Class<?>	BeanContextServiceRevokedEvent.serviceClass	对被撤销服务的 Class 引用。

java.beans.beancontext 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	BeanContextServiceAvailableEvent.getServiceClass()	获取作为此通知主题的服务类。
Class<?>	BeanContextServiceRevokedEvent.getServiceClass()	获取作为此通知主题的服务类

java.beans.beancontext 中的方法，参数类型为 Class

修饰符和类型	方法	描述
boolean	BeanContextServices.addService(Class<?> serviceClass, BeanContextServiceProvider serviceProvider)	向此 BeanContext 添加服务。
boolean	BeanContextServicesSupport.addService(Class<?> serviceClass, BeanContextServiceProvider bcsp)	添加服务
protected boolean	BeanContextServicesSupport.addService(Class<?> serviceClass, BeanContextServiceProvider bcsp, boolean fireEvent)	添加服务
protected static final boolean	BeanContextSupport.classEquals(Class<?> first, Class<?> second)	测试两个类对象或它们的名称是否相等。
protected BeanContextServicesSupport.BCSSServiceProvider	BeanContextServicesSupport.createBCSSServiceProvider(Class<?> sc, BeanContextServiceProvider bcsp)	子类可以重写此方法来创建 BCSSServiceProvider 的新子类，而无需重写 addService() 以实例化。
protected final void	BeanContextServicesSupport.fireServiceAdded(Class<?> serviceClass)	触发 BeanContextServiceEvent 通知新服务。
protected final void	BeanContextServicesSupport.fireServiceRevoked(Class<?> serviceClass, boolean revokeNow)	触发 BeanContextServiceRevokedEvent 指示特定服务不再可用。
Iterator<?>	BeanContextServiceProvider.getCurrentServiceSelectors(BeanContextServices bcs, Class<?> serviceClass)	由 BeanContextServices 调用，此方法获取指定服务的当前服务选择器。
Iterator<?>	BeanContextServices.getCurrentServiceSelectors(Class<?> serviceClass)	通过调用底层 BeanContextServiceProvider 上的 getCurrentServiceSelectors() 获取指定服务的服务相关服务参数（服务选择器）列表。
Iterator<?>	BeanContextServicesSupport.BCSSProxyServiceProvider.getCurrentServiceSelectors(BeanContextServices bcs, Class<?> serviceClass)
Iterator<?>	BeanContextServicesSupport.getCurrentServiceSelectors(Class<?> serviceClass)
Object	BeanContextServiceProvider.getService(BeanContextServices bcs, Object requestor, Class<?> serviceClass, Object serviceSelector)	由 BeanContextServices 调用，此方法请求来自此 BeanContextServiceProvider 的服务实例。
Object	BeanContextServices.getService(BeanContextChild child, Object requestor, Class<?> serviceClass, Object serviceSelector, BeanContextServiceRevokedListener bcsrl)	BeanContextChild 或与 BeanContextChild 关联的任意对象可以通过调用此方法从其嵌套 BeanContextServices 获取对当前注册服务的引用。
Object	BeanContextServicesSupport.BCSSProxyServiceProvider.getService(BeanContextServices bcs, Object requestor, Class<?> serviceClass, Object serviceSelector)
Object	BeanContextServicesSupport.getService(BeanContextChild child, Object requestor, Class<?> serviceClass, Object serviceSelector, BeanContextServiceRevokedListener bcsrl)	获得可以委托的服务
boolean	BeanContextServices.hasService(Class<?> serviceClass)	报告此上下文中当前是否提供给定服务。
boolean	BeanContextServicesSupport.hasService(Class<?> serviceClass)	有一个服务，可以委托
boolean	BeanContextServiceRevokedEvent.isServiceClass(Class<?> service)	检查此事件以确定被撤销的服务是否属于特定类。
void	BeanContextServices.revokeService(Class<?> serviceClass, BeanContextServiceProvider serviceProvider, boolean revokeCurrentServicesNow)	BeanContextServiceProviders 希望从此上下文中删除当前注册的服务可以通过调用此方法来实现。
void	BeanContextServicesSupport.revokeService(Class<?> serviceClass, BeanContextServiceProvider bcsp, boolean revokeCurrentServicesNow)	删除服务

java.beans.beancontext 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	BeanContextServiceAvailableEvent(BeanContextServices bcs, Class<?> sc)	构造一个 BeanContextAvailableServiceEvent 。
	BeanContextServiceRevokedEvent(BeanContextServices bcs, Class<?> sc, boolean invalidate)	构造一个 BeanContextServiceEvent 。

Class 在 java.io 中的用法

java.io 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	ObjectStreamClass.forClass()	返回此版本映射到的本地 VM 中的类。
Class<?>	ObjectStreamField.getType()	获取字段的类型。
protected Class<?>	ObjectInputStream.resolveClass(ObjectStreamClass desc)	加载与指定流类描述等效的本地类。
protected Class<?>	ObjectInputStream.resolveProxyClass(String[] interfaces)	返回一个代理类，该代理类实现了代理类描述符中命名的接口；子类可以实现此方法以从流中读取自定义数据以及动态代理类的描述符，从而允许它们为接口和代理类使用备用加载机制。
Class<?>	ObjectInputFilter.FilterInfo.serialClass()	被反序列化的对象的类。

java.io 中的方法，参数类型为 Class

修饰符和类型	方法	描述
protected void	ObjectOutputStream.annotateClass(Class<?> cl)	子类可以实现此方法以允许将类数据存储在流中。
protected void	ObjectOutputStream.annotateProxyClass(Class<?> cl)	子类可以实现此方法以将自定义数据与动态代理类的描述符一起存储在流中。
static ObjectStreamClass	ObjectStreamClass.lookup(Class<?> cl)	查找可以序列化的类的描述符。
static ObjectStreamClass	ObjectStreamClass.lookupAny(Class<?> cl)	返回任何类的描述符，无论它是否实现 Serializable 。

java.io 中的方法参数，类型参数为 Class

修饰符和类型	方法	描述
static ObjectInputFilter	ObjectInputFilter.allowFilter(Predicate<Class<?>> predicate, ObjectInputFilter.Status otherStatus)	如果类的谓词是 true ，则返回一个返回 Status.ALLOWED 的过滤器。
static ObjectInputFilter	ObjectInputFilter.rejectFilter(Predicate<Class<?>> predicate, ObjectInputFilter.Status otherStatus)	如果类上的谓词是 true ，则返回一个返回 Status.REJECTED 的过滤器。

java.io 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	ObjectStreamField(String name, Class<?> type)	创建具有指定类型的可序列化字段。
	ObjectStreamField(String name, Class<?> type, boolean unshared)	创建一个 ObjectStreamField，表示具有给定名称和类型的可序列化字段。

Class 在 java.lang 中的用法

java.lang 中的字段声明为 Class

修饰符和类型	Field	描述
static final Class<Boolean>	Boolean.TYPE	表示基本类型boolean的 Class 对象。
static final Class<Byte>	Byte.TYPE	代表原始类型 byte 的 Class 实例。
static final Class<Character>	Character.TYPE	代表原始类型 char 的 Class 实例。
static final Class<Double>	Double.TYPE	代表原始类型 double 的 Class 实例。
static final Class<Float>	Float.TYPE	代表原始类型 float 的 Class 实例。
static final Class<Integer>	Integer.TYPE	代表原始类型 int 的 Class 实例。
static final Class<Long>	Long.TYPE	代表原始类型 long 的 Class 实例。
static final Class<Short>	Short.TYPE	代表原始类型 short 的 Class 实例。
static final Class<Void>	Void.TYPE	Class 对象表示对应于关键字 void 的伪类型。

java.lang 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	Class.arrayType()	为其组件类型由此 Class 描述的数组类型返回 Class。
<U> Class<? extends U>	Class.asSubclass(Class<U> clazz)	转换此 Class 对象以表示由指定类对象表示的类的子类。
Class<?>	Class.componentType()	返回此 Class 的组件类型，如果它描述数组类型，否则返回 null。
protected final Class<?>	ClassLoader.defineClass(byte[] b, int off, int len)	已弃用。 替换为defineClass(String, byte[], int, int)
protected final Class<?>	ClassLoader.defineClass(String name, byte[] b, int off, int len)	将字节数组转换为类 Class 的实例。
protected final Class<?>	ClassLoader.defineClass(String name, byte[] b, int off, int len, ProtectionDomain protectionDomain)	使用给定的 ProtectionDomain 将字节数组转换为类 Class 的实例。
protected final Class<?>	ClassLoader.defineClass(String name, ByteBuffer b, ProtectionDomain protectionDomain)	使用给定的 ProtectionDomain 将 ByteBuffer 转换为类 Class 的实例。
Class<? extends Enum>	EnumConstantNotPresentException.enumType()	返回缺少的枚举常量的类型。
protected Class<?>	ClassLoader.findClass(String name)	查找具有指定 二进制名称 的类。
protected Class<?>	ClassLoader.findClass(String moduleName, String name)	在为此类加载器定义的模块中查找具有给定 二进制名称 的类。
protected final Class<?>	ClassLoader.findLoadedClass(String name)	如果此加载器已被 Java 虚拟机记录为具有该 二进制名称 的类的启动加载器，则返回具有给定 二进制名称 的类。
protected final Class<?>	ClassLoader.findSystemClass(String name)	查找具有指定 二进制名称 的类，必要时加载它。
static Class<?>	Class.forName(Module module, String name)	返回给定模块中具有给定 二进制名称 的 Class。
static Class<?>	Class.forName(String className)	返回与具有给定字符串名称的类或接口关联的 Class 对象。
static Class<?>	Class.forName(String name, boolean initialize, ClassLoader loader)	使用给定的类加载器返回与具有给定字符串名称的类或接口关联的 Class 对象。
Class<?>	StackWalker.getCallerClass()	获取调用 getCallerClass 方法的调用方的 Class 对象。
final Class<?>	Object.getClass()	返回此 Object 的运行时类。
protected Class<?>[]	SecurityManager.getClassContext()	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 将当前执行堆栈作为类数组返回。
Class<?>[]	Class.getClasses()	返回一个包含 Class 对象的数组，这些对象表示作为此 Class 对象所表示的类的成员的所有公共类和接口。
Class<?>	Class.getComponentType()	返回表示数组组件类型的Class。
Class<?>[]	Class.getDeclaredClasses()	返回一个 Class 对象数组，反映声明为此 Class 对象表示的类的成员的所有类和接口。
Class<?>	Class.getDeclaringClass()	如果此 Class 对象表示的类或接口是另一个类的成员，则返回表示声明它的类的 Class 对象。
final Class<E>	Enum.getDeclaringClass()	返回与此枚举常量的枚举类型对应的 Class 对象。
Class<?>	StackWalker.StackFrame.getDeclaringClass()	获取此堆栈帧表示的方法的声明 Class。
Class<?>	Class.getEnclosingClass()	返回基础类的直接封闭类。
Class<?>[]	Class.getInterfaces()	返回由此 Class 对象表示的类或接口直接实现的接口。
Class<?>	Class.getNestHost()	返回由此 Class 对象表示的类或接口所属的 巢 的嵌套主机。
Class<?>[]	Class.getNestMembers()	返回一个包含 Class 对象的数组，这些对象表示作为此 Class 对象所表示的类或接口所属的嵌套成员的所有类和接口。
Class<?>[]	Class.getPermittedSubclasses()	返回一个包含 Class 对象的数组，这些对象表示允许扩展或实现此类或接口（如果它是密封的）的直接子接口或子类。
Class<? super T>	Class.getSuperclass()	返回表示此 Class 表示的实体（类、接口、原始类型或 void）的直接超类的 Class。
Class<?>	ClassLoader.loadClass(String name)	加载具有指定 二进制名称 的类。
protected Class<?>	ClassLoader.loadClass(String name, boolean resolve)	加载具有指定 二进制名称 的类。

返回类型中包含 Class 类型参数的 java.lang 中的方法

修饰符和类型	方法	描述
TypeVariable<Class<T>>[]	Class.getTypeParameters()	返回一个 TypeVariable 对象数组，这些对象表示由此 GenericDeclaration 对象表示的泛型声明所声明的类型变量，按声明顺序排列。

java.lang 中的方法，参数类型为 Class

修饰符和类型	方法	描述
Module	Module.addUses(Class<?> service)	如果调用者的模块是此模块，则更新此模块以添加对给定服务类型的服务依赖。
<U> Class<? extends U>	Class.asSubclass(Class<U> clazz)	转换此 Class 对象以表示由指定类对象表示的类的子类。
boolean	Module.canUse(Class<?> service)	指示此模块是否具有对给定服务类型的服务依赖性。
static boolean	Compiler.compileClass(Class<?> clazz)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 编译指定的类。
protected abstract T	ClassValue.computeValue(Class<?> type)	计算此 ClassValue 的给定类的派生值。
T	ClassValue.get(Class<?> type)	返回给定类的值。
<A extends Annotation> A	Class.getAnnotation(Class<A> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T	Module.getAnnotation(Class<T> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<A extends Annotation> A	Package.getAnnotation(Class<A> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<A extends Annotation> A[]	Class.getAnnotationsByType(Class<A> annotationClass)	返回带有此元素的 associated 注释。
<A extends Annotation> A[]	Package.getAnnotationsByType(Class<A> annotationClass)	返回带有此元素的 associated 注释。
Constructor<T>	Class.getConstructor(Class<?>... parameterTypes)	返回一个 Constructor 对象，该对象反映此 Class 对象表示的类的指定公共构造函数。
<A extends Annotation> A	Class.getDeclaredAnnotation(Class<A> annotationClass)	如果此类注解为 directly present ，则返回此元素针对指定类型的注解，否则为 null。
<A extends Annotation> A	Package.getDeclaredAnnotation(Class<A> annotationClass)	如果此类注解为 directly present ，则返回此元素针对指定类型的注解，否则为 null。
<A extends Annotation> A[]	Class.getDeclaredAnnotationsByType(Class<A> annotationClass)	如果此类注解是 directly present 或 indirectly present ，则返回此元素的指定类型的注解。
<A extends Annotation> A[]	Package.getDeclaredAnnotationsByType(Class<A> annotationClass)
Constructor<T>	Class.getDeclaredConstructor(Class<?>... parameterTypes)	返回一个 Constructor 对象，该对象反映此 Class 对象表示的类的指定构造函数。
Method	Class.getDeclaredMethod(String name, Class<?>... parameterTypes)	返回一个 Method 对象，该对象反映了此 Class 对象表示的类或接口的指定声明方法。
Method	Class.getMethod(String name, Class<?>... parameterTypes)	返回一个 Method 对象，该对象反映此 Class 对象表示的类或接口的指定公共成员方法。
boolean	Class.isAnnotationPresent(Class<? extends Annotation> annotationClass)	如果指定类型的注解在此元素上为 present，则返回 true，否则返回 false。
boolean	Package.isAnnotationPresent(Class<? extends Annotation> annotationClass)	如果指定类型的注解在此元素上为 present，则返回 true，否则返回 false。
boolean	Class.isAssignableFrom(Class<?> cls)	确定此 Class 对象表示的类或接口是否与指定的 Class 参数表示的类或接口相同，或者是其超类或超接口。
boolean	Class.isNestmateOf(Class<?> c)	确定给定的 Class 是否是此 Class 对象表示的类或接口的 nestmate。
void	ClassValue.remove(Class<?> type)	删除给定类的关联值。
protected final void	ClassLoader.resolveClass(Class<?> c)	链接指定的类。
protected final void	ClassLoader.setSigners(Class<?> c, Object[] signers)	设置类的签名者。
static <T extends Enum<T>> T	Enum.valueOf(Class<T> enumClass, String name)	返回具有指定名称的指定枚举类的枚举常量。

java.lang 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	EnumConstantNotPresentException(Class<? extends Enum> enumType, String constantName)	为指定常量构造一个 EnumConstantNotPresentException。

Class 在 java.lang.annotation 中的用法

java.lang.annotation 中返回 Class 的方法

修饰符和类型	方法	描述
Class<? extends Annotation>	Annotation.annotationType()	返回该注解的注解。
Class<? extends Annotation>	IncompleteAnnotationException.annotationType()	返回带有缺失元素的注解的 Class 对象。

java.lang.annotation 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	IncompleteAnnotationException(Class<? extends Annotation> annotationType, String elementName)	构造一个 IncompleteAnnotationException 以指示指定的注解中缺少命名元素。

Class 在 java.lang.foreign 中的用法

java.lang.foreign 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	ValueLayout.carrier()	返回与此值布局关联的载体。

java.lang.foreign 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static ValueLayoutPREVIEW	MemoryLayout.valueLayout(Class<?> carrier, ByteOrder order)	创建给定 Java 载体和字节顺序的值布局。

Class 在 java.lang.instrument 中的用法

java.lang.instrument 中返回 Class 的方法

修饰符和类型	方法	描述
Class[]	Instrumentation.getAllLoadedClasses()	返回 JVM 当前加载的所有类的数组。
Class<?>	ClassDefinition.getDefinitionClass()	返回类。
Class[]	Instrumentation.getInitiatedClasses(ClassLoader loader)	返回所有类的数组，loader 可以通过 ClassLoader::loadClass 、Class::forName 和字节码链接按名称找到这些类。

java.lang.instrument 中的方法，参数类型为 Class

修饰符和类型	方法	描述
boolean	Instrumentation.isModifiableClass(Class<?> theClass)	测试类是否可由 再改造 或 重新定义 修改。
void	Instrumentation.retransformClasses(Class<?>... classes)	重新转换提供的类集。
default byte[]	ClassFileTransformer.transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer)	转换给定的类文件并返回一个新的替换类文件。
default byte[]	ClassFileTransformer.transform(Module module, ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer)	转换给定的类文件并返回一个新的替换类文件。

java.lang.instrument 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	ClassDefinition(Class<?> theClass, byte[] theClassFile)	使用提供的类和类文件字节创建新的 ClassDefinition 绑定。

Class 在 java.lang.invoke 中的用法

java.lang.invoke 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	MethodHandles.Lookup.accessClass(Class<?> targetClass)	确定是否可以从此 Lookup 对象定义的查找上下文访问类。
Class<?>	MethodHandles.Lookup.defineClass(byte[] bytes)	使用相同的类加载器和相同的运行时包和 保护域 创建并链接来自 bytes 的类或接口作为此查找的 查找类 ，就好像调用 ClassLoader::defineClass 一样。
Class<?>	MethodHandles.Lookup.ensureInitialized(Class<?> targetClass)	确保 targetClass 已被初始化。
Class<?>	MethodHandles.Lookup.findClass(String targetName)	从此 Lookup 对象定义的查找上下文中按名称查找类，仿佛解决了 通过 ldc 指令。
Class<?>	MethodHandleInfo.getDeclaringClass()	返回定义破解方法句柄的底层成员的类。
Class<?>	MethodType.lastParameterType()	返回此方法类型的最后一个参数类型。
Class<?>	MethodHandles.Lookup.lookupClass()	告诉哪个类正在执行查找。
Class<?>[]	MethodType.parameterArray()	将参数类型呈现为数组（一种便捷方法）。
Class<?>	MethodType.parameterType(int num)	在此方法类型中返回指定索引处的参数类型。
Class<?>	MethodHandles.Lookup.previousLookupClass()	报告另一个模块中的查找类，该查找对象先前是从中传送的，或 null 。
static Class<?>	ConstantBootstraps.primitiveClass(MethodHandles.Lookup lookup, String name, Class<?> type)	返回原始类型的 Class 镜像，其类型描述符由 name 指定。
Class<?>	MethodType.returnType()	返回此方法类型的返回类型。
Class<?>	VarHandle.varType()	返回此 VarHandle 引用的变量的变量类型。
static Class<?>	MethodHandleProxies.wrapperInstanceType(Object x)	恢复为其创建此包装器实例的唯一单一方法接口类型。

返回类型中包含 Class 类型参数的 java.lang.invoke 中的方法

修饰符和类型	方法	描述
List<Class<?>>	VarHandle.coordinateTypes()	返回此 VarHandle 的坐标类型。
List<Class<?>>	MethodType.parameterList()	将参数类型呈现为列表（一种便捷方法）。

java.lang.invoke 中的方法，参数类型为 Class

修饰符和类型	方法	描述
Class<?>	MethodHandles.Lookup.accessClass(Class<?> targetClass)	确定是否可以从此 Lookup 对象定义的查找上下文访问类。
MethodType	MethodType.appendParameterTypes(Class<?>... ptypesToInsert)	查找或创建具有附加参数类型的方法类型。
static MethodHandle	MethodHandles.arrayConstructor(Class<?> arrayClass)	生成一个方法句柄来构造所需类型的数组，就像通过 anewarray 字节码一样。
static MethodHandle	MethodHandles.arrayElementGetter(Class<?> arrayClass)	生成一个方法句柄，提供对数组元素的读取访问权限，就像通过 aaload 字节码一样。
static MethodHandle	MethodHandles.arrayElementSetter(Class<?> arrayClass)	生成一个方法句柄，提供对数组元素的写访问权限，就像通过 astore 字节码一样。
static VarHandle	MethodHandles.arrayElementVarHandle(Class<?> arrayClass)	生成一个 VarHandle，可以访问类型为 arrayClass 的数组的元素。
static MethodHandle	MethodHandles.arrayLength(Class<?> arrayClass)	生成一个返回数组长度的方法句柄，就像由 arraylength 字节码一样。
static VarHandle	ConstantBootstraps.arrayVarHandle(MethodHandles.Lookup lookup, String name, Class<VarHandle> type, Class<?> arrayClass)	查找数组类型的 VarHandle 。
MethodHandle	MethodHandle.asCollector(int collectArgPos, Class<?> arrayType, int arrayLength)	创建一个 array-collecting 方法句柄，它接受从给定位置开始的给定数量的位置参数，并将它们收集到一个数组参数中。
MethodHandle	MethodHandle.asCollector(Class<?> arrayType, int arrayLength)	创建一个 array-collecting 方法句柄，它接受给定数量的尾随位置参数并将它们收集到一个数组参数中。
static <T> T	MethodHandleProxies.asInterfaceInstance(Class<T> intfc, MethodHandle target)	生成给定的单一方法接口的实例，该接口将其调用重定向到给定的方法句柄。
MethodHandle	MethodHandle.asSpreader(int spreadArgPos, Class<?> arrayType, int arrayLength)	创建一个 array-spreading 方法句柄，它在给定位置接受数组参数，并将其元素作为位置参数展开以代替数组。
MethodHandle	MethodHandle.asSpreader(Class<?> arrayType, int arrayLength)	创建一个 array-spreading 方法句柄，它接受尾随数组参数并将其元素作为位置参数展开。
MethodHandle	MethodHandle.asVarargsCollector(Class<?> arrayType)	制作一个 variable arity 适配器，它能够接受任意数量的尾随位置参数并将它们收集到一个数组参数中。
static VarHandle	MethodHandles.byteArrayViewVarHandle(Class<?> viewArrayClass, ByteOrder byteOrder)	生成一个 VarHandle，可以访问 byte[] 数组的元素，就像它是不同的原始数组类型一样，例如 int[] 或 long[] 。
static VarHandle	MethodHandles.byteBufferViewVarHandle(Class<?> viewArrayClass, ByteOrder byteOrder)	生成一个 VarHandle，允许访问 ByteBuffer 的元素，将其视为与 byte 不同的基本组件类型的元素数组，例如 int[] 或 long[]。
static MethodHandle	MethodHandles.catchException(MethodHandle target, Class<? extends Throwable> exType, MethodHandle handler)	通过在异常处理程序中运行它来创建一个适应目标方法句柄的方法句柄。
MethodType	MethodType.changeParameterType(int num, Class<?> nptype)	查找或创建具有单个不同参数类型的方法类型。
MethodType	MethodType.changeReturnType(Class<?> nrtype)	查找或创建具有不同返回类型的方法类型。
static <T> T	MethodHandles.classData(MethodHandles.Lookup caller, String name, Class<T> type)	返回与给定 caller 查找对象或 null 的查找类关联的 class data。
static <T> T	MethodHandles.classDataAt(MethodHandles.Lookup caller, String name, Class<T> type, int index)	如果与给定 caller 查找对象的查找类关联的类数据是 List ，则返回 类数据 中指定索引处的元素。
static MethodHandle	MethodHandles.constant(Class<?> type, Object value)	生成请求的返回类型的方法句柄，每次调用时返回给定的常量值。
static MethodHandle	MethodHandles.dropArguments(MethodHandle target, int pos, Class<?>... valueTypes)	生成一个方法句柄，该句柄将在调用其他指定的参数之前丢弃一些伪参数目标方法句柄。
static VarHandle	MethodHandles.dropCoordinates(VarHandle target, int pos, Class<?>... valueTypes)	预览。 返回一个 var 句柄，它将在委托给目标 var 句柄之前丢弃一些虚拟坐标。
Class<?>	MethodHandles.Lookup.ensureInitialized(Class<?> targetClass)	确保 targetClass 已被初始化。
static <E extends Enum<E>> E	ConstantBootstraps.enumConstant(MethodHandles.Lookup lookup, String name, Class<E> type)	返回一个 enum 常量，其类型由 type 指定，名称由 name 指定。
static Object	ConstantBootstraps.explicitCast(MethodHandles.Lookup lookup, String name, Class<?> dstType, Object value)	应用从源类型到目标类型的转换。
static VarHandle	ConstantBootstraps.fieldVarHandle(MethodHandles.Lookup lookup, String name, Class<VarHandle> type, Class<?> declaringClass, Class<?> fieldType)	为实例字段查找 VarHandle 。
MethodHandle	MethodHandles.Lookup.findConstructor(Class<?> refc, MethodType type)	使用指定类型的构造方法生成一个方法句柄，该句柄创建一个对象并对其进行初始化。
MethodHandle	MethodHandles.Lookup.findGetter(Class<?> refc, String name, Class<?> type)	生成一个方法句柄，提供对非静态字段的读取访问权限。
MethodHandle	MethodHandles.Lookup.findSetter(Class<?> refc, String name, Class<?> type)	生成一个方法句柄，提供对非静态字段的写访问权限。
MethodHandle	MethodHandles.Lookup.findSpecial(Class<?> refc, String name, MethodType type, Class<?> specialCaller)	为虚拟方法生成早期绑定方法句柄。
MethodHandle	MethodHandles.Lookup.findStatic(Class<?> refc, String name, MethodType type)	为静态方法生成方法句柄。
MethodHandle	MethodHandles.Lookup.findStaticGetter(Class<?> refc, String name, Class<?> type)	生成一个方法句柄，提供对静态字段的读取访问权限。
MethodHandle	MethodHandles.Lookup.findStaticSetter(Class<?> refc, String name, Class<?> type)	生成一个方法句柄，提供对静态字段的写访问权。
VarHandle	MethodHandles.Lookup.findStaticVarHandle(Class<?> decl, String name, Class<?> type)	生成一个 VarHandle，允许访问类型为 decl 的类中声明的类型为 type 的静态字段 name。
VarHandle	MethodHandles.Lookup.findVarHandle(Class<?> recv, String name, Class<?> type)	生成一个 VarHandle，允许访问类型为 recv 的类中声明的类型为 type 的非静态字段 name。
MethodHandle	MethodHandles.Lookup.findVirtual(Class<?> refc, String name, MethodType type)	为虚拟方法生成方法句柄。
static Object	ConstantBootstraps.getStaticFinal(MethodHandles.Lookup lookup, String name, Class<?> type)	返回在类中声明的与字段类型相同的静态最终字段的值（或者，对于原始值字段，在包装类中声明。）
static Object	ConstantBootstraps.getStaticFinal(MethodHandles.Lookup lookup, String name, Class<?> type, Class<?> declaringClass)	返回静态最终字段的值。
static MethodHandle	MethodHandles.identity(Class<?> type)	生成一个方法句柄，该句柄在调用时返回其唯一参数。
MethodHandles.Lookup	MethodHandles.Lookup.in(Class<?> requestedLookupClass)	在指定的新查找类上创建查找。
MethodType	MethodType.insertParameterTypes(int num, Class<?>... ptypesToInsert)	查找或创建具有附加参数类型的方法类型。
static Object	ConstantBootstraps.invoke(MethodHandles.Lookup lookup, String name, Class<?> type, MethodHandle handle, Object... args)	返回使用提供的参数调用方法句柄的结果。
static MethodType	MethodType.methodType(Class<?> rtype)	查找或创建具有给定组件的方法类型。
static MethodType	MethodType.methodType(Class<?> rtype, Class<?> ptype0)	查找或创建具有给定组件的方法类型。
static MethodType	MethodType.methodType(Class<?> rtype, Class<?>[] ptypes)	查找或创建给定方法类型的实例。
static MethodType	MethodType.methodType(Class<?> rtype, Class<?> ptype0, Class<?>... ptypes)	查找或创建具有给定组件的方法类型。
static MethodType	MethodType.methodType(Class<?> rtype, MethodType ptypes)	查找或创建具有给定组件的方法类型。
static MethodType	MethodType.methodType(Class<?> rtype, List<Class<?>> ptypes)	查找或创建具有给定组件的方法类型。
static Object	ConstantBootstraps.nullConstant(MethodHandles.Lookup lookup, String name, Class<?> type)	为 type 指定的引用类型返回一个 null 对象引用。
static Class<?>	ConstantBootstraps.primitiveClass(MethodHandles.Lookup lookup, String name, Class<?> type)	返回原始类型的 Class 镜像，其类型描述符由 name 指定。
static MethodHandles.Lookup	MethodHandles.privateLookupIn(Class<?> targetClass, MethodHandles.Lookup caller)	返回目标类上的 lookup 对象以模拟所有支持的字节码行为，包括 私人访问 。
<T extends Member> T	MethodHandleInfo.reflectAs(Class<T> expected, MethodHandles.Lookup lookup)	将基础成员反映为方法、构造方法或字段对象。
static <T extends Member> T	MethodHandles.reflectAs(Class<T> expected, MethodHandle target)	对 直接方法句柄 执行未经检查的“破解”。
static VarHandle	ConstantBootstraps.staticFieldVarHandle(MethodHandles.Lookup lookup, String name, Class<VarHandle> type, Class<?> declaringClass, Class<?> fieldType)	为静态字段查找 VarHandle 。
static MethodHandle	MethodHandles.throwException(Class<?> returnType, Class<? extends Throwable> exType)	生成一个方法句柄，它将抛出给定 exType 的异常。
static String	MethodHandleInfo.toString(int kind, Class<?> defc, String name, MethodType type)	给定其符号引用的四个部分，返回 MethodHandleInfo 的字符串表示形式。
MethodHandle	MethodHandles.Lookup.unreflectSpecial(Method m, Class<?> specialCaller)	为反射方法生成方法句柄。
static MethodHandle	MethodHandles.zero(Class<?> type)	生成所请求返回类型的常量方法句柄，每次调用时返回该类型的默认值。

java.lang.invoke 中的方法参数，类型参数为 Class

修饰符和类型	方法	描述
MethodType	MethodType.appendParameterTypes(List<Class<?>> ptypesToInsert)	查找或创建具有附加参数类型的方法类型。
static MethodHandle	MethodHandles.dropArguments(MethodHandle target, int pos, List<Class<?>> valueTypes)	生成一个方法句柄，该句柄将在调用其他指定的参数之前丢弃一些伪参数目标方法句柄。
static MethodHandle	MethodHandles.dropArgumentsToMatch(MethodHandle target, int skip, List<Class<?>> newTypes, int pos)	调整目标方法句柄以匹配给定的参数类型列表。
MethodType	MethodType.insertParameterTypes(int num, List<Class<?>> ptypesToInsert)	查找或创建具有附加参数类型的方法类型。
static MethodType	MethodType.methodType(Class<?> rtype, List<Class<?>> ptypes)	查找或创建具有给定组件的方法类型。
static VarHandle	MethodHandles.permuteCoordinates(VarHandle target, List<Class<?>> newCoordinates, int... reorder)	预览。 提供一个 var 句柄，它通过重新排列目标 var 句柄的坐标值来调整它们，以便新坐标与提供的坐标相匹配。

java.lang.invoke 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	SerializedLambda(Class<?> capturingClass, String functionalInterfaceClass, String functionalInterfaceMethodName, String functionalInterfaceMethodSignature, int implMethodKind, String implClass, String implMethodName, String implMethodSignature, String instantiatedMethodType, Object[] capturedArgs)	根据存在于 lambda 工厂站点的低级信息创建一个 SerializedLambda。

Class 在 java.lang.management 中的用法

返回类型中包含 Class 类型参数的 java.lang.management 中的方法

修饰符和类型	方法	描述
static Set<Class<? extends PlatformManagedObject>>	ManagementFactory.getPlatformManagementInterfaces()	返回 Class 对象的集合， PlatformManagedObject 的子接口，代表用于监视和管理 Java 平台的所有管理接口。

java.lang.management 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static <T extends PlatformManagedObject> T	ManagementFactory.getPlatformMXBean(Class<T> mxbeanInterface)	返回实现给定 mxbeanInterface 的平台 MXBean，它被指定为在 Java 虚拟机中具有一个实例。
static <T extends PlatformManagedObject> T	ManagementFactory.getPlatformMXBean(MBeanServerConnection connection, Class<T> mxbeanInterface)	返回 mxbeanInterface 的平台 MXBean 代理，它被指定为在 Java 虚拟机中有一个实例，代理将通过给定的 MBeanServerConnection 转发方法调用。
static <T extends PlatformManagedObject> List<T>	ManagementFactory.getPlatformMXBeans(Class<T> mxbeanInterface)	返回在 Java 虚拟机中实现给定 mxbeanInterface 的平台 MXBeans 列表。
static <T extends PlatformManagedObject> List<T>	ManagementFactory.getPlatformMXBeans(MBeanServerConnection connection, Class<T> mxbeanInterface)	返回平台 MXBean 代理的列表，用于通过给定的 MBeanServerConnection 转发 mxbeanInterface 的方法调用。
static <T> T	ManagementFactory.newPlatformMXBeanProxy(MBeanServerConnection connection, String mxbeanName, Class<T> mxbeanInterface)	返回给定 MXBean 名称 的平台 MXBean 接口的代理，该接口通过给定 MBeanServerConnection 转发其方法调用。

Class 在 java.lang.reflect 中的用法

java.lang.reflect 中返回 Class 的方法

修饰符和类型	方法	描述
Class<T>	Constructor.getDeclaringClass()	返回表示声明此对象表示的构造函数的类的 Class 对象。
abstract Class<?>	Executable.getDeclaringClass()	返回表示声明此对象表示的可执行文件的类或接口的 Class 对象。
Class<?>	Field.getDeclaringClass()	返回表示声明此 Field 对象表示的字段的类或接口的 Class 对象。
Class<?>	Member.getDeclaringClass()	返回表示声明此成员表示的成员或构造方法的类或接口的类对象。
Class<?>	Method.getDeclaringClass()	返回表示声明此对象表示的方法的类或接口的 Class 对象。
Class<?>	RecordComponent.getDeclaringRecord()	返回声明此记录组件的记录类。
Class<?>[]	Constructor.getExceptionTypes()	返回一个 Class 对象数组，这些对象表示声明由该对象表示的底层可执行文件抛出的异常类型。
abstract Class<?>[]	Executable.getExceptionTypes()	返回一个 Class 对象数组，这些对象表示声明由该对象表示的底层可执行文件抛出的异常类型。
Class<?>[]	Method.getExceptionTypes()	返回一个 Class 对象数组，这些对象表示声明由该对象表示的底层可执行文件抛出的异常类型。
Class<?>[]	Constructor.getParameterTypes()	返回一个 Class 对象数组，这些对象按声明顺序表示此对象表示的可执行文件的形式参数类型。
abstract Class<?>[]	Executable.getParameterTypes()	返回一个 Class 对象数组，这些对象按声明顺序表示此对象表示的可执行文件的形式参数类型。
Class<?>[]	Method.getParameterTypes()	返回一个 Class 对象数组，这些对象按声明顺序表示此对象表示的可执行文件的形式参数类型。
static Class<?>	Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)	已弃用。 在命名模块中生成的代理类是封装的，其模块外部的代码无法访问。
Class<?>	Method.getReturnType()	返回一个 Class 对象，该对象表示此 Method 对象所表示的方法的正式返回类型。
Class<?>	Field.getType()	返回一个 Class 对象，该对象标识此 Field 对象表示的字段的声明类型。
Class<?>	Parameter.getType()	返回一个 Class 对象，该对象标识此 Parameter 对象表示的参数的声明类型。
Class<?>	RecordComponent.getType()	返回一个 Class 标识此记录组件的声明类型。

java.lang.reflect 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T extends Annotation> T	AccessibleObject.getAnnotation(Class<T> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T	AnnotatedElement.getAnnotation(Class<T> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T	AnnotatedType.getAnnotation(Class<T> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T	Constructor.getAnnotation(Class<T> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T	Executable.getAnnotation(Class<T> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T	Field.getAnnotation(Class<T> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T	Method.getAnnotation(Class<T> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T	Parameter.getAnnotation(Class<T> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T	RecordComponent.getAnnotation(Class<T> annotationClass)	如果此类注解为 present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T[]	AccessibleObject.getAnnotationsByType(Class<T> annotationClass)	返回带有此元素的 associated 注释。
default <T extends Annotation> T[]	AnnotatedElement.getAnnotationsByType(Class<T> annotationClass)	返回带有此元素的 associated 注释。
<T extends Annotation> T[]	Executable.getAnnotationsByType(Class<T> annotationClass)	返回带有此元素的 associated 注释。
<T extends Annotation> T[]	Field.getAnnotationsByType(Class<T> annotationClass)	返回带有此元素的 associated 注释。
<T extends Annotation> T[]	Parameter.getAnnotationsByType(Class<T> annotationClass)	返回带有此元素的 associated 注释。
<T extends Annotation> T	AccessibleObject.getDeclaredAnnotation(Class<T> annotationClass)	如果此类注解为 directly present ，则返回此元素针对指定类型的注解，否则为 null。
default <T extends Annotation> T	AnnotatedElement.getDeclaredAnnotation(Class<T> annotationClass)	如果此类注解为 directly present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T	Parameter.getDeclaredAnnotation(Class<T> annotationClass)	如果此类注解为 directly present ，则返回此元素针对指定类型的注解，否则为 null。
<T extends Annotation> T[]	AccessibleObject.getDeclaredAnnotationsByType(Class<T> annotationClass)	如果此类注解是 directly present 或 indirectly present ，则返回此元素的指定类型的注解。
default <T extends Annotation> T[]	AnnotatedElement.getDeclaredAnnotationsByType(Class<T> annotationClass)	如果此类注解是 directly present 或 indirectly present ，则返回此元素的指定类型的注解。
<T extends Annotation> T[]	Parameter.getDeclaredAnnotationsByType(Class<T> annotationClass)	如果此类注解是 directly present 或 indirectly present ，则返回此元素的指定类型的注解。
static Class<?>	Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)	已弃用。 在命名模块中生成的代理类是封装的，其模块外部的代码无法访问。
boolean	AccessibleObject.isAnnotationPresent(Class<? extends Annotation> annotationClass)	如果指定类型的注解在此元素上为 present，则返回 true，否则返回 false。
default boolean	AnnotatedElement.isAnnotationPresent(Class<? extends Annotation> annotationClass)	如果指定类型的注解在此元素上为 present，则返回 true，否则返回 false。
static boolean	Proxy.isProxyClass(Class<?> cl)	如果给定类是代理类，则返回 true。
static Object	Array.newInstance(Class<?> componentType, int length)	创建具有指定组件类型和长度的新数组。
static Object	Array.newInstance(Class<?> componentType, int... dimensions)	创建具有指定组件类型和维度的新数组。
static Object	Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)	返回指定接口的代理实例，该接口将方法调用分派给指定的调用处理程序。

Class 在 java.lang.runtime 中的用法

java.lang.runtime 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static Object	ObjectMethods.bootstrap(MethodHandles.Lookup lookup, String methodName, TypeDescriptor type, Class<?> recordClass, String names, MethodHandle... getters)	用于生成 Object.equals(Object) 、 Object.hashCode() 和 Object.toString() 方法的引导方法，基于组件名称和访问器方法的描述，用于 invokedynamic 调用站点或动态常量池条目。

Class 在 java.net 中的用法

java.net 中返回 Class 的方法

修饰符和类型	方法	描述
protected Class<?>	URLClassLoader.findClass(String name)	从 URL 搜索路径中查找并加载具有指定名称的类。
Class<T>	SocketOption.type()	返回套接字选项值的类型。

java.net 中的方法，参数类型为 Class

修饰符和类型	方法	描述
Object	ContentHandler.getContent(URLConnection urlc, Class[] classes)	给定一个位于对象表示开头的 URL 连接流，此方法读取该流并创建一个与指定类型之一匹配的对象。
final Object	URL.getContent(Class<?>[] classes)	获取此 URL 的内容。
Object	URLConnection.getContent(Class<?>[] classes)	检索此 URL 连接的内容。

Class 在 java.nio.file 中的用法

java.nio.file 中返回 Class 的方法

修饰符和类型	方法	描述
Class<T>	WatchEvent.Kind.type()	返回 context 值的类型。

java.nio.file 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static <V extends FileAttributeView> V	Files.getFileAttributeView(Path path, Class<V> type, LinkOption... options)	返回给定类型的文件属性视图。
<V extends FileAttributeView> V	SecureDirectoryStream.getFileAttributeView(Class<V> type)	返回一个新的文件属性视图以访问该目录的文件属性。
<V extends FileAttributeView> V	SecureDirectoryStream.getFileAttributeView(T path, Class<V> type, LinkOption... options)	返回一个新的文件属性视图以访问此目录中文件的文件属性。
abstract <V extends FileStoreAttributeView> V	FileStore.getFileStoreAttributeView(Class<V> type)	返回给定类型的 FileStoreAttributeView。
static <A extends BasicFileAttributes> A	Files.readAttributes(Path path, Class<A> type, LinkOption... options)	作为批量操作读取文件的属性。
abstract boolean	FileStore.supportsFileAttributeView(Class<? extends FileAttributeView> type)	告知此文件存储是否支持由给定文件属性视图标识的文件属性。

Class 在 java.nio.file.spi 中的用法

java.nio.file.spi 中的方法，参数类型为 Class

修饰符和类型	方法	描述
abstract <V extends FileAttributeView> V	FileSystemProvider.getFileAttributeView(Path path, Class<V> type, LinkOption... options)	返回给定类型的文件属性视图。
abstract <A extends BasicFileAttributes> A	FileSystemProvider.readAttributes(Path path, Class<A> type, LinkOption... options)	作为批量操作读取文件的属性。
<A extends BasicFileAttributes> A	FileSystemProvider.readAttributesIfExists(Path path, Class<A> type, LinkOption... options)	如果文件存在，则将文件的属性作为批量操作读取。

Class 在 java.rmi.server 中的用法

java.rmi.server 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	LoaderHandler.loadClass(String name)	已弃用。 没有替代品
Class<?>	LoaderHandler.loadClass(URL codebase, String name)	已弃用。 没有替代品
static Class<?>	RMIClassLoader.loadClass(String name)	已弃用。 替换为loadClass(String,String)方法
static Class<?>	RMIClassLoader.loadClass(String codebase, String name)	从代码库 URL 路径加载类。
static Class<?>	RMIClassLoader.loadClass(String codebase, String name, ClassLoader defaultLoader)	从代码库 URL 路径加载一个类，可以选择使用提供的加载器。
static Class<?>	RMIClassLoader.loadClass(URL codebase, String name)	从代码库 URL 加载类。
abstract Class<?>	RMIClassLoaderSpi.loadClass(String codebase, String name, ClassLoader defaultLoader)	提供 RMIClassLoader.loadClass(URL,String) 、RMIClassLoader.loadClass(String,String) 和 RMIClassLoader.loadClass(String,String,ClassLoader) 的实现。
static Class<?>	RMIClassLoader.loadProxyClass(String codebase, String[] interfaces, ClassLoader defaultLoader)	加载动态代理类（请参阅 Proxy ），该类实现一组具有来自代码库 URL 路径的给定名称的接口。
abstract Class<?>	RMIClassLoaderSpi.loadProxyClass(String codebase, String[] interfaces, ClassLoader defaultLoader)	提供 RMIClassLoader.loadProxyClass(String,String[],ClassLoader) 的实现。

java.rmi.server 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static String	RMIClassLoader.getClassAnnotation(Class<?> cl)	返回注释字符串（表示类定义的位置），RMI 在编组给定类的对象时将使用它来注释类描述符。
abstract String	RMIClassLoaderSpi.getClassAnnotation(Class<?> cl)	提供 RMIClassLoader.getClassAnnotation(Class) 的实现。

Class 在 java.security 中的用法

java.security 中返回 Class 的方法

修饰符和类型	方法	描述
protected final Class<?>	SecureClassLoader.defineClass(String name, byte[] b, int off, int len, CodeSource cs)	将字节数组转换为类 Class 的实例，带有可选的 CodeSource。
protected final Class<?>	SecureClassLoader.defineClass(String name, ByteBuffer b, CodeSource cs)	将 ByteBuffer 转换为类 Class 的实例，带有可选的 CodeSource。

java.security 中的方法，参数类型为 Class

修饰符和类型	方法	描述
boolean	KeyStoreSpi.engineEntryInstanceOf(String alias, Class<? extends KeyStore.Entry> entryClass)	确定指定 alias 的密钥库 Entry 是否是指定 entryClass 的实例或子类。
protected abstract <T extends KeySpec> T	KeyFactorySpi.engineGetKeySpec(Key key, Class<T> keySpec)	返回给定密钥对象的规范（密钥材料）。
protected abstract <T extends AlgorithmParameterSpec> T	AlgorithmParametersSpi.engineGetParameterSpec(Class<T> paramSpec)	返回此参数对象的（透明）规范。
final boolean	KeyStore.entryInstanceOf(String alias, Class<? extends KeyStore.Entry> entryClass)	确定指定 alias 的密钥库 Entry 是否是指定 entryClass 的实例或子类。
final <T extends KeySpec> T	KeyFactory.getKeySpec(Key key, Class<T> keySpec)	返回给定密钥对象的规范（密钥材料）。
final <T extends AlgorithmParameterSpec> T	AlgorithmParameters.getParameterSpec(Class<T> paramSpec)	返回此参数对象的（透明）规范。

Class 在 java.sql 中的用法

返回类型中包含 Class 类型参数的 java.sql 中的方法

修饰符和类型	方法	描述
Map<String,Class<?>>	Connection.getTypeMap()	检索与此 Connection 对象关联的 Map 对象。

java.sql 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T> T	CallableStatement.getObject(int parameterIndex, Class<T> type)	返回表示 OUT 参数 parameterIndex 值的对象，如果支持转换，将从参数的 SQL 类型转换为请求的 Java 数据类型。
<T> T	CallableStatement.getObject(String parameterName, Class<T> type)	返回表示 OUT 参数 parameterName 值的对象，并将从参数的 SQL 类型转换为请求的 Java 数据类型（如果支持转换）。
<T> T	ResultSet.getObject(int columnIndex, Class<T> type)	检索此 ResultSet 对象的当前行中指定列的值，如果支持转换，则将该列的 SQL 类型转换为请求的 Java 数据类型。
<T> T	ResultSet.getObject(String columnLabel, Class<T> type)	检索此 ResultSet 对象的当前行中指定列的值，如果支持转换，则将该列的 SQL 类型转换为请求的 Java 数据类型。
<T extends Source> T	SQLXML.getSource(Class<T> sourceClass)	返回用于读取此 SQLXML 实例指定的 XML 值的源。
boolean	Wrapper.isWrapperFor(Class<?> iface)	如果这实现了接口参数或者是直接或间接实现的对象的包装器，则返回 true。
default <T> T	SQLInput.readObject(Class<T> type)	读取流中的下一个属性并将其作为 Java 编程语言中的 Object 返回。
<T extends Result> T	SQLXML.setResult(Class<T> resultClass)	返回用于设置此 SQLXML 实例指定的 XML 值的结果。
<T> T	Wrapper.unwrap(Class<T> iface)	返回一个实现给定接口的对象，以允许访问非标准方法或代理未公开的标准方法。

java.sql 中的方法参数，类型参数为 Class

修饰符和类型	方法	描述
Object	Array.getArray(long index, int count, Map<String,Class<?>> map)	检索此 Array 对象指定的 SQL ARRAY 值的切片，从指定的 index 开始，最多包含 SQL 数组的 count 个连续元素。
Object	Array.getArray(Map<String,Class<?>> map)	检索此 Array 对象指定的 SQL ARRAY 值的内容。
Object[]	Struct.getAttributes(Map<String,Class<?>> map)	生成此 Struct 对象表示的 SQL 结构化类型的属性的有序值。
Object	CallableStatement.getObject(int parameterIndex, Map<String,Class<?>> map)	返回表示 OUT 参数 parameterIndex 值的对象，并将 map 用于参数值的自定义映射。
Object	CallableStatement.getObject(String parameterName, Map<String,Class<?>> map)	返回表示 OUT 参数值的对象 parameterName 并使用 map 进行参数值的自定义映射。
Object	Ref.getObject(Map<String,Class<?>> map)	检索引用的对象并使用给定的类型映射将其映射到 Java 类型。
Object	ResultSet.getObject(int columnIndex, Map<String,Class<?>> map)	检索此 ResultSet 对象的当前行中指定列的值作为 Java 编程语言中的 Object。
Object	ResultSet.getObject(String columnLabel, Map<String,Class<?>> map)	检索此 ResultSet 对象的当前行中指定列的值作为 Java 编程语言中的 Object。
ResultSet	Array.getResultSet(long index, int count, Map<String,Class<?>> map)	检索包含子数组元素的结果集，该子数组从索引 index 开始，最多包含 count 个连续元素。
ResultSet	Array.getResultSet(Map<String,Class<?>> map)	检索包含此 Array 对象指定的 SQL ARRAY 值的元素的结果集。
void	Connection.setTypeMap(Map<String,Class<?>> map)	安装给定的 TypeMap 对象作为此 Connection 对象的类型映射。

Class 在 java.util 中的用法

java.util 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	IllegalFormatConversionException.getArgumentClass()	返回不匹配参数的类。
Class<? extends S>	ServiceLoader.Provider.type()	返回提供者类型。

java.util 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static <E extends Enum<E>> EnumSet<E>	EnumSet.allOf(Class<E> elementType)	创建一个枚举集，其中包含指定元素类型中的所有元素。
static <E> Collection<E>	Collections.checkedCollection(Collection<E> c, Class<E> type)	返回指定集合的动态类型安全视图。
static <E> List<E>	Collections.checkedList(List<E> list, Class<E> type)	返回指定列表的动态类型安全视图。
static <K, V> Map<K,V>	Collections.checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType)	返回指定map的动态类型安全视图。
static <K, V> NavigableMap<K,V>	Collections.checkedNavigableMap(NavigableMap<K,V> m, Class<K> keyType, Class<V> valueType)	返回指定可navigable map的动态类型安全视图。
static <E> NavigableSet<E>	Collections.checkedNavigableSet(NavigableSet<E> s, Class<E> type)	返回指定可导航集的动态类型安全视图。
static <E> Queue<E>	Collections.checkedQueue(Queue<E> queue, Class<E> type)	返回指定队列的动态类型安全视图。
static <E> Set<E>	Collections.checkedSet(Set<E> s, Class<E> type)	返回指定集合的动态类型安全视图。
static <K, V> SortedMap<K,V>	Collections.checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType)	返回指定排序映射的动态类型安全视图。
static <E> SortedSet<E>	Collections.checkedSortedSet(SortedSet<E> s, Class<E> type)	返回指定排序集的动态类型安全视图。
static <T, U> T[]	Arrays.copyOf(U[] original, int newLength, Class<? extends T[]> newType)	复制指定的数组，用空值截断或填充（如有必要），以便副本具有指定的长度。
static <T, U> T[]	Arrays.copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)	将指定数组的指定范围复制到新数组中。
static <S> ServiceLoader<S>	ServiceLoader.load(Class<S> service)	使用当前线程的 上下文类加载器 为给定的服务类型创建一个新的服务加载器。
static <S> ServiceLoader<S>	ServiceLoader.load(Class<S> service, ClassLoader loader)	为给定的服务创建一个新的服务加载器。
static <S> ServiceLoader<S>	ServiceLoader.load(ModuleLayer layer, Class<S> service)	为给定的服务类型创建一个新的服务加载器，以从给定模块层及其祖先的模块加载服务提供者。
static <S> ServiceLoader<S>	ServiceLoader.loadInstalled(Class<S> service)	使用 平台类加载器 为给定的服务类型创建一个新的服务加载器。
static <E extends Enum<E>> EnumSet<E>	EnumSet.noneOf(Class<E> elementType)	创建具有指定元素类型的空枚举集。

java.util 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	EnumMap(Class<K> keyType)	创建具有指定键类型的空枚举map。
	IllegalFormatConversionException(char c, Class<?> arg)	使用不匹配的转换和相应的参数类构造此类的实例。

Class 在 java.util.concurrent.atomic 中的用法

java.util.concurrent.atomic 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static <U> AtomicIntegerFieldUpdater<U>	AtomicIntegerFieldUpdater.newUpdater(Class<U> tclass, String fieldName)	为具有给定字段的对象创建并返回更新程序。
static <U> AtomicLongFieldUpdater<U>	AtomicLongFieldUpdater.newUpdater(Class<U> tclass, String fieldName)	为具有给定字段的对象创建并返回更新程序。
static <U, W> AtomicReferenceFieldUpdater<U,W>	AtomicReferenceFieldUpdater.newUpdater(Class<U> tclass, Class<W> vclass, String fieldName)	为具有给定字段的对象创建并返回更新程序。

Class 在 java.util.prefs 中的用法

java.util.prefs 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static Preferences	Preferences.systemNodeForPackage(Class<?> c)	从系统首选项树中返回首选项节点（按照惯例）与指定类的包相关联。
static Preferences	Preferences.userNodeForPackage(Class<?> c)	从与指定类的包相关联（按照惯例）的调用用户的首选项树中返回首选项节点。

Class 在 javax.annotation.processing 中的用法

javax.annotation.processing 中的方法，参数类型为 Class

修饰符和类型	方法	描述
Set<? extends Element>	RoundEnvironment.getElementsAnnotatedWith(Class<? extends Annotation> a)	返回使用给定注释接口注释的元素。

javax.annotation.processing 中的方法参数，类型参数为 Class

修饰符和类型	方法	描述
default Set<? extends Element>	RoundEnvironment.getElementsAnnotatedWithAny(Set<Class<? extends Annotation>> annotations)	返回使用一个或多个给定注释接口注释的元素。

Class 在 javax.crypto 中的用法

javax.crypto 中的方法，参数类型为 Class

修饰符和类型	方法	描述
protected abstract KeySpec	SecretKeyFactorySpi.engineGetKeySpec(SecretKey key, Class<?> keySpec)	以请求的格式返回给定密钥对象的规范（密钥材料）。
final KeySpec	SecretKeyFactory.getKeySpec(SecretKey key, Class<?> keySpec)	以请求的格式返回给定密钥对象的规范（密钥材料）。

Class 在 javax.imageio.metadata 中的用法

javax.imageio.metadata 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	IIOMetadataFormat.getObjectClass(String elementName)	返回存储在元素中的 Object 引用的 Class 类型。
Class<?>	IIOMetadataFormatImpl.getObjectClass(String elementName)

javax.imageio.metadata 中的方法，参数类型为 Class

修饰符和类型	方法	描述
protected void	IIOMetadataFormatImpl.addObjectValue(String elementName, Class<?> classType, int arrayMinLength, int arrayMaxLength)	允许将给定类类型的Object 引用存储在实现命名元素的节点中。
protected <T> void	IIOMetadataFormatImpl.addObjectValue(String elementName, Class<T> classType, boolean required, T defaultValue)	允许将给定类类型的Object 引用存储在实现命名元素的节点中。
protected <T> void	IIOMetadataFormatImpl.addObjectValue(String elementName, Class<T> classType, boolean required, T defaultValue, List<? extends T> enumeratedValues)	允许将给定类类型的Object 引用存储在实现命名元素的节点中。
protected <T extends Object & Comparable<? super T>> void	IIOMetadataFormatImpl.addObjectValue(String elementName, Class<T> classType, T defaultValue, Comparable<? super T> minValue, Comparable<? super T> maxValue, boolean minInclusive, boolean maxInclusive)	允许将给定类类型的Object 引用存储在实现命名元素的节点中。

Class 在 javax.imageio.spi 中的用法

javax.imageio.spi 中的字段声明为 Class

修饰符和类型	Field	描述
protected Class<?>	ImageInputStreamSpi.inputClass	一个 Class 对象，指示 createInputStreamInstance 方法使用的合法对象类型。
protected Class<?>[]	ImageReaderSpi.inputTypes	从 getInputTypes 返回的 Class 对象数组，最初是 null 。
protected Class<?>	ImageOutputStreamSpi.outputClass	一个 Class 对象，指示 createInputStreamInstance 方法使用的合法对象类型。
protected Class<?>[]	ImageWriterSpi.outputTypes	从 getOutputTypes 返回的 Class 对象数组，最初是 null 。
static final Class<?>[]	ImageReaderSpi.STANDARD_INPUT_TYPE	已弃用。 不使用此字段，而是直接创建等效数组 { ImageInputStream.class } 。
static final Class<?>[]	ImageWriterSpi.STANDARD_OUTPUT_TYPE	已弃用。 不使用此字段，而是直接创建等效数组 { ImageOutputStream.class } 。

javax.imageio.spi 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	ImageInputStreamSpi.getInputClass()	返回一个 Class 对象，表示必须由输入源实现的类或接口类型，以便通过 createInputStreamInstance 方法“包装”在 ImageInputStream 中。
Class<?>[]	ImageReaderSpi.getInputTypes()	返回一个 Class 对象数组，指示哪些类型的对象可以用作读取器的 setInput 方法的参数。
Class<?>	ImageOutputStreamSpi.getOutputClass()	返回一个 Class 对象，表示必须由输出目标实现的类或接口类型，以便通过 createOutputStreamInstance 方法“包装”在 ImageOutputStream 中。
Class<?>[]	ImageWriterSpi.getOutputTypes()	返回一个 Class 对象数组，指示哪些类型的对象可以用作作者的 setOutput 方法的参数。

返回类型中包含 Class 类型参数的 javax.imageio.spi 中的方法

修饰符和类型	方法	描述
Iterator<Class<?>>	ServiceRegistry.getCategories()	返回 Iterator 个 Class 个对象，指示当前类别集。

javax.imageio.spi 中的方法，参数类型为 Class

修饰符和类型	方法	描述
void	ServiceRegistry.deregisterAll(Class<?> category)	注销当前在给定类别下注册的所有服务提供者对象。
<T> boolean	ServiceRegistry.deregisterServiceProvider(T provider, Class<T> category)	从给定类别中删除服务提供者对象。
<T> T	ServiceRegistry.getServiceProviderByClass(Class<T> providerClass)	返回给定类类型的当前注册的服务提供者对象。
<T> Iterator<T>	ServiceRegistry.getServiceProviders(Class<T> category, boolean useOrdering)	返回包含给定类别中所有注册服务提供商的 Iterator。
<T> Iterator<T>	ServiceRegistry.getServiceProviders(Class<T> category, ServiceRegistry.Filter filter, boolean useOrdering)	返回一个 Iterator 包含给定类别中的服务提供者对象，这些对象满足由提供的 ServiceRegistry.Filter 对象的 filter 方法强加的标准。
static <T> Iterator<T>	ServiceRegistry.lookupProviders(Class<T> providerClass)	使用上下文类加载器定位并逐步实例化给定服务的可用提供者。
static <T> Iterator<T>	ServiceRegistry.lookupProviders(Class<T> providerClass, ClassLoader loader)	使用给定的类加载器搜索特定服务类的实现。
void	IIOServiceProvider.onDeregistration(ServiceRegistry registry, Class<?> category)	每当 Spi 类从 ServiceRegistry 中注销时都会发生的回调。
void	RegisterableService.onDeregistration(ServiceRegistry registry, Class<?> category)	当实现此接口的对象从给定 registry 的给定 category 中移除时调用。
void	IIOServiceProvider.onRegistration(ServiceRegistry registry, Class<?> category)	在 Spi 类实例化并在 ServiceRegistry 中注册后将调用一次的回调。
void	RegisterableService.onRegistration(ServiceRegistry registry, Class<?> category)	当实现此接口的对象添加到给定 registry 的给定 category 时调用。
<T> boolean	ServiceRegistry.registerServiceProvider(T provider, Class<T> category)	将服务提供者对象添加到注册表。
<T> boolean	ServiceRegistry.setOrdering(Class<T> category, T firstProvider, T secondProvider)	设置给定类别中两个服务提供者对象之间的成对排序。
<T> boolean	ServiceRegistry.unsetOrdering(Class<T> category, T firstProvider, T secondProvider)	设置给定类别中两个服务提供者对象之间的成对排序。

javax.imageio.spi 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	ImageInputStreamSpi(String vendorName, String version, Class<?> inputClass)	使用给定的一组值构造一个 ImageInputStreamSpi。
	ImageOutputStreamSpi(String vendorName, String version, Class<?> outputClass)	使用给定的一组值构造一个 ImageOutputStreamSpi。
	ImageReaderSpi(String vendorName, String version, String[] names, String[] suffixes, String[] MIMETypes, String readerClassName, Class<?>[] inputTypes, String[] writerSpiNames, boolean supportsStandardStreamMetadataFormat, String nativeStreamMetadataFormatName, String nativeStreamMetadataFormatClassName, String[] extraStreamMetadataFormatNames, String[] extraStreamMetadataFormatClassNames, boolean supportsStandardImageMetadataFormat, String nativeImageMetadataFormatName, String nativeImageMetadataFormatClassName, String[] extraImageMetadataFormatNames, String[] extraImageMetadataFormatClassNames)	使用给定的一组值构造一个 ImageReaderSpi。
	ImageWriterSpi(String vendorName, String version, String[] names, String[] suffixes, String[] MIMETypes, String writerClassName, Class<?>[] outputTypes, String[] readerSpiNames, boolean supportsStandardStreamMetadataFormat, String nativeStreamMetadataFormatName, String nativeStreamMetadataFormatClassName, String[] extraStreamMetadataFormatNames, String[] extraStreamMetadataFormatClassNames, boolean supportsStandardImageMetadataFormat, String nativeImageMetadataFormatName, String nativeImageMetadataFormatClassName, String[] extraImageMetadataFormatNames, String[] extraImageMetadataFormatClassNames)	使用给定的一组值构造一个 ImageWriterSpi。

javax.imageio.spi 中的构造函数参数，类型参数为 Class

修饰符	构造方法	描述
	ServiceRegistry(Iterator<Class<?>> categories)	使用从 categories 参数中获取的一组类别构造一个 ServiceRegistry 实例。

Class 在 javax.lang.model 中的用法

javax.lang.model 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<A extends Annotation> A	AnnotatedConstruct.getAnnotation(Class<A> annotationType)	如果这样的注释是 present ，则返回此构造的指定类型的注解，否则返回 null 。
<A extends Annotation> A[]	AnnotatedConstruct.getAnnotationsByType(Class<A> annotationType)	返回带有此构造的 associated 注释。

Class 在 javax.lang.model.element 中的用法

javax.lang.model.element 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<A extends Annotation> A	Element.getAnnotation(Class<A> annotationType)	如果这样的注释是 present ，则返回此构造的指定类型的注解，否则返回 null 。
<A extends Annotation> A[]	Element.getAnnotationsByType(Class<A> annotationType)	返回带有此构造的 associated 注释。

Class 在 javax.lang.model.type 中的用法

javax.lang.model.type 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<A extends Annotation> A	TypeMirror.getAnnotation(Class<A> annotationType)	如果这样的注释是 present ，则返回此构造的指定类型的注解，否则返回 null 。
<A extends Annotation> A[]	TypeMirror.getAnnotationsByType(Class<A> annotationType)	返回带有此构造的 associated 注释。

Class 在 javax.management 中的用法

javax.management 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	StandardMBean.getImplementationClass()	获取此 Standard MBean（或 MXBean）的实现类。
final Class<?>	StandardMBean.getMBeanInterface()	获取此标准 MBean（或 MXBean）的管理接口。
static Class<?>	DefaultLoaderRepository.loadClass(String className)	已弃用。 浏览类加载器列表并尝试加载请求的类。
static Class<?>	DefaultLoaderRepository.loadClassWithout(ClassLoader loader, String className)	已弃用。 浏览类加载器列表但排除给定的类加载器，然后尝试加载请求的类。

javax.management 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static boolean	JMX.isMXBeanInterface(Class<?> interfaceClass)	测试接口是否为 MXBean 接口。
static <T> T	JMX.newMBeanProxy(MBeanServerConnection connection, ObjectName objectName, Class<T> interfaceClass)	在本地或远程 MBean Server 中为 Standard MBean 创建代理。
static <T> T	JMX.newMBeanProxy(MBeanServerConnection connection, ObjectName objectName, Class<T> interfaceClass, boolean notificationEmitter)	为本地或远程 MBean 服务中的 Standard MBean 创建代理，该服务也可能支持 NotificationEmitter 的方法。
static <T> T	JMX.newMXBeanProxy(MBeanServerConnection connection, ObjectName objectName, Class<T> interfaceClass)	在本地或远程 MBean Server 中为 MXBean 创建代理。
static <T> T	JMX.newMXBeanProxy(MBeanServerConnection connection, ObjectName objectName, Class<T> interfaceClass, boolean notificationEmitter)	在本地或远程 MBean Server 中为 MXBean 创建代理，该服务也可能支持 NotificationEmitter 的方法。
static <T> T	MBeanServerInvocationHandler.newProxyInstance(MBeanServerConnection connection, ObjectName objectName, Class<T> interfaceClass, boolean notificationBroadcaster)	通过给定的 MBean 服务将其方法转发到指定的 MBean，返回一个实现给定接口的代理。

javax.management 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
protected	StandardEmitterMBean(Class<?> mbeanInterface, boolean isMXBean, NotificationEmitter emitter)	创建一个 MBean，其管理接口由 mbeanInterface 指定，通知由给定的 NotificationEmitter 处理。
protected	StandardEmitterMBean(Class<?> mbeanInterface, NotificationEmitter emitter)	创建一个 MBean，其管理接口由 mbeanInterface 指定，通知由给定的 NotificationEmitter 处理。
	StandardEmitterMBean(T implementation, Class<T> mbeanInterface, boolean isMXBean, NotificationEmitter emitter)	创建一个 MBean，其管理接口由 mbeanInterface 指定，具有给定的实现，通知由给定的 NotificationEmitter 处理。
	StandardEmitterMBean(T implementation, Class<T> mbeanInterface, NotificationEmitter emitter)	创建一个 MBean，其管理接口由 mbeanInterface 指定，具有给定的实现，通知由给定的 NotificationEmitter 处理。
protected	StandardMBean(Class<?> mbeanInterface)	制作一个 DynamicMBean这, 使用指定的mbean接口类。
protected	StandardMBean(Class<?> mbeanInterface, boolean isMXBean)	制作一个 DynamicMBean这, 使用指定的mbean接口类，并选择生成的 MBean 是否为 MXBean。
	StandardMBean(T implementation, Class<T> mbeanInterface)	从对象中创建一个 DynamicMBean执行, 使用指定的mbean接口类。
	StandardMBean(T implementation, Class<T> mbeanInterface, boolean isMXBean)	从对象中创建一个 DynamicMBean执行, 使用指定的mbean接口类，并选择生成的 MBean 是否为 MXBean。

Class 在 javax.management.loading 中的用法

javax.management.loading 中返回 Class 的方法

修饰符和类型	方法	描述
protected Class<?>	MLet.findClass(String name)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 这是正在重新定义的类加载器的主要方法。
Class<?>	ClassLoaderRepository.loadClass(String className)	通过类加载器列表加载给定的类名。
static Class<?>	DefaultLoaderRepository.loadClass(String className)	已弃用。 浏览类加载器列表并尝试加载请求的类。
Class<?>	MLet.loadClass(String name, ClassLoaderRepository clr)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 如果在此 MLet 的 URL 中找不到该类，则使用给定的 ClassLoaderRepository 加载该类。
Class<?>	ClassLoaderRepository.loadClassBefore(ClassLoader stop, String className)	通过类加载器列表加载给定的类名，在给定的加载器处停止。
Class<?>	ClassLoaderRepository.loadClassWithout(ClassLoader exclude, String className)	通过类加载器列表加载给定的类名，不包括给定的。
static Class<?>	DefaultLoaderRepository.loadClassWithout(ClassLoader loader, String className)	已弃用。 浏览类加载器列表但排除给定的类加载器，然后尝试加载请求的类。

Class 在 javax.management.openmbean 中的用法

javax.management.openmbean 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static <T> ArrayType<T>	ArrayType.getPrimitiveArrayType(Class<T> arrayClass)	以类型安全的方式创建一个 ArrayType 实例。

Class 在 javax.naming.spi 中的用法

javax.naming.spi 中的方法，参数类型为 Class

修饰符和类型	方法	描述
ResolveResult	Resolver.resolveToClass(String name, Class<? extends Context> contextType)	部分解析名称。
ResolveResult	Resolver.resolveToClass(Name name, Class<? extends Context> contextType)	部分解析名称。

Class 在 javax.print 中的用法

javax.print 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>[]	PrintService.getSupportedAttributeCategories()	确定客户端在为此打印服务设置作业时可以指定的打印属性类别。
Class<?>[]	AttributeException.getUnsupportedAttributes()	返回打印服务实例根本不支持该属性的打印属性类数组，如果没有此类属性，则返回 null。

javax.print 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T extends PrintServiceAttribute> T	PrintService.getAttribute(Class<T> category)	获取单个指定服务属性的值。
Object	PrintService.getDefaultAttributeValue(Class<? extends Attribute> category)	确定此打印服务在给定类别中的默认打印属性值。
Object	PrintService.getSupportedAttributeValues(Class<? extends Attribute> category, DocFlavor flavor, AttributeSet attributes)	确定客户端在为此打印服务设置作业时可以在给定类别中指定的打印属性值。
boolean	PrintService.isAttributeCategorySupported(Class<? extends Attribute> category)	确定客户端在为此打印服务设置作业时是否可以指定给定的打印属性类别。

Class 在 javax.print.attribute 中的用法

javax.print.attribute 中返回 Class 的方法

修饰符和类型	方法	描述
Class<? extends Attribute>	Attribute.getCategory()	获取打印属性类，在将打印属性值添加到属性集时，该类将用作此打印属性值的“类别”。
static Class<?>	AttributeSetUtilities.verifyAttributeCategory(Object object, Class<?> interfaceName)	验证给定对象是实现给定接口的Class ，假定为接口Attribute 或其子接口。

javax.print.attribute 中的方法，参数类型为 Class

修饰符和类型	方法	描述
boolean	AttributeSet.containsKey(Class<?> category)	如果此属性集包含指定类别的属性，则返回 true。
boolean	HashAttributeSet.containsKey(Class<?> category)	如果此属性集包含指定类别的属性，则返回 true。
Attribute	AttributeSet.get(Class<?> category)	返回此属性集包含在给定属性类别中的属性值。
Attribute	HashAttributeSet.get(Class<?> category)	返回此属性集包含在给定属性类别中的属性值。
boolean	AttributeSet.remove(Class<?> category)	从此属性集中移除此类别的任何属性（如果存在）。
boolean	HashAttributeSet.remove(Class<?> category)	从此属性集中移除此类别的任何属性（如果存在）。
static Class<?>	AttributeSetUtilities.verifyAttributeCategory(Object object, Class<?> interfaceName)	验证给定对象是实现给定接口的Class ，假定为接口Attribute 或其子接口。
static Attribute	AttributeSetUtilities.verifyAttributeValue(Object object, Class<?> interfaceName)	验证给定对象是否为给定接口的实例，假定为接口 Attribute 或其子接口。
static void	AttributeSetUtilities.verifyCategoryForValue(Class<?> category, Attribute attribute)	验证给定的属性类别对象是否等于给定的属性值对象的类别。

javax.print.attribute 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
protected	HashAttributeSet(Class<?> interfaceName)	构造一个新的空属性集，其中属性集的成员仅限于给定的接口。
protected	HashAttributeSet(Attribute[] attributes, Class<?> interfaceName)	构造一个新的属性集，其中属性集的成员仅限于给定的接口。
protected	HashAttributeSet(Attribute attribute, Class<?> interfaceName)	构造一个新的属性集，最初使用给定的属性填充，其中属性集的成员仅限于给定的接口。
protected	HashAttributeSet(AttributeSet attributes, Class<?> interfaceName)	构造一个新的属性集，最初使用给定集中的值填充，其中属性集的成员仅限于给定的接口。

Class 在 javax.print.attribute.standard 中的用法

javax.print.attribute.standard 中返回 Class 的方法

修饰符和类型	方法	描述
final Class<? extends Attribute>	Chromaticity.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	ColorSupported.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	Compression.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	Copies.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	CopiesSupported.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	DateTimeAtCompleted.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	DateTimeAtCreation.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	DateTimeAtProcessing.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	Destination.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	DialogOwner.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	DialogTypeSelection.getCategory()	获取要用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	DocumentName.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	Fidelity.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	Finishings.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobHoldUntil.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobImpressions.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobImpressionsCompleted.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobImpressionsSupported.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobKOctets.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobKOctetsProcessed.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobKOctetsSupported.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobMediaSheets.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobMediaSheetsCompleted.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobMediaSheetsSupported.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobMessageFromOperator.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobName.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobOriginatingUserName.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobPriority.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobPrioritySupported.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobSheets.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobState.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobStateReason.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	JobStateReasons.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	Media.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	MediaPrintableArea.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	MediaSize.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	MultipleDocumentHandling.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	NumberOfDocuments.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	NumberOfInterveningJobs.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	NumberUp.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	NumberUpSupported.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	OrientationRequested.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	OutputDeviceAssigned.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PageRanges.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PagesPerMinute.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PagesPerMinuteColor.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PDLOverrideSupported.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PresentationDirection.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterInfo.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterIsAcceptingJobs.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterLocation.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterMakeAndModel.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterMessageFromOperator.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterMoreInfo.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterMoreInfoManufacturer.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterName.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterResolution.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterState.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterStateReason.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterStateReasons.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrinterURI.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	PrintQuality.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	QueuedJobCount.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	ReferenceUriSchemesSupported.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	RequestingUserName.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	Severity.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	SheetCollate.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。
final Class<? extends Attribute>	Sides.getCategory()	获取将用作此打印属性值的“类别”的打印属性类。

Class 在 javax.script 中的用法

javax.script 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T> T	Invocable.getInterface(Class<T> clasz)	使用在解释器中编译的函数返回接口的实现。
<T> T	Invocable.getInterface(Object thiz, Class<T> clasz)	使用在解释器中编译的脚本对象的成员函数返回接口的实现。

Class 在 javax.security.auth 中的用法

javax.security.auth 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T extends Principal> Set<T>	Subject.getPrincipals(Class<T> c)	返回与此 Subject 关联的主体的 Set，它们是指定的 Class 的实例或子类。
<T> Set<T>	Subject.getPrivateCredentials(Class<T> c)	返回与此 Subject 关联的私有凭证的 Set，它们是指定 Class 的实例或子类。
<T> Set<T>	Subject.getPublicCredentials(Class<T> c)	返回与此 Subject 关联的公共凭证的 Set，它们是指定 Class 的实例或子类。

Class 在 javax.sound.midi 中的用法

javax.sound.midi 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	SoundbankResource.getDataClass()	获取此示例用来表示其数据的类。

javax.sound.midi 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
protected	Instrument(Soundbank soundbank, Patch patch, String name, Class<?> dataClass)	从指定的 Patch 构造一个新的 MIDI 乐器。
protected	SoundbankResource(Soundbank soundBank, String name, Class<?> dataClass)	从给定的声音库和波表索引构造一个新的 SoundbankResource。

Class 在 javax.sound.sampled 中的用法

javax.sound.sampled 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	Line.Info.getLineClass()	获取此 Line.Info 对象描述的线路的类。

javax.sound.sampled 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	Info(Class<?> lineClass, AudioFormat format)	根据指定信息构造数据行的信息对象，其中包括单一音频格式。
	Info(Class<?> lineClass, AudioFormat[] formats, int minBufferSize, int maxBufferSize)	根据指定信息构造数据行的信息对象，其中包括一组支持的音频格式和缓冲区大小的范围。
	Info(Class<?> lineClass, AudioFormat format, int bufferSize)	根据指定信息构造数据行的信息对象，其中包括单一音频格式和所需的缓冲区大小。
	Info(Class<?> lineClass)	构造一个描述指定类的行的信息对象。
	Info(Class<?> lineClass, String name, boolean isSource)	根据给定的信息构造端口的信息对象。

Class 在 javax.sql 中的用法

返回类型中包含 Class 类型参数的 javax.sql 中的方法

修饰符和类型	方法	描述
Map<String,Class<?>>	RowSet.getTypeMap()	检索与此 RowSet 对象关联的 Map 对象，它指定 SQL 用户定义类型的自定义映射（如果有）。

javax.sql 中的方法参数，类型参数为 Class

修饰符和类型	方法	描述
void	RowSet.setTypeMap(Map<String,Class<?>> map)	安装给定的 java.util.Map 对象作为此 RowSet 对象的默认类型映射。

Class 在 javax.sql.rowset 中的用法

返回类型中包含 Class 类型参数的 javax.sql.rowset 中的方法

修饰符和类型	方法	描述
Map<String,Class<?>>	BaseRowSet.getTypeMap()	检索与此 RowSet 对象的 Connection 对象关联的类型映射。

javax.sql.rowset 中的方法，参数类型为 Class

修饰符和类型	方法	描述
boolean	RowSetMetaDataImpl.isWrapperFor(Class<?> interfaces)	如果这实现了接口参数或者是直接或间接实现的对象的包装器，则返回 true。
<T> T	RowSetMetaDataImpl.unwrap(Class<T> iface)	返回一个实现给定接口的对象，以允许访问非标准方法或代理未公开的标准方法。

javax.sql.rowset 中的方法参数，类型参数为 Class

修饰符和类型	方法	描述
void	BaseRowSet.setTypeMap(Map<String,Class<?>> map)	安装给定的 java.util.Map 对象作为与此 RowSet 对象的 Connection 对象关联的类型映射。

Class 在 javax.sql.rowset.serial 中的用法

javax.sql.rowset.serial 中的方法参数，类型参数为 Class

修饰符和类型	方法	描述
Object	SerialArray.getArray(long index, int count, Map<String,Class<?>> map)	返回一个新数组，它是此 SerialArray 对象的一个切片的副本，从给定索引处的元素开始并包含给定数量的连续元素。
Object	SerialArray.getArray(Map<String,Class<?>> map)	返回一个新数组，它是此 SerialArray 对象的副本，当元素是 SQL UDT 时，使用给定的类型映射为每个元素的自定义映射。
Object[]	SerialStruct.getAttributes(Map<String,Class<?>> map)	检索此 SerialStruct 表示为 Object 值数组的 SQL 结构类型的属性，如果合适，使用给定的类型映射进行自定义映射。
Object	SerialRef.getObject(Map<String,Class<?>> map)	返回表示此 SerialRef 对象引用的 SQL 结构类型的 Object。
ResultSet	SerialArray.getResultSet(long index, int count, Map<String,Class<?>> map)	Retrieves a result set holding the elements of the subarray that starts at 检索包含此 SerialArray 对象中元素子数组的 ResultSet 对象，从索引开始指数最多包含count连续的元素。
ResultSet	SerialArray.getResultSet(Map<String,Class<?>> map)	检索一个 ResultSet 对象，该对象包含此 SerialArray 对象表示的 SQL ARRAY 值的所有元素。

javax.sql.rowset.serial 中的构造函数参数，类型参数为 Class

修饰符	构造方法	描述
	SerialArray(Array array, Map<String,Class<?>> map)	从给定的 Array 对象构造一个新的 SerialArray 对象，当元素是 SQL UDT 时，将给定的类型映射用于每个元素的自定义映射。
	SerialStruct(SQLData in, Map<String,Class<?>> map)	从给定的 SQLData 对象构造一个 SerialStruct 对象，使用给定的类型映射将其自定义映射到 Java 编程语言中的类。
	SerialStruct(Struct in, Map<String,Class<?>> map)	从给定的 Struct 对象构造一个 SerialStruct 对象，使用给定的 java.util.Map 对象自定义映射 SQL 结构类型或其任何属于 SQL 结构类型的属性。
	SQLInputImpl(Object[] attributes, Map<String,Class<?>> map)	创建一个用给定的属性数组和给定的类型映射初始化的 SQLInputImpl 对象。

Class 在 javax.swing 中的用法

javax.swing 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	JTable.getColumnClass(int column)	返回列位置 column 处出现在视图中的列的类型。
Class<? extends ComponentUI>	UIDefaults.getUIClass(String uiClassID)	返回呈现此组件的 L&F 类。
Class<? extends ComponentUI>	UIDefaults.getUIClass(String uiClassID, ClassLoader uiClassLoader)	get(uidClassID) 的值必须是实现相应 ComponentUI 类的类的 String 名称。

javax.swing 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static Container	SwingUtilities.getAncestorOfClass(Class<?> c, Component comp)	在组件层次结构中搜索 comp 上方的便捷方法，并返回它找到的类 c 的第一个对象。
TableCellEditor	JTable.getDefaultEditor(Class<?> columnClass)	返回在 TableColumn 中没有设置编辑器时要使用的编辑器。
TableCellRenderer	JTable.getDefaultRenderer(Class<?> columnClass)	返回未在 TableColumn 中设置渲染器时要使用的单元格渲染器。
<T extends EventListener> T[]	AbstractListModel.getListeners(Class<T> listenerType)	返回当前在此模型上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	AbstractSpinnerModel.getListeners(Class<T> listenerType)	返回添加到此模型的给定类型的所有监听的数组。
<T extends EventListener> T[]	DefaultBoundedRangeModel.getListeners(Class<T> listenerType)	返回当前在此模型上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	DefaultButtonModel.getListeners(Class<T> listenerType)	返回当前在此模型上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	DefaultListSelectionModel.getListeners(Class<T> listenerType)	返回当前在此模型上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	DefaultSingleSelectionModel.getListeners(Class<T> listenerType)	返回当前在此模型上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	JComponent.getListeners(Class<T> listenerType)	返回当前在此 JComponent 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	Timer.getListeners(Class<T> listenerType)	返回当前在此 Timer 上注册为 FooListener 的所有对象的数组。
static Object	LookAndFeel.makeIcon(Class<?> baseClass, String gifFile)	创建并返回加载图像的 UIDefault.LazyValue。
void	JTable.setDefaultEditor(Class<?> columnClass, TableCellEditor editor)	如果 TableColumn 中没有设置编辑器，则设置要使用的默认单元格编辑器。
void	JTable.setDefaultRenderer(Class<?> columnClass, TableCellRenderer renderer)	如果在 TableColumn 中没有设置渲染器，则设置要使用的默认单元格渲染器。

Class 在 javax.swing.event 中的用法

javax.swing.event 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T extends EventListener> void	EventListenerList.add(Class<T> t, T l)	将监听添加为指定类型的监听。
int	EventListenerList.getListenerCount(Class<?> t)	返回此监听列表所提供类型的监听总数。
<T extends EventListener> T[]	EventListenerList.getListeners(Class<T> t)	返回给定类型的所有监听的数组。
<T extends EventListener> void	EventListenerList.remove(Class<T> t, T l)	删除作为指定类型的监听的监听。

Class 在 javax.swing.plaf.synth 中的用法

javax.swing.plaf.synth 中的方法，参数类型为 Class

修饰符和类型	方法	描述
void	SynthLookAndFeel.load(InputStream input, Class<?> resourceBase)	加载将由该 SynthLookAndFeel 使用的一组 SynthStyle 。

Class 在 javax.swing.table 中的用法

javax.swing.table 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	AbstractTableModel.getColumnClass(int columnIndex)	返回 Object.class 而不管 columnIndex 。
Class<?>	TableModel.getColumnClass(int columnIndex)	返回列中所有单元格值的最具体的超类。

javax.swing.table 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T extends EventListener> T[]	AbstractTableModel.getListeners(Class<T> listenerType)	返回当前在此 AbstractTableModel 上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	DefaultTableColumnModel.getListeners(Class<T> listenerType)	返回当前在此模型上注册为 FooListener 的所有对象的数组。

Class 在 javax.swing.text 中的用法

javax.swing.text 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	DefaultFormatter.getValueClass()	返回用于创建新对象的类。

javax.swing.text 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T extends EventListener> T[]	AbstractDocument.getListeners(Class<T> listenerType)	返回当前在本文档中注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	DefaultCaret.getListeners(Class<T> listenerType)	返回当前在此插入符号上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	StyleContext.NamedStyle.getListeners(Class<T> listenerType)	返回添加到此模型的给定类型的所有监听的数组。
void	DefaultFormatter.setValueClass(Class<?> valueClass)	设置用于创建新对象的类。

Class 在 javax.swing.tree 中的用法

javax.swing.tree 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<T extends EventListener> T[]	DefaultTreeModel.getListeners(Class<T> listenerType)	返回当前在此模型上注册为 FooListener 的所有对象的数组。
<T extends EventListener> T[]	DefaultTreeSelectionModel.getListeners(Class<T> listenerType)	返回当前在此模型上注册为 FooListener 的所有对象的数组。

Class 在 javax.tools 中的用法

javax.tools 中的方法，参数类型为 Class

修饰符和类型	方法	描述
<S> ServiceLoader<S>	ForwardingJavaFileManager.getServiceLoader(JavaFileManager.Location location, Class<S> service)
default <S> ServiceLoader<S>	JavaFileManager.getServiceLoader(JavaFileManager.Location location, Class<S> service)	从给定位置获取特定服务类的服务加载器。
DocumentationTool.DocumentationTask	DocumentationTool.getTask(Writer out, JavaFileManager fileManager, DiagnosticListener<? super JavaFileObject> diagnosticListener, Class<?> docletClass, Iterable<String> options, Iterable<? extends JavaFileObject> compilationUnits)	使用给定的组件和参数为文档任务创建未来。

Class 在 javax.xml.xpath 中的用法

javax.xml.xpath 中的方法，参数类型为 Class

修饰符和类型	方法	描述
default <T> T	XPath.evaluateExpression(String expression, Object item, Class<T> type)	在指定的上下文中计算 XPath 表达式并返回具有通过 class type 指定的类型的结果
default <T> T	XPath.evaluateExpression(String expression, InputSource source, Class<T> type)	在指定的 source 的上下文中计算 XPath 表达式并返回指定的结果。
default <T> T	XPathExpression.evaluateExpression(Object item, Class<T> type)	在指定的上下文中计算已编译的 XPath 表达式，并返回具有通过 class type 指定的类型的结果。
default <T> T	XPathExpression.evaluateExpression(InputSource source, Class<T> type)	在指定的上下文中计算已编译的 XPath 表达式，并返回具有通过 class type 指定的类型的结果
static QName	XPathEvaluationResult.XPathResultType.getQNameType(Class<?> clsType)	返回对应于指定类类型的 XPathConstants 中指定的 QName 类型。

Class 在 jdk.dynalink.beans 中的用法

jdk.dynalink.beans 中返回 Class 的方法

修饰符和类型	方法	描述
Class<?>	StaticClass.getRepresentedClass()	返回表示的 Java 类。

jdk.dynalink.beans 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static StaticClass	StaticClass.forClass(Class<?> clazz)	检索指定类的 StaticClass 实例。
static Object	BeansLinker.getConstructorMethod(Class<?> clazz, String signature)	返回给定类和给定签名的构造方法的动态方法。
static Set<String>	BeansLinker.getInstanceMethodNames(Class<?> clazz)	返回类的所有实例方法的一组名称。
TypeBasedGuardingDynamicLinker	BeansLinker.getLinkerForClass(Class<?> clazz)	返回特定单个类的 bean 链接器。
static Set<String>	BeansLinker.getReadableInstancePropertyNames(Class<?> clazz)	返回类的所有可读实例属性的一组名称。
static Set<String>	BeansLinker.getReadableStaticPropertyNames(Class<?> clazz)	返回类的所有可读静态属性的一组名称。
static Set<String>	BeansLinker.getStaticMethodNames(Class<?> clazz)	返回一个类的所有静态方法的一组名称。
static Set<String>	BeansLinker.getWritableInstancePropertyNames(Class<?> clazz)	返回类的所有可写实例属性的一组名称。
static Set<String>	BeansLinker.getWritableStaticPropertyNames(Class<?> clazz)	返回类的所有可写静态属性的一组名称。

Class 在 jdk.dynalink.linker 中的用法

jdk.dynalink.linker 中返回 Class 的方法

修饰符和类型	方法	描述
Class<? extends Throwable>	GuardedInvocation.getException()	返回异常类型，如果调用抛出该异常类型，则应使此受保护调用的链接无效。

jdk.dynalink.linker 中的方法，参数类型为 Class

修饰符和类型	方法	描述
boolean	LinkerServices.canConvert(Class<?> from, Class<?> to)	如果请求的类型之间可能存在转换（自动 JVM 转换，或任何可用的 GuardingTypeConverterFactory 提供的转换），则返回 true，如果请求的类型之间肯定不存在转换，则返回 false。
boolean	TypeBasedGuardingDynamicLinker.canLinkType(Class<?> type)	如果链接器可以链接第一个参数（接收器）为指定类型的调用，则返回 true。
ConversionComparator.Comparison	ConversionComparator.compareConversion(Class<?> sourceType, Class<?> targetType1, Class<?> targetType2)	确定两种目标类型中的哪一种是来自源类型的首选转换目标。
ConversionComparator.Comparison	LinkerServices.compareConversion(Class<?> sourceType, Class<?> targetType1, Class<?> targetType2)	确定从源类型到两个目标类型的两种类型转换中的哪一种是首选。
GuardedInvocation	GuardingTypeConverterFactory.convertToType(Class<?> sourceType, Class<?> targetType, Supplier<MethodHandles.Lookup> lookupSupplier)	返回一个受保护的类型转换，它接收指定源类型的值并返回转换为指定目标类型的值。
GuardedInvocation	GuardedInvocation.dropArguments(int pos, Class<?>... valueTypes)	使用 MethodHandles.dropArguments(MethodHandle, int, Class...) 进行调用，在调用和守卫（如果它存在并且至少有 pos 个参数）中删除参数。
MethodHandle	LinkerServices.getTypeConverter(Class<?> sourceType, Class<?> targetType)	给定源类型和目标类型，返回在它们之间转换的方法句柄。

jdk.dynalink.linker 中的方法参数，类型参数为 Class

修饰符和类型	方法	描述
GuardedInvocation	GuardedInvocation.dropArguments(int pos, List<Class<?>> valueTypes)	使用 MethodHandles.dropArguments(MethodHandle, int, List) 进行调用，在调用和守卫（如果存在并且至少具有 pos 参数）中删除参数。

jdk.dynalink.linker 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	GuardedInvocation(MethodHandle invocation, MethodHandle guard, SwitchPoint[] switchPoints, Class<? extends Throwable> exception)	创建一个新的受保护的调用，带有一个保护方法句柄、任意数量的可用于使其无效的切换点，以及一个在调用时抛出的异常也会使其无效。
	GuardedInvocation(MethodHandle invocation, MethodHandle guard, SwitchPoint switchPoint, Class<? extends Throwable> exception)	创建一个新的受保护的调用，带有一个保护方法句柄，一个可用于使其无效的切换点，以及一个如果在调用时抛出也会使其无效的异常。

Class 在 jdk.dynalink.linker.support 中的用法

jdk.dynalink.linker.support 中返回 Class 的方法

修饰符和类型	方法	描述
static Class<?>	TypeUtilities.getPrimitiveType(Class<?> wrapperType)	当传递一个表示基本类型包装器的类时，返回表示相应基本类型的类。
static Class<?>	TypeUtilities.getPrimitiveTypeByName(String name)	给定原始类型的名称，返回表示它的类。
static Class<?>	TypeUtilities.getWrapperType(Class<?> primitiveType)	当传递表示原始类型的类时，返回表示相应包装类型的类。

jdk.dynalink.linker.support 中的方法，参数类型为 Class

修饰符和类型	方法	描述
boolean	CompositeTypeBasedGuardingDynamicLinker.canLinkType(Class<?> type)	如果至少有一个复合链接器从 TypeBasedGuardingDynamicLinker.canLinkType(Class) 为该类型返回 true，则返回 true。
MethodHandle	Lookup.findGetter(Class<?> refc, String name, Class<?> type)	执行 MethodHandles.Lookup.findGetter(Class, String, Class) ，将遇到的任何 IllegalAccessException 转换为 IllegalAccessError 并将 NoSuchFieldException 转换为 NoSuchFieldError 。
static MethodHandle	Lookup.findOwnSpecial(MethodHandles.Lookup lookup, String name, Class<?> rtype, Class<?>... ptypes)	给定一个查找，使用 Lookup.findSpecial(Class, String, MethodType) 查找该查找类的方法。
MethodHandle	Lookup.findOwnSpecial(String name, Class<?> rtype, Class<?>... ptypes)	使用 Lookup.findSpecial(Class, String, MethodType) 查找该查找类的方法。
static MethodHandle	Lookup.findOwnStatic(MethodHandles.Lookup lookup, String name, Class<?> rtype, Class<?>... ptypes)	给定一个查找，使用 Lookup.findStatic(Class, String, MethodType) 查找该查找类的方法。
MethodHandle	Lookup.findOwnStatic(String name, Class<?> rtype, Class<?>... ptypes)	使用 Lookup.findStatic(Class, String, MethodType) 查找该查找类的方法。
MethodHandle	Lookup.findSpecial(Class<?> declaringClass, String name, MethodType type)	对底层查找执行 MethodHandles.Lookup.findSpecial(Class, String, MethodType, Class) 。
MethodHandle	Lookup.findStatic(Class<?> declaringClass, String name, MethodType type)	对底层查找执行 MethodHandles.Lookup.findStatic(Class, String, MethodType) 。
MethodHandle	Lookup.findVirtual(Class<?> declaringClass, String name, MethodType type)	对基础查找执行 MethodHandles.Lookup.findVirtual(Class, String, MethodType) 。
static MethodHandle	Guards.getClassGuard(Class<?> clazz)	创建一个保护方法来测试其唯一参数是否属于特定的类。
static MethodHandle	Guards.getInstanceOfGuard(Class<?> clazz)	创建一个保护方法，测试其唯一参数是否为特定类的实例。
static Class<?>	TypeUtilities.getPrimitiveType(Class<?> wrapperType)	当传递一个表示基本类型包装器的类时，返回表示相应基本类型的类。
static Class<?>	TypeUtilities.getWrapperType(Class<?> primitiveType)	当传递表示原始类型的类时，返回表示相应包装类型的类。
static boolean	TypeUtilities.isConvertibleWithoutLoss(Class<?> sourceType, Class<?> targetType)	确定是否可以在不损失任何精度的情况下将一种类型转换为另一种类型。
static MethodHandle	Guards.isInstance(Class<?> clazz, int pos, MethodType type)	使用指定类型的参数创建方法句柄，但返回boolean。
static MethodHandle	Guards.isInstance(Class<?> clazz, MethodType type)	使用指定类型的参数创建方法句柄，但返回boolean。
static boolean	TypeUtilities.isMethodInvocationConvertible(Class<?> sourceType, Class<?> targetType)	根据 JLS 5.3“方法调用转换”，确定是否可以使用方法调用转换将一种类型转换为另一种类型。
static MethodHandle	Guards.isOfClass(Class<?> clazz, MethodType type)	使用指定类型的参数创建一个守卫方法句柄，但返回boolean。
static boolean	TypeUtilities.isSubtype(Class<?> subType, Class<?> superType)	根据 JLS 4.10“子类型化”，确定一种类型是否是另一种类型的子类型。
static boolean	TypeUtilities.isWrapperType(Class<?> type)	如果传递的类型是原始类型的包装器，则返回 true。

Class 在 jdk.incubator.vector 中的用法

jdk.incubator.vector 中返回 Class 的方法

修饰符和类型	方法	描述
Class<E>	VectorOperators.Conversion.domainType()	此转换的域，原始类型。
abstract Class<E>	Vector.elementType()	返回此向量的原语 元素类型 (ETYPE )。
Class<E>	VectorSpecies.elementType()	返回该物种向量的原始元素类型。
Class<? extends VectorMask<E>>	VectorSpecies.maskType()	返回该物种的矢量掩码类型。
Class<F>	VectorOperators.Conversion.rangeType()	此转换的范围，原始类型。
Class<?>	VectorOperators.Operator.rangeType()	报告此运算符的特殊返回类型。
Class<? extends Vector<E>>	VectorSpecies.vectorType()	返回该物种的向量类型。

jdk.incubator.vector 中的方法，参数类型为 Class

修饰符和类型	方法	描述
abstract <F> Vector<F>	Vector.check(Class<F> elementType)	检查此向量是否具有给定的元素类型，并返回此向量不变。
abstract <F> VectorMask<F>	VectorMask.check(Class<F> elementType)	检查此掩码是否适用于具有给定元素类型的向量，并返回此掩码不变。
<E, F> VectorOperators.Conversion<E,F>	VectorOperators.Conversion.check(Class<E> from, Class<F> to)	确保此转换具有所需的域和范围类型。
<F> VectorSpecies<F>	VectorSpecies.check(Class<F> elementType)	检查该物种是否具有给定的元素类型，并返回该物种不变。
boolean	VectorOperators.Operator.compatibleWith(Class<?> elementType)	报告此运算符是否与建议的元素类型兼容。
static int	VectorSpecies.elementSize(Class<?> elementType)	返回给定向量元素类型 (ETYPE) 的位大小。
static <E> VectorSpecies<E>	VectorSpecies.of(Class<E> elementType, VectorShape shape)	查找元素类型和形状的种类。
static <E, F> VectorOperators.Conversion<E,F>	VectorOperators.Conversion.ofCast(Class<E> from, Class<F> to)	两种类型之间的 Java 语言赋值或强制转换。
static <E> VectorSpecies<E>	VectorSpecies.ofLargestShape(Class<E> etype)	查找给定元素类型的最大向量种类。
static <E> VectorSpecies<E>	VectorSpecies.ofPreferred(Class<E> etype)	为给定的矢量元素类型查找当前平台首选的物种。
static <E, F> VectorOperators.Conversion<E,F>	VectorOperators.Conversion.ofReinterpret(Class<E> from, Class<F> to)	两种类型之间的按位重新解释。
<E> VectorSpecies<E>	VectorShape.withLanes(Class<E> elementType)	查找具有给定元素类型和当前形状的矢量种类。
<F> VectorSpecies<F>	VectorSpecies.withLanes(Class<F> newType)	查找具有给定元素类型和与该物种相同形状的物种。

Class 在 jdk.jfr 中的用法

jdk.jfr 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static void	FlightRecorder.addPeriodicEvent(Class<? extends Event> eventClass, Runnable hook)	为周期性事件添加一个挂钩。
EventSettings	Recording.disable(Class<? extends Event> eventClass)	禁用事件。
EventSettings	Recording.enable(Class<? extends Event> eventClass)	启用事件。
final <A> A	AnnotationElement.getAnnotation(Class<? extends Annotation> annotationType)	如果存在具有相同名称的 AnnotationElement，则返回指定类型的第一个注释，否则返回 null。
<A extends Annotation> A	EventType.getAnnotation(Class<A> annotationClass)	如果直接存在具有相同名称的注解元素，则返回指定类型的第一个注释，否则返回 null 。
<A extends Annotation> A	SettingDescriptor.getAnnotation(Class<A> annotationType)	如果具有相同名称的注解元素可用，则返回指定类型的第一个注释，否则返回 null。
<A extends Annotation> A	ValueDescriptor.getAnnotation(Class<A> annotationType)	如果此值描述符直接存在具有相同名称的注解元素，则返回指定类型的第一个注释，否则返回 null。
static EventType	EventType.getEventType(Class<? extends Event> eventClass)	返回事件类的事件类型，如果不存在则返回 null。
static void	FlightRecorder.register(Class<? extends Event> eventClass)	注册一个事件类。
static void	FlightRecorder.unregister(Class<? extends Event> eventClass)	注销事件类。

jdk.jfr 中的构造函数，参数类型为 Class

修饰符	构造方法	描述
	AnnotationElement(Class<? extends Annotation> annotationType)	创建一个注解元素以用于动态定义的事件。
	AnnotationElement(Class<? extends Annotation> annotationType, Object value)	创建一个注解元素以用于动态定义的事件。
	AnnotationElement(Class<? extends Annotation> annotationType, Map<String,Object> values)	创建一个注解元素以用于动态定义的事件。
	ValueDescriptor(Class<?> type, String name)	构造一个值描述符，用于动态创建事件类型和注解。
	ValueDescriptor(Class<?> type, String name, List<AnnotationElement> annotations)	构造一个值描述符，用于动态创建事件类型和注解。

Class 在 jdk.jfr.consumer 中的用法

jdk.jfr.consumer 中的方法，参数类型为 Class

修饰符和类型	方法	描述
EventSettings	RecordingStream.disable(Class<? extends Event> eventClass)	禁用事件。
EventSettings	RecordingStream.enable(Class<? extends Event> eventClass)	启用事件。

Class 在 jdk.jshell.execution 中的用法

jdk.jshell.execution 中返回 Class 的方法

修饰符和类型	方法	描述
protected Class<?>	DirectExecutionControl.findClass(String name)	查找具有指定二进制名称的类。
Class<?>	LoaderDelegate.findClass(String name)	查找具有指定二进制名称的类。

Class 在 jdk.net 中的用法

jdk.net 中的方法，参数类型为 Class

修饰符和类型	方法	描述
static Set<SocketOption<?>>	Sockets.supportedOptions(Class<?> socketType)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 请改用 Socket.supportedOptions() 、 ServerSocket.supportedOptions() 或 DatagramSocket.supportedOptions() 。