©
Dieses Dokument verwendet PHP-Handbuch für chinesische Websites Freigeben
|
JavaTM 2 Platform Standard Ed. 6 |
|||||||||
| 上一个 下一个 | 框架 无框架 | |||||||||
| 使用 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 中的方法 | ||
|---|---|---|
|
Toolkit.createDragGestureRecognizer(Class<T> abstractRecognizerClass,
DragSource ds,
Component c,
int srcActions,
DragGestureListener dgl)
创建所请求的抽象 DragGestureRecognizer 类的具体的、与平台有关的子类，并将它与指定的 DragSource、Component 和 DragGestureListener 关联。 |
|
|
Button.getListeners(Class<T> listenerType)
返回当前在此 Button 上注册为 FooListener 的所有对象的数组。 |
|
|
Checkbox.getListeners(Class<T> listenerType)
返回目前已在此 Checkbox 上注册为 FooListener 的所有对象组成的数组。 |
|
|
CheckboxMenuItem.getListeners(Class<T> listenerType)
返回当前在此 CheckboxMenuItem 上注册为 FooListener 的所有对象组成的数组。 |
|
|
Choice.getListeners(Class<T> listenerType)
返回目前已在此 Choice 上注册为 FooListener 的所有对象组成的数组。 |
|
|
List.getListeners(Class<T> listenerType)
返回目前已在此 List 上注册为 FooListener 的所有对象的数组。 |
|
|
Scrollbar.getListeners(Class<T> listenerType)
返回目前已在此 Scrollbar 上注册为 FooListener 的所有对象组成的数组。 |
|
|
TextComponent.getListeners(Class<T> listenerType)
返回当前已在此 TextComponent 上注册为 FooListener 的所有对象的数组。 |
|
|
TextField.getListeners(Class<T> listenerType)
返回当前已在此 TextField 上注册为 FooListener 的所有对象的数组。 |
|
|
MenuItem.getListeners(Class<T> listenerType)
返回当前在此 MenuItem 上注册为 FooListener 的所有对象组成的数组。 |
|
|
Window.getListeners(Class<T> listenerType)
返回当前在此 Window 上注册为 FooListener 的所有对象所组成的数组。 |
|
|
Container.getListeners(Class<T> listenerType)
返回当前已在此 Container 上注册为 FooListener 的所有对象的数组。 |
|
|
Component.getListeners(Class<T> listenerType)
返回一个当前在此 Component 上作为 FooListener 注册的所有对象的数组。 |
|
static
|
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 中的方法 | ||
|---|---|---|
|
DragSource.createDragGestureRecognizer(Class<T> recognizerAbstractClass,
Component c,
int actions,
DragGestureListener dgl)
创建一个新的 DragGestureRecognizer，实现 DragGestureRecognizer 的指定抽象子类并在新创建的对象上设置指定的 Component 和 DragGestureListener。 |
|
|
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
|
EventHandler.create(Class<T> listenerInterface,
Object target,
String action)
创建 listenerInterface 的实现，在该实现中，侦听器接口中的所有 方法都会将处理程序的 action 应用到 target。 |
|
static
|
EventHandler.create(Class<T> listenerInterface,
Object target,
String action,
String eventPropertyName)
创建 listenerInterface 的实现，在该实现中，所有 方法都会将事件表达式的值 eventPropertyName 传递给语句中的最终方法 action，后者被应用于 target。 |
|
static
|
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 中的方法 | ||
|---|---|---|
|
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 中的方法 | ||
|---|---|---|
|
Class.asSubclass(Class<U> clazz)
强制转换该 Class 对象，以表示指定的 class 对象所表示的类的一个子类。 |
|
void |
SecurityManager.checkMemberAccess(Class<?> clazz,
int which)
如果不允许调用线程访问程序，则抛出 SecurityException。 |
|
static boolean |
Compiler.compileClass(Class<?> clazz)
编译指定的类。 |
|
|
Package.getAnnotation(Class<A> annotationClass)
|
|
|
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
|
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
|
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 中的方法 | ||
|---|---|---|
|
Constructor.getAnnotation(Class<T> annotationClass)
|
|
|
Method.getAnnotation(Class<T> annotationClass)
|
|
|
Field.getAnnotation(Class<T> annotationClass)
|
|
|
AccessibleObject.getAnnotation(Class<T> annotationClass)
|
|
|
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
|
KeyFactorySpi.engineGetKeySpec(Key key,
Class<T> keySpec)
返回给定密钥对象的规范（密钥材料）。 |
|
protected abstract
|
AlgorithmParametersSpi.engineGetParameterSpec(Class<T> paramSpec)
返回此参数对象的（透明）规范。 |
|
boolean |
KeyStore.entryInstanceOf(String alias,
Class<? extends KeyStore.Entry> entryClass)
确定指定 alias 的 keystore Entry 是否是指定 entryClass 的实例或子类。 |
|
|
KeyFactory.getKeySpec(Key key,
Class<T> keySpec)
返回给定密钥对象的规范（密钥材料）。 |
|
|
AlgorithmParameters.getParameterSpec(Class<T> paramSpec)
返回此参数对象的（透明）规范。 |
|
| java.sql 中 Class 的使用 |
|---|
| 返回变量类型为 Class 的类型的 java.sql 中的方法 | |
|---|---|
Map<String,Class<?>> |
Connection.getTypeMap()
获取与此 Connection 对象关联的 Map 对象。 |
| 参数类型为 Class 的 java.sql 中的方法 | ||
|---|---|---|
|
SQLXML.getSource(Class<T> sourceClass)
返回读取此 SQLXML 实例指定的 XML 值的 Source。 |
|
boolean |
Wrapper.isWrapperFor(Class<?> iface)
如果调用此方法的对象实现接口参数，或者是实现接口参数的对象的直接或间接包装器，则返回 true。 |
|
|
SQLXML.setResult(Class<T> resultClass)
返回设置此 SQLXML 实例指定的 XML 值的 Result。 |
|
|
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
|
EnumSet.allOf(Class<E> elementType)
创建一个包含指定元素类型的所有元素的枚举 set。 |
|
static
|
Collections.checkedCollection(Collection<E> c,
Class<E> type)
返回指定 collection 的一个动态类型安全视图。 |
|
static
|
Collections.checkedList(List<E> list,
Class<E> type)
返回指定列表的一个动态类型安全视图。 |
|
static
|
Collections.checkedMap(Map<K,V> m,
Class<K> keyType,
Class<V> valueType)
返回指定映射的一个动态类型安全视图。 |
|
static
|
Collections.checkedMap(Map<K,V> m,
Class<K> keyType,
Class<V> valueType)
返回指定映射的一个动态类型安全视图。 |
|
static
|
Collections.checkedSet(Set<E> s,
Class<E> type)
返回指定 set 的一个动态类型安全视图。 |
|
static
|
Collections.checkedSortedMap(SortedMap<K,V> m,
Class<K> keyType,
Class<V> valueType)
返回指定有序映射的一个动态类型安全视图。 |
|
static
|
Collections.checkedSortedMap(SortedMap<K,V> m,
Class<K> keyType,
Class<V> valueType)
返回指定有序映射的一个动态类型安全视图。 |
|
static
|
Collections.checkedSortedSet(SortedSet<E> s,
Class<E> type)
返回指定有序 set 的一个动态类型安全视图。 |
|
static
|
Arrays.copyOf(U[] original,
int newLength,
Class<? extends T[]> newType)
复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。 |
|
static
|
Arrays.copyOfRange(U[] original,
int from,
int to,
Class<? extends T[]> newType)
将指定数组的指定范围复制到一个新数组。 |
|
static
|
ServiceLoader.load(Class<S> service)
针对给定服务类型创建新的服务加载器，使用当前线程的上下文类加载器。 |
|
static
|
ServiceLoader.load(Class<S> service,
ClassLoader loader)
针对给定服务类型和类加载器创建新的服务加载器。 |
|
static
|
ServiceLoader.loadInstalled(Class<S> service)
针对给定服务类型创建新的服务加载器，使用扩展类加载器。 |
|
static
|
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
|
AtomicReferenceFieldUpdater.newUpdater(Class<U> tclass,
Class<W> vclass,
String fieldName)
使用给定的字段为对象创建和返回一个更新器。 |
|
static
|
AtomicReferenceFieldUpdater.newUpdater(Class<U> tclass,
Class<W> vclass,
String fieldName)
使用给定的字段为对象创建和返回一个更新器。 |
|
static
|
AtomicIntegerFieldUpdater.newUpdater(Class<U> tclass,
String fieldName)
使用给定字段为对象创建和返回一个更新器。 |
|
static
|
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
|
IIOMetadataFormatImpl.addObjectValue(String elementName,
Class<T> classType,
boolean required,
T defaultValue)
允许将给定类类型的 Object 引用存储在实现指定元素的节点中。 |
|
protected
|
IIOMetadataFormatImpl.addObjectValue(String elementName,
Class<T> classType,
boolean required,
T defaultValue,
List<? extends T> enumeratedValues)
允许将给定类类型的 Object 引用存储在实现指定元素的节点中。 |
|
protected
|
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)
注销给定类别下当前注册的所有服务提供者对象。 |
|
|
ServiceRegistry.deregisterServiceProvider(T provider,
Class<T> category)
从给定的类别中移除服务提供者对象。 |
|
|
ServiceRegistry.getServiceProviderByClass(Class<T> providerClass)
返回当前注册的属于给定类类型的服务提供者对象。 |
|
|
ServiceRegistry.getServiceProviders(Class<T> category,
boolean useOrdering)
返回一个包含给定类别中的所有已注册的服务提供者的 Iterator。 |
|
|
ServiceRegistry.getServiceProviders(Class<T> category,
ServiceRegistry.Filter filter,
boolean useOrdering)
返回一个 Iterator，其包含给定类别中满足由指定的 ServiceRegistry.Filter 对象的 filter 方法定义的条件的服务提供者对象。 |
|
static
|
ServiceRegistry.lookupProviders(Class<T> providerClass)
使用上下文类加载器定位和递增地实例化给定服务的可用的提供者。 |
|
static
|
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 时调用此方法。 |
|
|
ServiceRegistry.registerServiceProvider(T provider,
Class<T> category)
将一个服务提供者对象添加到注册表。 |
|
|
ServiceRegistry.setOrdering(Class<T> category,
T firstProvider,
T secondProvider)
为给定类别中的两个服务提供者对象设置配对排序。 |
|
|
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 中的方法 | ||
|---|---|---|
|
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
|
JMX.newMBeanProxy(MBeanServerConnection connection,
ObjectName objectName,
Class<T> interfaceClass)
在本地或远程 MBean Server 中为 Standard MBean 构造一个代理。 |
|
static
|
JMX.newMBeanProxy(MBeanServerConnection connection,
ObjectName objectName,
Class<T> interfaceClass,
boolean notificationBroadcaster)
在同样支持 NotificationEmitter 方法的本地或远程 MBean Server 中为 Standard MBean 构造一个代理。 |
|
static
|
JMX.newMXBeanProxy(MBeanServerConnection connection,
ObjectName objectName,
Class<T> interfaceClass)
在本地或远程 MBean Server 中为 MXBean 构造一个代理。 |
|
static
|
JMX.newMXBeanProxy(MBeanServerConnection connection,
ObjectName objectName,
Class<T> interfaceClass,
boolean notificationBroadcaster)
在同样支持 NotificationEmitter 方法的本地或远程 MBean Server 中为 MXBean 构造一个代理。 |
|
static
|
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
|
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 中的方法 | ||
|---|---|---|
|
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 中的方法 | ||
|---|---|---|
|
Invocable.getInterface(Class<T> clasz)
返回一个接口的实现，该接口使用解释器中编译的函数。 |
|
|
Invocable.getInterface(Object thiz,
Class<T> clasz)
返回一个接口的实现，该接口使用解释器中已编译脚本对象的成员函数。 |
|
| javax.security.auth 中 Class 的使用 |
|---|
| 参数类型为 Class 的 javax.security.auth 中的方法 | ||
|---|---|---|
|
Subject.getPrincipals(Class<T> c)
返回与此 Subject 关联的 Principal Set，它是指定的 Class 的实例或子类。 |
|
|
Subject.getPrivateCredentials(Class<T> c)
返回与此 Subject关联的私有证书 Set，它是指定的 Class 的实例或子类。 |
|
|
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。 |
|
|
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 中设置渲染器时，返回要使用的单元格渲染器。 |
|
|
AbstractSpinnerModel.getListeners(Class<T> listenerType)
返回具有添加到此模型中的给定类型的所有侦听器组成的数组。 |
|
|
DefaultListSelectionModel.getListeners(Class<T> listenerType)
返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。 |
|
|
AbstractListModel.getListeners(Class<T> listenerType)
返回目前已在此模型上注册为 FooListener 的所有对象组成的数组。 |
|
|
DefaultBoundedRangeModel.getListeners(Class<T> listenerType)
返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。 |
|
|
DefaultSingleSelectionModel.getListeners(Class<T> listenerType)
返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。 |
|
|
DefaultButtonModel.getListeners(Class<T> listenerType)
返回目前已在此模型上注册为 FooListener 的所有对象组成的数组。 |
|
|
Timer.getListeners(Class<T> listenerType)
返回目前已在此 Timer 上注册为 FooListener 的所有对象所组成的数组。 |
|
|
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 中的方法 | ||
|---|---|---|
|
EventListenerList.add(Class<T> t,
T l)
将侦听器作为指定类型的侦听器进行添加。 |
|
int |
EventListenerList.getListenerCount(Class<?> t)
返回此侦听器列表中所提供类型的侦听器的总数。 |
|
|
EventListenerList.getListeners(Class<T> t)
返回给定类型的所有侦听器组成的数组。 |
|
|
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 中的方法 | ||
|---|---|---|
|
DefaultTableColumnModel.getListeners(Class<T> listenerType)
返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。 |
|
|
AbstractTableModel.getListeners(Class<T> listenerType)
返回一个包含当前注册为此 AbstractTableModel 上的 FooListener 的所有对象的数组。 |
|
| javax.swing.text 中 Class 的使用 |
|---|
| 返回 Class 的 javax.swing.text 中的方法 | |
|---|---|
Class<?> |
DefaultFormatter.getValueClass()
返回用于创建新 Objects 的类。 |
| 参数类型为 Class 的 javax.swing.text 中的方法 | ||
|---|---|---|
|
DefaultCaret.getListeners(Class<T> listenerType)
返回目前已在此插入符上注册为 FooListener 的所有对象组成的数组。 |
|
|
StyleContext.NamedStyle.getListeners(Class<T> listenerType)
返回具有添加到此模型中的给定类型的所有侦听器组成的数组。 |
|
|
AbstractDocument.getListeners(Class<T> listenerType)
返回目前已在此文档上注册为 FooListener 的所有对象组成的数组。 |
|
void |
DefaultFormatter.setValueClass(Class<?> valueClass)
设置用于创建新 Objects 的类。 |
|
| javax.swing.tree 中 Class 的使用 |
|---|
| 参数类型为 Class 的 javax.swing.tree 中的方法 | ||
|---|---|---|
|
DefaultTreeModel.getListeners(Class<T> listenerType)
返回当前已在此模型上注册为 FooListener 的所有对象组成的数组。 |
|
|
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 中的方法 | ||
|---|---|---|
|
JAXBContext.createBinder(Class<T> domType)
创建一个可用于关联/原地解组/编组操作的 Binder 对象。 |
|
|
Marshaller.getAdapter(Class<A> type)
获取与指定类型关联的适配器。 |
|
|
Unmarshaller.getAdapter(Class<A> type)
获取与指定类型关联的适配器。 |
|
static JAXBContext |
JAXBContext.newInstance(Class... classesToBeBound)
获得 JAXBContext 类的新实例。 |
|
static JAXBContext |
JAXBContext.newInstance(Class[] classesToBeBound,
Map<String,?> properties)
获得 JAXBContext 类的新实例。 |
|
|
Marshaller.setAdapter(Class<A> type,
A adapter)
将已配置的 XmlAdapter 实例与此 marshaller 关联。 |
|
|
Unmarshaller.setAdapter(Class<A> type,
A adapter)
将已配置的 XmlAdapter 实例与此 unmarshaller 关联。 |
|
|
Unmarshaller.unmarshal(Node node,
Class<T> declaredType)
通过 JAXB 映射的 declaredType 解组 XML 数据并返回得到的内容树。 |
|
|
Unmarshaller.unmarshal(Source source,
Class<T> declaredType)
从 declaredType 指定的 XML Source 解组 XML 数据并返回得到的内容树。 |
|
|
Unmarshaller.unmarshal(XMLEventReader reader,
Class<T> declaredType)
将根元素解组到 JAXB 映射的 declaredType 并返回得到的内容树。 |
|
abstract
|
Binder.unmarshal(XmlNode xmlNode,
Class<T> declaredType)
根据提供的 declaredType 将 XML 根元素解组为 JAXB 对象树。 |
|
|
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 中的方法 | ||
|---|---|---|
|
AbstractMarshallerImpl.getAdapter(Class<A> type)
|
|
|
AbstractUnmarshallerImpl.getAdapter(Class<A> type)
|
|
|
AbstractMarshallerImpl.setAdapter(Class<A> type,
A adapter)
|
|
|
AbstractUnmarshallerImpl.setAdapter(Class<A> type,
A adapter)
|
|
|
AbstractUnmarshallerImpl.unmarshal(Node node,
Class<T> expectedType)
|
|
|
AbstractUnmarshallerImpl.unmarshal(Source source,
Class<T> expectedType)
|
|
|
AbstractUnmarshallerImpl.unmarshal(XMLEventReader reader,
Class<T> expectedType)
|
|
|
AbstractUnmarshallerImpl.unmarshal(XMLStreamReader reader,
Class<T> expectedType)
|
|
| javax.xml.ws 中 Class 的使用 |
|---|
| 参数类型为 Class 的 javax.xml.ws 中的方法 | ||
|---|---|---|
|
Service.createDispatch(QName portName,
Class<T> type,
Service.Mode mode)
创建与用户选择的对象一起使用的 Dispatch 实例。 |
|
|
Service.getPort(Class<T> serviceEndpointInterface)
getPort 返回 stub。 |
|
|
Service.getPort(QName portName,
Class<T> serviceEndpointInterface)
getPort 方法返回 stub。 |
|
| javax.xml.ws.spi 中 Class 的使用 |
|---|
| 参数类型为 Class 的 javax.xml.ws.spi 中的方法 | ||
|---|---|---|
abstract
|
ServiceDelegate.createDispatch(QName portName,
Class<T> type,
Service.Mode mode)
创建与用户选择的对象一起使用的 Dispatch 实例。 |
|
abstract ServiceDelegate |
Provider.createServiceDelegate(URL wsdlDocumentLocation,
QName serviceName,
Class serviceClass)
创建一个服务委托对象。 |
|
abstract
|
ServiceDelegate.getPort(Class<T> serviceEndpointInterface)
getPort 方法返回一个桩模块。 |
|
abstract
|
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 2 Platform Standard Ed. 6 |
|||||||||
| 上一个 下一个 | 框架 无框架 | |||||||||
版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。
