概述  软件包  类   使用  树  已过时  索引  帮助 
JavaTM Platform
Standard Ed. 6
 上一个   下一个 框架    无框架    

类 java.lang.Class
的使用

使用 Class 的软件包
java.awt 包含用于创建用户界面和绘制图形图像的所有类。 
java.awt.datatransfer 提供在应用程序之间和在应用程序内部传输数据的接口和类。 
java.awt.dnd Drag 和 Drop 是一种直接操作动作，在许多图形用户界面系统中都会遇到它，它提供了一种机制，能够在两个与 GUI 中显示元素逻辑相关的实体之间传输信息。 
java.awt.image.renderable 提供用于生成与呈现无关的图像的类和接口。 
java.beans 包含与开发 beans 有关的类，即基于 JavaBeansTM 架构的组件。 
java.beans.beancontext 提供与 bean 上下文有关的类和接口。 
java.io 通过数据流、序列化和文件系统提供系统输入和输出。 
java.lang 提供利用 Java 编程语言进行程序设计的基础类。 
java.lang.annotation 为 Java 编程语言注释设施提供库支持。 
java.lang.instrument 提供允许 Java 编程语言代理检测运行在 JVM 上的程序的服务。 
java.lang.management 提供管理接口，用于监视和管理 Java 虚拟机以及 Java 虚拟机在其上运行的操作系统。 
java.lang.reflect 提供类和接口，以获得关于类和对象的反射信息。 
java.net 为实现网络应用程序提供类。 
java.rmi.server 提供支持服务器端 RMI 的类和接口。 
java.security 为安全框架提供类和接口。 
java.sql 提供使用 JavaTM 编程语言访问并处理存储在数据源（通常是一个关系数据库）中的数据的 API。 
java.util 包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。 
java.util.concurrent.atomic 类的小工具包，支持在单个变量上解除锁的线程安全编程。 
java.util.prefs 此包允许应用程序存储并获取用户和系统首选项和配置数据。 
javax.activation   
javax.annotation.processing 用来声明注释处理器并允许注释处理器与注释处理工具环境通信的工具。 
javax.crypto 为加密操作提供类和接口。 
javax.imageio.metadata 用于处理读写元数据的 Java Image I/O API 的包。 
javax.imageio.spi 包含用于 reader、writer、transcoder 和流的插件接口以及一个运行时注册表的 Java Image I/O API 包。 
javax.lang.model.element 用于 Java 编程语言的模型元素的接口。 
javax.management 提供 Java Management Extensions 的核心类。 
javax.management.loading 提供实现高级动态加载的类。 
javax.management.openmbean 提供开放数据类型和 Open MBean 描述符类。 
javax.naming.spi 提供一些方法来动态地插入对通过 javax.naming 和相关包访问命名和目录服务的支持。 
javax.print 为 JavaTM Print Service API 提供了主要类和接口。 
javax.print.attribute 提供了描述 JavaTM Print Service 属性的类型以及如何分类这些属性的类和接口。 
javax.print.attribute.standard 包 javax.print.attribute.standard 包括特定打印属性的类。 
javax.rmi 包含 RMI-IIOP 的用户 API。 
javax.rmi.CORBA 包含用于 RMI-IIOP 的可移植性 API。 
javax.script 脚本 API 由定义 Java TM Scripting Engines 的接口和类组成，并为它们在 Java 应用程序中的使用提供框架。 
javax.security.auth 此包提供用于进行验证和授权的框架。 
javax.sound.midi 提供用于 MIDI（音乐乐器数字接口）数据的 I/O、序列化和合成的接口和类。 
javax.sound.sampled 提供用于捕获、处理和回放取样的音频数据的接口和类。 
javax.sql 为通过 JavaTM 编程语言进行服务器端数据源访问和处理提供 API。 
javax.sql.rowset JDBC RowSet 实现的标准接口和基类。 
javax.sql.rowset.serial 提供实用工具类，允许 SQL 类型与 Java 编程语言数据类型之间的可序列化映射关系。 
javax.swing 提供一组“轻量级”（全部是 Java 语言）组件，尽量让这些组件在所有平台上的工作方式都相同。 
javax.swing.event 供 Swing 组件触发的事件使用。 
javax.swing.plaf.synth Synth 是一个可更换皮肤 (skinnable) 的外观，在其中可委托所有绘制。 
javax.swing.table 提供用于处理 javax.swing.JTable 的类和接口。 
javax.swing.text 提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类。 
javax.swing.tree 提供处理 javax.swing.JTree 的类和接口。 
javax.xml.bind 为包含解组、编组和验证功能的客户端应用程序提供运行时绑定框架。 
javax.xml.bind.helpers 仅由 JAXB 提供者用于： 提供某些 javax.xml.bind 接口的部分默认实现。 
javax.xml.ws 此包包含核心 JAX-WS API。 
javax.xml.ws.spi 该包定义用于 JAX-WS 2.0 的 SPI。 
org.omg.CORBA 提供 OMG CORBA API 到 JavaTM 编程语言的映射，包括 ORB 类，如果已实现该类，则程序员可以使用此类作为全功能对象请求代理（Object Request Broker，ORB）。 
org.omg.CORBA_2_3.portable 提供输入和输出值类型的各种方法，并包含 org/omg/CORBA/portable 包的其他更新。 
org.omg.CORBA.portable 提供可移植性层，即可以使一个供应商生成的代码运行在另一个供应商 ORB 上的 ORB API 集合。 
org.omg.DynamicAny 提供一些类和接口使得在运行时能够遍历与 any 有关联的数据值，并提取数据值的基本成分。 
org.omg.PortableServer 提供一些类和接口，用来生成跨多个供应商 ORB 的可移植应用程序的服务器端。 
 

java.awt 中 Class 的使用
 

参数类型为 Class 的 java.awt 中的方法
<T extends DragGestureRecognizer>
T
Toolkit.createDragGestureRecognizer(Class<T> abstractRecognizerClass, DragSource ds, Component c, int srcActions, DragGestureListener dgl)
          创建所请求的抽象 DragGestureRecognizer 类的具体的、与平台有关的子类，并将它与指定的 DragSource、Component 和 DragGestureListener 关联。
<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[]
List.getListeners(Class<T> listenerType)
          返回目前已在此 List 上注册为 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[]
MenuItem.getListeners(Class<T> listenerType)
          返回当前在此 MenuItem 上注册为 FooListener 的所有对象组成的数组。
<T extends EventListener>
T[]
Window.getListeners(Class<T> listenerType)
          返回当前在此 Window 上注册为 FooListener 的所有对象所组成的数组。
<T extends EventListener>
T[]
Container.getListeners(Class<T> listenerType)
          返回当前已在此 Container 上注册为 FooListener 的所有对象的数组。
<T extends EventListener>
T[]
Component.getListeners(Class<T> listenerType)
          返回一个当前在此 Component 上作为 FooListener 注册的所有对象的数组。
static
<T extends EventListener>
T[]
AWTEventMulticaster.getListeners(EventListener l, Class<T> listenerType)
          返回通过指定的 java.util.EventListener 链接为 FooListener 的所有对象的数组。
protected static void AWTKeyStroke.registerSubclass(Class<?> subclass)
          注册一个新类，AWTKeyStroke 中的工厂方法在生成 AWTKeyStroke 的新实例时将使用它。
 

java.awt.datatransfer 中 Class 的使用
 

返回 Class 的 java.awt.datatransfer 中的方法
 Class<?> DataFlavor.getDefaultRepresentationClass()
           
 Class<?> DataFlavor.getRepresentationClass()
          返回请求此 DataFlavor 时，支持此 DataFlavor 的对象将返回的 Class。
protected static Class<?> DataFlavor.tryToLoadClass(String className, ClassLoader fallback)
          试图从以下位置加载类：引导加载器、系统加载器、上下文加载器（如果存在）和指定的最终加载器。
 

参数类型为 Class 的 java.awt.datatransfer 中的构造方法
DataFlavor(Class<?> representationClass, String humanPresentableName)
          构造一个表示 Java 类的 DataFlavor。
 

java.awt.dnd 中 Class 的使用
 

参数类型为 Class 的 java.awt.dnd 中的方法
<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 的所有对象。
 

java.awt.image.renderable 中 Class 的使用
 

返回 Class 的 java.awt.image.renderable 中的方法
 Class[] ParameterBlock.getParamClasses()
          返回描述该参数的 Class 对象的数组。
 

java.beans 中 Class 的使用
 

返回 Class 的 java.beans 中的方法
 Class<?> BeanDescriptor.getBeanClass()
          获得 bean 的 Class 对象。
 Class<?> BeanDescriptor.getCustomizerClass()
          获得 bean 的 customizer 的 Class 对象。
 Class<?> IndexedPropertyDescriptor.getIndexedPropertyType()
          获得索引属性类型的 Class 对象。
 Class<?> EventSetDescriptor.getListenerType()
          获得目标接口的 Class 对象。
 Class<?> PropertyDescriptor.getPropertyEditorClass()
          获得已为此属性注册的任何显式 PropertyEditor Class。
 Class<?> PropertyDescriptor.getPropertyType()
          获得属性的 Class 对象。
 

参数类型为 Class 的 java.beans 中的方法
static
<T> T
EventHandler.create(Class<T> listenerInterface, Object target, String action)
          创建 listenerInterface 的实现，在该实现中，侦听器接口中的所有 方法都会将处理程序的 action 应用到 target。
static
<T> T
EventHandler.create(Class<T> listenerInterface, Object target, String action, String eventPropertyName)
          创建 listenerInterface 的实现，在该实现中，所有 方法都会将事件表达式的值 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)
          刷新给定类的 Introspector 的内部缓存信息。
static BeanInfo Introspector.getBeanInfo(Class<?> beanClass)
          在 Java Bean 上进行内省，了解其所有属性、公开的方法和事件。
static BeanInfo Introspector.getBeanInfo(Class<?> beanClass, Class<?> stopClass)
          在给定的“断”点之下，在 Java Bean 上进行内省，了解其所有属性和公开的方法。
static BeanInfo Introspector.getBeanInfo(Class<?> beanClass, Class<?> stopClass)
          在给定的“断”点之下，在 Java Bean 上进行内省，了解其所有属性和公开的方法。
static BeanInfo Introspector.getBeanInfo(Class<?> beanClass, int flags)
          在 Java Bean 上进行内省，了解其所有属性、公开的方法和事件，并将结果用一些控制标记表示。
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" 方法对来公开的，公开的顺序是 Introspector 返回它们的顺序。
protected  void PersistenceDelegate.initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out)
          产生一系列对 newInstance 有副作用的语句，使得新实例等于 oldInstance。
static boolean Beans.isInstanceOf(Object bean, Class<?> targetType)
          检查是否可以将 bean 视为给定目标类型。
static void PropertyEditorManager.registerEditor(Class<?> targetType, Class<?> editorClass)
          注册一个将用来编辑给定目标类的值的编辑器类。
static void PropertyEditorManager.registerEditor(Class<?> targetType, Class<?> editorClass)
          注册一个将用来编辑给定目标类的值的编辑器类。
 void Encoder.setPersistenceDelegate(Class<?> type, PersistenceDelegate persistenceDelegate)
          将与此 type 相关联的持久委托设置为 persistenceDelegate。
 void PropertyDescriptor.setPropertyEditorClass(Class<?> propertyEditorClass)
          通常 PropertyEditor 是使用 PropertyEditorManager 找到的。
 

参数类型为 Class 的 java.beans 中的构造方法
BeanDescriptor(Class<?> beanClass)
          为没有 customizer 的 bean 创建一个 BeanDescriptor。
BeanDescriptor(Class<?> beanClass, Class<?> customizerClass)
          为有 customizer 的 bean 创建一个 BeanDescriptor。
BeanDescriptor(Class<?> beanClass, Class<?> customizerClass)
          为有 customizer 的 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 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)
          使用字符串名称从头开始创建 EventSetDescriptor。
EventSetDescriptor(Class<?> sourceClass, String eventSetName, Class<?> listenerType, String[] listenerMethodNames, String addListenerMethodName, String removeListenerMethodName, String getListenerMethodName)
          此构造方法使用字符串名称从头开始创建 EventSetDescriptor。
EventSetDescriptor(Class<?> sourceClass, String eventSetName, Class<?> listenerType, String[] listenerMethodNames, String addListenerMethodName, String removeListenerMethodName, String getListenerMethodName)
          此构造方法使用字符串名称从头开始创建 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。
EventSetDescriptor(String eventSetName, Class<?> listenerType, MethodDescriptor[] listenerMethodDescriptors, Method addListenerMethod, Method removeListenerMethod)
          使用 java.lang.reflect.MethodDescriptor 和 java.lang.Class 对象从头开始创建 EventSetDescriptor。
IndexedPropertyDescriptor(String propertyName, Class<?> beanClass)
          此构造方法通过 getFoo 和 setFoo 存取方法为符合标准 Java 约定的属性构造 IndexedPropertyDescriptor，将其用于索引访问和数组访问。
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)
          此构造方法带有一个简单属性的名称和用于读写属性的方法名称。
 

java.beans.beancontext 中 Class 的使用
 

声明为 Class 的 java.beans.beancontext 中的字段
protected  Class BeanContextServiceAvailableEvent.serviceClass
          新近可用服务的 Class 引用
protected  Class BeanContextServiceRevokedEvent.serviceClass
          将被取消服务的 Class 引用。
 

返回 Class 的 java.beans.beancontext 中的方法
 Class BeanContextServiceAvailableEvent.getServiceClass()
          获得作为此通知主题的服务类。
 Class BeanContextServiceRevokedEvent.getServiceClass()
          获得作为此通知主题的服务类
 

参数类型为 Class 的 java.beans.beancontext 中的方法
 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 boolean BeanContextSupport.classEquals(Class first, Class second)
          测试以查看两个类对象或其名称是否相等。
protected static boolean BeanContextSupport.classEquals(Class first, Class second)
          测试以查看两个类对象或其名称是否相等。
protected  BeanContextServicesSupport.BCSSServiceProvider BeanContextServicesSupport.createBCSSServiceProvider(Class sc, BeanContextServiceProvider bcsp)
          子类可以重写此方法来创建 BCSSServiceProvider 的新子类，而不必为了实例化而重写 addService()。
protected  void BeanContextServicesSupport.fireServiceAdded(Class serviceClass)
          触发一个通知新服务的 BeanContextServiceEvent。
protected  void BeanContextServicesSupport.fireServiceRevoked(Class serviceClass, boolean revokeNow)
          触发一个指示某一特定服务不再可用的 BeanContextServiceRevokedEvent。
 Iterator BeanContextServiceProvider.getCurrentServiceSelectors(BeanContextServices bcs, Class serviceClass)
          由 BeanContextServices 调用，此方法获得指定服务的当前服务选择器。
 Iterator BeanContextServicesSupport.BCSSProxyServiceProvider.getCurrentServiceSelectors(BeanContextServices bcs, Class serviceClass)
           
 Iterator BeanContextServices.getCurrentServiceSelectors(Class serviceClass)
          通过在基础 BeanContextServiceProvider 上调用 getCurrentServiceSelectors() 获得指定服务的与服务有关的服务参数列表（服务选择器）。
 Iterator BeanContextServicesSupport.getCurrentServiceSelectors(Class serviceClass)
           
 Object BeanContextServices.getService(BeanContextChild child, Object requestor, Class serviceClass, Object serviceSelector, BeanContextServiceRevokedListener bcsrl)
          BeanContextChild（或任意与 BeanContextChild 关联的对象）可以通过调用此方法从其嵌套 BeanContextServices 中获得对当前已注册服务的引用。
 Object BeanContextServicesSupport.getService(BeanContextChild child, Object requestor, Class serviceClass, Object serviceSelector, BeanContextServiceRevokedListener bcsrl)
          获得一个可被委托的服务。
 Object BeanContextServiceProvider.getService(BeanContextServices bcs, Object requestor, Class serviceClass, Object serviceSelector)
          由 BeanContextServices 调用，此方法请求来自此 BeanContextServiceProvider 服务的一个实例。
 Object BeanContextServicesSupport.BCSSProxyServiceProvider.getService(BeanContextServices bcs, Object requestor, Class serviceClass, Object serviceSelector)
           
 boolean BeanContextServices.hasService(Class serviceClass)
          报告是否可以从此上下文中得到给定服务。
 boolean BeanContextServicesSupport.hasService(Class serviceClass)
          具有一个可被委托的服务。
 boolean BeanContextServiceRevokedEvent.isServiceClass(Class service)
          检查此事件，以确定将被取消的服务是否属于某个特定类。
 void BeanContextServices.revokeService(Class serviceClass, BeanContextServiceProvider serviceProvider, boolean revokeCurrentServicesNow)
          希望从此上下文中移除当前已注册服务的 BeanContextServiceProvider 可以通过调用此方法实现移除。
 void BeanContextServicesSupport.revokeService(Class serviceClass, BeanContextServiceProvider bcsp, boolean revokeCurrentServicesNow)
          移除服务。
 

参数类型为 Class 的 java.beans.beancontext 中的构造方法
BeanContextServiceAvailableEvent(BeanContextServices bcs, Class sc)
          构造一个 BeanContextAvailableServiceEvent。
BeanContextServiceRevokedEvent(BeanContextServices bcs, Class sc, boolean invalidate)
          构造一个 BeanContextServiceEvent。
 

java.io 中 Class 的使用
 

返回 Class 的 java.io 中的方法
 Class<?> ObjectStreamClass.forClass()
          返回此版本所映射的本地 VM 中的类。
 Class<?> ObjectStreamField.getType()
          获取字段的类型。
protected  Class<?> ObjectInputStream.resolveClass(ObjectStreamClass desc)
          加载指定流类描述的本地等价类。
protected  Class<?> ObjectInputStream.resolveProxyClass(String[] interfaces)
          返回一个代理类，该类实现在代理类描述符中命名的接口；子类可以实现此方法，以便从流及动态代理类的描述符中读取自定义数据，允许它们使用接口和代理类的替换加载机制。
 

参数类型为 Class 的 java.io 中的方法
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。
 

参数类型为 Class 的 java.io 中的构造方法
ObjectStreamField(String name, Class<?> type)
          创建具有指定类型的 Serializable 字段。
ObjectStreamField(String name, Class<?> type, boolean unshared)
          创建一个 ObjectStreamField，表示给定名称和类型的可序列化字段。
 

java.lang 中 Class 的使用
 

声明为 Class 的 java.lang 中的字段
static Class<Void> Void.TYPE
          表示对应于关键字 void 的伪类型的 Class 对象。
static Class<Long> Long.TYPE
          表示基本类型 long 的 Class 实例。
static Class<Integer> Integer.TYPE
          表示基本类型 int 的 Class 实例。
static Class<Short> Short.TYPE
          表示基本类型 short 的 Class 实例。
static Class<Byte> Byte.TYPE
          表示基本类型 byte 的 Class 实例。
static Class<Double> Double.TYPE
          表示基本类型 double 的 Class 实例。
static Class<Float> Float.TYPE
          表示 float 基本类型的 Class 实例。
static Class<Character> Character.TYPE
          表示基本类型 char 的 Class 实例。
static Class<Boolean> Boolean.TYPE
          表示基本类型 boolean 的 Class 对象。
 

返回 Class 的 java.lang 中的方法
<U> Class<? extends U>
Class.asSubclass(Class<U> clazz)
          强制转换该 Class 对象，以表示指定的 class 对象所表示的类的一个子类。
protected  Class<?> SecurityManager.currentLoadedClass()
          已过时。 建议不使用该类安全检查。建议使用 checkPermission 调用。
protected  Class<?> ClassLoader.defineClass(byte[] b, int off, int len)
          已过时。 由 defineClass(String, byte[], int, int) 取代
protected  Class<?> ClassLoader.defineClass(String name, byte[] b, int off, int len)
          将一个 byte 数组转换为 Class 类的实例。
protected  Class<?> ClassLoader.defineClass(String name, byte[] b, int off, int len, ProtectionDomain protectionDomain)
          使用可选的 ProtectionDomain 将一个 byte 数组转换为 Class 类的实例。
protected  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.findLoadedClass(String name)
          如果 Java 虚拟机已将此加载器记录为具有给定二进制名称的某个类的启动加载器，则返回该二进制名称的类。
protected  Class<?> ClassLoader.findSystemClass(String name)
          查找具有指定的二进制名称的类，必要时加载它。
static Class<?> Class.forName(String className)
          返回与带有给定字符串名的类或接口相关联的 Class 对象。
static Class<?> Class.forName(String name, boolean initialize, ClassLoader loader)
          使用给定的类加载器，返回与带有给定字符串名的类或接口相关联的 Class 对象。
 Class<?> Object.getClass()
          返回此 Object 的运行时类。
protected  Class[] SecurityManager.getClassContext()
          以类数组的形式返回当前执行堆栈。
 Class<?>[] Class.getClasses()
          返回一个包含某些 Class 对象的数组，这些对象表示属于此 Class 对象所表示的类的成员的所有公共类和接口。
 Class<?> Class.getComponentType()
          返回表示数组组件类型的 Class。
 Class<?>[] Class.getDeclaredClasses()
          返回 Class 对象的一个数组，这些对象反映声明为此 Class 对象所表示的类的成员的所有类和接口。
 Class<E> Enum.getDeclaringClass()
          返回与此枚举常量的枚举类型相对应的 Class 对象。
 Class<?> Class.getDeclaringClass()
          如果此 Class 对象所表示的类或接口是另一个类的成员，则返回的 Class 对象表示该对象的声明类。
 Class<?> Class.getEnclosingClass()
          返回底层类的立即封闭类。
 Class<?>[] Class.getInterfaces()
          确定此对象所表示的类或接口实现的接口。
 Class<? super T> Class.getSuperclass()
          返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。
 Class<?> ClassLoader.loadClass(String name)
          使用指定的二进制名称来加载类。
protected  Class<?> ClassLoader.loadClass(String name, boolean resolve)
          使用指定的二进制名称来加载类。
 

参数类型为 Class 的 java.lang 中的方法
<U> Class<? extends U>
Class.asSubclass(Class<U> clazz)
          强制转换该 Class 对象，以表示指定的 class 对象所表示的类的一个子类。
 void SecurityManager.checkMemberAccess(Class<?> clazz, int which)
          如果不允许调用线程访问程序，则抛出 SecurityException。
static boolean Compiler.compileClass(Class<?> clazz)
          编译指定的类。
<A extends Annotation>
A
Package.getAnnotation(Class<A> annotationClass)
           
<A extends Annotation>
A
Class.getAnnotation(Class<A> annotationClass)
           
 Constructor<T> Class.getConstructor(Class<?>... parameterTypes)
          返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。
 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 Package.isAnnotationPresent(Class<? extends Annotation> annotationClass)
           
 boolean Class.isAnnotationPresent(Class<? extends Annotation> annotationClass)
           
 boolean Class.isAssignableFrom(Class<?> cls)
          判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口。
protected  void ClassLoader.resolveClass(Class<?> c)
          链接指定的类。
protected  void ClassLoader.setSigners(Class<?> c, Object[] signers)
          设置类的签署者。
static
<T extends Enum<T>>
T
Enum.valueOf(Class<T> enumType, String name)
          返回带指定名称的指定枚举类型的枚举常量。
 

参数类型为 Class 的 java.lang 中的构造方法
EnumConstantNotPresentException(Class<? extends Enum> enumType, String constantName)
          为指定常量构造一个 EnumConstantNotPresentException。
 

java.lang.annotation 中 Class 的使用
 

返回 Class 的 java.lang.annotation 中的方法
 Class<? extends Annotation> IncompleteAnnotationException.annotationType()
          返回带有缺少元素的注释类型的 Class 对象。
 Class<? extends Annotation> Annotation.annotationType()
          返回此 annotation 的注释类型。
 

参数类型为 Class 的 java.lang.annotation 中的构造方法
IncompleteAnnotationException(Class<? extends Annotation> annotationType, String elementName)
          构造一个指示指定注释类型中缺少指定元素的 IncompleteAnnotationException。
 

java.lang.instrument 中 Class 的使用
 

返回 Class 的 java.lang.instrument 中的方法
 Class[] Instrumentation.getAllLoadedClasses()
          返回 JVM 当前加载的所有类的数组。
 Class<?> ClassDefinition.getDefinitionClass()
          返回该类。
 Class[] Instrumentation.getInitiatedClasses(ClassLoader loader)
          返回所有初始化加载器是 loader 的类的数组。
 

参数类型为 Class 的 java.lang.instrument 中的方法
 boolean Instrumentation.isModifiableClass(Class<?> theClass)
          确定一个类是否可以被 retransformation 或 redefinition 修改。
 void Instrumentation.retransformClasses(Class<?>... classes)
          重转换提供的类集。
 byte[] ClassFileTransformer.transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer)
          此方法的实现可以转换提供的类文件，并返回一个新的替换类文件。
 

参数类型为 Class 的 java.lang.instrument 中的构造方法
ClassDefinition(Class<?> theClass, byte[] theClassFile)
          使用提供的类和类文件字节创建一个新的 ClassDefinition 绑定。
 

java.lang.management 中 Class 的使用
 

参数类型为 Class 的 java.lang.management 中的方法
static
<T> T
ManagementFactory.newPlatformMXBeanProxy(MBeanServerConnection connection, String mxbeanName, Class<T> mxbeanInterface)
          返回用于给定 MXBean 名称的平台 MXBean 接口的代理，以便通过给定 MBeanServerConnection 转发其方法调用。
 

java.lang.reflect 中 Class 的使用
 

返回 Class 的 java.lang.reflect 中的方法
 Class<T> Constructor.getDeclaringClass()
          返回 Class 对象，该对象表示声明由此 Constructor 对象表示的构造方法的类。
 Class<?> Method.getDeclaringClass()
          返回表示声明由此 Method 对象表示的方法的类或接口的 Class 对象。
 Class<?> Field.getDeclaringClass()
          返回表示类或接口的 Class 对象，该类或接口声明由此 Field 对象表示的字段。
 Class<?> Member.getDeclaringClass()
          返回表示声明由此 Member 表示的成员或构造方法的类或接口的 Class 对象。
 Class<?>[] Constructor.getExceptionTypes()
          返回一组表示声明要抛出的异常类型的 Class 对象，这些异常是由此 Constructor 对象表示的底层构造方法抛出的。
 Class<?>[] Method.getExceptionTypes()
          返回 Class 对象的数组，这些对象描述了声明将此 Method 对象表示的底层方法抛出的异常类型。
 Class<?>[] Constructor.getParameterTypes()
          按照声明顺序返回一组 Class 对象，这些对象表示此 Constructor 对象所表示构造方法的形参类型。
 Class<?>[] Method.getParameterTypes()
          按照声明顺序返回 Class 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型。
static Class<?> Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)
          返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。
 Class<?> Method.getReturnType()
          返回一个 Class 对象，该对象描述了此 Method 对象所表示的方法的正式返回类型。
 Class<?> Field.getType()
          返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。
 

参数类型为 Class 的 java.lang.reflect 中的方法
<T extends Annotation>
T
Constructor.getAnnotation(Class<T> annotationClass)
           
<T extends Annotation>
T
Method.getAnnotation(Class<T> annotationClass)
           
<T extends Annotation>
T
Field.getAnnotation(Class<T> annotationClass)
           
<T extends Annotation>
T
AccessibleObject.getAnnotation(Class<T> annotationClass)
           
<T extends Annotation>
T
AnnotatedElement.getAnnotation(Class<T> annotationClass)
          如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
static Class<?> Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)
          返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。
 boolean AccessibleObject.isAnnotationPresent(Class<? extends Annotation> annotationClass)
           
 boolean AnnotatedElement.isAnnotationPresent(Class<? extends Annotation> annotationClass)
          如果指定类型的注释存在于此元素上，则返回 true，否则返回 false。
static boolean Proxy.isProxyClass(Class<?> cl)
          当且仅当指定的类通过 getProxyClass 方法或 newProxyInstance 方法动态生成为代理类时，返回 true。
static Object Array.newInstance(Class<?> componentType, int... dimensions)
          创建一个具有指定的组件类型和维度的新数组。
static Object Array.newInstance(Class<?> componentType, int length)
          创建一个具有指定的组件类型和长度的新数组。
static Object Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
          返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
 

java.net 中 Class 的使用
 

返回 Class 的 java.net 中的方法
protected  Class<?> URLClassLoader.findClass(String name)
          通过 URL 搜索路径查找并加载具有指定名称的类。
 

参数类型为 Class 的 java.net 中的方法
 Object URLConnection.getContent(Class[] classes)
          获取此 URL 连接的内容。
 Object URL.getContent(Class[] classes)
          获取此 URL 的内容。
 Object ContentHandler.getContent(URLConnection urlc, Class[] classes)
          如果给出位于对象表示形式开头的 URL 连接流，则此方法读取该流并创建与给定类型之一匹配的对象。
 

java.rmi.server 中 Class 的使用
 

返回 Class 的 java.rmi.server 中的方法
 Class<?> LoaderHandler.loadClass(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 路径加载类。
abstract  Class<?> RMIClassLoaderSpi.loadClass(String codebase, String name, ClassLoader defaultLoader)
          提供 RMIClassLoader.loadClass(URL,String)、RMIClassLoader.loadClass(String,String) 和 RMIClassLoader.loadClass(String,String,ClassLoader) 的实现。
 Class<?> LoaderHandler.loadClass(URL codebase, String name)
          已过时。 无替代版本
static Class<?> RMIClassLoader.loadClass(URL codebase, String name)
          从基本代码 URL 加载类。
static Class<?> RMIClassLoader.loadProxyClass(String codebase, String[] interfaces, ClassLoader defaultLoader)
          从基本代码 URL 路径加载一个实现一组具有给定名称的接口的动态代理类（请参阅 Proxy）。
abstract  Class<?> RMIClassLoaderSpi.loadProxyClass(String codebase, String[] interfaces, ClassLoader defaultLoader)
          提供 RMIClassLoader.loadProxyClass(String,String[],ClassLoader) 的实现。
 

参数类型为 Class 的 java.rmi.server 中的方法
static String RMIClassLoader.getClassAnnotation(Class<?> cl)
          返回表示类定义位置的注释字符串，RMI 将在编组给定类的对象时用其注释类描述符。
abstract  String RMIClassLoaderSpi.getClassAnnotation(Class<?> cl)
          提供 RMIClassLoader.getClassAnnotation(Class) 的实现。
 

java.security 中 Class 的使用
 

返回 Class 的 java.security 中的方法
protected  Class<?> SecureClassLoader.defineClass(String name, byte[] b, int off, int len, CodeSource cs)
          使用可选的 CodeSource 将 byte 数组转换为 Class 类的实例。
protected  Class<?> SecureClassLoader.defineClass(String name, ByteBuffer b, CodeSource cs)
          使用可选的 CodeSource 将 ByteBuffer 转换为 Class 类的实例。
 

参数类型为 Class 的 java.security 中的方法
 boolean KeyStoreSpi.engineEntryInstanceOf(String alias, Class<? extends KeyStore.Entry> entryClass)
          确定指定 alias 的 keystore 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)
          返回此参数对象的（透明）规范。
 boolean KeyStore.entryInstanceOf(String alias, Class<? extends KeyStore.Entry> entryClass)
          确定指定 alias 的 keystore Entry 是否是指定 entryClass 的实例或子类。
<T extends KeySpec>
T
KeyFactory.getKeySpec(Key key, Class<T> keySpec)
          返回给定密钥对象的规范（密钥材料）。
<T extends AlgorithmParameterSpec>
T
AlgorithmParameters.getParameterSpec(Class<T> paramSpec)
          返回此参数对象的（透明）规范。
 

java.sql 中 Class 的使用
 

返回变量类型为 Class 的类型的 java.sql 中的方法
 Map<String,Class<?>> Connection.getTypeMap()
          获取与此 Connection 对象关联的 Map 对象。
 

参数类型为 Class 的 java.sql 中的方法
<T extends Source>
T
SQLXML.getSource(Class<T> sourceClass)
          返回读取此 SQLXML 实例指定的 XML 值的 Source。
 boolean Wrapper.isWrapperFor(Class<?> iface)
          如果调用此方法的对象实现接口参数，或者是实现接口参数的对象的直接或间接包装器，则返回 true。
<T extends Result>
T
SQLXML.setResult(Class<T> resultClass)
          返回设置此 SQLXML 实例指定的 XML 值的 Result。
<T> T
Wrapper.unwrap(Class<T> iface)
          返回一个对象，该对象实现给定接口，以允许访问非标准方法或代理未公开的标准方法。
 

类型变量类型为 Class 的 java.sql 中的方法参数
 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 ResultSet.getObject(int columnIndex, Map<String,Class<?>> map)
          以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
 Object Ref.getObject(Map<String,Class<?>> map)
          获取引用对象并使用给定类型映射表将其映射到 Java 类型。
 Object CallableStatement.getObject(String parameterName, Map<String,Class<?>> map)
          返回一个表示 OUT 参数 parameterName 值的对象，并将 map 用于该参数值的自定义映射关系。
 Object ResultSet.getObject(String columnLabel, Map<String,Class<?>> map)
          以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
 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 对象的类型映射。
 

java.util 中 Class 的使用
 

返回 Class 的 java.util 中的方法
 Class<?> IllegalFormatConversionException.getArgumentClass()
          返回不匹配参数的类。
 

参数类型为 Class 的 java.util 中的方法
static
<E extends Enum<E>>
EnumSet<E>
EnumSet.allOf(Class<E> elementType)
          创建一个包含指定元素类型的所有元素的枚举 set。
static
<E> Collection<E>
Collections.checkedCollection(Collection<E> c, Class<E> type)
          返回指定 collection 的一个动态类型安全视图。
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)
          返回指定映射的一个动态类型安全视图。
static
<K,V> Map<K,V>
Collections.checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType)
          返回指定映射的一个动态类型安全视图。
static
<E> Set<E>
Collections.checkedSet(Set<E> s, Class<E> type)
          返回指定 set 的一个动态类型安全视图。
static
<K,V> SortedMap<K,V>
Collections.checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType)
          返回指定有序映射的一个动态类型安全视图。
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)
          返回指定有序 set 的一个动态类型安全视图。
static
<T,U> T[]
Arrays.copyOf(U[] original, int newLength, Class<? extends T[]> newType)
          复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
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.loadInstalled(Class<S> service)
          针对给定服务类型创建新的服务加载器，使用扩展类加载器。
static
<E extends Enum<E>>
EnumSet<E>
EnumSet.noneOf(Class<E> elementType)
          创建一个具有指定元素类型的空枚举 set。
 

参数类型为 Class 的 java.util 中的构造方法
EnumMap(Class<K> keyType)
          创建一个具有指定键类型的空枚举映射。
IllegalFormatConversionException(char c, Class<?> arg)
          使用不匹配转换和相应参数类构造此类的实例。
 

java.util.concurrent.atomic 中 Class 的使用
 

参数类型为 Class 的 java.util.concurrent.atomic 中的方法
static
<U,W> AtomicReferenceFieldUpdater<U,W>
AtomicReferenceFieldUpdater.newUpdater(Class<U> tclass, Class<W> vclass, String fieldName)
          使用给定的字段为对象创建和返回一个更新器。
static
<U,W> AtomicReferenceFieldUpdater<U,W>
AtomicReferenceFieldUpdater.newUpdater(Class<U> tclass, Class<W> vclass, String fieldName)
          使用给定的字段为对象创建和返回一个更新器。
static
<U> AtomicIntegerFieldUpdater<U>
AtomicIntegerFieldUpdater.newUpdater(Class<U> tclass, String fieldName)
          使用给定字段为对象创建和返回一个更新器。
static
<U> AtomicLongFieldUpdater<U>
AtomicLongFieldUpdater.newUpdater(Class<U> tclass, String fieldName)
          为对象创建并返回一个具有给定字段的更新器。
 

java.util.prefs 中 Class 的使用
 

参数类型为 Class 的 java.util.prefs 中的方法
static Preferences Preferences.systemNodeForPackage(Class<?> c)
          从系统首选项树（根据约定，它与指定类的包相关联）返回首选项节点。
static Preferences Preferences.userNodeForPackage(Class<?> c)
          从调用用户首选项树（根据约定，它与指定类的包相关联）返回首选项节点。
 

javax.activation 中 Class 的使用
 

返回 Class 的 javax.activation 中的方法
 Class ActivationDataFlavor.getRepresentationClass()
          返回表示形式类。
 

参数类型为 Class 的 javax.activation 中的构造方法
ActivationDataFlavor(Class representationClass, String humanPresentableName)
          构造一个表示 MimeType 的 DataFlavor。
ActivationDataFlavor(Class representationClass, String mimeType, String humanPresentableName)
          构造一个表示任意 Java 对象的 DataFlavor。
 

javax.annotation.processing 中 Class 的使用
 

参数类型为 Class 的 javax.annotation.processing 中的方法
 Set<? extends Element> RoundEnvironment.getElementsAnnotatedWith(Class<? extends Annotation> a)
          返回使用给定注释类型注释的元素。
 

javax.crypto 中 Class 的使用
 

参数类型为 Class 的 javax.crypto 中的方法
protected abstract  KeySpec SecretKeyFactorySpi.engineGetKeySpec(SecretKey key, Class keySpec)
          以所需格式返回给定密钥对象的规范（密钥材料）。
 KeySpec SecretKeyFactory.getKeySpec(SecretKey key, Class keySpec)
          以请求的格式返回给定密钥对象的规范（密钥材料）。
 

javax.imageio.metadata 中 Class 的使用
 

返回 Class 的 javax.imageio.metadata 中的方法
 Class<?> IIOMetadataFormat.getObjectClass(String elementName)
          返回存储在元素中的 Class 类型的 Object 引用。
 Class<?> IIOMetadataFormatImpl.getObjectClass(String elementName)
           
 

参数类型为 Class 的 javax.imageio.metadata 中的方法
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 引用存储在实现指定元素的节点中。
 

javax.imageio.spi 中 Class 的使用
 

声明为 Class 的 javax.imageio.spi 中的字段
protected  Class<?> ImageInputStreamSpi.inputClass
          指示供 createInputStreamInstance 方法使用的合法对象类型的 Class 对象。
protected  Class[] ImageReaderSpi.inputTypes
          将从 getInputTypes 返回的 Class 对象数组，该数组最初为 null。
protected  Class<?> ImageOutputStreamSpi.outputClass
          指示供 createInputStreamInstance 方法使用的合法对象类型的 Class 对象。
protected  Class[] ImageWriterSpi.outputTypes
          将从 getOutputTypes 返回的 Class 对象的数组，该数组最初为 null。
static Class[] ImageReaderSpi.STANDARD_INPUT_TYPE
          将从 getInputTypes 返回的单元素数组，该数组最初包含 ImageInputStream.class。
static Class[] ImageWriterSpi.STANDARD_OUTPUT_TYPE
          从 getInputTypes 返回的单元素数组，该数组最初包含 ImageInputStream.class。
 

返回 Class 的 javax.imageio.spi 中的方法
 Class<?> ImageInputStreamSpi.getInputClass()
          返回表示必须由输入源实现（以便使用 createInputStreamInstance 方法在 ImageInputStream 中“包装”）的类或接口的类型的 Class 对象。
 Class[] ImageReaderSpi.getInputTypes()
          返回 Class 对象数组，指示可用作 reader 的 setInput 方法参数的对象类型。
 Class<?> ImageOutputStreamSpi.getOutputClass()
          返回表示必须由输出目标位置实现（以便使用 createOutputStreamInstance 方法在 ImageOutputStream 中“包装”）的类或接口的类型的 Class 对象。
 Class[] ImageWriterSpi.getOutputTypes()
          返回 Class 对象数组，指示可用作 setOutput 方法参数的对象类型。
 

返回变量类型为 Class 的类型的 javax.imageio.spi 中的方法
 Iterator<Class<?>> ServiceRegistry.getCategories()
          返回指示当前类别集的 Class 对象的 Iterator。
 

参数类型为 Class 的 javax.imageio.spi 中的方法
 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)
          在 ServiceRegistry 中实例化和注册 Spi 类后即执行的回调。
 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)
          为给定类别中的两个服务提供者对象设置配对排序。
 

参数类型为 Class 的 javax.imageio.spi 中的构造方法
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。
 

类型变量类型为 Class 的 javax.imageio.spi 中的构造方法参数
ServiceRegistry(Iterator<Class<?>> categories)
          使用取自 categories 参数的一组类别构造 ServiceRegistry 实例。
 

javax.lang.model.element 中 Class 的使用
 

参数类型为 Class 的 javax.lang.model.element 中的方法
<A extends Annotation>
A
Element.getAnnotation(Class<A> annotationType)
          返回此元素针对指定类型的注释（如果存在这样的注释），否则返回 null。
 

javax.management 中 Class 的使用
 

返回 Class 的 javax.management 中的方法
 Class<?> StandardMBean.getImplementationClass()
          获取此 Standard MBean（或 MXBean）的实现类。
 Class<?> StandardMBean.getMBeanInterface()
          获取此 Standard MBean（或 MXBean）的管理接口。
static Class DefaultLoaderRepository.loadClass(String className)
          已过时。 仔细检查类加载器列表，并尝试加载所请求的类。
static Class DefaultLoaderRepository.loadClassWithout(ClassLoader loader, String className)
          已过时。 仔细检查除了给定类加载器之外的类加载器列表，然后尝试加载所请求的类。
 

参数类型为 Class 的 javax.management 中的方法
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 notificationBroadcaster)
          在同样支持 NotificationEmitter 方法的本地或远程 MBean Server 中为 Standard MBean 构造一个代理。
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 notificationBroadcaster)
          在同样支持 NotificationEmitter 方法的本地或远程 MBean Server 中为 MXBean 构造一个代理。
static
<T> T
MBeanServerInvocationHandler.newProxyInstance(MBeanServerConnection connection, ObjectName objectName, Class<T> interfaceClass, boolean notificationBroadcaster)
          返回一个代理，该代理通过将其方法从给定 MBean 服务器转发到指定 MBean 来实现给定的接口。
 

参数类型为 Class 的 javax.management 中的构造方法
StandardEmitterMBean(Class<?> mbeanInterface, boolean isMXBean, NotificationEmitter emitter)
          构造一个 MBean，其管理接口由 mbeanInterface 指定，并且其中的通知由给定的 NotificationEmitter 处理。
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 处理。
StandardMBean(Class<?> mbeanInterface)
          使用指定的 mbeanInterface 类从 this 中生成 DynamicMBean。
StandardMBean(Class<?> mbeanInterface, boolean isMXBean)
          使用指定的 mbeanInterface 类从 this 中生成 DynamicMBean。
StandardMBean(T implementation, Class<T> mbeanInterface)
          使用指定的 mbeanInterface 类从对象 implementation 中生成 DynamicMBean。
StandardMBean(T implementation, Class<T> mbeanInterface, boolean isMXBean)
          使用指定的 mbeanInterface 类从对象 implementation 中生成 DynamicMBean。
 

javax.management.loading 中 Class 的使用
 

返回 Class 的 javax.management.loading 中的方法
protected  Class<?> MLet.findClass(String name)
          这是要重新定义的类加载器的主要方法。
 Class<?> ClassLoaderRepository.loadClass(String className)
          通过类加载器列表加载给定的类名称。
static Class DefaultLoaderRepository.loadClass(String className)
          已过时。 仔细检查类加载器列表，并尝试加载所请求的类。
 Class<?> MLet.loadClass(String name, ClassLoaderRepository clr)
          如果在此 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)
          已过时。 仔细检查除了给定的类加载器的类加载器列表，然后尝试加载所请求的类。
 

javax.management.openmbean 中 Class 的使用
 

参数类型为 Class 的 javax.management.openmbean 中的方法
static
<T> ArrayType<T>
ArrayType.getPrimitiveArrayType(Class<T> arrayClass)
          以类型安全的方式创建一个 ArrayType 实例。
 

javax.naming.spi 中 Class 的使用
 

参数类型为 Class 的 javax.naming.spi 中的方法
 ResolveResult Resolver.resolveToClass(Name name, Class<? extends Context> contextType)
          部分解析某一名称。
 ResolveResult Resolver.resolveToClass(String name, Class<? extends Context> contextType)
          部分解析某一名称。
 

javax.print 中 Class 的使用
 

返回 Class 的 javax.print 中的方法
 Class<?>[] PrintService.getSupportedAttributeCategories()
          确定客户端在设置此 PrintService 的作业时，可以指定的打印属性类别。
 Class[] AttributeException.getUnsupportedAttributes()
          返回其 PrintService 实例根本不支持该属性的打印属性类数组，如果没有这种属性，则返回 null。
 

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

javax.print.attribute 中 Class 的使用
 

返回 Class 的 javax.print.attribute 中的方法
 Class<? extends Attribute> Attribute.getCategory()
          将此打印属性值添加到属性集时，为它获取用作“类别”的打印属性类。
static Class<?> AttributeSetUtilities.verifyAttributeCategory(Object object, Class<?> interfaceName)
          验证给定的对象是否为实现给定接口（假定为接口 Attribute 或其子接口）的 Class。
 

参数类型为 Class 的 javax.print.attribute 中的方法
 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)
          验证给定的对象是否为实现给定接口（假定为接口 Attribute 或其子接口）的 Class。
static Attribute AttributeSetUtilities.verifyAttributeValue(Object object, Class<?> interfaceName)
          验证给定的对象是否为给定接口（假定为接口 Attribute 或其子接口）的一个实例。
static void AttributeSetUtilities.verifyCategoryForValue(Class<?> category, Attribute attribute)
          验证给定的属性类别对象是否等于给定属性值对象的类别。
 

参数类型为 Class 的 javax.print.attribute 中的构造方法
HashAttributeSet(Attribute[] attributes, Class<?> interfaceName)
          构造一个新的属性集，其中该属性集的成员限于给定的接口。
HashAttributeSet(Attribute attribute, Class<?> interfaceName)
          构造一个最初使用给定属性填充的新属性集，其中该属性集的成员限于给定的接口。
HashAttributeSet(AttributeSet attributes, Class<?> interfaceName)
          构造一个最初使用给定集合中的值填充的新属性集，其中该属性集的成员限于给定的接口。
HashAttributeSet(Class<?> interfaceName)
          构造一个新的空属性集，其中该属性集的成员限于给定的接口。
 

javax.print.attribute.standard 中 Class 的使用
 

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

javax.rmi 中 Class 的使用
 

参数类型为 Class 的 javax.rmi 中的方法
static Object PortableRemoteObject.narrow(Object narrowFrom, Class narrowTo)
          检查以确保远程或抽象接口类型的对象可以强制转换为所需的类型。
 

javax.rmi.CORBA 中 Class 的使用
 

返回 Class 的 javax.rmi.CORBA 中的方法
static Class Util.loadClass(String className, String remoteCodebase, ClassLoader loader)
          为指定的类返回一个类实例。
 Class UtilDelegate.loadClass(String className, String remoteCodebase, ClassLoader loader)
          Util.loadClass(java.lang.String, java.lang.String, java.lang.ClassLoader) 的委托调用。
 

参数类型为 Class 的 javax.rmi.CORBA 中的方法
static String Util.getCodebase(Class clz)
          返回给定类的代码基（如果存在）。
 String UtilDelegate.getCodebase(Class clz)
          Util.getCodebase(java.lang.Class) 的委托调用。
 String ValueHandler.getRMIRepositoryID(Class clz)
          返回给定 Java 类的 CORBA RepositoryId。
 boolean ValueHandler.isCustomMarshaled(Class clz)
          指示给定的类是执行自定义编组还是默认编组。
 Object PortableRemoteObjectDelegate.narrow(Object narrowFrom, Class narrowTo)
          PortableRemoteObject.narrow(java.lang.Object, java.lang.Class) 的委托调用。
 Serializable ValueHandler.readValue(InputStream in, int offset, Class clz, String repositoryID, RunTime sender)
          使用 Java 语义从流中读取一个值。
 

javax.script 中 Class 的使用
 

参数类型为 Class 的 javax.script 中的方法
<T> T
Invocable.getInterface(Class<T> clasz)
          返回一个接口的实现，该接口使用解释器中编译的函数。
<T> T
Invocable.getInterface(Object thiz, Class<T> clasz)
          返回一个接口的实现，该接口使用解释器中已编译脚本对象的成员函数。
 

javax.security.auth 中 Class 的使用
 

参数类型为 Class 的 javax.security.auth 中的方法
<T extends Principal>
Set<T>
Subject.getPrincipals(Class<T> c)
          返回与此 Subject 关联的 Principal Set，它是指定的 Class 的实例或子类。
<T> Set<T>
Subject.getPrivateCredentials(Class<T> c)
          返回与此 Subject关联的私有证书 Set，它是指定的 Class 的实例或子类。
<T> Set<T>
Subject.getPublicCredentials(Class<T> c)
          返回与此 Subject 关联的公开证书 Set，它是指定的 Class 的实例或子类。
 

javax.sound.midi 中 Class 的使用
 

返回 Class 的 javax.sound.midi 中的方法
 Class<?> SoundbankResource.getDataClass()
          获得此采样所使用的表示其数据的类。
 

参数类型为 Class 的 javax.sound.midi 中的构造方法
Instrument(Soundbank soundbank, Patch patch, String name, Class<?> dataClass)
          从指定的 Patch 构造一个新的 MIDI 乐器。
SoundbankResource(Soundbank soundBank, String name, Class<?> dataClass)
          根据给定的音库和波表索引构造一个新的 SoundbankResource。
 

javax.sound.sampled 中 Class 的使用
 

返回 Class 的 javax.sound.sampled 中的方法
 Class<?> Line.Info.getLineClass()
          获得此 Line.Info 对象所描述的行的类。
 

参数类型为 Class 的 javax.sound.sampled 中的构造方法
DataLine.Info(Class<?> lineClass, AudioFormat format)
          根据指定信息构造数据行的信息对象，这些信息包括单个音频格式。
DataLine.Info(Class<?> lineClass, AudioFormat[] formats, int minBufferSize, int maxBufferSize)
          根据指定信息构造数据行的信息对象，这些包括受支持音频格式的集合和缓冲区大小的范围。
DataLine.Info(Class<?> lineClass, AudioFormat format, int bufferSize)
          根据指定信息构造数据行的信息对象，这些信息包括单个音频格式和所需的缓冲区大小。
Line.Info(Class<?> lineClass)
          构造描述指定类的行的 info 对象。
Port.Info(Class<?> lineClass, String name, boolean isSource)
          根据给定的信息构造端口的 info 对象。
 

javax.sql 中 Class 的使用
 

返回变量类型为 Class 的类型的 javax.sql 中的方法
 Map<String,Class<?>> RowSet.getTypeMap()
          获取与此 RowSet 对象关联的 Map 对象，该对象指定 SQL 用户定义类型的自定义映射关系（如果有）。
 

类型变量类型为 Class 的 javax.sql 中的方法参数
 void RowSet.setTypeMap(Map<String,Class<?>> map)
          将给定 java.util.Map 对象安装为此 RowSet 对象的默认类型映射表。
 

javax.sql.rowset 中 Class 的使用
 

返回变量类型为 Class 的类型的 javax.sql.rowset 中的方法
 Map<String,Class<?>> BaseRowSet.getTypeMap()
          获取与此 RowSet 对象的 Connection 对象关联的类型映射表。
 

参数类型为 Class 的 javax.sql.rowset 中的方法
 boolean RowSetMetaDataImpl.isWrapperFor(Class<?> interfaces)
          如果调用者实现接口参数或者是实现接口参数的对象的直接或间接包装器，则返回 true。
<T> T
RowSetMetaDataImpl.unwrap(Class<T> iface)
          返回实现给定接口以允许访问非标准方法，或者代理未公开标准方法的的对象。
 

类型变量类型为 Class 的 javax.sql.rowset 中的方法参数
 void BaseRowSet.setTypeMap(Map<String,Class<?>> map)
          将给定的 java.util.Map 对象安装为与此 RowSet 对象的 Connection 对象关联的类型映射表。
 

javax.sql.rowset.serial 中 Class 的使用
 

类型变量类型为 Class 的 javax.sql.rowset.serial 中的方法参数
 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)
          获取包含此 SerialArray 对象中元素的子数组的 ResultSet 对象，该子数组从 index 索引处开始，包含 count 个连续元素。
 ResultSet SerialArray.getResultSet(Map<String,Class<?>> map)
          获取 ResultSet 对象，该对象包含由此 SerialArray 对象所表示的所有 SQL ARRAY 值的元素。
 

类型变量类型为 Class 的 javax.sql.rowset.serial 中的构造方法参数
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 对象，并使用给定的属性数组和类型映射表进行初始化。
 

javax.swing 中 Class 的使用
 

返回 Class 的 javax.swing 中的方法
 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) 的值必须为一个类的 String 名称，该类实现相应的 ComponentUI 类。
 

参数类型为 Class 的 javax.swing 中的方法
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[]
AbstractSpinnerModel.getListeners(Class<T> listenerType)
          返回具有添加到此模型中的给定类型的所有侦听器组成的数组。
<T extends EventListener>
T[]
DefaultListSelectionModel.getListeners(Class<T> listenerType)
          返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。
<T extends EventListener>
T[]
AbstractListModel.getListeners(Class<T> listenerType)
          返回目前已在此模型上注册为 FooListener 的所有对象组成的数组。
<T extends EventListener>
T[]
DefaultBoundedRangeModel.getListeners(Class<T> listenerType)
          返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。
<T extends EventListener>
T[]
DefaultSingleSelectionModel.getListeners(Class<T> listenerType)
          返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。
<T extends EventListener>
T[]
DefaultButtonModel.getListeners(Class<T> listenerType)
          返回目前已在此模型上注册为 FooListener 的所有对象组成的数组。
<T extends EventListener>
T[]
Timer.getListeners(Class<T> listenerType)
          返回目前已在此 Timer 上注册为 FooListener 的所有对象所组成的数组。
<T extends EventListener>
T[]
JComponent.getListeners(Class<T> listenerType)
          返回当前在此 JComponent 上注册为 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 中设置渲染器，则设置要使用的默认单元格渲染器。
 

javax.swing.event 中 Class 的使用
 

参数类型为 Class 的 javax.swing.event 中的方法
<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)
          将侦听器作为指定类型的侦听器进行移除。
 

javax.swing.plaf.synth 中 Class 的使用
 

参数类型为 Class 的 javax.swing.plaf.synth 中的方法
 void SynthLookAndFeel.load(InputStream input, Class<?> resourceBase)
          加载此 SynthLookAndFeel 将使用的 SynthStyle 集合。
 

javax.swing.table 中 Class 的使用
 

返回 Class 的 javax.swing.table 中的方法
 Class<?> AbstractTableModel.getColumnClass(int columnIndex)
          返回 Object.class 而不管 columnIndex 是多少。
 Class<?> TableModel.getColumnClass(int columnIndex)
          针对列中所有的单元格值，返回最具体的超类。
 

参数类型为 Class 的 javax.swing.table 中的方法
<T extends EventListener>
T[]
DefaultTableColumnModel.getListeners(Class<T> listenerType)
          返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。
<T extends EventListener>
T[]
AbstractTableModel.getListeners(Class<T> listenerType)
          返回一个包含当前注册为此 AbstractTableModel 上的 FooListener 的所有对象的数组。
 

javax.swing.text 中 Class 的使用
 

返回 Class 的 javax.swing.text 中的方法
 Class<?> DefaultFormatter.getValueClass()
          返回用于创建新 Objects 的类。
 

参数类型为 Class 的 javax.swing.text 中的方法
<T extends EventListener>
T[]
DefaultCaret.getListeners(Class<T> listenerType)
          返回目前已在此插入符上注册为 FooListener 的所有对象组成的数组。
<T extends EventListener>
T[]
StyleContext.NamedStyle.getListeners(Class<T> listenerType)
          返回具有添加到此模型中的给定类型的所有侦听器组成的数组。
<T extends EventListener>
T[]
AbstractDocument.getListeners(Class<T> listenerType)
          返回目前已在此文档上注册为 FooListener 的所有对象组成的数组。
 void DefaultFormatter.setValueClass(Class<?> valueClass)
          设置用于创建新 Objects 的类。
 

javax.swing.tree 中 Class 的使用
 

参数类型为 Class 的 javax.swing.tree 中的方法
<T extends EventListener>
T[]
DefaultTreeModel.getListeners(Class<T> listenerType)
          返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。
<T extends EventListener>
T[]
DefaultTreeSelectionModel.getListeners(Class<T> listenerType)
          返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。
 

javax.xml.bind 中 Class 的使用
 

声明为 Class 的 javax.xml.bind 中的字段
protected  Class<T> JAXBElement.declaredType
          xml 元素声明类型的 Java 数据类型绑定。
protected  Class JAXBElement.scope
          表示此 xml 元素实例的 xml 元素声明的作用域。
 

返回 Class 的 javax.xml.bind 中的方法
 Class<T> JAXBElement.getDeclaredType()
          返回 xml 元素声明的类型属性的 Java 绑定。
 Class JAXBElement.getScope()
          返回 xml 元素声明的作用域。
 

参数类型为 Class 的 javax.xml.bind 中的方法
<T> Binder<T>
JAXBContext.createBinder(Class<T> domType)
          创建一个可用于关联/原地解组/编组操作的 Binder 对象。
<A extends XmlAdapter>
A
Marshaller.getAdapter(Class<A> type)
          获取与指定类型关联的适配器。
<A extends XmlAdapter>
A
Unmarshaller.getAdapter(Class<A> type)
          获取与指定类型关联的适配器。
static JAXBContext JAXBContext.newInstance(Class... classesToBeBound)
           获得 JAXBContext 类的新实例。
static JAXBContext JAXBContext.newInstance(Class[] classesToBeBound, Map<String,?> properties)
           获得 JAXBContext 类的新实例。
<A extends XmlAdapter>
void
Marshaller.setAdapter(Class<A> type, A adapter)
          将已配置的 XmlAdapter 实例与此 marshaller 关联。
<A extends XmlAdapter>
void
Unmarshaller.setAdapter(Class<A> type, A adapter)
          将已配置的 XmlAdapter 实例与此 unmarshaller 关联。
<T> JAXBElement<T>
Unmarshaller.unmarshal(Node node, Class<T> declaredType)
          通过 JAXB 映射的 declaredType 解组 XML 数据并返回得到的内容树。
<T> JAXBElement<T>
Unmarshaller.unmarshal(Source source, Class<T> declaredType)
          从 declaredType 指定的 XML Source 解组 XML 数据并返回得到的内容树。
<T> JAXBElement<T>
Unmarshaller.unmarshal(XMLEventReader reader, Class<T> declaredType)
          将根元素解组到 JAXB 映射的 declaredType 并返回得到的内容树。
abstract
<T> JAXBElement<T>
Binder.unmarshal(XmlNode xmlNode, Class<T> declaredType)
          根据提供的 declaredType 将 XML 根元素解组为 JAXB 对象树。
<T> JAXBElement<T>
Unmarshaller.unmarshal(XMLStreamReader reader, Class<T> declaredType)
          将根元素解组到 JAXB 映射的 declaredType 并返回得到的内容树。
 

参数类型为 Class 的 javax.xml.bind 中的构造方法
JAXBElement(QName name, Class<T> declaredType, Class scope, T value)
          构造一个 xml 元素实例。
JAXBElement(QName name, Class<T> declaredType, Class scope, T value)
          构造一个 xml 元素实例。
JAXBElement(QName name, Class<T> declaredType, T value)
          构造一个 xml 元素实例。
 

javax.xml.bind.helpers 中 Class 的使用
 

参数类型为 Class 的 javax.xml.bind.helpers 中的方法
<A extends XmlAdapter>
A
AbstractMarshallerImpl.getAdapter(Class<A> type)
           
<A extends XmlAdapter>
A
AbstractUnmarshallerImpl.getAdapter(Class<A> type)
           
<A extends XmlAdapter>
void
AbstractMarshallerImpl.setAdapter(Class<A> type, A adapter)
           
<A extends XmlAdapter>
void
AbstractUnmarshallerImpl.setAdapter(Class<A> type, A adapter)
           
<T> JAXBElement<T>
AbstractUnmarshallerImpl.unmarshal(Node node, Class<T> expectedType)
           
<T> JAXBElement<T>
AbstractUnmarshallerImpl.unmarshal(Source source, Class<T> expectedType)
           
<T> JAXBElement<T>
AbstractUnmarshallerImpl.unmarshal(XMLEventReader reader, Class<T> expectedType)
           
<T> JAXBElement<T>
AbstractUnmarshallerImpl.unmarshal(XMLStreamReader reader, Class<T> expectedType)
           
 

javax.xml.ws 中 Class 的使用
 

参数类型为 Class 的 javax.xml.ws 中的方法
<T> Dispatch<T>
Service.createDispatch(QName portName, Class<T> type, Service.Mode mode)
          创建与用户选择的对象一起使用的 Dispatch 实例。
<T> T
Service.getPort(Class<T> serviceEndpointInterface)
          getPort 返回 stub。
<T> T
Service.getPort(QName portName, Class<T> serviceEndpointInterface)
          getPort 方法返回 stub。
 

javax.xml.ws.spi 中 Class 的使用
 

参数类型为 Class 的 javax.xml.ws.spi 中的方法
abstract
<T> Dispatch<T>
ServiceDelegate.createDispatch(QName portName, Class<T> type, Service.Mode mode)
          创建与用户选择的对象一起使用的 Dispatch 实例。
abstract  ServiceDelegate Provider.createServiceDelegate(URL wsdlDocumentLocation, QName serviceName, Class serviceClass)
          创建一个服务委托对象。
abstract
<T> T
ServiceDelegate.getPort(Class<T> serviceEndpointInterface)
          getPort 方法返回一个桩模块。
abstract
<T> T
ServiceDelegate.getPort(QName portName, Class<T> serviceEndpointInterface)
          getPort 方法返回一个桩模块 (stub)。
 

org.omg.CORBA 中 Class 的使用
 

参数类型为 Class 的 org.omg.CORBA 中的方法
 ServantObject LocalObject._servant_preinvoke(String operation, Class expectedType)
          抛出 org.omg.CORBA.NO_IMPLEMENT 异常，并带有消息 "This is a locally constrained object"。
 

org.omg.CORBA_2_3.portable 中 Class 的使用
 

参数类型为 Class 的 org.omg.CORBA_2_3.portable 中的方法
 Object InputStream.read_abstract_interface(Class clz)
          解组与传递类型相对应的类对象或 stub 类。
 Serializable InputStream.read_value(Class clz)
          从输入流解组值类型。
 void OutputStream.write_value(Serializable value, Class clz)
          将值类型编组到输出流中。
 

org.omg.CORBA.portable 中 Class 的使用
 

参数类型为 Class 的 org.omg.CORBA.portable 中的方法
 ServantObject ObjectImpl._servant_preinvoke(String operation, Class expectedType)
          返回对本地 servant 的 Java 引用，该引用应该被用来发送对指定方法的请求。
 Object InputStream.read_Object(Class clz)
          取消对象的编组并返回一个 CORBA Object，该对象是作为参数传递的类的实例。
 ServantObject Delegate.servant_preinvoke(Object self, String operation, Class expectedType)
          返回对应该用作此请求的 servant 的 Java 引用。
 

org.omg.DynamicAny 中 Class 的使用
 

声明为 Class 的 org.omg.DynamicAny 中的字段
static Class _DynAnyFactoryStub._opsClass
           
static Class _DynAnyStub._opsClass
           
static Class _DynArrayStub._opsClass
           
static Class _DynEnumStub._opsClass
           
static Class _DynFixedStub._opsClass
           
static Class _DynSequenceStub._opsClass
           
static Class _DynStructStub._opsClass
           
static Class _DynUnionStub._opsClass
           
static Class _DynValueStub._opsClass
           
 

org.omg.PortableServer 中 Class 的使用
 

声明为 Class 的 org.omg.PortableServer 中的字段
static Class _ServantActivatorStub._opsClass
           
static Class _ServantLocatorStub._opsClass
           
 

概述  软件包  类   使用  树  已过时  索引  帮助 
JavaTM Platform
Standard Ed. 6
 上一个   下一个 框架    无框架    
提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

版权所有 2007 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。