JavaTM 2 Platform
Standard Ed. 6

类 java.lang.Object
的使用

使用 Object 的软件包
java.applet 提供创建 applet 所必需的类和 applet 用来与其 applet 上下文通信的类。 
java.awt 包含用于创建用户界面和绘制图形图像的所有类。 
java.awt.color 提供用于颜色空间的类。 
java.awt.datatransfer 提供在应用程序之间和在应用程序内部传输数据的接口和类。 
java.awt.dnd Drag 和 Drop 是一种直接操作动作,在许多图形用户界面系统中都会遇到它,它提供了一种机制,能够在两个与 GUI 中显示元素逻辑相关的实体之间传输信息。 
java.awt.event 提供处理由 AWT 组件所激发的各类事件的接口和类。 
java.awt.font 提供与字体相关的类和接口。 
java.awt.geom 提供用于在与二维几何形状相关的对象上定义和执行操作的 Java 2D 类。 
java.awt.im 提供输入方法框架所需的类和接口。 
java.awt.im.spi 提供启用可以与 Java 运行时环境一起使用的输入方法开发的接口。 
java.awt.image 提供创建和修改图像的各种类。 
java.awt.image.renderable 提供用于生成与呈现无关的图像的类和接口。 
java.awt.print 为通用的打印 API 提供类和接口。 
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.ref 提供了引用对象类,支持在某种程度上与垃圾回收器之间的交互。 
java.lang.reflect 提供类和接口,以获得关于类和对象的反射信息。 
java.math 提供用于执行任意精度整数算法 (BigInteger) 和任意精度小数算法 (BigDecimal) 的类。 
java.net 为实现网络应用程序提供类。 
java.nio 定义作为数据容器的缓冲区,并提供其他 NIO 包的概述。 
java.nio.channels 定义了各种通道,这些通道表示到能够执行 I/O 操作的实体(如文件和套接字)的连接;定义了用于多路复用的、非阻塞 I/O 操作的选择器。 
java.nio.channels.spi 用于 java.nio.channels 包的服务提供者类。 
java.nio.charset 定义用来在字节和 Unicode 字符之间转换的 charset、解码器和编码器。 
java.nio.charset.spi java.nio.charset 包的服务提供者类。 
java.rmi 提供 RMI 包。 
java.rmi.activation 为 RMI 对象激活提供支持。 
java.rmi.dgc 为 RMI 分布式垃圾回收提供了类和接口。 
java.rmi.registry 提供 RMI 注册表的一个类和两个接口。 
java.rmi.server 提供支持服务器端 RMI 的类和接口。 
java.security 为安全框架提供类和接口。 
java.security.acl 此包中的类和接口已经被 java.security 包中的类取代。 
java.security.cert 提供用于解析和管理证书、证书撤消列表 (CRL) 和证书路径的类和接口。 
java.security.spec 提供密钥规范和算法参数规范的类和接口。 
java.sql 提供使用 JavaTM 编程语言访问并处理存储在数据源(通常是一个关系数据库)中的数据的 API。 
java.text 提供以与自然语言无关的方式来处理文本、日期、数字和消息的类和接口。 
java.text.spi java.text 包中类的服务提供者类。 
java.util 包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类(字符串标记生成器、随机数生成器和位数组)。 
java.util.concurrent 在并发编程中很常用的实用工具类。 
java.util.concurrent.atomic 类的小工具包,支持在单个变量上解除锁的线程安全编程。 
java.util.concurrent.locks 为锁和等待条件提供一个框架的接口和类,它不同于内置同步和监视器。 
java.util.jar 提供读写 JAR (Java ARchive) 文件格式的类,该格式基于具有可选清单文件的标准 ZIP 文件格式。 
java.util.logging 提供 JavaTM 2 平台核心日志工具的类和接口。 
java.util.prefs 此包允许应用程序存储并获取用户和系统首选项和配置数据。 
java.util.regex 用于匹配字符序列与正则表达式指定模式的类。 
java.util.spi java.util 包中类的服务提供者类。 
java.util.zip 提供用于读写标准 ZIP 和 GZIP 文件格式的类。 
javax.accessibility 定义了用户界面组件与提供对这些组件进行访问的辅助技术之间的协定。 
javax.activation   
javax.activity 包含解组期间通过 ORB 机制抛出的与 Activity 服务有关的异常。 
javax.annotation.processing 用来声明注释处理器并允许注释处理器与注释处理工具环境通信的工具。 
javax.crypto 为加密操作提供类和接口。 
javax.crypto.spec 为密钥规范和算法参数规范提供类和接口。 
javax.imageio Java Image I/O API 的主要包。 
javax.imageio.metadata 用于处理读写元数据的 Java Image I/O API 的包。 
javax.imageio.plugins.bmp 包含供内置 BMP 插件使用的公共类的包。 
javax.imageio.plugins.jpeg 支持内置 JPEG 插件的类。 
javax.imageio.spi 包含用于 reader、writer、transcoder 和流的插件接口以及一个运行时注册表的 Java Image I/O API 包。 
javax.imageio.stream Java Image I/O API 的一个包,用来处理从文件和流中产生的低级别 I/O。 
javax.lang.model.element 用于 Java 编程语言的模型元素的接口。 
javax.lang.model.type 用来为 Java 编程语言类型建立模型的接口。 
javax.lang.model.util 用来帮助处理程序元素类型的实用工具。 
javax.management 提供 Java Management Extensions 的核心类。 
javax.management.loading 提供实现高级动态加载的类。 
javax.management.modelmbean 提供了 ModelMBean 类的定义。 
javax.management.monitor 提供 monitor 类的定义。 
javax.management.openmbean 提供开放数据类型和 Open MBean 描述符类。 
javax.management.relation 提供 Relation Service 的定义。 
javax.management.remote 对 JMX MBean 服务器进行远程访问使用的接口。 
javax.management.remote.rmi RMI 连接器是供 JMX Remote API 使用的一种连接器,后者使用 RMI 将客户端请求传输到远程 MBean 服务器。 
javax.management.timer 提供对 Timer MBean(计时器 MBean)的定义。 
javax.naming 为访问命名服务提供类和接口。 
javax.naming.directory 扩展 javax.naming 包以提供访问目录服务的功能。 
javax.naming.event 在访问命名和目录服务时提供对事件通知的支持。 
javax.naming.ldap 提供对 LDAPv3 扩展操作和控件的支持。 
javax.naming.spi 提供一些方法来动态地插入对通过 javax.naming 和相关包访问命名和目录服务的支持。 
javax.net 提供用于网络应用程序的类。 
javax.net.ssl 提供用于安全套接字包的类。 
javax.print 为 JavaTM Print Service API 提供了主要类和接口。 
javax.print.attribute 提供了描述 JavaTM Print Service 属性的类型以及如何分类这些属性的类和接口。 
javax.print.attribute.standard 包 javax.print.attribute.standard 包括特定打印属性的类。 
javax.print.event 包 javax.print.event 包含事件类和侦听器接口。 
javax.rmi 包含 RMI-IIOP 的用户 API。 
javax.rmi.CORBA 包含用于 RMI-IIOP 的可移植性 API。 
javax.rmi.ssl 通过安全套接字层 (SSL) 或传输层安全 (TLS) 协议提供 RMIClientSocketFactoryRMIServerSocketFactory 的实现。 
javax.script 脚本 API 由定义 Java TM Scripting Engines 的接口和类组成,并为它们在 Java 应用程序中的使用提供框架。 
javax.security.auth 此包提供用于进行验证和授权的框架。 
javax.security.auth.callback 此包提供与应用程序进行交互所必需的类,以便检索信息(例如,包括用户名和密码的验证数据)或显示信息(例如,错误和警告消息)。 
javax.security.auth.kerberos 此包包含与 Kerberos 网络验证协议相关的实用工具类。 
javax.security.auth.login 此包提供可插入的验证框架。 
javax.security.auth.x500 此包包含应该用来在 Subject 中存储 X500 Principal 和 X500 Private Crendentials 的类。 
javax.security.cert 为公钥证书提供类。 
javax.security.sasl 包含用于支持 SASL 的类和接口。 
javax.sound.midi 提供用于 MIDI(音乐乐器数字接口)数据的 I/O、序列化和合成的接口和类。 
javax.sound.midi.spi 在提供新的 MIDI 设备、MIDI 文件 reader 和 writer、或音库 reader 时提供服务提供者要实现的接口。 
javax.sound.sampled 提供用于捕获、处理和回放取样的音频数据的接口和类。 
javax.sound.sampled.spi 在提供新音频设备、声音文件 reader 和 writer,或音频格式转换器时,提供将为其创建子类的服务提供者的抽象类。 
javax.sql 为通过 JavaTM 编程语言进行服务器端数据源访问和处理提供 API。 
javax.sql.rowset JDBC RowSet 实现的标准接口和基类。 
javax.sql.rowset.serial 提供实用工具类,允许 SQL 类型与 Java 编程语言数据类型之间的可序列化映射关系。 
javax.sql.rowset.spi 第三方供应商在其同步提供者的实现中必须使用的标准类和接口。 
javax.swing 提供一组“轻量级”(全部是 Java 语言)组件,尽量让这些组件在所有平台上的工作方式都相同。 
javax.swing.border 提供围绕 Swing 组件绘制特殊边框的类和接口。 
javax.swing.colorchooser 包含供 JColorChooser 组件使用的类和接口。 
javax.swing.event 供 Swing 组件触发的事件使用。 
javax.swing.filechooser 包含 JFileChooser 组件使用的类和接口。 
javax.swing.plaf 提供一个接口和许多抽象类,Swing 用它们来提供自己的可插入外观功能。 
javax.swing.plaf.basic 提供了根据基本外观构建的用户界面对象。 
javax.swing.plaf.metal 提供根据 Java 外观(曾经代称为 Metal)构建的用户界面对象,Java 外观是默认外观。 
javax.swing.plaf.multi 提供了组合两个或多个外观的用户界面对象。 
javax.swing.plaf.synth Synth 是一个可更换皮肤 (skinnable) 的外观,在其中可委托所有绘制。 
javax.swing.table 提供用于处理 javax.swing.JTable 的类和接口。 
javax.swing.text 提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类。 
javax.swing.text.html 提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类。 
javax.swing.text.html.parser 提供默认的 HTML 解析器以及支持类。 
javax.swing.text.rtf 提供一个类 (RTFEditorKit),用于创建富文本格式(Rich-Text-Format)的文本编辑器。 
javax.swing.tree 提供处理 javax.swing.JTree 的类和接口。 
javax.swing.undo 允许开发人员为应用程序(例如文本编辑器)中的撤消/恢复提供支持。 
javax.tools 为能够从程序(例如,编译器)中调用的工具提供接口。 
javax.transaction 包含解组期间通过 ORB 机制抛出的三个异常。 
javax.transaction.xa 提供定义事务管理器和资源管理器之间的协定的 API,它允许事务管理器添加或删除 JTA 事务中的资源对象(由资源管理器驱动程序提供)。 
javax.xml 根据 XML 规范定义核心 XML 常量和功能。 
javax.xml.bind 为包含解组、编组和验证功能的客户端应用程序提供运行时绑定框架。 
javax.xml.bind.annotation 定义将 Java 程序元素定制成 XML 模式映射的注释。 
javax.xml.bind.annotation.adapters XmlAdapter 及其规范定义的子类允许任意 Java 类与 JAXB 一起使用。 
javax.xml.bind.attachment 此包由基于 MIME 的包处理器实现,该处理器能够解释并创建基于 MIME 的包格式的已优化的二进制数据。 
javax.xml.bind.helpers 仅由 JAXB 提供者用于: 提供某些 javax.xml.bind 接口的部分默认实现。 
javax.xml.bind.util 有用的客户端实用工具类。 
javax.xml.crypto 用于 XML 加密的通用类。 
javax.xml.crypto.dom javax.xml.crypto 包的特定于 DOM 的类。 
javax.xml.crypto.dsig 用于生成和验证 XML 数字签名的类。 
javax.xml.crypto.dsig.dom javax.xml.crypto.dsig 包特定于 DOM 的类。 
javax.xml.crypto.dsig.keyinfo 用来解析和处理 KeyInfo 元素和结构的类。 
javax.xml.crypto.dsig.spec XML 数字签名的参数类。 
javax.xml.datatype XML/Java 类型映射关系。 
javax.xml.namespace XML 名称空间处理。 
javax.xml.parsers 提供允许处理 XML 文档的类。 
javax.xml.soap 提供用于创建和构建 SOAP 消息的 API。 
javax.xml.stream   
javax.xml.stream.events   
javax.xml.stream.util   
javax.xml.transform 此包定义了用于处理转换指令,以及执行从源到结果的转换的一般 API。 
javax.xml.transform.dom 此包实现特定于 DOM 的转换 API。 
javax.xml.transform.sax 此包实现特定于 SAX2 的转换 API。 
javax.xml.transform.stax 提供特定于 StAX 的转换 API。 
javax.xml.transform.stream 此包实现特定于流和 URI 的转换 API。 
javax.xml.validation 此包提供了用于 XML 文档验证的 API。 
javax.xml.ws 此包包含核心 JAX-WS API。 
javax.xml.ws.handler.soap 该包定义用于 SOAP 消息处理程序的 API。 
javax.xml.ws.http 该包定义特定于 HTTP 绑定的 API。 
javax.xml.ws.soap 该包定义特定于 SOAP 绑定的 API。 
javax.xml.ws.spi 该包定义用于 JAX-WS 2.0 的 SPI。 
javax.xml.xpath 此包提供了用于 XPath 表达式的计算和访问计算环境的 object-model neutral API。 
org.ietf.jgss 此包提供一个框架,该框架允许应用程序开发人员通过利用统一的 API 使用一些来自各种基础安全机制(如 Kerberos)的安全服务,如验证、数据完整性和和数据机密性。 
org.omg.CORBA 提供 OMG CORBA API 到 JavaTM 编程语言的映射,包括 ORB 类,如果已实现该类,则程序员可以使用此类作为全功能对象请求代理(Object Request Broker,ORB)。 
org.omg.CORBA_2_3 CORBA_2_3 包定义对 Java[tm] Standard Edition 6 中现有 CORBA 接口所进行的添加。 
org.omg.CORBA_2_3.portable 提供输入和输出值类型的各种方法,并包含 org/omg/CORBA/portable 包的其他更新。 
org.omg.CORBA.DynAnyPackage 提供与 DynAny 接口一起使用的异常(InvalidValueInvalidInvalidSeqTypeMismatch)。 
org.omg.CORBA.ORBPackage 提供由 ORB.resolve_initial_references 方法抛出的异常 InvalidName,以及由 ORB 类中的动态 Any 创建方法抛出的异常 InconsistentTypeCode。 
org.omg.CORBA.portable 提供可移植性层,即可以使一个供应商生成的代码运行在另一个供应商 ORB 上的 ORB API 集合。 
org.omg.CORBA.TypeCodePackage 提供用户定义的异常 BadKindBounds,它们将由 TypeCode 类中的方法抛出。 
org.omg.CosNaming 为 Java IDL 提供命名服务。 
org.omg.CosNaming.NamingContextExtPackage 此包包含以下在 org.omg.CosNaming.NamingContextExt 中使用的类: AddressHelper StringNameHelper URLStringHelper InvalidAddress 包规范 有关 Java[tm] Platform, Standard Edition 6 ORB 遵守的官方规范的受支持部分的明确列表,请参阅 Official Specifications for CORBA support in Java[tm] SE 6。 
org.omg.CosNaming.NamingContextPackage 此包包含 org.omg.CosNaming 包的 Exception 类。 
org.omg.Dynamic 此包包含 OMG Portable Interceptor 规范 http://cgi.omg.org/cgi-bin/doc?ptc/2000-08-06 的第 21.9 小节中指定的 Dynamic 模块。 
org.omg.DynamicAny 提供一些类和接口使得在运行时能够遍历与 any 有关联的数据值,并提取数据值的基本成分。 
org.omg.DynamicAny.DynAnyFactoryPackage 此包包含 DynamicAny 模块的 DynAnyFactory 接口中的类和异常,该模块在 OMG The Common Object Request Broker: Architecture and Specification http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 的第 9.2.2 小节中指定。 
org.omg.DynamicAny.DynAnyPackage 此包包含 DynAny 模块的 DynAnyFactory 接口中的类和异常,该模块在 OMG The Common Object Request Broker: Architecture and Specification http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 的第 9.2 小节中指定。 
org.omg.IOP 此包包含在 OMG 文档 The Common Object Request Broker: Architecture and Specification http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 的 13.6.小节中指定的 IOP 模块。 
org.omg.IOP.CodecFactoryPackage 此包包含 IOP::CodeFactory 接口中指定的异常(作为 Portable Interceptor 规范的一部分)。 
org.omg.IOP.CodecPackage 此包根据 IOP::Codec IDL 接口定义生成。 
org.omg.Messaging 此包包含 OMG Messaging Interceptor 规范 http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 中指定的 Messaging 模块。 
org.omg.PortableInterceptor 提供一个注册 ORB 钩子 (hook) 的机制,通过这些钩子 ORB 服务可以截取执行 ORB 的正常流。 
org.omg.PortableInterceptor.ORBInitInfoPackage 此包包含 OMG Portable Interceptor 规范 http://cgi.omg.org/cgi-bin/doc?ptc/2000-08-06 的第 21.7.2 小节中指定的 PortableInterceptor 模块的 ORBInitInfo 本地接口中的异常和 typedef。 
org.omg.PortableServer 提供一些类和接口,用来生成跨多个供应商 ORB 的可移植应用程序的服务器端。 
org.omg.PortableServer.CurrentPackage 提供各种方法实现,这些实现能够访问调用方法的对象的身份。 
org.omg.PortableServer.POAManagerPackage 封装 POA 关联的处理状态。 
org.omg.PortableServer.POAPackage 允许程序员构造可在不同 ORB 产品间移植的对象实现。 
org.omg.PortableServer.ServantLocatorPackage 提供定位 servant 的类和接口。 
org.omg.stub.java.rmi 包含用于 java.rmi 包中出现的 Remote 类型的 RMI-IIOP Stub。 
org.w3c.dom 为文档对象模型 (DOM) 提供接口,该模型是 Java API for XML Processing 的组件 API。 
org.w3c.dom.bootstrap   
org.w3c.dom.events   
org.w3c.dom.ls   
org.xml.sax 此包提供了核心 SAX API。 
org.xml.sax.ext 此包包含适合的 SAX 驱动程序不一定支持的 SAX2 设施的接口。 
org.xml.sax.helpers 此包包含“帮助器”类,其中包括对引导基于 SAX 的应用程序的支持。 
 

java.appletObject 的使用
 

java.appletObject 的子类
 class Applet
          applet 是一种不能单独运行但可嵌入在其他应用程序中的小程序。
protected  class Applet.AccessibleApplet
          此类实现对 Applet 类的可访问性支持。
 

java.awtObject 的使用
 

java.awtObject 的子类
 class AlphaComposite
          AlphaComposite 类实现一些基本的 alpha 合成规则,将源色与目标色组合,在图形和图像中实现混合和透明效果。
 class AWTError
          当发生严重的 Abstract Window Toolkit 错误时,抛出此错误。
 class AWTEvent
          所有 AWT 事件的根事件类。
 class AWTEventMulticaster
          AWTEventMulticaster 实现对 java.awt.event 包中定义的 AWT 事件的指派,该指派是有效的、线程安全的多路广播事件指派。
 class AWTException
          表示发生了 Absract Window Toolkit 异常。
 class AWTKeyStroke
          AWTKeyStroke 表示键盘(或等效输入设备)上的键操作。
 class AWTPermission
          此类用于 AWT 权限。
 class BasicStroke
          BasicStroke 类定义针对图形图元轮廓呈现属性的一个基本集合,这些图元使用 Graphics2D 对象呈现,而该对象的 Stroke 属性设置为此 BasicStroke
 class BorderLayout
          这是一个布置容器的边框布局,它可以对容器组件进行安排,并调整其大小,使其符合下列五个区域:北、南、东、西、中。
 class BufferCapabilities
          缓冲区的能力和属性。
static class BufferCapabilities.FlipContents
          页面翻转后可能的后台缓冲区内容的一个类型安全的枚举
 class Button
          此类创建一个标签按钮。
protected  class Button.AccessibleAWTButton
          此类实现对 Button 类的可访问性支持。
 class Canvas
          Canvas 组件表示屏幕上一个空白矩形区域,应用程序可以在该区域内绘图,或者可以从该区域捕获用户的输入事件。
protected  class Canvas.AccessibleAWTCanvas
          此类实现对 Canvas 类的可访问性支持。
 class CardLayout
          CardLayout 对象是容器的布局管理器。
 class Checkbox
          复选框是一个可处于“开”(true) 或“关”(false) 状态的图形组件。
protected  class Checkbox.AccessibleAWTCheckbox
          此类实现对 Checkbox 类的可访问性支持。
 class CheckboxGroup
          CheckboxGroup 类用于集合 Checkbox 按钮集。
 class CheckboxMenuItem
          此类表示一个可包括在菜单中的复选框。
protected  class CheckboxMenuItem.AccessibleAWTCheckboxMenuItem
          用来为可访问性提供默认支持的 CheckboxMenuItem 的内部类。
 class Choice
          Choice 类表示一个弹出式选择菜单。
protected  class Choice.AccessibleAWTChoice
          此类实现对 Choice 类的可访问性支持。
 class Color
          Color 类用于封装默认 sRGB 颜色空间中的颜色,或者用于封装由 ColorSpace 标识的任意颜色空间中的颜色。
 class Component
          component 是一个具有图形表示能力的对象,可在屏幕上显示,并可与用户进行交互。
protected  class Component.AccessibleAWTComponent
          用来为可访问性提供默认支持的 Component 的内部类。
protected  class Component.AccessibleAWTComponent.AccessibleAWTComponentHandler
          当发生显示/隐藏操作时,激活 PropertyChange 侦听器(如果注册了该侦听器)
protected  class Component.AccessibleAWTComponent.AccessibleAWTFocusHandler
          当发生焦点事件时,激活 PropertyChange 侦听器(如果注册了该侦听器)
protected  class Component.BltBufferStrategy
          用于将屏幕外的画面以位图传输方式传输到一个组件的内部类。
protected  class Component.FlipBufferStrategy
          在组件上翻转缓冲区的内部类。
 class ComponentOrientation
          ComponentOrientation 类封装语言敏感的方向,用于排序组件或文本内容。
 class Container
          一般的 Abstract Window Toolkit(AWT) 容器对象是一个可包含其他 AWT 组件的组件。
protected  class Container.AccessibleAWTContainer
          用于对可访问性提供默认支持的 Container 内部类。
protected  class Container.AccessibleAWTContainer.AccessibleContainerHandler
          添加或移除子容器时激发 PropertyChange 侦听器(如果已注册了此侦听器)。
 class ContainerOrderFocusTraversalPolicy
          根据 Container 中的子 Component 的顺序确定遍历顺序的 FocusTraversalPolicy。
 class Cursor
          封装鼠标光标的位图表示形式的类。
 class DefaultFocusTraversalPolicy
          根据 Container 中的子 Component 的顺序确定遍历顺序的 FocusTraversalPolicy。
 class DefaultKeyboardFocusManager
          AWT 应用程序的默认 KeyboardFocusManager。
 class Desktop
          Desktop 类允许 Java 应用程序启动已在本机桌面上注册的关联应用程序,以处理 URI 或文件。
 class Dialog
          Dialog 是一个带标题和边界的顶层窗口,边界一般用于从用户处获得某种形式的输入。
protected  class Dialog.AccessibleAWTDialog
          此类实现对 Dialog 类的可访问性支持。
 class Dimension
          Dimension 类封装单个对象中组件的宽度和高度(精确到整数)。
 class DisplayMode
          DisplayMode 类封装 GraphicsDevice 的位深、高度、宽度和刷新率。
 class Event
          注:Event 类已废弃,只可用于向后兼容。
 class EventQueue
          EventQueue 是一个与平台无关的类,它将来自于底层同位体类和受信任的应用程序类的事件列入队列。
 class FileDialog
          FileDialog 类显示一个对话框窗口,用户可以从中选择文件。
 class FlowLayout
          流布局用于安排有向流中的组件,这非常类似于段落中的文本行。
 class FocusTraversalPolicy
          FocusTraversalPolicy 定义一种顺序,按此顺序遍历具有特定焦点循环根的 Component。
 class Font
          Font 类表示字体,可以使用它以可见方式呈现文本。
 class FontFormatException
          此异常由 Font 类中的 createFont 方法抛出,以指示指定的字体很糟糕。
 class FontMetrics
          FontMetrics 类定义字体规格对象,该对象封装将在特定屏幕上呈现特定字体的有关信息。
 class Frame
          Frame 是带有标题和边框的顶层窗口。
protected  class Frame.AccessibleAWTFrame
          此类实现对 Frame 类的可访问性支持。
 class GradientPaint
          GradientPaint 类提供了使用线性颜色渐变模式填充 Shape 的方法。
 class Graphics
          Graphics 类是所有图形上下文的抽象基类,允许应用程序在组件(已经在各种设备上实现)以及闭屏图像上进行绘制。
 class Graphics2D
          此 Graphics2D 类扩展 Graphics 类,以提供对几何形状、坐标转换、颜色管理和文本布局更为复杂的控制。
 class GraphicsConfigTemplate
          GraphicsConfigTemplate 类用于获得有效的 GraphicsConfiguration
 class GraphicsConfiguration
          GraphicsConfiguration 类描述图形目标(如打印机或监视器)的特征。
 class GraphicsDevice
          GraphicsDevice 类描述可以在特定图形环境中使用的图形设备。
 class GraphicsEnvironment
          GraphicsEnvironment 类描述了 Java(tm) 应用程序在特定平台上可用的 GraphicsDevice 对象和 Font 对象的集合。
 class GridBagConstraints
          GridBagConstraints 类指定使用 GridBagLayout 类布置的组件的约束。
 class GridBagLayout
          GridBagLayout 类是一个灵活的布局管理器,它不要求组件的大小相同便可以将组件垂直、水平或沿它们的基线对齐。
 class GridBagLayoutInfo
          GridBagLayoutInfoGridBagLayout 布局管理器的一个实用工具类。
 class GridLayout
          GridLayout 类是一个布局处理器,它以矩形网格形式对容器的组件进行布置。
 class HeadlessException
          在不支持键盘、显示器或鼠标的环境中调用与键盘、显示器或鼠标有关的代码时,被抛出的异常。
 class IllegalComponentStateException
          当 AWT 组件未处于所请求操作的适当状态时,抛出该异常。
 class Image
          抽象类 Image 是表示图形图像的所有类的超类。
 class ImageCapabilities
          图像的功能和属性。
 class Insets
          Insets 对象是容器边界的表示形式。
 class JobAttributes
          控制打印作业的属性集合。
static class JobAttributes.DefaultSelectionType
          可能的默认选择状态的类型安全的枚举。
static class JobAttributes.DestinationType
          可能的作业目标的类型安全枚举。
static class JobAttributes.DialogType
          显示给用户的可能对话框的类型安全枚举。
static class JobAttributes.MultipleDocumentHandlingType
          可能的多副本处理状态的类型安全枚举。
static class JobAttributes.SidesType
          可能的多页整版的类型安全枚举。
 class KeyboardFocusManager
          KeyboardFocusManager 负责管理激活状态的聚焦 Window 和当前焦点所有者。
 class Label
          Label 对象是一个可在容器中放置文本的组件。
protected  class Label.AccessibleAWTLabel
          此类实现对 Label 类的可访问性支持。
 class LinearGradientPaint
          LinearGradientPaint 类提供利用线性颜色渐变模式填充 Shape 的方式。
 class List
          List 组件为用户提供了一个可滚动的文本项列表。
protected  class List.AccessibleAWTList
          此类实现 List 类的可访问性支持。
protected  class List.AccessibleAWTList.AccessibleAWTListChild
          此类实现 List 子级的可访问性支持。
 class MediaTracker
          MediaTracker 类是一个跟踪多种媒体对象状态的实用工具类。
 class Menu
          Menu 对象是从菜单栏部署的下拉式菜单组件。
protected  class Menu.AccessibleAWTMenu
          菜单的内部类,用于为可访问性提供默认支持。
 class MenuBar
          MenuBar 类封装绑定到框架的菜单栏的平台概念。
protected  class MenuBar.AccessibleAWTMenuBar
          菜单栏的内部类,用于为可访问性提供默认支持。
 class MenuComponent
          抽象类 MenuComponent 是所有与菜单相关的组件的超类。
protected  class MenuComponent.AccessibleAWTMenuComponent
          用于为可访问性提供默认支持的 MenuComponent 的内部类。
 class MenuItem
          菜单中的所有项必须属于类 MenuItem 或其子类之一。
protected  class MenuItem.AccessibleAWTMenuItem
          用于为可访问性提供默认支持的 MenuItem 的内部类。
 class MenuShortcut
          表示 MenuItem 键盘加速器的 MenuShortcut 类。
 class MouseInfo
          MouseInfo 提供获取有关鼠标信息的方法,如鼠标指针位置和鼠标按钮数。
 class MultipleGradientPaint
          这是 Paints 的超类,它使用多个颜色渐变来填充它们的光栅。
 class PageAttributes
          用来控制打印页面输出的属性集。
static class PageAttributes.ColorType
          可能颜色状态的类型安全的枚举。
static class PageAttributes.MediaType
          可能的纸张大小的类型安全的枚举。
static class PageAttributes.OrientationRequestedType
          可能打印方向的类型安全的枚举。
static class PageAttributes.OriginType
          可能原点的类型安全的枚举。
static class PageAttributes.PrintQualityType
          可能的打印质量的类型安全的枚举。
 class Panel
          Panel 是最简单的容器类。
protected  class Panel.AccessibleAWTPanel
          此类实现 Panel 类的可访问性支持。
 class Point
          表示 (x,y) 坐标空间中的位置的点,以整数精度指定。
 class PointerInfo
          描述指针位置的类。
 class Polygon
          Polygon 类封装了坐标空间中封闭的二维区域的描述。
 class PopupMenu
          此类实现能够在组件中的指定位置上动态弹出的菜单。
protected  class PopupMenu.AccessibleAWTPopupMenu
          用于为可访问性提供默认支持的 PopupMenu 的内部类。
 class PrintJob
          启动并执行打印作业的抽象类。
 class RadialGradientPaint
          RadialGradientPaint 类提供使用圆形辐射颜色渐变模式填充某一形状的方式。
 class Rectangle
          Rectangle 指定坐标空间中的一个区域,通过坐标空间中 Rectangle 对象左上方的点 (x,y)、宽度和高度可以定义这个区域。
 class RenderingHints
          RenderingHints 类定义和管理键和关联值的集合,它允许应用程序将输入提供给其他类使用的算法选择,这些类执行呈现和图像处理服务。
static class RenderingHints.Key
          定义与 RenderingHints 一起使用的、用来控制呈现和图像管线中各种算法选择的所有键的基本类型。
 class Robot
          此类用于为测试自动化、自运行演示程序和其他需要控制鼠标和键盘的应用程序生成本机系统输入事件。
 class Scrollbar
          Scrollbar 类描述了一个滚动条,这是大家都很熟悉的用户界面对象。
protected  class Scrollbar.AccessibleAWTScrollBar
          此类实现 Scrollbar 类的可访问性支持。
 class ScrollPane
          实现用于单个子组件的自动水平和/或垂直滚动的容器类。
protected  class ScrollPane.AccessibleAWTScrollPane
          此类实现 ScrollPane 类的可访问性支持。
 class ScrollPaneAdjustable
          此类表示 ScrollPane 的水平或垂直滚动条的状态。
 class SplashScreen
          在 Java 虚拟机 (JVM) 启动之前,可以在应用程序启动时创建闪现屏幕。
 class SystemColor
          封装表示系统中本机 GUI 对象颜色的象征性颜色的类。
 class SystemTray
          SystemTray 类表示桌面的系统托盘。
 class TextArea
          TextArea 对象是显示文本的多行区域。
protected  class TextArea.AccessibleAWTTextArea
          此类实现 TextArea 类的可访问性支持。
 class TextComponent
          TextComponent 类是所有允许编辑文本的组件的超类。
protected  class TextComponent.AccessibleAWTTextComponent
          此类实现对 TextComponent 类的可访问性支持。
 class TextField
          TextField 对象是允许编辑单行文本的文本组件。
protected  class TextField.AccessibleAWTTextField
          此类实现 TextField 类的可访问性支持。
 class TexturePaint
          TexturePaint 类提供一种用被指定为 BufferedImage 的纹理填充 Shape 的方式。
 class Toolkit
          此类是所有 Abstract Window Toolkit 实际实现的抽象超类。
 class TrayIcon
          TrayIcon 对象表示可以添加到系统托盘的托盘图标。
 class Window
          Window 对象是一个没有边界和菜单栏的顶层窗口。
protected  class Window.AccessibleAWTWindow
          此类实现对 Window 类的可访问性支持。
 

声明为 Objectjava.awt 中的字段
 Object Event.arg
          事件的任意参数。
 Object Event.target
          目标组件。
static Object Image.UndefinedProperty
          每当获得某个不是为特定图像定义的属性时,应返回 UndefinedProperty 对象。
static Object RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT
          Alpha 插值提示值——由实现选择对性能和质量进行良好权衡的 alpha 混合算法
static Object RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY
          Alpha 插值提示值——选择偏重于精确度和视觉质量的 alpha 混合算法。
static Object RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED
          Alpha 插值提示值——选择偏重于计算速度的 alpha 混合算法。
static Object RenderingHints.VALUE_ANTIALIAS_DEFAULT
          抗锯齿提示值——使用由实现选择的默认抗锯齿模式完成呈现。
static Object RenderingHints.VALUE_ANTIALIAS_OFF
          抗锯齿提示值——在不使用抗锯齿模式的情况下完成呈现。
static Object RenderingHints.VALUE_ANTIALIAS_ON
          抗锯齿提示值——使用抗锯齿模式完成呈现。
static Object RenderingHints.VALUE_COLOR_RENDER_DEFAULT
          颜色呈现提示值——根据实现的选择执行颜色转换计算,以表示可用的性能和精确度之间的最佳权衡。
static Object RenderingHints.VALUE_COLOR_RENDER_QUALITY
          颜色呈现提示值——用最高的精确度和视觉质量执行颜色转换计算。
static Object RenderingHints.VALUE_COLOR_RENDER_SPEED
          颜色呈现提示值——最快地执行输出设备格式的颜色转换。
static Object RenderingHints.VALUE_DITHER_DEFAULT
          抖动提示值——对该实现选择的抖动使用默认值。
static Object RenderingHints.VALUE_DITHER_DISABLE
          抖动提示值——呈现几何形状时不抖动。
static Object RenderingHints.VALUE_DITHER_ENABLE
          抖动提示值——如果需要,在呈现几何形状时抖动。
static Object RenderingHints.VALUE_FRACTIONALMETRICS_DEFAULT
          字体小数规格提示值——用实现选择的精度定位字符字形。
static Object RenderingHints.VALUE_FRACTIONALMETRICS_OFF
          字体小数规格提示值——用舍入为像素边界的 advance width 定位字符字形。
static Object RenderingHints.VALUE_FRACTIONALMETRICS_ON
          字体小数规格提示值——用子像素精确度定位字符字形。
static Object RenderingHints.VALUE_INTERPOLATION_BICUBIC
          插值提示值—— 使用 XY 中的立方函数插入图像中整数坐标附近的 9 个样本,以生成一个颜色样本。
static Object RenderingHints.VALUE_INTERPOLATION_BILINEAR
          插值提示值——图像中最接近整数坐标样本的 4 种颜色样本被线性地插入,以生成一个颜色样本。
static Object RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR
          插值提示值——使用图像中最接近整数坐标样本的颜色样本。
static Object RenderingHints.VALUE_RENDER_DEFAULT
          呈现提示值——由实现选择对性能和质量进行良好权衡的呈现算法。
static Object RenderingHints.VALUE_RENDER_QUALITY
          呈现提示值——选择偏重输出质量的呈现算法。
static Object RenderingHints.VALUE_RENDER_SPEED
          呈现提示值——选择偏重输出速度的呈现算法。
static Object RenderingHints.VALUE_STROKE_DEFAULT
          笔划规范化控制提示值——根据给定实现的权衡,可以修改几何形状或保留原来的几何形状。
static Object RenderingHints.VALUE_STROKE_NORMALIZE
          笔划规范化控制提示值——几何形状应当规范化,以提高均匀性或直线间隔和整体美观。
static Object RenderingHints.VALUE_STROKE_PURE
          笔划规范化控制提示值——几何形状应该保持不变并使用子像素精确度呈现。
static Object RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT
          文本抗锯齿提示值——根据 RenderingHints.KEY_ANTIALIASING 提示或由实现选择的默认值完成文本呈现。
static Object RenderingHints.VALUE_TEXT_ANTIALIAS_GASP
          文本抗锯齿提示值——文本呈现需要使用字体资源中的信息,这些信息指定了每个点大小是否适合应用 RenderingHints.VALUE_TEXT_ANTIALIAS_ONRenderingHints.VALUE_TEXT_ANTIALIAS_OFF
static Object RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HBGR
          文本抗锯齿提示值——要求针对 LCD 显示器优化文本显示,子像素按从左到右为 B、G、R 的顺序显示,从而使水平子像素分辨率是全部水平像素分辨率 (HBGR) 的三倍。
static Object RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB
          文本抗锯齿提示值——要求针对 LCD 显示器优化文本显示,该 LCD 显示器子像素按从左到右为 R、G、B 的顺序显示,从而使水平子像素分辨率是全部水平像素分辨率 (HRGB) 的三倍。
static Object RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VBGR
          文本抗锯齿提示值——要求针对 LCD 显示器优化文本显示,子像素组织按从顶部到底部为 R、G、B 的顺序显示,从而使垂直子像素分辨率是全部垂直像素分辨率 (VBGR) 的三倍。
static Object RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VRGB
          文本抗锯齿提示值——要求针对 LCD 显示器优化文本显示,子像素组织按从顶部到底部为 R、G、B 的顺序显示,从而使垂直子像素分辨率是全部垂直像素分辨率 (VRGB) 的三倍。
static Object RenderingHints.VALUE_TEXT_ANTIALIAS_OFF
          文本抗锯齿提示值——不使用任何抗锯齿形式完成文本呈现。
static Object RenderingHints.VALUE_TEXT_ANTIALIAS_ON
          文本抗锯齿提示值——使用某种抗锯齿形式完成文本呈现。
 

类型参数类型为 Objectjava.awt 中的字段
protected  Map<String,Object> Toolkit.desktopProperties
           
 

返回 Objectjava.awt 中的方法
 Object GridBagConstraints.clone()
          创建此网格包约束(grid bag constraint)的副本。
 Object JobAttributes.clone()
          创建并返回此 JobAttributes 的一个副本。
 Object PageAttributes.clone()
          创建并返回此 PageAttributes 的一个副本。
 Object BufferCapabilities.clone()
           
 Object Insets.clone()
          创建此对象的副本。
 Object ImageCapabilities.clone()
           
 Object RenderingHints.clone()
          创建此 RenderingHints 对象的一个副本,它与此 RenderingHints 对象具有相同的内容。
 Object RenderingHints.get(Object key)
          返回指定键所映射的值。
 Object BorderLayout.getConstraints(Component comp)
          获取指定组件的约束
 Object Toolkit.getDesktopProperty(String propertyName)
          获取指定桌面属性的值。
 Object[] MediaTracker.getErrorsAny()
          返回所有出错媒体的列表。
 Object[] MediaTracker.getErrorsID(int id)
          返回具有出错的指定 ID 的媒体列表。
abstract  Object Image.getProperty(String name, ImageObserver observer)
          通过名称获取此图像的属性。
abstract  Object Graphics2D.getRenderingHint(RenderingHints.Key hintKey)
          返回呈现算法的单个首选项的值。
 Object[] Checkbox.getSelectedObjects()
          返回包含复选框标签的数组 (length 1),如果没有选定复选框,则返回 null。
 Object[] CheckboxMenuItem.getSelectedObjects()
          返回一个数组(长度为 1),它包含复选框菜单项的标签,如果没有选中复选框,则返回 null。
 Object[] Choice.getSelectedObjects()
          返回包含当前选定项的数组(长度为 1)。
 Object[] List.getSelectedObjects()
          获取对象数组中此滚动列表的选中项。
 Object[] ItemSelectable.getSelectedObjects()
          返回选定项;如果没有选定的项,则返回 null
protected  Object MenuComponent.getTreeLock()
          获取此组件的锁定对象(拥有该线程同步监视器的对象),该对象可用于 AWT 组件树和布局操作。
 Object Component.getTreeLock()
          获取此组件用于 AWT 组件树和布局操作的锁定对象(拥有线程同步监视器的对象)。
protected  Object Toolkit.lazilyLoadDesktopProperty(String name)
          一个对桌面属性值延迟计算的机会。
 Object RenderingHints.put(Object key, Object value)
          将指定 key 映射到此 RenderingHints 对象中指定的 value
protected  Object AWTKeyStroke.readResolve()
          返回 AWTKeyStroke 的一个缓存实例(或 AWTKeyStroke 的子类),它与此实例相等。
 Object RenderingHints.remove(Object key)
          从此 RenderingHints 对象中移除键和它所对应的值。
 

返回变量类型为 Object 的类型的 java.awt 中的方法
 Set<Map.Entry<Object,Object>> RenderingHints.entrySet()
          返回此 RenderingHints 中所包含映射关系的 Set 视图。
 Set<Map.Entry<Object,Object>> RenderingHints.entrySet()
          返回此 RenderingHints 中所包含映射关系的 Set 视图。
 Set<Object> RenderingHints.keySet()
          返回此 RenderingHints 中所包含键的 Set 视图。
 Collection<Object> RenderingHints.values()
          返回此 RenderinHints 中所包含键的 Collection 视图。
 

参数类型为 Objectjava.awt 中的方法
 boolean Component.action(Event evt, Object what)
          已过时。 从 JDK version 1.1 开始,应该将此组件作为组件(激发动作事件)上的 ActionListener 来注册。
 void Container.add(Component comp, Object constraints)
          将指定的组件添加到此容器的尾部。
 void Container.add(Component comp, Object constraints, int index)
          使用指定约束,将指定组件添加到此容器的指定索引所在的位置上。
protected  void ScrollPane.addImpl(Component comp, Object constraints, int index)
          将指定的组件添加到此滚动窗格容器。
protected  void Container.addImpl(Component comp, Object constraints, int index)
          将指定组件添加到此容器的指定索引所在的位置上。
 void GridBagLayout.addLayoutComponent(Component comp, Object constraints)
          使用指定 constraints 对象将指定组件添加到布局中。
 void CardLayout.addLayoutComponent(Component comp, Object constraints)
          将指定的组件添加到此卡片布局的内部名称表。
 void BorderLayout.addLayoutComponent(Component comp, Object constraints)
          使用指定的约束对象将指定组件添加到布局中。
 void LayoutManager2.addLayoutComponent(Component comp, Object constraints)
          使用指定约束对象,将指定组件添加到布局。
 boolean RenderingHints.containsKey(Object key)
          如果此 RenderingHints 包含指定键的映射关系,则返回 true
 boolean RenderingHints.containsValue(Object value)
          如果此 RenderingHints 将一个或多个键映射到指定值,则返回 true。
 boolean DisplayMode.equals(Object dm)
          指示其他某个对象是否与此对象“相等”。
 boolean JobAttributes.equals(Object obj)
          确定两个 JobAttributes 是否相等。
 boolean PageAttributes.equals(Object obj)
          确定两个 PageAttributes 是否相等。
 boolean MenuShortcut.equals(Object obj)
          返回此菜单快捷方式是否与另一个相同:定义相等性意味着两个菜单快捷方式使用相同的键,而且两者或者使用或者不使用 SHIFT 键。
 boolean Point.equals(Object obj)
          确定两个点是否相等。
 boolean AWTKeyStroke.equals(Object anObject)
          如果此对象与指定对象相同,则返回 true。
 boolean Insets.equals(Object obj)
          检查两个 insets 对象是否等价。
 boolean Rectangle.equals(Object obj)
          检查两个矩形是否相等。
 boolean BasicStroke.equals(Object obj)
          测试指定对象与此 BasicStroke 是否相等,首先测试指定对象是否是一个 BasicStroke,然后将其宽度、连接、cap、斜接限制、虚线和虚线相位属性与 BasicStroke 的那些属性进行比较。
 boolean AlphaComposite.equals(Object obj)
          确定指定的对象是否等于此 AlphaComposite
 boolean Color.equals(Object obj)
          确定另一个对象是否与此 Color 相同。
 boolean RenderingHints.equals(Object o)
          对指定的 Object 与此 RenderingHints 进行相等性比较。
 boolean RenderingHints.Key.equals(Object o)
          用于所有 Key 对象的 equals 方法将返回与等号运算符 '==' 相同的结果。
 boolean Font.equals(Object obj)
          将此 Font 对象与指定 Object 进行比较。
 boolean Dimension.equals(Object obj)
          检查两个 dimension 对象是否具有相同的值。
protected  void KeyboardFocusManager.firePropertyChange(String propertyName, Object oldValue, Object newValue)
          激发 PropertyChangeEvent 以响应绑定属性中的更改。
protected  void Component.firePropertyChange(String propertyName, Object oldValue, Object newValue)
          支持报告 Object 属性的绑定属性改变。
protected  void KeyboardFocusManager.fireVetoableChange(String propertyName, Object oldValue, Object newValue)
          激发 PropertyChangeEvent 以响应可否决属性中的更改。
 Object RenderingHints.get(Object key)
          返回指定键所映射的值。
 Component BorderLayout.getLayoutComponent(Container target, Object constraints)
          基于目标 Container 的组件方向,返回给定约束位置对应的组件。
 Component BorderLayout.getLayoutComponent(Object constraints)
          获取使用给定约束添加的组件。
 boolean Component.gotFocus(Event evt, Object what)
          已过时。 从 JDK version 1.1 开始,由 processFocusEvent(FocusEvent) 取代。
abstract  boolean RenderingHints.Key.isCompatibleValue(Object val)
          如果指定对象是此 Key 的有效值,则返回 true。
 boolean Component.lostFocus(Event evt, Object what)
          已过时。 从 JDK version 1.1 开始,由 processFocusEvent(FocusEvent) 取代。
 Object RenderingHints.put(Object key, Object value)
          将指定 key 映射到此 RenderingHints 对象中指定的 value
 Object RenderingHints.remove(Object key)
          从此 RenderingHints 对象中移除键和它所对应的值。
protected  void Toolkit.setDesktopProperty(String name, Object newValue)
          将指定桌面属性设置为指定值,并触发一个属性更改事件,以通知所有侦听器该值已更改。
abstract  void Graphics2D.setRenderingHint(RenderingHints.Key hintKey, Object hintValue)
          为呈现算法设置单个首选项的值。
 void AWTEvent.setSource(Object newSource)
          将事件的目标更改为新的源。
 

参数类型为 Objectjava.awt 中的构造方法
AWTEvent(Object source, int id)
          使用指定的源对象和类型构造一个 AWTEvent 对象。
Event(Object target, int id, Object arg)
          注:Event 类已废弃,只可用于向后兼容。
Event(Object target, long when, int id, int x, int y, int key, int modifiers)
          注:Event 类已废弃,只可用于向后兼容。
Event(Object target, long when, int id, int x, int y, int key, int modifiers, Object arg)
          注:Event 类已废弃,只可用于向后兼容。
RenderingHints(RenderingHints.Key key, Object value)
          构造一个具有指定键/值对的新对象。
 

java.awt.colorObject 的使用
 

java.awt.colorObject 的子类
 class CMMException
          如果本机 CMM 返回一个错误,则抛出此异常。
 class ColorSpace
          此抽象类用做一个颜色空间标记,标识 Color 对象的特定颜色空间,或者通过 ColorModel 对象标识 Image、BufferedImage 或 GraphicsDevice 的特定颜色空间。
 class ICC_ColorSpace
          ICC_ColorSpace 类是抽象 ColorSpace 类的实现。
 class ICC_Profile
          与设备无关和设备相关颜色空间的颜色配置文件数据表示形式,该表示形式基于国际色彩联盟规范 ICC.1:2001-12,颜色配置文件的文件格式(请参阅 http://www.color.org)。
 class ICC_ProfileGray
          ICC_Profile 类的子类,表示满足以下标准的配置文件:配置文件的颜色空间类型是 TYPE_GRAY,并且配置文件包括 grayTRCTag 和 mediaWhitePointTag 标记。
 class ICC_ProfileRGB
          ICC_ProfileRGB 类是 ICC_Profile 类的子类,它表示满足以下标准的配置文件: 配置文件的颜色空间类型是 RGB。
 class ProfileDataException
          当访问或处理 ICC_Profile 对象出现错误时,抛出此异常。
 

返回 Objectjava.awt.color 中的方法
protected  Object ICC_Profile.readResolve()
          解析将被反序列化为用 CMM 注册的实例的实例。
 

java.awt.datatransferObject 的使用
 

java.awt.datatransferObject 的子类
 class Clipboard
          此类实现一种使用剪切/复制/粘贴操作传输数据的机制。
 class DataFlavor
          DataFlavor 提供有关数据的元信息。
 class FlavorEvent
          FlavorEvent 用于通知感兴趣的参与者,可用的 DataFlavorClipboard(事件源)中已改变。
 class MimeTypeParseException
          对分析相关异常的 MimeType 进行封装的类
 class StringSelection
          实现传输 String 所需能力的 Transferable
 class SystemFlavorMap
          SystemFlavorMap 是 "native" (String)(对应于特定于平台的数据格式)和 "flavor" (DataFlavor)(对应于与平台无关的 MIME 类型)之间的可配置映射。
 class UnsupportedFlavorException
          在此 flavor 中不支持所请求的数据的信号。
 

返回 Objectjava.awt.datatransfer 中的方法
 Object DataFlavor.clone()
          返回此 DataFlavor 的副本。
 Object Clipboard.getData(DataFlavor flavor)
          返回一个对象,表示此剪贴板中指定 DataFlavor 类型的当前内容。
 Object StringSelection.getTransferData(DataFlavor flavor)
          如果可能,则使用请求的 DataFlavor 返回 Transferable 的数据。
 Object Transferable.getTransferData(DataFlavor flavor)
          返回一个对象,该对象表示将要被传输的数据。
 

参数类型为 Objectjava.awt.datatransfer 中的方法
 boolean DataFlavor.equals(Object o)
          测试任意 Object 与此 DataFlavor 的相等性。
 Transferable Clipboard.getContents(Object requestor)
          返回表示剪贴板当前内容的 transferable 对象。
 

java.awt.dndObject 的使用
 

java.awt.dndObject 的子类
 class DnDConstants
          此类包含了表示 Drag 和 Drop 操作所执行的操作类型的常量值。
 class DragGestureEvent
          当特定的 DragGestureRecognizer 检测到它正在跟踪的 Component 上已发生与平台相关的拖动启动动作时,将 DragGestureEvent 传递给 DragGestureListener 的 dragGestureRecognized() 方法。
 class DragGestureRecognizer
          DragGestureRecognizer 是一个针对与平台相关的侦听器规范的抽象基类,它可以与特定 Component 关联以标识与平台相关的拖动开始动作。
 class DragSource
          DragSource 是负责开始 Drag 和 Drop 操作的实体,可以用在如下场景中: JVM 生命周期中每个 JVM 的一个默认实例。
 class DragSourceAdapter
          用于接收拖动源事件的抽象适配器类。
 class DragSourceContext
          DragSourceContext 类负责管理 Drag 和 Drop 协议的起始端。
 class DragSourceDragEvent
          通过 DragSourceContext,将 DragSourceDragEventDragSourceContextPeer 传递给向 DragSourceContext 及其关联 DragSource 注册的 DragSourceListener
 class DragSourceDropEvent
          通过 DragSourceContext,将 DragSourceDropEventDragSourceContextPeer 传递给向 DragSourceContext 及其关联 DragSource 注册的 DragSourceListenerdragDropEnd 方法。
 class DragSourceEvent
          此类是 DragSourceDragEventDragSourceDropEvent 的基类。
 class DropTarget
          在 Drag 和 Drop 操作期间,当 Component 希望接受 drop 时,DropTargetComponent 有关联。
protected static class DropTarget.DropTargetAutoScroller
          此受保护的嵌套类实现自动滚动
 class DropTargetAdapter
          接收放置目标事件的抽象适配器类。
 class DropTargetContext
          每当与 Drag 和 Drop 操作相关的逻辑光标和与 DropTarget 相关的 Component 的可见几何结构重合时,就创建一个 DropTargetContext
protected  class DropTargetContext.TransferableProxy
          TransferableProxy 是一个帮助器内部类,它实现 Transferable 接口,并用作另一个表示特定 drag-n-drop(拖放)操作数据转换的 Transferable 对象的代理。
 class DropTargetDragEvent
          通过 dragEnter() 和 dragOver() 方法将 DropTargetDragEvent 发送给 DropTargetListener
 class DropTargetDropEvent
          通过 DropTargetListener drop() 方法发送 DropTargetDropEvent
 class DropTargetEvent
          DropTargetEventDropTargetDragEventDropTargetDropEvent 的基类。
 class InvalidDnDOperationException
          java.awt.dnd 包中的各种方法都会抛出此异常。
 class MouseDragGestureRecognizer
          DragGestureRecognizer 的抽象子类,它定义了一个基于鼠标动作的 DragGestureRecognizer
 

返回 Objectjava.awt.dnd 中的方法
 Object DropTargetContext.TransferableProxy.getTransferData(DataFlavor df)
          返回一个对象,该对象表示数据是由封装的 transferable 为所请求的数据 flavor 提供的。
 Object[] DragGestureEvent.toArray()
          返回组成拖动动作的事件 Object 数组。
 Object[] DragGestureEvent.toArray(Object[] array)
          返回组成拖动动作的事件数组。
 

参数类型为 Objectjava.awt.dnd 中的方法
 Object[] DragGestureEvent.toArray(Object[] array)
          返回组成拖动动作的事件数组。
 

java.awt.eventObject 的使用
 

java.awt.eventObject 的子类
 class ActionEvent
          指示发生了组件定义的动作的语义事件。
 class AdjustmentEvent
          由 Adjustable 对象所发出的调整事件。
 class AWTEventListenerProxy
          扩展 EventListenerProxy 的类,特别适用于为特定事件掩码添加 AWTEventListener
 class ComponentAdapter
          用于接收组件事件的抽象适配器类。
 class ComponentEvent
          指示组件被移动、大小被更改或可见性被更改的低级别事件(它也是其他组件级事件的根类)。
 class ContainerAdapter
          用于接收容器事件的抽象适配器类。
 class ContainerEvent
          指示容器内容因为添加或移除组件而更改的低级别事件。
 class FocusAdapter
          用于接收键盘焦点事件的抽象适配器类。
 class FocusEvent
          指示 Component 已获得或失去输入焦点的低级别事件。
 class HierarchyBoundsAdapter
          用于接收祖先的移动和大小重调事件的抽象适配器类。
 class HierarchyEvent
          指示 Component 所属的 Component 层次结构发生更改的事件。
 class InputEvent
          所有组件级别输入事件的根事件类。
 class InputMethodEvent
          输入方法事件包含有关使用输入方法进行撰写的文本的信息。
 class InvocationEvent
          当通过 AWT 事件调度线程进行调度时,在 Runnable 上执行 run() 方法的事件。
 class ItemEvent
          指示项被选定或取消选定的语义事件。
 class KeyAdapter
          接收键盘事件的抽象适配器类。
 class KeyEvent
          表示组件中发生键击的事件。
 class MouseAdapter
          接收鼠标事件的抽象适配器类。
 class MouseEvent
          指示组件中发生鼠标动作的事件。
 class MouseMotionAdapter
          接收鼠标移动事件的抽象适配器类。
 class MouseWheelEvent
          表示鼠标滚轮在组件中滚动的事件。
 class PaintEvent
          组件级绘制事件。
 class TextEvent
          指示对象文本已改变的语义事件。
 class WindowAdapter
          接收窗口事件的抽象适配器类。
 class WindowEvent
          指示窗口状态改变的低级别事件。
 

声明为 Objectjava.awt.event 中的字段
protected  Object InvocationEvent.notifier
          在 Runnable.run() 方法返回之后立即调用其 notifyAll() 方法的对象(可能为 null)。
 

返回 Objectjava.awt.event 中的方法
 Object ItemEvent.getItem()
          返回受事件影响的项。
 

参数类型为 Objectjava.awt.event 中的构造方法
ActionEvent(Object source, int id, String command)
          构造一个 ActionEvent 对象。
ActionEvent(Object source, int id, String command, int modifiers)
          使用修改键构造一个 ActionEvent 对象。
ActionEvent(Object source, int id, String command, long when, int modifiers)
          使用指定修改键和时间戳构造一个 ActionEvent 对象。
InvocationEvent(Object source, int id, Runnable runnable, Object notifier, boolean catchThrowables)
          构造一个具有指定源和 ID 的 InvocationEvent,此源和 ID 将在被指派时执行 runnable 的 run 方法。
InvocationEvent(Object source, Runnable runnable)
          构造一个具有指定源的 InvocationEvent,此源将在被指派时执行 runnable 的 run 方法。
InvocationEvent(Object source, Runnable runnable, Object notifier, boolean catchThrowables)
          构造一个具有指定源的 InvocationEvent,此源将在被指派时执行 runnable 的 run 方法。
ItemEvent(ItemSelectable source, int id, Object item, int stateChange)
          构造一个 ItemEvent 对象。
TextEvent(Object source, int id)
          构造一个 TextEvent 对象。
 

java.awt.fontObject 的使用
 

java.awt.fontObject 的子类
 class FontRenderContext
          FontRenderContext 类是正确测量文本所需的信息容器。
 class GlyphJustificationInfo
          GlyphJustificationInfo 类表示关于字形调整属性的信息。
 class GlyphMetrics
          GlyphMetrics 类表示单个字形的信息。
 class GlyphVector
          GlyphVector 对象是一个字形的集合,包含在转换坐标空间中放置每个字形的几何信息,该坐标空间对应于最终要显示 GlyphVector 的设备。
 class GraphicAttribute
          此类与 CHAR_REPLACEMENT 属性一起使用。
 class ImageGraphicAttribute
          ImageGraphicAttribute 类是在 TextLayout 中绘制图像的 GraphicAttribute 实现。
 class LayoutPath
          LayoutPath 提供相对于基线的位置与用户空间中的点之间的映射。
 class LineBreakMeasurer
          LineBreakMeasurer 类允许将样式化的文本断为行(或段),以符合特定的可视 advance。
 class LineMetrics
          LineMetrics 类允许访问沿着一行布局字符和多行布局所需要的规格。
 class NumericShaper
          NumericShaper 类用于将 Latin-1(欧洲语)数字转换成其他 Unicode 十进制数字。
 class ShapeGraphicAttribute
          ShapeGraphicAttribute 类是以 TextLayout 形式绘制形状的 GraphicAttribute 的实现。
 class TextAttribute
          TextAttribute 类定义用于呈现文本的属性键和属性值。
 class TextHitInfo
          TextHitInfo 类表示文本模型中的字符位置以及字符的斜线或“边”。
 class TextLayout
          TextLayout 是样式字符数据的不可变图形表示形式。
static class TextLayout.CaretPolicy
          定义确定强插入符位置的策略。
 class TextMeasurer
          TextMeasurer 类提供换行所需的基本操作:测量到给定的 advance,确定字符范围的 advance,并为字符范围生成一个 TextLayout
 class TransformAttribute
          TransformAttribute 类为转换提供一个不可变的包装器,使其可以安全地作为属性使用。
 

返回 Objectjava.awt.font 中的方法
protected  Object TextLayout.clone()
          创建此 TextLayout 的副本。
protected  Object TextMeasurer.clone()
           
 Object FontRenderContext.getAntiAliasingHint()
          返回此 FontRenderContext 中使用的文本 anti-aliasing 呈现模式提示。
 Object FontRenderContext.getFractionalMetricsHint()
          返回此 FontRenderContext 中使用的文本 fractional metrics 呈现模式提示。
protected  Object TextAttribute.readResolve()
          将反序列化的实例解析为预定义常量。
 

参数类型为 Objectjava.awt.font 中的方法
 boolean ImageGraphicAttribute.equals(Object rhs)
          比较此 ImageGraphicAttribute 与指定的 Object
 boolean NumericShaper.equals(Object o)
          如果指定的对象是 NumericShaper 的一个实例,并且完全一致地成形到此实例,则返回 true。
 boolean ShapeGraphicAttribute.equals(Object rhs)
          将此 ShapeGraphicAttribute 与指定的 Object 进行比较。
 boolean TextHitInfo.equals(Object obj)
          如果指定的 Object 是一个 TextHitInfo 并且等于此 TextHitInfo,则返回 true
 boolean TextLayout.equals(Object obj)
          如果指定 Object 是一个 TextLayout 对象,且指定的 Object 等于此 TextLayout,则返回 true
 boolean TransformAttribute.equals(Object rhs)
          如果 rhs 是一个变换等效于此 TransformAttribute 变换的 TransformAttribute,则返回 true
 boolean FontRenderContext.equals(Object obj)
          如果 obj 是 FontRenderContext 的一个实例,并且具有与此 FontRenderContext 相同的转换、antialiasing 和 fractional metrics 值,则返回 true。
 

参数类型为 Objectjava.awt.font 中的构造方法
FontRenderContext(AffineTransform tx, Object aaHint, Object fmHint)
          根据一个可选 AffineTransform 和两个 Object 值构造一个 FontRenderContext 对象,这两个值决定了新创建的对象是具有 anti-aliasing 属性,还是具有 fractional metrics 属性。
 

java.awt.geomObject 的使用
 

java.awt.geomObject 的子类
 class AffineTransform
          AffineTransform 类表示 2D 仿射变换,它执行从 2D 坐标到其他 2D 坐标的线性映射,保留了线的“直线性”和“平行性”。
 class Arc2D
          Arc2D 是所有存储 2D 弧度的对象的抽象超类,其中 2D 弧度由窗体矩形、起始角度、角跨越(弧的长度)和闭合类型(OPENCHORDPIE)定义。
static class Arc2D.Double
          此类定义以 double 精度指定的弧。
static class Arc2D.Float
          此类定义以 float 精度指定的弧。
 class Area
          Area 对象存储和操作 2 维空间封闭区域的与解析无关的描述。
 class CubicCurve2D
          CubicCurve2D 类定义 (x,y) 坐标空间内的三次参数曲线段。
static class CubicCurve2D.Double
          使用 double 坐标指定的三次参数曲线段。
static class CubicCurve2D.Float
          使用 float 坐标指定的三次参数曲线段。
 class Dimension2D
          Dimension2D 类用于封装宽度和高度尺寸。
 class Ellipse2D
          Ellipse2D 类描述窗体矩形定义的椭圆。
static class Ellipse2D.Double
          Double 类以 double 精度定义椭圆。
static class Ellipse2D.Float
          Float 类以 float 精度定义椭圆。
 class FlatteningPathIterator
          FlatteningPathIterator 类返回另一个 PathIterator 对象的变平视图。
 class GeneralPath
          GeneralPath 类表示根据直线、二次曲线和三次 (Bézier) 曲线构造的几何路径。
 class IllegalPathStateException
          对于正在执行的特定操作而言(如将路径段追加到不具有初始 moveto 的 GeneralPath),如果操作在处于非法状态的路径上执行,则 IllegalPathStateException 表示抛出的异常。
 class Line2D
          Line2D 表示 (x,y) 坐标空间中的线段。
static class Line2D.Double
          使用 double 坐标指定的线段。
static class Line2D.Float
          使用 float 坐标指定的线段。
 class NoninvertibleTransformException
          NoninvertibleTransformException 类表示在执行的操作要求 AffineTransform 对象可逆但 AffineTransform 处于不可逆状态时抛出的异常。
 class Path2D
          Path2D 类提供一个表示任意几何形状路径的简单而又灵活的形状。
static class Path2D.Double
          Double 类定义了一条几何路径,它具有以双精度浮点值形式存储的坐标。
static class Path2D.Float
          Float 类定义了一条几何路径,它具有以单精度浮点值形式存储的坐标。
 class Point2D
          Point2D 类定义表示 (x,y) 坐标空间中位置的点。
static class Point2D.Double
          Double 类以 double 精度定义指定的点。
static class Point2D.Float
          Float 类以 float 精度定义指定的点。
 class QuadCurve2D
          QuadCurve2D 类定义 (x,y) 坐标空间内的二次参数曲线段。
static class QuadCurve2D.Double
          使用 double 坐标指定的二次参数曲线段。
static class QuadCurve2D.Float
          使用 float 坐标指定的二次参数曲线段。
 class Rectangle2D
          Rectangle2D 类描述通过位置 (x,y) 和尺寸 (w x h) 定义的矩形。
static class Rectangle2D.Double
          Double 类定义一个在 double 坐标中指定的矩形。
static class Rectangle2D.Float
          Float 类定义一个在 float 坐标中指定的矩形。
 class RectangularShape
          RectangularShape 是许多 Shape 对象的基类,这些对象的几何形状由矩形窗体定义。
 class RoundRectangle2D
          RoundRectangle2D 类定义一个矩形,该矩形具有由位置 (x,y)、维度 (w x h) 以及圆角弧的宽度和高度定义的圆角。
static class RoundRectangle2D.Double
          Double 类定义一个所有圆角都使用 double 坐标指定的矩形。
static class RoundRectangle2D.Float
          Float 类定义一个所有圆角都使用 float 坐标指定的矩形。
 

返回 Objectjava.awt.geom 中的方法
 Object Area.clone()
          返回此 Area 对象的精确副本。
 Object CubicCurve2D.clone()
          创建一个与此对象具有相同类的新对象。
 Object Line2D.clone()
          创建一个与此对象具有相同类的新对象。
abstract  Object Path2D.clone()
          创建一个与此对象具有相同类的新对象。
 Object Path2D.Float.clone()
          创建一个与此对象具有相同类的新对象。
 Object Path2D.Double.clone()
          创建一个与此对象具有相同类的新对象。
 Object QuadCurve2D.clone()
          创建一个与此对象具有相同类和相同内容的新对象。
 Object RectangularShape.clone()
          创建一个与此对象具有相同类和相同内容的新对象。
 Object Point2D.clone()
          创建一个与此对象具有相同类和相同内容的新对象。
 Object AffineTransform.clone()
          返回此 AffineTransform 对象的副本。
 Object Dimension2D.clone()
          创建一个与此对象具有相同类的新对象。
 

参数类型为 Objectjava.awt.geom 中的方法
 boolean Arc2D.equals(Object obj)
          确定指定的 Object 是否与此 Arc2D 相等。
 boolean Ellipse2D.equals(Object obj)
          确定指定的 Object 是否与此 Ellipse2D 相等。
 boolean RoundRectangle2D.equals(Object obj)
          确定指定的 Object 是否与此 RoundRectangle2D 相等。
 boolean Rectangle2D.equals(Object obj)
          确定指定的 Object 是否与此 Rectangle2D 相等。
 boolean Point2D.equals(Object obj)
          确定两个点是否相等。
 boolean AffineTransform.equals(Object obj)
          如果此 AffineTransform 表示与指定参数相同的仿射坐标变换,则返回 true
 

java.awt.imObject 的使用
 

java.awt.imObject 的子类
 class InputContext
          提供控制诸如输入方法和键盘布局之类的文本输入设施的方法。
 class InputMethodHighlight
          InputMethodHighlight 用于描述正在撰写的文本的高亮显示属性。
 class InputSubset
          定义输入方法使用的其他 Unicode 子集。
 

返回 Objectjava.awt.im 中的方法
 Object InputContext.getInputMethodControlObject()
          返回当前输入方法中的一个控制对象,或 null。
 

java.awt.im.spiObject 的使用
 

返回 Objectjava.awt.im.spi 中的方法
 Object InputMethod.getControlObject()
          从此输入方法返回一个控制对象,或 null。
 

java.awt.imageObject 的使用
 

java.awt.imageObject 的子类
 class AffineTransformOp
          此类使用仿射转换来执行从源图像或 Raster 中 2D 坐标到目标图像或 Raster 中 2D 坐标的线性映射。
 class AreaAveragingScaleFilter
          这是一个 ImageFilter 类,它使用一个简单的区域平均算法来进行图像缩放,该算法产生比其最相近算法更平滑的结果。
 class BandCombineOp
          此类使用一个指定矩阵对 Raster 中的 band 进行任意线性组合。
 class BandedSampleModel
          此类表示以 band 交错方式存储的图像数据,像素的每个样本都占用 DataBuffer 的一个数据元素。
 class BufferedImage
          BufferedImage 子类描述具有可访问图像数据缓冲区的 Image
 class BufferedImageFilter
          BufferedImageFilter 类是 ImageFilter 的子类,提供一种使用单一源图像/单一目标图像操作符 (BufferedImageOp) 的简单方式来过滤 Image Producer/Consumer/Observerto 范例中的 BufferedImage
 class BufferStrategy
          BufferStrategy 类表示用来在特定的 CanvasWindow 上组织复杂内存的机制。
 class ByteLookupTable
          此类定义一个 lookup table 对象。
 class ColorConvertOp
          此类对源图像中的数据执行逐像素的颜色转换。
 class ColorModel
          此 ColorModel 抽象类封装了将像素值转换为颜色分量(例如,红色、绿色和蓝色)和 alpha 分量的方法。
 class ComponentColorModel
          使用像素值将颜色和 alpha 信息表示为独立样本的 ColorModel 类,该类以独立的数据元素存储每个样本。
 class ComponentSampleModel
          此类表示按每个像素样本占用 DataBuffer 中一个数据元素的方式存储的图像数据。
 class ConvolveOp
          此类实现从源到目标的卷积。
 class CropImageFilter
          用于裁剪图像的 ImageFilter 类。
 class DataBuffer
          此类用于包装一个或多个数据数组。
 class DataBufferByte
          此类扩展了 DataBuffer,并在内部按字节存储数据。
 class DataBufferDouble
          此类扩展了 DataBuffer,并在内部以 double 形式存储数据。
 class DataBufferFloat
          此类扩展了 DataBuffer,并在内部以 float 形式存储数据。
 class DataBufferInt
          此类扩展了 DataBuffer,并在内部以整数形式存储数据。
 class DataBufferShort
          此类扩展了 DataBuffer,并在内部以 short 类型存储数据。
 class DataBufferUShort
          此类扩展了 DataBuffer,并在内部以 short 类型存储数据。
 class DirectColorModel
          DirectColorModel 类是使用像素值的 ColorModel 类,像素值以单独样本的形式表示 RGB 颜色和 alpha 信息,并将单个像素的所有样本打包成单个 int、short 或 byte 量。
 class FilteredImageSource
          此类是 ImageProducer 接口的一个实现,该接口使用现有的图像和过滤器对象作为参数,并使用它们为原图像的新过滤版本产生图像数据。
 class ImageFilter
          此类为用于从 ImageProducer 向 ImageConsumer 传递数据的接口方法集合实现了一个过滤器。
 class ImagingOpException
          如果某个 BufferedImageOpRasterOp 过滤器方法无法处理图像,则抛出 ImagingOpException
 class IndexColorModel
          IndexColorModel 类是一个 ColorModel 类,它使用由单个样本组成的像素值,这些像素值是默认 sRGB 颜色空间中固定 colormap 中的索引。
 class Kernel
          Kernel 类定义了一个矩阵,描述指定的像素及其周围像素如何影响过滤操作输出图像中像素位置的计算值。
 class LookupOp
          此类实现从源到目标的查找操作。
 class LookupTable
          此抽象类定义了一个查找表对象。
 class MemoryImageSource
          此类是 ImageProducer 接口的一个实现,该接口使用一个数组为 Image 生成像素值。
 class MultiPixelPackedSampleModel
          MultiPixelPackedSampleModel 类表示单 band 图像,能够将多个单样本像素打包到一个数据元素中。
 class PackedColorModel
          PackedColorModel 类是一个抽象 ColorModel 类,它使用的像素值以单独采样表示颜色和 alpha 信息,并将单个像素的所有采样打包到单个 int、short 或 byte 量中。
 class PixelGrabber
          PixelGrabber 类实现可以附加在 Image 或 ImageProducer 对象上获得图像像素子集的 ImageConsumer。
 class PixelInterleavedSampleModel
          此类表示以像素交替方式存储的图像数据,其中像素的每个采样占用 DataBuffer 的一个数据元素。
 class Raster
          表示像素矩形数组的类。
 class RasterFormatException
          如果 Raster 中存在无效的布局信息,则抛出 RasterFormatException
 class ReplicateScaleFilter
          使用最简单的算法缩放图像的 ImageFilter 类。
 class RescaleOp
          通过将每个像素的样本值乘以一个缩放因子,然后加上一个偏移量,此类对源图像中数据进行逐像素重缩放。
 class RGBImageFilter
          此类提供一种便捷方式创建 ImageFilter,创建的 ImageFilter 可修改使用默认 RGB ColorModel 图像的像素。
 class SampleModel
          此抽象类定义一个提取图像像素样本的接口。
 class ShortLookupTable
          此类定义了一个查找表对象。
 class SinglePixelPackedSampleModel
          此类表示压缩的像素数据:将 N 个样本组成的单个像素存储在单个数据数组元素中,每个数据数组元素只保存一个像素的样本。
 class VolatileImage
          VolatileImage 是一种图像,它可以在不受应用程序控制的情形下(例如,由操作系统或其他应用程序引起的情况)随时丢失其内容。
 class WritableRaster
          此类扩展了 Raster 以提供像素写入功能。
 

声明为 Objectjava.awt.image 中的字段
protected  Object ReplicateScaleFilter.outpixbuf
          使用 ReplicateScaleFilter.destWidth 的大小初始化的 byte 数组,用于将像素数据行传递给 ImageConsumer
 

返回 Objectjava.awt.image 中的方法
 Object Kernel.clone()
          复制此对象。
 Object ImageFilter.clone()
          复制此对象。
 Object ComponentColorModel.getDataElements(float[] normComponents, int normOffset, Object obj)
          在已给定标准化颜色/alpha 分量的数组的情况下,返回此 ColorModel 中像素的数据元素数组表示形式。
 Object ColorModel.getDataElements(float[] normComponents, int normOffset, Object obj)
          在已给定标准化颜色/alpha 分量的数组的情况下,返回此 ColorModel 中像素的数据元素数组表示形式。
 Object ComponentColorModel.getDataElements(int[] components, int offset, Object obj)
          在已给定非标准化颜色/alpha 分量的情况下,返回此 ColorModel 中像素的数据元素数组表示形式。
 Object IndexColorModel.getDataElements(int[] components, int offset, Object pixel)
          在给定非标准化颜色/alpha 分量数组的情况下,返回表示此 ColorModel 中像素的数据元素数组。
 Object DirectColorModel.getDataElements(int[] components, int offset, Object obj)
          在给定未标准化的颜色/alpha 分量的数组的情况下,返回此 ColorModel 中的像素的数据元素数组表示形式。
 Object ColorModel.getDataElements(int[] components, int offset, Object obj)
          在已给定非标准化颜色/alpha 分量的情况下,返回此 ColorModel 中像素的数据元素数组表示形式。
 Object Raster.getDataElements(int x, int y, int w, int h, Object outData)
          以 TransferType 类型基本数组形式返回指定像素矩形的像素数据。
 Object SampleModel.getDataElements(int x, int y, int w, int h, Object obj, DataBuffer data)
          在 TransferType 类型基本数组中返回指定像素矩形的像素数据。
 Object Raster.getDataElements(int x, int y, Object outData)
          以 TransferType 类型的基本数组形式返回单个像素的数据。
 Object BandedSampleModel.getDataElements(int x, int y, Object obj, DataBuffer data)
          在 TransferType 类型基本数组中返回单个像素的数据。
 Object MultiPixelPackedSampleModel.getDataElements(int x, int y, Object obj, DataBuffer data)
          返回 TransferType 类型基本数组中单个像素的数据。
 Object SinglePixelPackedSampleModel.getDataElements(int x, int y, Object obj, DataBuffer data)
          返回 TransferType 类型基本数组中单个像素的数据。
 Object ComponentSampleModel.getDataElements(int x, int y, Object obj, DataBuffer data)
          以 TransferType 类型基本数组形式返回单个像素的数据。
abstract  Object SampleModel.getDataElements(int x, int y, Object obj, DataBuffer data)
          在 TransferType 类型的基本数组中返回单个像素的数据。
 Object ComponentColorModel.getDataElements(int rgb, Object pixel)
          在默认 RGB 颜色模型中给定整数像素的表示形式的情况下,返回此 ColorModel 中像素的数据元素数组的表示形式。
 Object IndexColorModel.getDataElements(int rgb, Object pixel)
          根据默认 RGB 颜色模型中的整数像素表示形式,返回此 ColorModel 中像素的数据元素数组表示形式。
 Object DirectColorModel.getDataElements(int rgb, Object pixel)
          在默认 RGB 颜色模型中给定整数像素的表示形式的情况下,返回此 ColorModel 中像素的数据元素数组的表示形式。
 Object ColorModel.getDataElements(int rgb, Object pixel)
          在默认 RGB 颜色模型中给定整数像素的表示形式的情况下,返回此 ColorModel 中像素的数据元素数组的表示形式。
 Object PixelGrabber.getPixels()
          获取像素缓冲区。
 Object BufferedImage.getProperty(String name)
          按名称返回图像的属性。
 Object RenderedImage.getProperty(String name)
          从此图像的属性设置中获取一个属性。
 Object BufferedImage.getProperty(String name, ImageObserver observer)
          按名称返回图像的属性。
 

参数类型为 Objectjava.awt.image 中的方法
 boolean ComponentColorModel.equals(Object obj)
          将此颜色模型与其他模型进行相等性比较。
 boolean MultiPixelPackedSampleModel.equals(Object o)
           
 boolean SinglePixelPackedSampleModel.equals(Object o)
           
 boolean ComponentSampleModel.equals(Object o)
           
 boolean PackedColorModel.equals(Object obj)
          测试指定的 Object 是否为 PackedColorModel 的一个实例并且等于此 PackedColorModel
 boolean ColorModel.equals(Object obj)
          测试指定的 Object 是否是 ColorModel 的实例,以及它是否等于此 ColorModel
 int ComponentColorModel.getAlpha(Object inData)
          返回指定像素(在 0 到 255 之间缩放)的 alpha 分量。
 int DirectColorModel.getAlpha(Object inData)
          返回指定像素(在 0 到 255 之间缩放)的 alpha 分量。
 int ColorModel.getAlpha(Object inData)
          返回指定像素(在 0 到 255 之间缩放)的 alpha 分量。
 int ComponentColorModel.getBlue(Object inData)
          返回指定像素的蓝颜色分量,指定像素在默认的 RGB ColorSpace(即 sRGB)中缩放范围是 0 到 255。
 int DirectColorModel.getBlue(Object inData)
          返回指定像素的蓝颜色分量,指定像素在默认的 RGB ColorSpace(即 sRGB)中缩放范围是 0 到 255。
 int ColorModel.getBlue(Object inData)
          返回指定像素的蓝颜色分量,指定像素在默认的 RGB ColorSpace(即 sRGB)中缩放范围是 0 到 255。
 int[] ComponentColorModel.getComponents(Object pixel, int[] components, int offset)
          返回在此 ColorModel 中已给定像素的非标准化颜色/alpha 分量的数组。
 int[] IndexColorModel.getComponents(Object pixel, int[] components, int offset)
          返回此 ColorModel 中指定像素的非标准化颜色/alpha 分量数组。
 int[] DirectColorModel.getComponents(Object pixel, int[] components, int offset)
          返回在 ColorModel 中已给定像素的未标准化颜色/alpha 分量。
 int[] ColorModel.getComponents(Object pixel, int[] components, int offset)
          返回在此 ColorModel 中已给定像素的非标准化颜色/alpha 分量的数组。
 Object ComponentColorModel.getDataElements(float[] normComponents, int normOffset, Object obj)
          在已给定标准化颜色/alpha 分量的数组的情况下,返回此 ColorModel 中像素的数据元素数组表示形式。
 Object ColorModel.getDataElements(float[] normComponents, int normOffset, Object obj)
          在已给定标准化颜色/alpha 分量的数组的情况下,返回此 ColorModel 中像素的数据元素数组表示形式。
 Object ComponentColorModel.getDataElements(int[] components, int offset, Object obj)
          在已给定非标准化颜色/alpha 分量的情况下,返回此 ColorModel 中像素的数据元素数组表示形式。
 Object IndexColorModel.getDataElements(int[] components, int offset, Object pixel)
          在给定非标准化颜色/alpha 分量数组的情况下,返回表示此 ColorModel 中像素的数据元素数组。
 Object DirectColorModel.getDataElements(int[] components, int offset, Object obj)
          在给定未标准化的颜色/alpha 分量的数组的情况下,返回此 ColorModel 中的像素的数据元素数组表示形式。
 Object ColorModel.getDataElements(int[] components, int offset, Object obj)
          在已给定非标准化颜色/alpha 分量的情况下,返回此 ColorModel 中像素的数据元素数组表示形式。
 Object Raster.getDataElements(int x, int y, int w, int h, Object outData)
          以 TransferType 类型基本数组形式返回指定像素矩形的像素数据。
 Object SampleModel.getDataElements(int x, int y, int w, int h, Object obj, DataBuffer data)
          在 TransferType 类型基本数组中返回指定像素矩形的像素数据。
 Object Raster.getDataElements(int x, int y, Object outData)
          以 TransferType 类型的基本数组形式返回单个像素的数据。
 Object BandedSampleModel.getDataElements(int x, int y, Object obj, DataBuffer data)
          在 TransferType 类型基本数组中返回单个像素的数据。
 Object MultiPixelPackedSampleModel.getDataElements(int x, int y, Object obj, DataBuffer data)
          返回 TransferType 类型基本数组中单个像素的数据。
 Object SinglePixelPackedSampleModel.getDataElements(int x, int y, Object obj, DataBuffer data)
          返回 TransferType 类型基本数组中单个像素的数据。
 Object ComponentSampleModel.getDataElements(int x, int y, Object obj, DataBuffer data)
          以 TransferType 类型基本数组形式返回单个像素的数据。
abstract  Object SampleModel.getDataElements(int x, int y, Object obj, DataBuffer data)
          在 TransferType 类型的基本数组中返回单个像素的数据。
 Object ComponentColorModel.getDataElements(int rgb, Object pixel)
          在默认 RGB 颜色模型中给定整数像素的表示形式的情况下,返回此 ColorModel 中像素的数据元素数组的表示形式。
 Object IndexColorModel.getDataElements(int rgb, Object pixel)
          根据默认 RGB 颜色模型中的整数像素表示形式,返回此 ColorModel 中像素的数据元素数组表示形式。
 Object DirectColorModel.getDataElements(int rgb, Object pixel)
          在默认 RGB 颜色模型中给定整数像素的表示形式的情况下,返回此 ColorModel 中像素的数据元素数组的表示形式。
 Object ColorModel.getDataElements(int rgb, Object pixel)
          在默认 RGB 颜色模型中给定整数像素的表示形式的情况下,返回此 ColorModel 中像素的数据元素数组的表示形式。
 int ComponentColorModel.getGreen(Object inData)
          返回指定像素的绿色分量,指定像素在默认的 RGB ColorSpace(即 sRGB)中缩放范围是 0 到 255。
 int DirectColorModel.getGreen(Object inData)
          返回指定像素的绿色颜色分量,指定像素在默认的 RGB ColorSpace(即 sRGB)中缩放范围是 0 到 255。
 int ColorModel.getGreen(Object inData)
          返回指定像素的绿色颜色分量,指定像素在默认的 RGB ColorSpace(即 sRGB)中缩放范围是 0 到 255)。
 float[] ComponentColorModel.getNormalizedComponents(Object pixel, float[] normComponents, int normOffset)
          返回已在 ColorModel 中给定了像素的标准化形式颜色/alpha 分量的数组。
 float[] ColorModel.getNormalizedComponents(Object pixel, float[] normComponents, int normOffset)
          返回已在 ColorModel 中给定了像素的标准化形式颜色/alpha 分量的数组。
 int ComponentColorModel.getRed(Object inData)
          返回指定像素的红色分量,指定像素在默认的 RGB ColorSpace(即 sRGB)中缩放范围是 0 到 255。
 int DirectColorModel.getRed(Object inData)
          返回指定像素的红色颜色分量,指定像素在默认的 RGB ColorSpace(即 sRGB)中缩放范围是 0 到 255。
 int ColorModel.getRed(Object inData)
          返回指定像素的红色颜色分量,指定像素在默认的 RGB ColorSpace(即 sRGB)中缩放范围是 0 到 255。
 int ComponentColorModel.getRGB(Object inData)
          返回默认的 RGB 颜色模型格式中的像素的颜色/alpha 分量。
 int DirectColorModel.getRGB(Object inData)
          返回默认的 RGB 颜色模型格式中的像素的颜色/alpha 分量。
 int ColorModel.getRGB(Object inData)
          返回默认的 RGB 颜色模型格式中的像素的颜色/alpha 分量。
 void WritableRaster.setDataElements(int x, int y, int w, int h, Object inData)
          为类型 TransferType 基本数组中的像素矩形设置数据。
 void SampleModel.setDataElements(int x, int y, int w, int h, Object obj, DataBuffer data)
          根据 TransferType 类型的基本数组设置指定 DataBuffer 中像素矩形的数据。
 void WritableRaster.setDataElements(int x, int y, Object inData)
          为类型 TransferType 基本数组中的单个像素设置数据。
 void BandedSampleModel.setDataElements(int x, int y, Object obj, DataBuffer data)
          根据 TransferType 类型基本数组设置指定 DataBuffer 中单个像素的数据。
 void MultiPixelPackedSampleModel.setDataElements(int x, int y, Object obj, DataBuffer data)
          根据 TransferType 类型基本数组设置指定 DataBuffer 中单个像素的数据。
 void SinglePixelPackedSampleModel.setDataElements(int x, int y, Object obj, DataBuffer data)
          根据 TransferType 类型的基本数组设置指定 DataBuffer 中单个像素的数据。
 void ComponentSampleModel.setDataElements(int x, int y, Object obj, DataBuffer data)
          根据 TransferType 类型基本数组设置指定 DataBuffer 中单个像素的数据。
abstract  void SampleModel.setDataElements(int x, int y, Object obj, DataBuffer data)
          根据 TransferType 类型基本数组设置指定 DataBuffer 中单个像素的数据。
 

java.awt.image.renderableObject 的使用
 

java.awt.image.renderableObject 的子类
 class ParameterBlock
          ParameterBlock 封装有关 RenderableImageOp 所需的源和参数 (Object) 的所有信息,或者其他处理图像的类。
 class RenderableImageOp
          此类借助其相关的 ContextualRenderedImageFactory 实例处理某个操作的可呈现方面。
 class RenderableImageProducer
          实现 ImageProducer 以允许异步生成 RenderableImage 的适配器类。
 class RenderContext
          RenderContext 封装从 enderableImage 生成特定呈现所需的信息。
 

类型参数类型为 Objectjava.awt.image.renderable 中的字段
protected  Vector<Object> ParameterBlock.parameters
          一个非源参数的 Vector,存储为任意 Object。
protected  Vector<Object> ParameterBlock.sources
          源的 Vector,存储为任意 Objects。
 

返回 Objectjava.awt.image.renderable 中的方法
 Object ParameterBlock.clone()
          创建 ParameterBlock 的一个副本。
 Object RenderContext.clone()
          对 RenderContext 进行复制。
 Object ParameterBlock.getObjectParameter(int index)
          获取作为对象的参数。
 Object ContextualRenderedImageFactory.getProperty(ParameterBlock paramBlock, String name)
          获取由 name 参数指定的属性的适当实例。
 Object RenderableImage.getProperty(String name)
          从此图像的属性集中获取某个属性。
 Object RenderableImageOp.getProperty(String name)
          从此图像的属性集中获取某个属性。
 Object ParameterBlock.getSource(int index)
          返回作为通用 Object 的源。
 Object ParameterBlock.shallowClone()
          创建 ParameterBlock 的一个浅表副本。
 

返回变量类型为 Object 的类型的 java.awt.image.renderable 中的方法
 Vector<Object> ParameterBlock.getParameters()
          返回参数的整个 Vector。
 Vector<Object> ParameterBlock.getSources()
          返回源的整个 Vector。
 

参数类型为 Objectjava.awt.image.renderable 中的方法
 ParameterBlock ParameterBlock.add(Object obj)
          将一个 Object 添加到此参数列表。
 ParameterBlock ParameterBlock.addSource(Object source)
          将一个图像添加到源列表的末尾。
 ParameterBlock ParameterBlock.set(Object obj, int index)
          替换此参数列表中的一个 Object。
 ParameterBlock ParameterBlock.setSource(Object source, int index)
          将源列表中的某个项替换为一个新源。
 

类型变量类型为 Objectjava.awt.image.renderable 中的方法参数
 void ParameterBlock.setParameters(Vector<Object> parameters)
          将参数的整个 Vector 设置为给定 Vector。
 void ParameterBlock.setSources(Vector<Object> sources)
          将源的整个 Vector 设置为给定 Vector。
 

类型变量类型为 Objectjava.awt.image.renderable 中的构造方法参数
ParameterBlock(Vector<Object> sources)
          使用源的给定 Vector 构造一个 ParameterBlock
ParameterBlock(Vector<Object> sources, Vector<Object> parameters)
          使用源的给定 Vector 和参数的 Vector 构造一个 ParameterBlock
ParameterBlock(Vector<Object> sources, Vector<Object> parameters)
          使用源的给定 Vector 和参数的 Vector 构造一个 ParameterBlock
 

java.awt.printObject 的使用
 

java.awt.printObject 的子类
 class Book
          Book 类提供文档的表示形式,该文档的页面可以使用不同的页面格式和页面 painter。
 class PageFormat
          PageFormat 类描述要打印的页面大小和方向。
 class Paper
          Paper 类描述一张纸的物理特征。
 class PrinterAbortException
          PrinterAbortException 类是 PrinterException 的子类,用于指示用户或应用程序在打印过程中终止打印作业。
 class PrinterException
          PrinterException 类及其子类用于指示打印系统中发生的异常情况。
 class PrinterIOException
          PrinterIOException 类是 PrinterException 的子类,用于指示在打印过程中发生了某种 IO 错误。
 class PrinterJob
          PrinterJob 类是控制打印的主要类。
 

返回 Objectjava.awt.print 中的方法
 Object PageFormat.clone()
          制作此 PageFormat 的副本,使它与此 PageFormat 具有相同的内容。
 Object Paper.clone()
          创建此 Paper 的一个副本,内容与此 Paper 相同。
 

java.beansObject 的使用
 

java.beansObject 的子类
 class BeanDescriptor
          BeanDescriptor 提供有关 "bean" 的全局信息,其中包括其 Java 类、其 displayName 等等。
 class Beans
          此类提供一些通用的 bean 控制方法。
 class DefaultPersistenceDelegate
          DefaultPersistenceDelegatePersistenceDelegate 抽象类的具体实现,是没有关于其可用信息的类在默认情况下使用的委托。
 class Encoder
          Encoder 是这样的类,它可用于创建根据其公共 API 对 JavaBeans 集合状态进行编码的文件或流。
 class EventHandler
          EventHandler 类为动态生成事件侦听器提供支持,这些侦听器的方法执行一条涉及传入事件对象和目标对象的简单语句。
 class EventSetDescriptor
          描述给定 Java bean 激发的一组事件的 EventSetDescriptor。
 class Expression
          Expression 对象表示基本表达式,其中将单个方法应用于某一目标和一组参数,以返回结果,与在 "a.getFoo()" 中一样。
 class FeatureDescriptor
          FeatureDescriptor 类是 PropertyDescriptor、EventSetDescriptor 和 MethodDescriptor 等的公共基类。
 class IndexedPropertyChangeEvent
          无论何时遵守 JavaBeans 规范的组件("bean")更改绑定 (bound) 索引 (indexed) 属性,都会提交一个 "IndexedPropertyChange" 事件。
 class IndexedPropertyDescriptor
          IndexedPropertyDescriptor 描述了类似数组行为的属性,且有一种访问数组特定元素的索引读和/或索引写方法。
 class IntrospectionException
          在 Introspection 期间发生异常时抛出异常。
 class Introspector
          Introspector 类为通过工具学习有关受目标 Java Bean 支持的属性、事件和方法的知识提供了一个标准方法。
 class MethodDescriptor
          MethodDescriptor 描述了一种特殊方法,即 Java Bean 支持从其他组件对其进行外部访问。
 class ParameterDescriptor
          ParameterDescriptor 类允许 bean 实现者提供除 java.lang.reflect.Method 类提供的低级别信息之外的关于其每个参数的额外信息。
 class PersistenceDelegate
          PersistenceDelegate 类负责根据类的公共 API 中的方法表示给定类的实例状态。
 class PropertyChangeEvent
          无论 bean 何时更改 "bound" 或 "constrained" 属性,都会提交一个 "PropertyChange" 事件。
 class PropertyChangeListenerProxy
          扩展 EventListenerProxy 的类,特别适用于添加指定的 PropertyChangeListener
 class PropertyChangeSupport
          这是一个实用工具类,支持绑定 (bound) 属性的 bean 可以使用该类。
 class PropertyDescriptor
          PropertyDescriptor 描述 Java Bean 通过一对存储器方法导出的一个属性。
 class PropertyEditorManager
          PropertyEditorManager 可用于查找任何给定类型名称的属性编辑器。
 class PropertyEditorSupport
          这是一个帮助构建属性编辑器的支持类。
 class PropertyVetoException
          当某一属性的提议更改表示一个不可接受的值时,将抛出 PropertyVetoException。
 class SimpleBeanInfo
          这是一个使得用户提供 BeanInfo 类更容易的支持类。
 class Statement
          Statement 对象表示基本语句,其中将单个方法应用于某一目标和一组参数,以返回结果,比如 "a.setFoo(b)"
 class VetoableChangeListenerProxy
          扩展 EventListenerProxy 的类,特别适用于将 VetoableChangeListener 与 "constrained" 属性相关联。
 class VetoableChangeSupport
          这是一个实用工具类,支持约束 (constrained) 属性的 bean 可以使用此类。
 class XMLDecoder
          XMLDecoder 类用于读取使用 XMLEncoder 创建的 XML 文档,用途类似于 ObjectInputStream
 class XMLEncoder
          XMLEncoder 类是 ObjectOutputStream 的互补替换,可用于生成 JavaBean 的文本表示形式,所使用方式与用 ObjectOutputStream 创建 Serializable 对象的二进制表示形式的方式相同。
 

返回 Objectjava.beans 中的方法
 Object Encoder.get(Object oldInstance)
          在由此流创建的环境中返回 oldInstance 的一个实验值。
 Object[] Statement.getArguments()
          返回此语句的参数。
static Object Beans.getInstanceOf(Object bean, Class<?> targetType)
          从给定 bean 中获得表示源对象的指定类型视图的对象。
 Object PropertyChangeEvent.getNewValue()
          获取属性的新值,以 Object 的形式表示。
 Object PropertyChangeEvent.getOldValue()
          获取属性的旧值,以 Object 的形式表示。
 Object XMLDecoder.getOwner()
          获得此解码器的所有者。
 Object XMLEncoder.getOwner()
          获得此编码器的所有者。
 Object PropertyChangeEvent.getPropagationId()
          保留 "propagationId" 字段以供将来使用。
 Object PropertyEditorSupport.getSource()
          返回用作事件源的 bean。
 Object EventHandler.getTarget()
          返回此事件处理程序将为其发送消息的对象。
 Object Statement.getTarget()
          返回此语句的目标。
 Object Expression.getValue()
          如果此实例的 value 属性尚未设置,则此方法利用这些参数,在此目标上动态查找具有指定 methodName 的方法,并调用该方法。
 Object PropertyEditor.getValue()
          获取属性值。
 Object PropertyEditorSupport.getValue()
          获得属性值。
 Object FeatureDescriptor.getValue(String attributeName)
          利用此特性检索指定属性。
static Object Beans.instantiate(ClassLoader cls, String beanName)
           实例化 JavaBean。
static Object Beans.instantiate(ClassLoader cls, String beanName, BeanContext beanContext)
           实例化 JavaBean。
static Object Beans.instantiate(ClassLoader cls, String beanName, BeanContext beanContext, AppletInitializer initializer)
          实例化 bean。
 Object EventHandler.invoke(Object proxy, Method method, Object[] arguments)
          从事件中提取适当属性值,并将其传递到与此 EventHandler 相关联的动作。
 Object XMLDecoder.readObject()
          从基础输入流中读取下一个对象。
 Object Encoder.remove(Object oldInstance)
          移除此实例的条目,返回旧条目。
 

参数类型为 Objectjava.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
 PropertyEditor PropertyDescriptor.createPropertyEditor(Object bean)
          使用当前属性编辑器类构造一个属性编辑器实例。
 boolean IndexedPropertyDescriptor.equals(Object obj)
          将此 PropertyDescriptor 与指定对象比较。
 boolean PropertyDescriptor.equals(Object obj)
          将此 PropertyDescriptor 与指定对象进行比较。
 void PropertyChangeSupport.fireIndexedPropertyChange(String propertyName, int index, Object oldValue, Object newValue)
          报告所有已注册侦听器的绑定 (bound) 索引 (indexed) 属性更新。
 void PropertyChangeSupport.firePropertyChange(String propertyName, Object oldValue, Object newValue)
          报告所有已注册侦听器的绑定属性更新。
 void VetoableChangeSupport.fireVetoableChange(String propertyName, Object oldValue, Object newValue)
          向所有已注册的侦听器报告 vetoable 属性更新。
 Object Encoder.get(Object oldInstance)
          在由此流创建的环境中返回 oldInstance 的一个实验值。
static Object Beans.getInstanceOf(Object bean, Class<?> targetType)
          从给定 bean 中获得表示源对象的指定类型视图的对象。
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
protected  Expression DefaultPersistenceDelegate.instantiate(Object oldInstance, Encoder out)
          instantiate 方法的此默认实现返回一个表达式,该表达式包含预先定义的方法名称 "new",该名称表示调用带有参数(在 DefaultPersistenceDelegate 的构造方法中指定)的构造方法。
protected abstract  Expression PersistenceDelegate.instantiate(Object oldInstance, Encoder out)
          返回其值为 oldInstance 的表达式。
 Object EventHandler.invoke(Object proxy, Method method, Object[] arguments)
          从事件中提取适当属性值,并将其传递到与此 EventHandler 相关联的动作。
 Object EventHandler.invoke(Object proxy, Method method, Object[] arguments)
          从事件中提取适当属性值,并将其传递到与此 EventHandler 相关联的动作。
static boolean Beans.isInstanceOf(Object bean, Class<?> targetType)
          检查是否可以将 bean 视为给定目标类型。
protected  boolean DefaultPersistenceDelegate.mutatesTo(Object oldInstance, Object newInstance)
          如果指定构造方法中的参数数量不为零,且 oldInstance 的类显式声明了一个 "equals" 方法,则此方法返回 oldInstance.equals(newInstance) 的值。
protected  boolean PersistenceDelegate.mutatesTo(Object oldInstance, Object newInstance)
          如果 oldInstance等效 副本可以可以通过应用 newInstance 的一系列语句来创建,则返回 true。
 Object Encoder.remove(Object oldInstance)
          移除此实例的条目,返回旧条目。
 void Customizer.setObject(Object bean)
          设置将要自定义的对象。
 void XMLDecoder.setOwner(Object owner)
          将此解码器的所有者设置为 owner
 void XMLEncoder.setOwner(Object owner)
          将此编码器的所有者设置为 owner
 void PropertyChangeEvent.setPropagationId(Object propagationId)
          设置事件的 propagationId 对象。
 void PropertyEditorSupport.setSource(Object source)
          设置源 bean。
 void Expression.setValue(Object value)
          将此表达式的值设置为 value
 void PropertyEditor.setValue(Object value)
          设置(或更改)将编辑的对象。
 void PropertyEditorSupport.setValue(Object value)
          设置(或更改)将被编辑的对象。
 void FeatureDescriptor.setValue(String attributeName, Object value)
          将某一指定属性与此特性相关联。
protected  void Encoder.writeObject(Object o)
          将指定对象写入输出流中。
 void XMLEncoder.writeObject(Object o)
          将指定对象的 XML 表示形式写入输出中。
 void PersistenceDelegate.writeObject(Object oldInstance, Encoder out)
          writeObject 是持久性的一个入口点,由传统委托模式中的 Encoder 使用。
 

参数类型为 Objectjava.beans 中的构造方法
EventHandler(Object target, String action, String eventPropertyName, String listenerMethodName)
          创建一个新的 EventHandler 对象;通常使用 create 方法之一,而不是直接调用此构造方法。
Expression(Object value, Object target, String methodName, Object[] arguments)
          为某个返回结果的方法创建一个新的 Expression 对象。
Expression(Object value, Object target, String methodName, Object[] arguments)
          为某个返回结果的方法创建一个新的 Expression 对象。
Expression(Object target, String methodName, Object[] arguments)
          按照所给参数创建一个新的 Statement 对象,使其具有 targetmethodNamearguments
Expression(Object target, String methodName, Object[] arguments)
          按照所给参数创建一个新的 Statement 对象,使其具有 targetmethodNamearguments
IndexedPropertyChangeEvent(Object source, String propertyName, Object oldValue, Object newValue, int index)
          构造一个新的 IndexedPropertyChangeEvent 对象。
PropertyChangeEvent(Object source, String propertyName, Object oldValue, Object newValue)
          构造一个新的 PropertyChangeEvent
PropertyChangeSupport(Object sourceBean)
          构造一个 PropertyChangeSupport 对象。
PropertyEditorSupport(Object source)
          构造一个 PropertyEditorSupport 对象。
Statement(Object target, String methodName, Object[] arguments)
          按照所给参数创建一个新的 Statement 对象,使其具有 targetmethodNamearguments
Statement(Object target, String methodName, Object[] arguments)
          按照所给参数创建一个新的 Statement 对象,使其具有 targetmethodNamearguments
VetoableChangeSupport(Object sourceBean)
          构造一个 VetoableChangeSupport 对象。
XMLDecoder(InputStream in, Object owner)
          创建一个新的输入流,以读取由 XMLEncoder 类创建的档案。
XMLDecoder(InputStream in, Object owner, ExceptionListener exceptionListener)
          创建一个新的输入流,以读取由 XMLEncoder 类创建的档案。
XMLDecoder(InputStream in, Object owner, ExceptionListener exceptionListener, ClassLoader cl)
          创建一个新的输入流,以读取由 XMLEncoder 类创建的档案。
 

java.beans.beancontextObject 的使用
 

java.beans.beancontextObject 的子类
 class BeanContextChildSupport
           这是一个为实现 BeanContextChild 协议提供支持的一般支持类。
 class BeanContextEvent
           BeanContextEvent 是所有从 BeanContext 发出并与其语义有关事件的抽象根事件类。
 class BeanContextMembershipEvent
          BeanContextMembershipEvent 封装添加到特定 BeanContext 成员关系中(或从中移除)子级的列表。
 class BeanContextServiceAvailableEvent
           BeanContextServicesListener 使用此事件类型来标识将被注册的服务。
 class BeanContextServiceRevokedEvent
           BeanContextServiceRevokedListener 使用此事件类型来标识将被取消的服务。
 class BeanContextServicesSupport
           此帮助器类提供 java.beans.beancontext.BeanContextServices 接口的实用工具实现。
protected  class BeanContextServicesSupport.BCSSChild
           
protected  class BeanContextServicesSupport.BCSSProxyServiceProvider
           
protected static class BeanContextServicesSupport.BCSSServiceProvider
          子类可以为此嵌套类创建子类,以便为每个 BeanContextServicesProvider 添加行为。
 class BeanContextSupport
          此帮助器类提供 java.beans.beancontext.BeanContext 接口的实用工具实现。
protected  class BeanContextSupport.BCSChild
           
protected static class BeanContextSupport.BCSIterator
          受保护的最终子类,它封装一个迭代器但实现无操作 remove() 方法。
 

声明为 Objectjava.beans.beancontext 中的字段
static Object BeanContext.globalHierarchyLock
          BeanContextBeanContextServices 实现者均使用此全局锁定来序列化 BeanContext 中的更改和所有服务请求等。
 

返回 Objectjava.beans.beancontext 中的方法
protected  Object[] BeanContextSupport.copyChildren()
          获得此 BeanContext 子级的副本。
 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)
           
 Object BeanContext.instantiateChild(String beanName)
          实例化指定为此 BeanContext 的一个子级的 javaBean。
 Object BeanContextSupport.instantiateChild(String beanName)
           instantiateChild 方法是 BeanContext 中的便捷钩子 (hook),用来简化将嵌套的 Bean 实例化为 BeanContext 这项任务。
 Object BeanContextSupport.BCSIterator.next()
           
 Object[] BeanContextMembershipEvent.toArray()
          获得受此事件影响的子级的数组。
 Object[] BeanContextSupport.toArray()
          获得当前嵌套在此 BeanContext 中的所有 JavaBean 或 BeanContext 实例。
 Object[] BeanContextSupport.toArray(Object[] arry)
          获得包含与数组中所包含类型匹配的此 BeanContext 的所有子级的数组。
 

参数类型为 Objectjava.beans.beancontext 中的方法
 boolean BeanContextSupport.add(Object targetChild)
          在此 BeanContext 中添加/嵌套一个子级。
protected  void BeanContextSupport.childDeserializedHook(Object child, BeanContextSupport.BCSChild bcsc)
          由 readObject 利用新近反序列化的子级和 BCSChild 调用。
protected  void BeanContextSupport.childJustAddedHook(Object child, BeanContextSupport.BCSChild bcsc)
          子类可以重写此方法,以便在已经添加子对象之后,且在发生事件通知之前,只扩展 add() 语义。
protected  void BeanContextServicesSupport.childJustRemovedHook(Object child, BeanContextSupport.BCSChild bcsc)
          在已成功移除子级之后,从超类的子级移除操作中调用。
protected  void BeanContextSupport.childJustRemovedHook(Object child, BeanContextSupport.BCSChild bcsc)
          子类可以重写此方法,以便在已经移除子对象之后,且在发生事件通知之前,只扩展 remove() 语义。
 boolean BeanContextMembershipEvent.contains(Object child)
          指定子级受事件影响吗?
 boolean BeanContextSupport.contains(Object o)
          确定指定对象当前是否是此 BeanContext 的子级。
 boolean BeanContextSupport.containsKey(Object o)
          确定指定对象当前是否是此 BeanContext 的子级。
protected  BeanContextSupport.BCSChild BeanContextServicesSupport.createBCSChild(Object targetChild, Object peer)
           子类可以重写此方法来插入自己的 Child 的子类,而不必重写 add() 或其他将子级添加到集合中的 Collection 方法。
protected  BeanContextSupport.BCSChild BeanContextSupport.createBCSChild(Object targetChild, Object peer)
           子类可以重写此方法来插入自己的 Child 的子类,而不必重写 add() 或其他将子级添加到集合中的 Collection 方法。
 void BeanContextChildSupport.firePropertyChange(String name, Object oldValue, Object newValue)
          向所有已注册的侦听器报告绑定 (bound) 属性更新。
 void BeanContextChildSupport.fireVetoableChange(String name, Object oldValue, Object newValue)
          向所有已注册的侦听器报告 vetoable 属性更新。
protected static BeanContextChild BeanContextSupport.getChildBeanContextChild(Object child)
          与指定 Child 相关联的 BeanContextChild(如果有)。
protected static BeanContextMembershipListener BeanContextSupport.getChildBeanContextMembershipListener(Object child)
          与指定 Child 相关联的 BeanContextMembershipListener(如果有)。
protected static BeanContextServicesListener BeanContextServicesSupport.getChildBeanContextServicesListener(Object child)
          获得指定子级的 BeanContextServicesListener(如果有)。
protected static PropertyChangeListener BeanContextSupport.getChildPropertyChangeListener(Object child)
          与指定 Child 相关联的 PropertyChangeListener(如果有)
protected static Serializable BeanContextSupport.getChildSerializable(Object child)
          获得与指定 Child 相关联的 Serializable(如果有)
protected static VetoableChangeListener BeanContextSupport.getChildVetoableChangeListener(Object child)
          与指定 Child 相关联的 VetoableChangeListener(如果有)。
protected static Visibility BeanContextSupport.getChildVisibility(Object child)
          获得与指定子级相关联的 Component(如果有)。
 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)
           
 void BeanContextServices.releaseService(BeanContextChild child, Object requestor, Object service)
          通过在基础 BeanContextServiceProvider 上调用 releaseService() 释放 BeanContextChild(或与 BeanContextChild 关联的任意对象)对指定服务的引用。
 void BeanContextServicesSupport.releaseService(BeanContextChild child, Object requestor, Object service)
          释放服务。
 void BeanContextServiceProvider.releaseService(BeanContextServices bcs, Object requestor, Object service)
          由 BeanContextServices 调用,此方法释放一个对特定服务的嵌套 BeanContextChild(或与 BeanContextChild 关联的任意对象)的引用。
 void BeanContextServicesSupport.BCSSProxyServiceProvider.releaseService(BeanContextServices bcs, Object requestor, Object service)
           
 boolean BeanContextSupport.remove(Object targetChild)
          从此 BeanContext 中移除一个子对象。
protected  boolean BeanContextSupport.remove(Object targetChild, boolean callChildSetBC)
          当由意外的 setBeanContextremove() 调用导致移除时使用的内部移除方法。
 Object[] BeanContextSupport.toArray(Object[] arry)
          获得包含与数组中所包含类型匹配的此 BeanContext 的所有子级的数组。
protected  boolean BeanContextSupport.validatePendingAdd(Object targetChild)
           此类的子类可以重写或封装此方法,以便为 BeanContext 添加有效行为,从而能在将子对象添加到 BeanContext 之前立即检查它们。
protected  boolean BeanContextSupport.validatePendingRemove(Object targetChild)
           此类的子类可以重写或封装此方法,以便为 BeanContext 添加有效行为,从而能在将子对象从 BeanContext 中移除之前立即检查它们。
 

参数类型为 Objectjava.beans.beancontext 中的构造方法
BeanContextMembershipEvent(BeanContext bc, Object[] changes)
          构造一个 BeanContextMembershipEvent
 

java.ioObject 的使用
 

java.ioObject 的子类
 class BufferedInputStream
          BufferedInputStream 为另一个输入流添加一些功能,即缓冲输入以及支持 markreset 方法的能力。
 class BufferedOutputStream
          该类实现缓冲的输出流。
 class BufferedReader
          从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。
 class BufferedWriter
          将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。
 class ByteArrayInputStream
          ByteArrayInputStream 包含一个内部缓冲区,该缓冲区包含从流中读取的字节。
 class ByteArrayOutputStream
          此类实现了一个输出流,其中的数据被写入一个 byte 数组。
 class CharArrayReader
          此类实现一个可用作字符输入流的字符缓冲区。
 class CharArrayWriter
          此类实现一个可用作 Writer 的字符缓冲区。
 class CharConversionException
          用于字符转换异常的基类。
 class Console
          此类包含多个方法,可访问与当前 Java 虚拟机关联的基于字符的控制台设备(如果有)。
 class DataInputStream
          数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。
 class DataOutputStream
          数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。
 class EOFException
          当输入过程中意外到达文件或流的末尾时,抛出此异常。
 class File
          文件和目录路径名的抽象表示形式。
 class FileDescriptor
          文件描述符类的实例用作与基础机器有关的某种结构的不透明句柄,该结构表示开放文件、开放套接字或者字节的另一个源或接收者。
 class FileInputStream
          FileInputStream 从文件系统中的某个文件中获得输入字节。
 class FileNotFoundException
          当试图打开指定路径名表示的文件失败时,抛出此异常。
 class FileOutputStream
          文件输出流是用于将数据写入 FileFileDescriptor 的输出流。
 class FilePermission
          此类表示对文件和目录的访问。
 class FileReader
          用来读取字符文件的便捷类。
 class FileWriter
          用来写入字符文件的便捷类。
 class FilterInputStream
          FilterInputStream 包含其他一些输入流,它将这些流用作其基本数据源,它可以直接传输数据或提供一些额外的功能。
 class FilterOutputStream
          此类是过滤输出流的所有类的超类。
 class FilterReader
          用于读取已过滤的字符流的抽象类。
 class FilterWriter
          用于写入已过滤的字符流的抽象类。
 class InputStream
          此抽象类是表示字节输入流的所有类的超类。
 class InputStreamReader
          InputStreamReader 是字节流通向字符流的桥梁:它使用指定的 charset 读取字节并将其解码为字符。
 class InterruptedIOException
          I/O 操作已中断信号,抛出此异常。
 class InvalidClassException
          当 Serialization 运行时检测到某个类具有以下问题之一时,抛出此异常。
 class InvalidObjectException
          指示一个或多个反序列化对象未通过验证测试。
 class IOError
          当发生严重的 I/O 错误时,抛出此错误。
 class IOException
          当发生某种 I/O 异常时,抛出此异常。
 class LineNumberInputStream
          已过时。 此类错误假定字节能充分表示字符。从 JDK 1.1 开始,对字符流操作的首选方法是通过新字符流类(其中包括计算行号的类)进行操作。
 class LineNumberReader
          跟踪行号的缓冲字符输入流。
 class NotActiveException
          当序列化和反序列化不活动时,抛出此异常。
 class NotSerializableException
          当实例需要具有序列化接口时,抛出此异常。
 class ObjectInputStream
          ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。
static class ObjectInputStream.GetField
          提供对从输入流读取的持久字段的访问权限。
 class ObjectOutputStream
          ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。
static class ObjectOutputStream.PutField
          提供对要写入 ObjectOutput 的持久字段的编程访问。
 class ObjectStreamClass
          类的序列化描述符。
 class ObjectStreamException
          特定于 Object Stream 类的所有异常的超类。
 class ObjectStreamField
          Serializable 类中 Serializable 字段的描述。
 class OptionalDataException
          指示对象读取操作失败的异常,原因是无法读取流中的基本数据或已序列化对象的数据末尾。
 class OutputStream
          此抽象类是表示输出字节流的所有类的超类。
 class OutputStreamWriter
          OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的 charset 将要写入流中的字符编码成字节。
 class PipedInputStream
          管道输入流应该连接到管道输出流;管道输入流提供要写入管道输出流的所有数据字节。
 class PipedOutputStream
          可以将管道输出流连接到管道输入流来创建通信管道。
 class PipedReader
          传送的字符输入流。
 class PipedWriter
          传送的字符输出流。
 class PrintStream
          PrintStream 为其他输出流添加了功能,使它们能够方便地打印各种数据值表示形式。
 class PrintWriter
          向文本输出流打印对象的格式化表示形式。
 class PushbackInputStream
          PushbackInputStream 为另一个输入流添加性能,即“推回 (push back)”或“取消读取 (unread)”一个字节的能力。
 class PushbackReader
          允许将字符推回到流的字符流 reader。
 class RandomAccessFile
          此类的实例支持对随机访问文件的读取和写入。
 class Reader
          用于读取字符流的抽象类。
 class SequenceInputStream
          SequenceInputStream 表示其他输入流的逻辑串联。
 class SerializablePermission
          此类用于可序列化权限。
 class StreamCorruptedException
          当从对象流中读取的控制信息与内部一致性检查相冲突时,抛出此异常。
 class StreamTokenizer
          StreamTokenizer 类获取输入流并将其解析为“标记”,允许一次读取一个标记。
 class StringBufferInputStream
          已过时。 此类未能正确地将字符转换为字节。从 JDK 1.1 开始,从字符串创建流的首选方法是通过 StringReader 类进行创建。
 class StringReader
          其源为一个字符串的字符流。
 class StringWriter
          一个字符流,可以用其回收在字符串缓冲区中的输出来构造字符串。
 class SyncFailedException
          当 sync 操作失败时,抛出此异常。
 class UnsupportedEncodingException
          不支持字符编码。
 class UTFDataFormatException
          在数据输入流中或由实现该数据输入接口的任何类中以 UTF-8 修改版格式读取错误字符串时,抛出此异常。
 class WriteAbortedException
          在写入操作过程中抛出 ObjectStreamException 之一的信号。
 class Writer
          写入字符流的抽象类。
 

声明为 Objectjava.io 中的字段
protected  Object Reader.lock
          用于同步针对此流的操作的对象。
protected  Object Writer.lock
          用于同步针对此流的操作的对象。
 

返回 Objectjava.io 中的方法
abstract  Object ObjectInputStream.GetField.get(String name, Object val)
          从持久字段获取指定 Object 字段的值。
 Object ObjectInputStream.readObject()
          从 ObjectInputStream 读取对象。
 Object ObjectInput.readObject()
          读取并返回对象。
protected  Object ObjectInputStream.readObjectOverride()
          此方法由 ObjectOutputStream 的受信任子类调用,这些子类使用受保护的无参数构造方法构造 ObjectOutputStream。
 Object ObjectInputStream.readUnshared()
          从 ObjectInputStream 读取“非共享”对象。
protected  Object ObjectOutputStream.replaceObject(Object obj)
          在序列化期间,此方法允许 ObjectOutputStream 的受信任子类使用一个对象替代另一个对象。
protected  Object ObjectInputStream.resolveObject(Object obj)
          在反序列化期间,此方法允许 ObjectInputStream 的受信任子类使用一个对象替代另一个。
 

参数类型为 Objectjava.io 中的方法
 int ObjectStreamField.compareTo(Object obj)
          将此字段与另一个 ObjectStreamField 进行比较。
 boolean FilePermission.equals(Object obj)
          检查两个 FilePermission 对象是否相等。
 boolean File.equals(Object obj)
          测试此抽象路径名与给定对象是否相等。
 PrintWriter PrintWriter.format(Locale l, String format, Object... args)
          使用指定格式字符串和参数将一个格式化字符串写入此 writer 中。
 PrintStream PrintStream.format(Locale l, String format, Object... args)
          使用指定格式字符串和参数将格式化字符串写入此输出流中。
 Console Console.format(String fmt, Object... args)
          使用指定格式字符串和参数将格式化字符串写入此控制台的输出流中。
 PrintWriter PrintWriter.format(String format, Object... args)
          使用指定格式字符串和参数将一个格式化字符串写入此 writer 中。
 PrintStream PrintStream.format(String format, Object... args)
          使用指定格式字符串和参数将格式化字符串写入此输出流中。
abstract  Object ObjectInputStream.GetField.get(String name, Object val)
          从持久字段获取指定 Object 字段的值。
 void PrintWriter.print(Object obj)
          打印对象。
 void PrintStream.print(Object obj)
          打印对象。
 PrintWriter PrintWriter.printf(Locale l, String format, Object... args)
          使用指定格式字符串和参数将格式化的字符串写入此 writer 的便捷方法。
 PrintStream PrintStream.printf(Locale l, String format, Object... args)
          使用指定格式字符串和参数将格式化的字符串写入此输出流的便捷方法。
 Console Console.printf(String format, Object... args)
          使用指定格式字符串和参数将格式化字符串写入此控制台输出流的便捷方法。
 PrintWriter PrintWriter.printf(String format, Object... args)
          使用指定格式字符串和参数将格式化的字符串写入此 writer 的便捷方法。
 PrintStream PrintStream.printf(String format, Object... args)
          使用指定格式字符串和参数将格式化的字符串写入此输出流的便捷方法。
 void PrintWriter.println(Object x)
          打印 Object,然后终止该行。
 void PrintStream.println(Object x)
          打印 Object,然后终止该行。
abstract  void ObjectOutputStream.PutField.put(String name, Object val)
          将指定的 Object 字段的值置于持久字段中。
 String Console.readLine(String fmt, Object... args)
          提供一个格式化提示,然后从控制台读取单行文本。
 char[] Console.readPassword(String fmt, Object... args)
          提供一个格式化提示,然后从控制台读取密码,禁用回显。
protected  Object ObjectOutputStream.replaceObject(Object obj)
          在序列化期间,此方法允许 ObjectOutputStream 的受信任子类使用一个对象替代另一个对象。
protected  Object ObjectInputStream.resolveObject(Object obj)
          在反序列化期间,此方法允许 ObjectInputStream 的受信任子类使用一个对象替代另一个。
 void ObjectOutputStream.writeObject(Object obj)
          将指定的对象写入 ObjectOutputStream。
 void ObjectOutput.writeObject(Object obj)
          将对象写入底层存储或流。
protected  void ObjectOutputStream.writeObjectOverride(Object obj)
          子类用于重写默认 writeObject 方法的方法。
 void ObjectOutputStream.writeUnshared(Object obj)
          将“未共享”对象写入 ObjectOutputStream。
 

参数类型为 Objectjava.io 中的构造方法
Reader(Object lock)
          创建一个新的字符流 reader,其重要部分将同步给定的对象。
Writer(Object lock)
          创建一个新的字符流 writer,其关键部分将同步给定的对象。
 

java.langObject 的使用
 

java.langObject 的子类
 class AbstractMethodError
          当应用程序试图调用一个抽象方法时,抛出此错误。
 class ArithmeticException
          当出现异常的运算条件时,抛出此异常。
 class ArrayIndexOutOfBoundsException
          用非法索引访问数组时抛出的异常。
 class ArrayStoreException
          试图将错误类型的对象存储到一个对象数组时抛出的异常。
 class AssertionError
          抛出该异常指示某个断言失败。
 class Boolean
          Boolean 类将基本类型为 boolean 的值包装在一个对象中。
 class Byte
          Byte 类将基本类型 byte 的值包装在一个对象中。
 class Character
          Character 类在对象中包装一个基本类型 char 的值。
static class Character.Subset
          此类的实例表示 Unicode 字符集的特定子集。
static class Character.UnicodeBlock
          表示 Unicode 规范中字符块的一系列字符子集。
 class Class<T>
          Class 类的实例表示正在运行的 Java 应用程序中的类和接口。
 class ClassCastException
          当试图将对象强制转换为不是实例的子类时,抛出该异常。
 class ClassCircularityError
          当初始化类时检测到类的循环调用的时候,抛出该错误。
 class ClassFormatError
          当 Java 虚拟机试图读取类文件并确定该文件存在格式错误或无法解释为类文件时,抛出该错误。
 class ClassLoader
          类加载器是负责加载类的对象。
 class ClassNotFoundException
          当应用程序试图使用以下方法通过字符串名加载类时,抛出该异常: Class 类中的 forName 方法。
 class CloneNotSupportedException
          当调用 Object 类中的 clone 方法复制对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。
 class Compiler
          Compiler 类主要支持 Java 到本机代码的编译器及相关服务。
 class Double
          Double 类在对象中包装一个基本类型 double 的值。
 class Enum<E extends Enum<E>>
          这是所有 Java 语言枚举类型的公共基本类。
 class EnumConstantNotPresentException
          当应用程序试图通过名称和枚举类型访问那些不包含具有指定名称的常量的枚举常量时,抛出该异常。
 class Error
          ErrorThrowable 的子类,用于指示合理的应用程序不应该试图捕获的严重问题。
 class Exception
          Exception 类及其子类是 Throwable 的一种形式,它指出了合理的应用程序想要捕获的条件。
 class ExceptionInInitializerError
          静态初始化程序中发生意外异常的信号。
 class Float
          Float 类在对象中包装一个基本类型 float 的值。
 class IllegalAccessError
          当应用程序试图访问或修改它不能访问的字段,或调用它不能访问的方法时,抛出该异常。
 class IllegalAccessException
          当应用程序试图反射性地创建一个实例(而不是数组)、设置或获取一个字段,或者调用一个方法,但当前正在执行的方法无法访问指定类、字段、方法或构造方法的定义时,抛出 IllegalAccessException。
 class IllegalArgumentException
          抛出的异常表明向方法传递了一个不合法或不正确的参数。
 class IllegalMonitorStateException
          抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
 class IllegalStateException
          在非法或不适当的时间调用方法时产生的信号。
 class IllegalThreadStateException
          指示线程没有处于请求操作所要求的适当状态时抛出的异常。
 class IncompatibleClassChangeError
          在某些类定义中出现不兼容的类更改时抛出该异常。
 class IndexOutOfBoundsException
          指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。
 class InheritableThreadLocal<T>
          该类扩展了 ThreadLocal,为子线程提供从父线程那里继承的值:在创建子线程时,子线程会接收所有可继承的线程局部变量的初始值,以获得父线程所具有的值。
 class InstantiationError
          当应用程序试图使用 Java 的 new 结构来实例化一个抽象类或一个接口时,抛出该异常。
 class InstantiationException
          当应用程序试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象无法被实例化时,抛出该异常。
 class Integer
          Integer 类在对象中包装了一个基本类型 int 的值。
 class InternalError
          该异常指示 Java 虚拟机中出现一些意外的内部错误。
 class InterruptedException
          当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时,抛出该异常。
 class LinkageError
          LinkageError 的子类指示一个类在一定程度上依赖于另一个类;但是,在编译前一个类之后,后一个类发生了不相容的改变。
 class Long
          Long 类在对象中包装了基本类型 long 的值。
 class Math
          Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。
 class NegativeArraySizeException
          如果应用程序试图创建大小为负的数组,则抛出该异常。
 class NoClassDefFoundError
          当 Java 虚拟机或 ClassLoader 实例试图在类的定义中加载(作为通常方法调用的一部分或者作为使用 new 表达式创建的新实例的一部分),但无法找到该类的定义时,抛出此异常。
 class NoSuchFieldError
          如果应用程序试图访问或修改一个指定的对象字段,而该对象不再包含该字段时,抛出该异常。
 class NoSuchFieldException
          类不包含指定名称的字段时产生的信号。
 class NoSuchMethodError
          当应用程序试图调用类(静态或实例)的指定方法,而该类已不再具有该方法的定义时,抛出该异常。
 class NoSuchMethodException
          无法找到某一特定方法时,抛出该异常。
 class NullPointerException
          当应用程序试图在需要对象的地方使用 null 时,抛出该异常。
 class Number
          抽象类 NumberBigDecimalBigIntegerByteDoubleFloatIntegerLongShort 类的超类。
 class NumberFormatException
          当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。
 class OutOfMemoryError
          因为内存溢出或没有可用的内存提供给垃圾回收器时,Java 虚拟机无法分配一个对象,这时抛出该异常。
 class Package
          Package 对象包含有关 Java 包的实现和规范的版本信息。
 class Process
          ProcessBuilder.start()Runtime.exec 方法创建一个本机进程,并返回 Process 子类的一个实例,该实例可用来控制进程并获得相关信息。
 class ProcessBuilder
          此类用于创建操作系统进程。
 class Runtime
          每个 Java 应用程序都有一个 Runtime 类实例,使应用程序能够与其运行的环境相连接。
 class RuntimeException
          RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。
 class RuntimePermission
          该类用于运行时权限。
 class SecurityException
          由安全管理器抛出的异常,指示存在安全侵犯。
 class SecurityManager
          安全管理器是一个允许应用程序实现安全策略的类。
 class Short
          Short 类在对象中包装基本类型 short 的值。
 class StackOverflowError
          当应用程序递归太深而发生堆栈溢出时,抛出该错误。
 class StackTraceElement
          堆栈跟踪中的元素,它由 Throwable.getStackTrace() 返回。
 class StrictMath
          StrictMath 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。
 class String
          String 类代表字符串。
 class StringBuffer
          线程安全的可变字符序列。
 class StringBuilder
          一个可变的字符序列。
 class StringIndexOutOfBoundsException
          此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。
 class System
          System 类包含一些有用的类字段和方法。
 class Thread
          线程 是程序中的执行线程。
 class ThreadDeath
          调用 Thread 类中带有零参数的 stop 方法时,受害线程将抛出一个 ThreadDeath 实例。
 class ThreadGroup
          线程组表示一个线程的集合。
 class ThreadLocal<T>
          该类提供了线程局部 (thread-local) 变量。
 class Throwable
          Throwable 类是 Java 语言中所有错误或异常的超类。
 class TypeNotPresentException
          当应用程序试图使用表示类型名称的字符串对类型进行访问,但无法找到带有指定名称的类型定义时,抛出该异常。
 class UnknownError
          当 Java 虚拟机中出现一个未知但严重的异常时,抛出该错误。
 class UnsatisfiedLinkError
          当 Java 虚拟机无法找到声明为 native 的方法的适当本地语言定义时,抛出该错误。
 class UnsupportedClassVersionError
          当 Java 虚拟机试图读取一个类文件,并确定文件的主辅版本号不受支持时,抛出该错误。
 class UnsupportedOperationException
          当不支持请求的操作时,抛出该异常。
 class VerifyError
          当“校验器”检测到一个类文件虽然格式正确,但包含着一些内部不一致性或安全性问题时,抛出该错误。
 class VirtualMachineError
          当 Java 虚拟机崩溃或用尽了它继续操作所需的资源时,抛出该错误。
 class Void
          Void 类是一个不可实例化的占位符类,它持有对表示 Java 关键字 void 的 Class 对象的引用。
 

返回 Objectjava.lang 中的方法
protected  Object Enum.clone()
          抛出 CloneNotSupportedException。
protected  Object Object.clone()
          创建并返回此对象的一个副本。
static Object Compiler.command(Object any)
          检查参数类型及其字段,并执行一些文档操作。
 T[] Class.getEnumConstants()
          如果此 Class 对象不表示枚举类型,则返回枚举类的元素或 null。
 Object SecurityManager.getSecurityContext()
          创建一个封装当前执行环境的对象。
 Object[] Class.getSigners()
          获取此类的标记。
 

参数类型为 Objectjava.lang 中的方法
 StringBuilder StringBuilder.append(Object obj)
           
 StringBuffer StringBuffer.append(Object obj)
           
static void System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
          从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结束。
 T Class.cast(Object obj)
          将一个对象强制转换成此 Class 对象所表示的类或接口。
 void SecurityManager.checkConnect(String host, int port, Object context)
          如果不允许指定的安全上下文打开与指定主机和端口号的套接字连接,则抛出 SecurityException
 void SecurityManager.checkPermission(Permission perm, Object context)
          如果拒绝指定的安全上下文访问由给定权限所指定的资源,则抛出 SecurityException
 void SecurityManager.checkRead(String file, Object context)
          如果不允许指定的安全上下文读取由字符串参数所指定的文件,则抛出 SecurityException
 boolean SecurityManager.checkTopLevelWindow(Object window)
          如果不受信任的调用线程调出由 window 参数指出的顶层窗口,则返回 false
static Object Compiler.command(Object any)
          检查参数类型及其字段,并执行一些文档操作。
 boolean Enum.equals(Object other)
          当指定对象等于此枚举常量时,返回 true。
 boolean Long.equals(Object obj)
          将此对象与指定对象进行比较。
 boolean Integer.equals(Object obj)
          比较此对象与指定对象。
 boolean Short.equals(Object obj)
          将此对象与指定对象比较。
 boolean Byte.equals(Object obj)
          将此对象与指定对象比较。
 boolean Double.equals(Object obj)
          将此对象与指定对象比较。
 boolean Float.equals(Object obj)
          将此对象与指定对象进行比较。
 boolean Character.equals(Object obj)
          将此对象与指定对象比较。
 boolean Character.Subset.equals(Object obj)
          比较两个 Subset 对象的相等性。
 boolean Boolean.equals(Object obj)
          当且仅当参数不是 null,而是一个与此对象一样,都表示同一个 Boolean 值的 boolean 对象时,才返回 true
 boolean StackTraceElement.equals(Object obj)
          如果指定的对象是另一个 StackTraceElement 实例,并且该对象表示的执行点与该实例的相同,则返回 ture。
 boolean String.equals(Object anObject)
          将此字符串与指定的对象比较。
 boolean Object.equals(Object obj)
          指示其他某个对象是否与此对象“相等”。
static String String.format(Locale l, String format, Object... args)
          使用指定的语言环境、格式字符串和参数返回一个格式化字符串。
static String String.format(String format, Object... args)
          使用指定的格式字符串和参数返回一个格式化字符串。
static boolean Thread.holdsLock(Object obj)
          当且仅当当前线程在指定的对象上保持监视器锁时,才返回 true
static int System.identityHashCode(Object x)
          返回给定对象的哈希码,该代码与默认的方法 hashCode() 返回的代码一样,无论给定对象的类是否重写 hashCode()。
 StringBuilder StringBuilder.insert(int offset, Object obj)
           
 StringBuffer StringBuffer.insert(int offset, Object obj)
           
 boolean Class.isInstance(Object obj)
          判定指定的 Object 是否与此 Class 所表示的对象赋值兼容。
protected  void ClassLoader.setSigners(Class<?> c, Object[] signers)
          设置类的签署者。
static String String.valueOf(Object obj)
          返回 Object 参数的字符串表示形式。
 

参数类型为 Objectjava.lang 中的构造方法
AssertionError(Object detailMessage)
          构造一个 AssertionError,其详细消息派生于指定的对象,该对象将根据 The Java Language Specification 第二版 第 15.18.1.1 节中的定义转换为一个字符串。
 

java.lang.annotationObject 的使用
 

java.lang.annotationObject 的子类
 class AnnotationFormatError
          当注释解析器试图从类文件读取注释并确定注释出现异常时,抛出该错误。
 class AnnotationTypeMismatchException
          若某个注释的类型在对该注释进行编译(或序列化)后发生了更改,而程序试图访问该注释的元素时,抛出此异常。
 class IncompleteAnnotationException
          若某个注释在编译(或序列化)后将某个注释类型添加到其类型定义中,而程序试图该注释类型的元素时,抛出此异常。
 

参数类型为 Objectjava.lang.annotation 中的方法
 boolean Annotation.equals(Object obj)
          如果指定的对象表示在逻辑上等效于此接口的注释,则返回 true。
 

java.lang.instrumentObject 的使用
 

java.lang.instrumentObject 的子类
 class ClassDefinition
          此类用作 Instrumentation.redefineClasses 方法的参数锁定。
 class IllegalClassFormatException
          当其输入参数无效时,由 ClassFileTransformer.transform 的实现抛出该异常。
 class UnmodifiableClassException
          在无法修改指定类之一时,由 Instrumentation.redefineClasses 的实现抛出此异常。
 

参数类型为 Objectjava.lang.instrument 中的方法
 long Instrumentation.getObjectSize(Object objectToSize)
          返回指定对象使用的特定于实现的近似存储量。
 

java.lang.managementObject 的使用
 

java.lang.managementObject 的子类
 class LockInfo
          关于 的信息。
 class ManagementFactory
          ManagementFactory 类是一种工厂类,用于获取 Java 平台的管理 Bean。
 class ManagementPermission
          使用 SecurityManager 运行的代码调用 Java 平台的管理接口中定义的方法时,SecurityManager 将要检查的权限。
 class MemoryNotificationInfo
          关于内存通知的信息。
 class MemoryUsage
          表示内存使用量快照的 MemoryUsage 对象。
 class MonitorInfo
          关于对象监视器锁的信息。
 class ThreadInfo
          线程信息。
 

java.lang.refObject 的使用
 

java.lang.refObject 的子类
 class PhantomReference<T>
          虚引用对象,在回收器确定其指示对象可另外回收之后,被加入队列。
 class Reference<T>
          引用对象的抽象基类。
 class ReferenceQueue<T>
          引用队列,在检测到适当的可到达性更改后,垃圾回收器将已注册的引用对象添加到该队列中。
 class SoftReference<T>
          软引用对象,在响应内存需要时,由垃圾回收器决定是否清除此对象。
 class WeakReference<T>
          弱引用对象,它们并不禁止其指示对象变得可终结,并被终结,然后被回收。
 

java.lang.reflectObject 的使用
 

java.lang.reflectObject 的子类
 class AccessibleObject
          AccessibleObject 类是 Field、Method 和 Constructor 对象的基类。
 class Array
          Array 类提供了动态创建和访问 Java 数组的方法。
 class Constructor<T>
          Constructor 提供关于类的单个构造方法的信息以及对它的访问权限。
 class Field
          Field 提供有关类或接口的单个字段的信息,以及对它的动态访问权限。
 class GenericSignatureFormatError
          当需要解释类型、方法或构造方法的一般签名信息的反射方法遇到语法错误的签名属性时,抛出该错误。
 class InvocationTargetException
          InvocationTargetException 是一种包装由调用方法或构造方法所抛出异常的经过检查的异常。
 class MalformedParameterizedTypeException
          当反射方法遇到语义错误的参数化类型,而反射方法需要实例化该类型时,抛出该异常。
 class Method
          Method 提供关于类或接口上单独某个方法(以及如何访问该方法)的信息。
 class Modifier
          Modifier 类提供了 static 方法和常量,对类和成员访问修饰符进行解码。
 class Proxy
          Proxy 提供用于创建动态代理类和实例的静态方法,它还是由这些方法创建的所有动态代理类的超类。
 class ReflectPermission
          反射操作的 Permission 类。
 class UndeclaredThrowableException
          如果代理实例的调用处理程序的 invoke 方法抛出一个经过检查的异常(不可分配给 RuntimeExceptionErrorThrowable),且该异常不可分配给该方法(在代理实例上调用该方法,并将其指派到调用处理程序)的 throws 子句中声明的任何异常类,则由代理实例上的方法调用抛出此异常。
 

返回 Objectjava.lang.reflect 中的方法
 Object Field.get(Object obj)
          返回指定对象上此 Field 表示的字段的值。
static Object Array.get(Object array, int index)
          返回指定数组对象中索引组件的值。
 Object Method.getDefaultValue()
          返回由此 Method 实例表示的注释成员的默认值。
 Object InvocationHandler.invoke(Object proxy, Method method, Object[] args)
          在代理实例上处理方法调用并返回结果。
 Object Method.invoke(Object obj, Object... args)
          对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
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)
          返回一个指定接口的代理类实例,该接口可以将方法调用指派到指定的调用处理程序。
 

参数类型为 Objectjava.lang.reflect 中的方法
 boolean Constructor.equals(Object obj)
          将此 Constructor 对象与指定的对象进行比较。
 boolean Method.equals(Object obj)
          将此 Method 与指定对象进行比较。
 boolean Field.equals(Object obj)
          将此 Field 与指定对象比较。
 Object Field.get(Object obj)
          返回指定对象上此 Field 表示的字段的值。
static Object Array.get(Object array, int index)
          返回指定数组对象中索引组件的值。
 boolean Field.getBoolean(Object obj)
          获取一个静态或实例 boolean 字段的值。
static boolean Array.getBoolean(Object array, int index)
          以 boolean 形式返回指定数组对象中索引组件的值。
 byte Field.getByte(Object obj)
          获取一个静态或实例 byte 字段的值。
static byte Array.getByte(Object array, int index)
          以 byte 形式返回指定数组对象中索引组件的值。
 char Field.getChar(Object obj)
          获取 char 类型或另一个通过扩展转换可以转换为 char 类型的基本类型的静态或实例字段的值。
static char Array.getChar(Object array, int index)
          以 char 形式返回指定数组对象中索引组件的值。
 double Field.getDouble(Object obj)
          获取 double 类型或另一个通过扩展转换可以转换为 double 类型的基本类型的静态或实例字段的值。
static double Array.getDouble(Object array, int index)
          以 double 形式返回指定数组对象中索引组件的值。
 float Field.getFloat(Object obj)
          获取 float 类型或另一个通过扩展转换可以转换为 float 类型的基本类型的静态或实例字段的值。
static float Array.getFloat(Object array, int index)
          以 float 形式返回指定数组对象中索引组件的值。
 int Field.getInt(Object obj)
          获取 int 类型或另一个通过扩展转换可以转换为 int 类型的基本类型的静态或实例字段的值。
static int Array.getInt(Object array, int index)
          以 int 形式返回指定数组对象中索引组件的值。
static InvocationHandler Proxy.getInvocationHandler(Object proxy)
          返回指定代理实例的调用处理程序。
static int Array.getLength(Object array)
          以 int 形式返回指定数组对象的长度。
 long Field.getLong(Object obj)
          获取 long 类型或另一个通过扩展转换可以转换为 long 类型的基本类型的静态或实例字段的值。
static long Array.getLong(Object array, int index)
          以 long 形式返回指定数组对象中索引组件的值。
 short Field.getShort(Object obj)
          获取 short 类型或另一个通过扩展转换可以转换为 short 类型的基本类型的静态或实例字段的值。
static short Array.getShort(Object array, int index)
          以 short 形式返回指定数组对象中索引组件的值。
 Object InvocationHandler.invoke(Object proxy, Method method, Object[] args)
          在代理实例上处理方法调用并返回结果。
 Object InvocationHandler.invoke(Object proxy, Method method, Object[] args)
          在代理实例上处理方法调用并返回结果。
 Object Method.invoke(Object obj, Object... args)
          对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
 Object Method.invoke(Object obj, Object... args)
          对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
 T Constructor.newInstance(Object... initargs)
          使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例,并用指定的初始化参数初始化该实例。
static void Array.set(Object array, int index, Object value)
          将指定数组对象中索引组件的值设置为指定的新值。
 void Field.set(Object obj, Object value)
          将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
 void Field.setBoolean(Object obj, boolean z)
          将字段的值设置为指定对象上的一个 boolean 值。
static void Array.setBoolean(Object array, int index, boolean z)
          将指定数组对象中索引组件的值设置为指定的 boolean 值。
 void Field.setByte(Object obj, byte b)
          将字段的值设置为指定对象上的一个 byte 值。
static void Array.setByte(Object array, int index, byte b)
          将指定数组对象中索引组件的值设置为指定的 byte 值。
 void Field.setChar(Object obj, char c)
          将字段的值设置为指定对象上的一个 char 值。
static void Array.setChar(Object array, int index, char c)
          将指定数组对象中索引组件的值设置为指定的 char 值。
 void Field.setDouble(Object obj, double d)
          将字段的值设置为指定对象上的一个 double 值。
static void Array.setDouble(Object array, int index, double d)
          将指定数组对象中索引组件的值设置为指定的 double 值。
 void Field.setFloat(Object obj, float f)
          将字段的值设置为指定对象上的一个 float 值。
static void Array.setFloat(Object array, int index, float f)
          将指定数组对象中索引组件的值设置为指定的 float 值。
 void Field.setInt(Object obj, int i)
          将字段的值设置为指定对象上的一个 int 值。
static void Array.setInt(Object array, int index, int i)
          将指定数组对象中索引组件的值设置为指定的 int 值。
static void Array.setLong(Object array, int index, long l)
          将指定数组对象中索引组件的值设置为指定的 long 值。
 void Field.setLong(Object obj, long l)
          将字段的值设置为指定对象上的一个 long 值。
static void Array.setShort(Object array, int index, short s)
          将指定数组对象中索引组件的值设置为指定的 short 值。
 void Field.setShort(Object obj, short s)
          将字段的值设置为指定对象上的一个 short 值。
 

java.mathObject 的使用
 

java.mathObject 的子类
 class BigDecimal
          不可变的、任意精度的有符号十进制数。
 class BigInteger
          不可变的任意精度的整数。
 class MathContext
          该对象是封装上下文设置的不可变对象,它描述数字运算符的某些规则,例如由 BigDecimal 类实现的规则。
 

参数类型为 Objectjava.math 中的方法
 boolean BigDecimal.equals(Object x)
          比较此 BigDecimal 与指定的 Object 的相等性。
 boolean MathContext.equals(Object x)
          将此 MathContext 与指定的 Object 进行相等性比较。
 boolean BigInteger.equals(Object x)
          比较此 BigInteger 与指定的 Object 的相等性。
 

java.netObject 的使用
 

java.netObject 的子类
 class Authenticator
          Authenticator 类表示懂得如何获得网络连接验证的对象。
 class BindException
          试图将套接字绑定到本地地址和端口时发生错误的情况下,抛出此异常。
 class CacheRequest
          表示在 ResponseCache 中存储资源的通道。
 class CacheResponse
          表示从 ResponseCache 获取资源的通道。
 class ContentHandler
          抽象类 ContentHandler 是从 URLConnection 读取 Object 的所有类的超类。
 class CookieHandler
          CookieHandler 对象提供一种回调机制以将 HTTP 状态管理策略实现挂钩到 HTTP 协议处理程序。
 class CookieManager
          CookieManager 提供 CookieHandler 的具体实现,它将 cookie 的存储区与围绕接受和拒绝 cookie 的策略分离开来。
 class DatagramPacket
          此类表示数据报包。
 class DatagramSocket
          此类表示用来发送和接收数据报包的套接字。
 class DatagramSocketImpl
          数据报和多播套接字实现的抽象基类。
 class HttpCookie
          HttpCookie 对象表示一个 http cookie,该 cookie 带有服务器和用户代理之间的状态信息。
 class HttpRetryException
          抛出此异常指示 HTTP 请求需要重试,但由于启用了流模式而无法自动重试。
 class HttpURLConnection
          支持 HTTP 特定功能的 URLConnection。
 class IDN
          提供在普通 Unicode 表示形式和 ASCII 兼容性编码 (ACE) 表示形式之间进行国际化域名 (IDN) 转换的方法。
 class Inet4Address
          此类表示 Internet Protocol version 4 (IPv4) 地址。
 class Inet6Address
          此类表示互联网协议第 6 版 (IPv6) 地址。
 class InetAddress
          此类表示互联网协议 (IP) 地址。
 class InetSocketAddress
          此类实现 IP 套接字地址(IP 地址 + 端口号)。
 class InterfaceAddress
          此类表示网络接口地址。
 class JarURLConnection
          连接到 Java ARchive (JAR) 文件或 JAR 文件中条目的 URL Connection。
 class MalformedURLException
          抛出这一异常指示出现了错误的 URL。
 class MulticastSocket
          多播数据报套接字类用于发送和接收 IP 多播包。
 class NetPermission
          此类可用于各种网络权限。
 class NetworkInterface
          此类表示一个由名称和分配给此接口的 IP 地址列表组成的网络接口。
 class NoRouteToHostException
          试图将套接字连接到远程地址和端口时发生错误的情况下,抛出此异常。
 class PasswordAuthentication
          PasswordAuthentication 类是供 Authenticator 使用的数据持有者。
 class PortUnreachableException
          在连接的数据报上已接收到 ICMP Port Unreachable 消息时,抛出该异常。
 class ProtocolException
          抛出此异常指示在底层协议中存在错误,如 TCP 错误。
 class ProxySelector
          连接到 URL 引用的网络资源时选择要使用的代理服务器(如果有)。
 class ResponseCache
          表示 URLConnection 缓存的实现。
 class SecureCacheResponse
          表示最初通过安全方法(如 TLS)获得的缓存响应。
 class ServerSocket
          此类实现服务器套接字。
 class Socket
          此类实现客户端套接字(也可以就叫“套接字”)。
 class SocketAddress
          此类表示不带任何协议附件的 Socket Address。
 class SocketException
          抛出此异常指示在底层协议中存在错误,如 TCP 错误。
 class SocketImpl
          抽象类 SocketImpl 是实际实现套接字的所有类的通用超类。
 class SocketPermission
          此类表示通过套接字对网络的访问。
 class SocketTimeoutException
          如果在读取或接受套接字时发生超时,则抛出此异常。
 class UnknownHostException
          指示主机 IP 地址无法确定而抛出的异常。
 class UnknownServiceException
          抛出这一异常指示出现了未知服务异常。
 class URI
          表示一个统一资源标识符 (URI) 引用。
 class URISyntaxException
          抛出经过检查的指示字符串不能解析为 URI 引用的异常。
 class URL
          类 URL 代表一个统一资源定位符,它是指向互联网“资源”的指针。
 class URLClassLoader
          该类加载器用于从指向 JAR 文件和目录的 URL 的搜索路径加载类和资源。
 class URLConnection
          抽象类 URLConnection 是所有类的超类,它代表应用程序和 URL 之间的通信链接。
 class URLDecoder
          HTML 格式解码的实用工具类。
 class URLEncoder
          HTML 格式编码的实用工具类。
 class URLStreamHandler
          抽象类 URLStreamHandler 是所有流协议处理程序的通用超类。
 

返回 Objectjava.net 中的方法
 Object HttpCookie.clone()
          创建并返回此对象的一个副本。
 Object URLConnection.getContent()
          获取此 URL 连接的内容。
 Object URL.getContent()
          获取此 URL 的内容。
 Object URLConnection.getContent(Class[] classes)
          获取此 URL 连接的内容。
 Object URL.getContent(Class[] classes)
          获取此 URL 的内容。
abstract  Object ContentHandler.getContent(URLConnection urlc)
          如果给出位于对象表示形式开头的 URL 连接流,则此方法读取该流并根据其创建对象。
 Object ContentHandler.getContent(URLConnection urlc, Class[] classes)
          如果给出位于对象表示形式开头的 URL 连接流,则此方法读取该流并创建与给定类型之一匹配的对象。
 Object SocketOptions.getOption(int optID)
          获取选项的值。
 

参数类型为 Objectjava.net 中的方法
 boolean HttpCookie.equals(Object obj)
          测试两个 http cookie 的相等性。
 boolean SocketPermission.equals(Object obj)
          检查两个 SocketPermission 对象的相等性。
 boolean InterfaceAddress.equals(Object obj)
          将此对象与指定对象比较。
 boolean NetworkInterface.equals(Object obj)
          将此对象与指定对象比较。
 boolean Proxy.equals(Object obj)
          将此对象与指定对象比较。
 boolean URI.equals(Object ob)
          测试此 URI 与另一对象的相等性。
 boolean Inet6Address.equals(Object obj)
          将此对象与指定对象比较。
 boolean InetSocketAddress.equals(Object obj)
          将此对象与指定对象比较。
 boolean Inet4Address.equals(Object obj)
          将此对象与指定对象比较。
 boolean InetAddress.equals(Object obj)
          将此对象与指定对象比较。
 boolean URL.equals(Object obj)
          比较此 URL 是否等于另一个对象。
 void SocketOptions.setOption(int optID, Object value)
          启用/禁用 optID 指定的选项。
 

java.nioObject 的使用
 

java.nioObject 的子类
 class Buffer
          一个用于特定基本类型数据的容器。
 class BufferOverflowException
          当相关 put 操作达到目标缓冲区限制时,抛出此未经检查的异常。
 class BufferUnderflowException
          当相关 get 操作达到源缓冲区限制时,抛出此未经检查的异常。
 class ByteBuffer
          字节缓冲区。
 class ByteOrder
          字节顺序的类型安全枚举。
 class CharBuffer
          字符缓冲区。
 class DoubleBuffer
          double 缓冲区。
 class FloatBuffer
          float 缓冲区。
 class IntBuffer
          int 缓冲区。
 class InvalidMarkException
          当试图重置一个尚未定义其标记的缓冲区时,抛出此未检查的异常。
 class LongBuffer
          long 缓冲区。
 class MappedByteBuffer
          直接字节缓冲区,其内容是文件的内存映射区域。
 class ReadOnlyBufferException
          当在只读缓冲区上调用内容可变(content-mutation)的方法(例如 putcompact 方法)时,抛出此未经检查的异常。
 class ShortBuffer
          short 缓冲区。
 

返回 Objectjava.nio 中的方法
abstract  Object Buffer.array()
          返回此缓冲区的底层实现数组(可选操作)
 

参数类型为 Objectjava.nio 中的方法
 boolean DoubleBuffer.equals(Object ob)
          判断此缓冲区是否与另一个对象相同。
 boolean FloatBuffer.equals(Object ob)
          判断此缓冲区是否与另一个对象相同。
 boolean LongBuffer.equals(Object ob)
          判断此缓冲区是否与另一个对象相同。
 boolean ShortBuffer.equals(Object ob)
          判断此缓冲区是否与另一个对象相同。
 boolean IntBuffer.equals(Object ob)
          判断此缓冲区是否与另一个对象相同。
 boolean CharBuffer.equals(Object ob)
          判断此缓冲区是否与另一个对象相同。
 boolean ByteBuffer.equals(Object ob)
          判断此缓冲区是否与另一个对象相同。
 

java.nio.channelsObject 的使用
 

java.nio.channelsObject 的子类
 class AlreadyConnectedException
          试图对已经连接的 SocketChannel 进行连接时抛出的未经检查的异常。
 class AsynchronousCloseException
          当在某个信道的 I/O 操作中处于阻塞状态的某个线程被另一个线程关闭了该信道或部分信道时,该信道所接收的经过检查的异常。
 class CancelledKeyException
          当试图使用不再有效的选择键时,抛出此未经检查的异常。
 class Channels
          针对信道和流的实用工具方法。
 class ClosedByInterruptException
          当在某个信道的 I/O 操作中处于阻塞状态的某个线程被另一个线程中断时,该线程将收到此经过检查的异常。
 class ClosedChannelException
          当试图对已关闭的、或者至少对某个 I/O 操作已关闭的信道上调用或完成该操作时,抛出此经过检查的异常。
 class ClosedSelectorException
          试图在已关闭的选择器上调用 I/O 操作时抛出的未经检查的异常。
 class ConnectionPendingException
          试图连接一个正在进行非阻塞连接操作的 SocketChannel 时抛出的未经检查的异常。
 class DatagramChannel
          针对面向数据报套接字的可选择通道。
 class FileChannel
          用于读取、写入、映射和操作文件的通道。
static class FileChannel.MapMode
          文件映射模式的类型安全的枚举。
 class FileLock
          表示文件区域锁定的标记。
 class FileLockInterruptionException
          当某个线程正在等待获取文件锁定时被另一个线程中断,则由该线程接收此经过检查的异常。
 class IllegalBlockingModeException
          当以错误的阻塞模式调用特定于某个阻塞模式的操作时,抛出此未经检查的异常。
 class IllegalSelectorException
          试图将一个通道注册到一个不是由创建该通道的提供者所创建的选择器时,抛出此未经检查的异常。
 class NoConnectionPendingException
          在没有首先成功调用 connect 方法的情况下调用 SocketChannelfinishConnect 方法时,抛出此未经检查的异常。
 class NonReadableChannelException
          试图对一个最初未允许对其进行读取操作的通道进行读取时,抛出此未经检查的异常。
 class NonWritableChannelException
          试图对一个最初未允许对其进行写入操作的通道进行写入时,抛出此未经检查的异常。
 class NotYetBoundException
          试图在尚未绑定的服务器套接字通道上调用 I/O 操作时,抛出此未经检查的异常。
 class NotYetConnectedException
          试图在尚未连接的套接字通道上调用 I/O 操作时,抛出此未经检查的异常。
 class OverlappingFileLockException
          试图获取某个文件区域上的锁定,而该区域与同一 Java 虚拟机已锁定的某个区域重叠时,或者当另一个线程已经等待锁定同一文件的重叠区域时,抛出此未经检查的异常。
 class Pipe
          实现单向管道传送的通道对。
static class Pipe.SinkChannel
          表示 Pipe 的可写入结尾的通道。
static class Pipe.SourceChannel
          表示 Pipe 的可读取结尾的通道。
 class SelectableChannel
          可通过 Selector 实现多路复用的通道。
 class SelectionKey
          表示 SelectableChannelSelector 中的注册的标记。
 class Selector
          SelectableChannel 对象的多路复用器。
 class ServerSocketChannel
          针对面向流的侦听套接字的可选择通道。
 class SocketChannel
          针对面向流的连接套接字的可选择通道。
 class UnresolvedAddressException
          试图对未解析的套接字地址调用网络操作时,抛出此未经检查的异常。
 class UnsupportedAddressTypeException
          试图绑定或连接到一个其类型不受支持的套接字地址时,抛出此未经检查的异常。
 

返回 Objectjava.nio.channels 中的方法
 Object SelectionKey.attach(Object ob)
          将给定的对象附加到此键。
 Object SelectionKey.attachment()
          获取当前的附加对象。
abstract  Object SelectableChannel.blockingLock()
          获取其 configureBlockingregister 方法实现同步的对象。
 

参数类型为 Objectjava.nio.channels 中的方法
 Object SelectionKey.attach(Object ob)
          将给定的对象附加到此键。
abstract  SelectionKey SelectableChannel.register(Selector sel, int ops, Object att)
          向给定的选择器注册此通道,返回一个选择键。
 

java.nio.channels.spiObject 的使用
 

java.nio.channels.spiObject 的子类
 class AbstractInterruptibleChannel
          可中断通道的基本实现类。
 class AbstractSelectableChannel
          可选择通道的基本实现类。
 class AbstractSelectionKey
          选择键的基本实现类。
 class AbstractSelector
          选择器的基本实现类。
 class SelectorProvider
          用于选择器和可选择通道的服务提供者类。
 

返回 Objectjava.nio.channels.spi 中的方法
 Object AbstractSelectableChannel.blockingLock()
           
 

参数类型为 Objectjava.nio.channels.spi 中的方法
protected abstract  SelectionKey AbstractSelector.register(AbstractSelectableChannel ch, int ops, Object att)
          向此选择器注册给定的通道。
 SelectionKey AbstractSelectableChannel.register(Selector sel, int ops, Object att)
          向给定的选择器注册此通道,返回一个选择键。
 

java.nio.charsetObject 的使用
 

java.nio.charsetObject 的子类
 class CharacterCodingException
          出现字符编码或解码错误时,抛出此经过检查的异常。
 class Charset
          16 位的 Unicode 代码单元序列和字节序列之间的指定映射关系。
 class CharsetDecoder
          能够把特定 charset 中的字节序列转换成 16 位 Unicode 字符序列的引擎。
 class CharsetEncoder
          能够把 16 位 Unicode 字符序列转换成特定 charset 中字节序列的引擎。
 class CoderMalfunctionError
          当 CharsetDecoderdecodeLoop 方法,或 CharsetEncoderencodeLoop 方法抛出不可预料的异常时抛出的错误。
 class CoderResult
          coder 结果状态的描述。
 class CodingErrorAction
          编码错误操作的类型安全的枚举。
 class IllegalCharsetNameException
          将一个不是合法 charset 名称的字符串用作 charset 名称时,抛出此未经检查的异常。
 class MalformedInputException
          当输入字节序列对于给定 charset 来说是不合法的,或者输入字符序列不是合法的 16 位 Unicode 序列时,抛出此经过检查的异常。
 class UnmappableCharacterException
          当输入字符(或字节)序列有效,但不能被映射为输出字节(或字符)序列时,抛出此经过检查的异常。
 class UnsupportedCharsetException
          当不支持请求的 charset 时,抛出此未经检查的异常。
 

参数类型为 Objectjava.nio.charset 中的方法
 boolean Charset.equals(Object ob)
          通知此对象是否和其他对象相等。
 

java.nio.charset.spiObject 的使用
 

java.nio.charset.spiObject 的子类
 class CharsetProvider
          Charset 服务提供者类。
 

java.rmiObject 的使用
 

java.rmiObject 的子类
 class AccessException
          AccessExceptionjava.rmi.Naming 类(特别是 bindrebindunbind)的某些方法和 java.rmi.activation.ActivationSystem 接口的方法抛出,以指示调用方不允许执行该方法调用所请求的操作。
 class AlreadyBoundException
          如果试图将注册表中的对象绑定到已具有相关绑定的名称上,则抛出 AlreadyBoundException
 class ConnectException
          如果拒绝远程主机对连接的远程方法调用,则抛出 ConnectException
 class ConnectIOException
          如果在连接到远程主机以便进行远程方法调用时发生 IOException,则抛出 ConnectIOException
 class MarshalledObject<T>
          MarshalledObject 包含一个字节流,该流具有给定了其构造方法的对象的序列化表示形式。
 class Naming
          Naming 类提供在对象注册表中存储和获得远程对远程对象引用的方法。
 class NoSuchObjectException
          如果试图调用远程虚拟机上已不存在的对象上的方法,则抛出 NoSuchObjectException
 class NotBoundException
          如果试图在注册表中查找或解绑没有相关绑定的名称,则抛出 NotBoundException
 class RemoteException
          RemoteException 是许多与通信相关的异常的通用超类,这些异常可能会在执行远程方法调用期间发生。
 class RMISecurityException
          已过时。 SecurityException 取代。应用程序代码从来不应直接引用此类,且 RMISecurityManager 不再抛出 java.lang.SecurityException 的这个子类。
 class RMISecurityManager
          由使用下载的代码的 RMI 应用程序使用的 SecurityManager 的子类。
 class ServerError
          当在服务器上处理远程方法调用时(既可以是解编参数、执行远程方法本身时,也可以是编组返回值时),如果抛出 Error,则作为远程方法调用的结果,将抛出 ServerError
 class ServerException
          在服务器上处理远程方法调用(既可以在解编参数时,也可以是在执行远程方法本身时)时,如果抛出 RemoteException,则作为远程方法调用的结果,也会抛出 ServerException
 class ServerRuntimeException
          已过时。 无替换版本
 class StubNotFoundException
          如果在导入某个远程对象时无法找到该对象的有效 stub 类,则抛出 StubNotFoundException
 class UnexpectedException
          如果远程方法调用的客户机因为该调用而收到一个未经检查的异常(该异常不属于远程接口方法的 throws 语句中声明的经检查的异常类型),则抛出 UnexpectedException
 class UnmarshalException
          在解组参数时或者如果发生以下任何情况导致远程方法调用,则抛出 UnmarshalException: 如果在解组调用标题时发生异常 如果返回值的协议无效 如果解组参数(在服务器端)或返回值(在客户机端)时发生 java.io.IOException
 

参数类型为 Objectjava.rmi 中的方法
 boolean MarshalledObject.equals(Object obj)
          将此 MarshalledObject 与另一对象进行比较。
 

java.rmi.activationObject 的使用
 

java.rmi.activationObject 的子类
 class Activatable
          Activatable 类为那些需要进行持久访问并能由系统激活的远程对象提供支持。
 class ActivateFailedException
          在一个对可激活对象的远程调用过程中,当激活失败时,此异常由 RMI 运行时抛出。
 class ActivationDesc
          激活描述符包含激活对象所必需的信息: 对象的组标识符, 对象的完全限定的类名, 对象的代码基(类中的位置),一个代码基 URL 路径, 对象的重启“模式”,以及 一个可包含特定于对象的初始化数据的“编组”对象。
 class ActivationException
          激活接口所使用的一般异常。
 class ActivationGroup
          ActivationGroup 负责创建组中“可激活”对象的新实例,在以下情况通知其 ActivationMonitor:它的对象变成活动的或者不活动的,或者整个组变成不活动的。
 class ActivationGroup_Stub
          ActivationGroup_Stub 是一个当作 java.rmi.server.UnicastRemoteObject 被导出的 java.rmi.activation.ActivationGroup 子类的 stub 类。
 class ActivationGroupDesc
          激活组描述符包含了创建/重建在其中激活对象的一个激活组所必需的信息。
static class ActivationGroupDesc.CommandEnvironment
          ActivationGroup 实现的启动选项。
 class ActivationGroupID
          针对一个注册激活组的标识符,它完成几个目标: 在激活系统中唯一地标识该组,以及 包含指向该组的激活系统的引用,以便该组在必要时能够联络上其激活系统。
 class ActivationID
          激活利用特定的标识符来表示远程对象,对象能随着时间被激活。
 class UnknownGroupException
          当 java.rmi.activation 包中类和接口的方法的 ActivationGroupID 参数被确定为无效时(即不为 ActivationSystem 所知),则这些方法将抛出一个 UnknownGroupException
 class UnknownObjectException
          当 java.rmi.activation 包中类和接口的方法的 ActivationID 参数被确定为无效时,这些方法将抛出一个 UnknownObjectException
 

参数类型为 Objectjava.rmi.activation 中的方法
 boolean ActivationDesc.equals(Object obj)
          比较两个激活描述符的内容相等性。
 boolean ActivationGroupDesc.equals(Object obj)
          比较两个激活组描述符的内容相等性。
 boolean ActivationGroupDesc.CommandEnvironment.equals(Object obj)
          比较两个命令环境的内容相等性。
 boolean ActivationGroupID.equals(Object obj)
          比较两个组标识符的内容相等性。
 boolean ActivationID.equals(Object obj)
          比较两个激活 id 的内容相等性。
 

java.rmi.dgcObject 的使用
 

java.rmi.dgcObject 的子类
 class Lease
          一个 lease 包含了一个唯一的 VM 标识符和一个租借期限。
 class VMID
          VMID 是跨所有 Java 虚拟机都唯一的标识符。
 

参数类型为 Objectjava.rmi.dgc 中的方法
 boolean VMID.equals(Object obj)
          将此 VMID 与另一个进行比较,如果它们是同一标识符,则返回 true。
 

java.rmi.registryObject 的使用
 

java.rmi.registryObject 的子类
 class LocateRegistry
          LocateRegistry 用于获得对特定主机(包括本地主机)上引导远程对象注册表的引用,或用于创建一个接受对特定端口调用的远程对象注册表。
 

java.rmi.serverObject 的使用
 

java.rmi.serverObject 的子类
 class ExportException
          ExportException 是在尝试导出远程对象失败时抛出的 RemoteException
 class LogStream
          已过时。 无替代版本
 class ObjID
          ObjID 是用于标识导出到 RMI 运行时的远程对象。
 class Operation
          已过时。 无替代版本
 class RemoteObject
          该 RemoteObject 类实现远程对象的 java.lang.Object 行为。
 class RemoteObjectInvocationHandler
          与 Java Remote Method Invocation(Java 远程方法调用,即 Java RMI)一起使用的 InvocationHandler 接口的实现。
 class RemoteServer
          该 RemoteServer 类是服务器实现的公共超类,并提供支持大量远程引用语义的框架。
 class RemoteStub
          该 RemoteStub 类是客户机 stub 的公共超类,并提供支持大量远程引用语义的框架。
 class RMIClassLoader
          RMIClassLoader 包含支持用 RMI 进行动态类加载的静态方法。
 class RMIClassLoaderSpi
          RMIClassLoaderSpiRMIClassLoader 的服务提供者接口。
 class RMISocketFactory
          RMISocketFactory 实例由 RMI 运行时使用,以便获得 RMI 调用所需的客户机和服务器套接字。
 class ServerCloneException
          如果在复制 UnicastRemoteObject 的过程中发生远程异常,则抛出 ServerCloneException
 class ServerNotActiveException
          如果在服务于远程方法调用之外调用 getClientHost 方法,则 ServerNotActiveException 是在调用 RemoteServer.getClientHost 的过程中抛出的 Exception
 class SkeletonMismatchException
          已过时。 无替代版本。在 Java 2 平台 1.2 版及更高版本中,远程方法调用不再需要 Skeleton。
 class SkeletonNotFoundException
          已过时。 无替代版本在 Java 2 平台 1.2 版及更高版本中,远程方法调用不再需要 Skeleton。
 class SocketSecurityException
          已废弃的 ExportException 的子类。
 class UID
          UID 表示一个和生成它的主机的时间有关的唯一标识符,或者是 216 个“熟知”标识符之一。
 class UnicastRemoteObject
          用于导出带 JRMP 的远程对象和获得与该远程对象通信的 stub。
 

返回 Objectjava.rmi.server 中的方法
 Object UnicastRemoteObject.clone()
          返回与初始对象不同的远程对象的副本。
 Object LoaderHandler.getSecurityContext(ClassLoader loader)
          已过时。 无替代版本
static Object RMIClassLoader.getSecurityContext(ClassLoader loader)
          已过时。 无替换版本。从 Java 2 平台 v1.2 开始,RMI 不再使用此方法来获取类加载器的安全上下文。
 Object RemoteObjectInvocationHandler.invoke(Object proxy, Method method, Object[] args)
          处理在封装的代理实例 proxy 上进行的方法调用并返回结果。
 Object RemoteRef.invoke(Remote obj, Method method, Object[] params, long opnum)
          调用某个方法。
 

参数类型为 Objectjava.rmi.server 中的方法
 boolean ObjID.equals(Object obj)
          比较指定对象与此 ObjID 是否相等。
 boolean RemoteObject.equals(Object obj)
          比较两个远程对象是否相等。
 boolean UID.equals(Object obj)
          比较给定对象与此 UID 的相等性。
 RemoteStub ServerRef.exportObject(Remote obj, Object data)
          为提供的 Remote 对象创建客户机 stub 对象。
 Object RemoteObjectInvocationHandler.invoke(Object proxy, Method method, Object[] args)
          处理在封装的代理实例 proxy 上进行的方法调用并返回结果。
 Object RemoteObjectInvocationHandler.invoke(Object proxy, Method method, Object[] args)
          处理在封装的代理实例 proxy 上进行的方法调用并返回结果。
 Object RemoteRef.invoke(Remote obj, Method method, Object[] params, long opnum)
          调用某个方法。
 

java.securityObject 的使用
 

java.securityObject 的子类
 class AccessControlContext
          AccessControlContext 用于基于它所封装的上下文作出系统资源访问决定。
 class AccessControlException
           此异常由 AccessController 抛出,提示请求的访问(对关键系统资源(如文件系统或网络)的访问)被拒绝。
 class AccessController
           AccessController 类用于与访问控制相关的操作和决定。
 class AlgorithmParameterGenerator
          AlgorithmParameterGenerator 类用于生成将在某个特定算法中使用的参数集合。
 class AlgorithmParameterGeneratorSpi
          此类为 AlgorithmParameterGenerator 类定义服务提供者接口 (SPI),AlgorithmParameterGenerator 类用于生成在某个特定算法中使用的参数集合。
 class AlgorithmParameters
          此类用作密码参数的不透明表示形式。
 class AlgorithmParametersSpi
          此类为 AlgorithmParameters 类定义服务提供者接口 (SPI),AlgorithmParameters 类用于管理算法参数。
 class AllPermission
          AllPermission 是暗含所有其他权限的权限。
 class AuthProvider
          此类定义 provider 的登录和注销方法。
 class BasicPermission
          BasicPermission 类扩展 Permission 类,并且可以用作希望与 BasicPermission 遵守相同命名约定的权限的基类。
 class CodeSigner
          此类封装关于代码签名者的信息。
 class CodeSource
          此类扩展 codebase 的概念,不仅可以封装位置 (URL) 而且可以封装用于验证起源于该位置的签名代码的证书链。
 class DigestException
          此为一般 Message Digest 异常。
 class DigestInputStream
          使用通过流的位更新关联消息摘要的透明流。
 class DigestOutputStream
          使用通过流的位更新关联消息摘要的透明流。
 class GeneralSecurityException
          GeneralSecurityException 类是一个一般安全异常类,可以为所有从其扩展的与安全有关的异常类提供类型安全。
 class GuardedObject
          GuardedObject 是一个用来保护对另一个对象的访问的对象。
 class Identity
          已过时。 不再使用此类。其功能已经由 java.security.KeyStorejava.security.cert 包和 java.security.Principal 取代。
 class IdentityScope
          已过时。 此类不再被使用。其功能已经由 java.security.KeyStorejava.security.cert 包和 java.security.Principal 取代。
 class InvalidAlgorithmParameterException
          用于无效或不合适的算法参数的异常。
 class InvalidKeyException
          用于无效 Key(无效的编码、错误的长度、未初始化等)的异常。
 class InvalidParameterException
          当将无效参数传递给某个方法时抛出此异常,设计该异常供 JCA/JCE 引擎类使用。
 class KeyException
          此异常是基本的密钥异常。
 class KeyFactory
          密钥工厂用于将密钥Key 类型的不透明加密密钥)转换成密钥规范(底层密钥材料的透明表示),反之亦然。
 class KeyFactorySpi
          此类为 KeyFactory 类定义服务提供者接口 (SPI)。
 class KeyManagementException
          此异常是用于所有处理密钥管理的操作的通用密钥管理异常。
 class KeyPair
          此类是简单的密钥对(公钥和私钥)持有者。
 class KeyPairGenerator
          KeyPairGenerator 类用于生成公钥和私钥对。
 class KeyPairGeneratorSpi
           此类为用来生成公钥和私钥的 KeyPairGenerator 类定义了服务提供者接口 (SPI)。
 class KeyRep
          已序列化的 Key 对象的标准表示形式。
 class KeyStore
          此类表示密钥和证书的存储设施。
static class KeyStore.Builder
          将被实例化的 KeyStore 对象的描述。
static class KeyStore.CallbackHandlerProtection
          封装 CallbackHandler 的 ProtectionParameter。
static class KeyStore.PasswordProtection
          ProtectionParameter 的一个基于密码的实现。
static class KeyStore.PrivateKeyEntry
          保存 PrivateKey 和相应证书链的 KeyStore 项。
static class KeyStore.SecretKeyEntry
          保存 SecretKeyKeyStore 项。
static class KeyStore.TrustedCertificateEntry
          保存可信的 CertificateKeyStore 项。
 class KeyStoreException
          这是一般的 KeyStore 异常。
 class KeyStoreSpi
          此类为 KeyStore 类定义服务提供者接口 (SPI)。
 class MessageDigest
          此 MessageDigest 类为应用程序提供信息摘要算法的功能,如 MD5 或 SHA 算法。
 class MessageDigestSpi
          此类为 MessageDigest 类定义服务提供者接口 (SPI),MessageDigest 类提供信息摘要算法的功能,如 MD5 或 SHA。
 class NoSuchAlgorithmException
          当请求特定的加密算法而它在该环境中不可用时抛出此异常。
 class NoSuchProviderException
          当请求特定安全性 provider 但它在该环境中不可用时抛出此异常。
 class Permission
          表示访问系统资源的抽象类。
 class PermissionCollection
          表示 Permission 对象集合的抽象类。
 class Permissions
          此类表示一个不同种类的 Permission 集合。
 class Policy
          Policy 对象负责确定在 Java 运行时环境中执行的代码是否有权执行安全敏感的操作。
 class PolicySpi
          此类为 Policy 类定义服务提供者接口 (SPI)。
 class PrivilegedActionException
          doPrivileged(PrivilegedExceptionAction)doPrivileged(PrivilegedExceptionAction, AccessControlContext context) 抛出此异常来指示执行的操作抛出了经过检查的异常。
 class ProtectionDomain
           此 ProtectionDomain 类封装域的特征,域中包装一个类集合,在代表给定的主体集合执行这些类的实例时会授予它们一个权限集合。
static class Provider.Service
          安全服务的描述。
 class ProviderException
          用于 Provider 异常(例如误配置错误或不可恢复的内部错误)的运行时异常,Provider 可以为它创建子类以抛出特殊的、特定于 provider 的运行时错误。
 class SecureClassLoader
          此类扩展了 ClassLoader,使它另外还支持使用相关的代码源和权限定义类,这些代码源和权限默认情况下可根据系统策略获取到。
 class SecureRandom
          此类提供强加密随机数生成器 (RNG)。
 class SecureRandomSpi
          此类为 SecureRandom 类定义了服务提供者接口 (SPI)。
 class Security
          此类集中了所有的安全属性和常见的安全方法。
 class SecurityPermission
          此类用于安全权限。
 class Signature
          此 Signature 类用来为应用程序提供数字签名算法功能。
 class SignatureException
          这是一般的签名异常。
 class SignatureSpi
          此类为 Signature 类定义了服务提供者接口 (SPI),可用来提供数字签名算法功能。
 class SignedObject
           SignedObject 是一个用来创建实际运行时对象的类,在检测不到这些对象的情况下,其完整性不会遭受损害。
 class Signer
          已过时。 将不再使用此类。其功能已由 java.security.KeyStorejava.security.cert 包和 java.security.Principal 所取代。
 class Timestamp
          此类封装有关签署时间戳的信息。
 class UnrecoverableEntryException
          如果 keystore 中的某项无法恢复,则抛出此异常。
 class UnrecoverableKeyException
          如果 keystore 中的密钥无法恢复,则抛出此异常。
 class UnresolvedPermission
          UnresolvedPermission 类用来保持初始化 Policy 时“未解析”的权限。
 class URIParameter
          包含一个 URI 的参数,该 URI 指向用于 PolicySpi 或 ConfigurationSpi 实现的数据。
 

返回 Objectjava.security 中的方法
 Object Signature.clone()
          如果此实现可以复制,则返回副本。
 Object SignatureSpi.clone()
          如果此实现可以复制,则返回一个副本。
 Object MessageDigest.clone()
          如果实现是可复制的,则返回一个副本。
 Object MessageDigestSpi.clone()
          如果实现是可复制的,则返回一个副本。
protected abstract  Object SignatureSpi.engineGetParameter(String param)
          已过时。  
 Object Provider.get(Object key)
           
 Object GuardedObject.getObject()
          获取受保护对象;如果 guard 拒绝了对受保护对象的访问,则抛出异常。
 Object SignedObject.getObject()
          获取已封装的对象。
 Object Signature.getParameter(String param)
          已过时。  
 Object Provider.Service.newInstance(Object constructorParameter)
          返回此服务描述的实现的新实例。
 Object Provider.put(Object key, Object value)
          设置 key 属性,使其具有指定的 value
protected  Object KeyRep.readResolve()
          解析 Key 对象。
 Object Provider.remove(Object key)
          移除 key 属性(及其相应的 value)。
 

返回变量类型为 Object 的类型的 java.security 中的方法
 Enumeration<Object> Provider.elements()
           
 Set<Map.Entry<Object,Object>> Provider.entrySet()
          返回此 Provider 中所包含的属性项的一个不可修改的 Set 视图。
 Set<Map.Entry<Object,Object>> Provider.entrySet()
          返回此 Provider 中所包含的属性项的一个不可修改的 Set 视图。
 Enumeration<Object> Provider.keys()
           
 Set<Object> Provider.keySet()
          返回此 provider 中所包含的属性键的一个不可修改的 Set 视图。
 Collection<Object> Provider.values()
          返回此 provider 中所包含的属性值的一个不可修改的 Collection 视图。
 

参数类型为 Objectjava.security 中的方法
 void Permission.checkGuard(Object object)
          为某权限实现 guard 接口。
 void Guard.checkGuard(Object object)
          确定是否允许访问受保护的 object 对象。
protected abstract  void SignatureSpi.engineSetParameter(String param, Object value)
          已过时。 engineSetParameter 取代。
 boolean Identity.equals(Object identity)
          已过时。 测试指定对象与此 Identity 的相等性。
 boolean Timestamp.equals(Object obj)
          比较指定的对象和此时间戳之间的相同性。
 boolean CodeSigner.equals(Object obj)
          测试指定对象与此代码签名者之间是否相等。
 boolean Principal.equals(Object another)
          将此主体与指定对象比较。
 boolean UnresolvedPermission.equals(Object obj)
          检查两个 UnresolvedPermission 对象的相等性。
 boolean AllPermission.equals(Object obj)
          检查两个 AllPermission 对象是否相等。
 boolean CodeSource.equals(Object obj)
          测试指定对象与此对象之间的相等性。
 boolean BasicPermission.equals(Object obj)
          检查两个 BasicPermission 对象是否相等。
abstract  boolean Permission.equals(Object obj)
          检查两个 Permission 对象是否相等。
 boolean AccessControlContext.equals(Object obj)
          检查两个 AccessControlContext 对象是否相等。
 Object Provider.get(Object key)
           
 Object Provider.Service.newInstance(Object constructorParameter)
          返回此服务描述的实现的新实例。
 Object Provider.put(Object key, Object value)
          设置 key 属性,使其具有指定的 value
 Object Provider.remove(Object key)
          移除 key 属性(及其相应的 value)。
 void Signature.setParameter(String param, Object value)
          已过时。 使用 setParameter 取代。
 boolean Provider.Service.supportsParameter(Object parameter)
          测试此 Service 是否能使用指定的参数。
 

参数类型为 Objectjava.security 中的构造方法
GuardedObject(Object object, Guard guard)
          使用指定的对象和 guard 构造 GuardedObject。
 

java.security.aclObject 的使用
 

java.security.aclObject 的子类
 class AclNotFoundException
          如果对不存在的 ACL(访问控制列表)进行引用,则抛出此异常。
 class LastOwnerException
          如果试图删除访问控制列表的最后一个所有者,则抛出此异常。
 class NotOwnerException
          当只允许对象(如访问控制列表)的所有者修改对象,但是试图进行修改的 Principal 不是所有者时,抛出此异常。
 

返回 Objectjava.security.acl 中的方法
 Object AclEntry.clone()
          复制此 ACL 项。
 

参数类型为 Objectjava.security.acl 中的方法
 boolean Permission.equals(Object another)
          如果传递的对象与此接口中所表示的权限相匹配,则返回 true。
 

java.security.certObject 的使用
 

java.security.certObject 的子类
 class Certificate
          管理各种身份证书的抽象类。
protected static class Certificate.CertificateRep
          用于序列化的替换 Certificate 类。
 class CertificateFactory
          此类定义了用于从相关的编码中生成证书、证书路径 (CertPath) 和证书撤消列表 (CRL) 对象的 CertificateFactory 功能。
 class CertificateFactorySpi
          此类定义了 CertificateFactory 类的服务提供者接口 (SPI)。
 class CertPath
          不可变的证书序列(证书路径)。
protected static class CertPath.CertPathRep
          用于序列化的替换 CertPath 类。
 class CertPathBuilder
          构建证书路径(也称为证书链)的类。
 class CertPathBuilderException
          指示在使用 CertPathBuilder 构建证书路径时遇到了某种问题的异常。
 class CertPathBuilderSpi
          CertPathBuilder 类的服务提供者接口 (SPI)。
 class CertPathValidator
          验证证书路径(也称为证书链)的类。
 class CertPathValidatorException
          指示在验证一个证书路径时遇到了某种问题的异常。
 class CertPathValidatorSpi
          CertPathValidator 类的服务提供者接口 (SPI)。
 class CertStore
          用于从存储库中获取 CertificateCRL 的类。
 class CertStoreException
          指示从 CertStore 中获取证书和 CRL 时遇到了某种问题的异常。
 class CertStoreSpi
          CertStore 类的服务提供者接口 (SPI)。
 class CollectionCertStoreParameters
          用作 Collection CertStore 算法输入的参数。
 class CRL
          此类是具有不同格式但很常用的证书撤消列表 (CRL) 的抽象。
 class CRLException
          CRL(证书撤消列表)异常。
 class LDAPCertStoreParameters
          用作 LDAP CertStore 算法的输入的参数。
 class PKIXBuilderParameters
          用作 PKIX CertPathBuilder 算法的输入的参数。
 class PKIXCertPathBuilderResult
          此类表示 PKIX 证书路径生成器算法执行成功时所返回的结果。
 class PKIXCertPathChecker
          对 X509Certificate 执行一种或多种检查的抽象类。
 class PKIXCertPathValidatorResult
          此类表示 PKIX 证书路径验证算法执行成功时所返回的结果。
 class PKIXParameters
          用作 PKIX CertPathValidator 算法的输入的参数。
 class PolicyQualifierInfo
          由 ASN.1 PolicyQualifierInfo 结构所表示的、不可变的策略限定符。
 class TrustAnchor
          一个信任定位点或最受信任的证书颁发机构 (CA)。
 class X509Certificate
           X.509 证书的抽象类。
 class X509CertSelector
          选择与所有指定标准匹配的 X509CertificatesCertSelector
 class X509CRL
           X.509 证书撤消列表 (CRL) 的抽象类。
 class X509CRLEntry
          用于 CRL(证书撤消列表)中已撤消证书的抽象类。
 class X509CRLSelector
          选择与所有指定标准相匹配的 X509CRLCRLSelector
 

返回 Objectjava.security.cert 中的方法
 Object CRLSelector.clone()
          对此 CRLSelector 进行复制。
 Object CertPathBuilderResult.clone()
          对此 CertPathBuilderResult 进行复制。
 Object CertPathParameters.clone()
          对此 CertPathParameters 进行复制。
 Object CertPathValidatorResult.clone()
          对此 CertPathValidatorResult 进行复制。
 Object CertSelector.clone()
          对此 CertSelector 进行复制。
 Object CertStoreParameters.clone()
          对此 CertStoreParameters 进行复制。
 Object CollectionCertStoreParameters.clone()
          返回此对象的副本。
 Object LDAPCertStoreParameters.clone()
          返回此对象的副本。
 Object PKIXCertPathChecker.clone()
          返回此对象的副本。
 Object PKIXCertPathValidatorResult.clone()
          返回此对象的副本。
 Object PKIXParameters.clone()
          对此 PKIXParameters 对象进行复制。
 Object X509CRLSelector.clone()
          返回此对象的副本。
 Object X509CertSelector.clone()
          返回此对象的副本。
protected  Object CertPath.CertPathRep.readResolve()
          返回根据类型和数据所构造的 CertPath
protected  Object Certificate.CertificateRep.readResolve()
          解析该 Certificate 对象。
protected  Object CertPath.writeReplace()
          使用 CertPathRep 对象替换要被序列化的 CertPath
protected  Object Certificate.writeReplace()
          替换要被序列化的 Certificate。
 

返回变量类型为 Object 的类型的 java.security.cert 中的方法
 Collection<Object> X509CRLSelector.getIssuerNames()
          返回该 issuerNames 标准的一个副本。
 

参数类型为 Objectjava.security.cert 中的方法
 boolean X509CRL.equals(Object other)
          比较此 CRL 与给定对象的相等性。
 boolean X509CRLEntry.equals(Object other)
          比较此 CRL 项与给定对象的相等性。
 boolean CertPath.equals(Object other)
          比较此证书路径与指定对象的相等性。
 boolean Certificate.equals(Object other)
          比较此证书与指定对象的相等性。
 

java.security.specObject 的使用
 

java.security.specObject 的子类
 class DSAParameterSpec
          此类指定用于 DSA 算法的参数的集合。
 class DSAPrivateKeySpec
          此类指定带关联参数的 DSA 专用密钥。
 class DSAPublicKeySpec
          此类指定带关联参数的 DSA 公用密钥。
 class ECFieldF2m
          此不可变类定义椭圆曲线 (EC) 首数为 2 的有限字段。
 class ECFieldFp
          此不可变类定义椭圆曲线 (EC) 素数的有限字段。
 class ECGenParameterSpec
          此不可变类指定用于生成椭圆曲线 (EC) 域参数的参数集。
 class ECParameterSpec
          此不可变类指定用于椭圆曲线加密方法 (ECC) 的域参数集。
 class ECPoint
          此不可变类在仿射坐标中表示椭圆曲线 (EC) 上的点。
 class ECPrivateKeySpec
          此不可变类指定带关联参数的椭圆曲线专用密钥。
 class ECPublicKeySpec
          此不可变类指定带关联参数的椭圆曲线公用密钥。
 class EllipticCurve
          此不可变类持有表示椭圆曲线所必需的值。
 class EncodedKeySpec
          此类用编码格式表示公用密钥或专用密钥。
 class InvalidKeySpecException
          这是针对无效密钥规范的异常。
 class InvalidParameterSpecException
          这是针对无效参数规范的异常。
 class MGF1ParameterSpec
          此类指定 OAEP Padding 和 RSA-PSS 签名方案中的掩码生成函数 MGF1(如 PKCS #1 v2.1 标准中所定义的)使用的参数集。
 class PKCS8EncodedKeySpec
          此类表示按照 ASN.1 类型 PrivateKeyInfo 进行编码的专用密钥的 ASN.1 编码。
 class PSSParameterSpec
          此类指定 RSA-PSS 签名方案的参数规范,如 PKCS#1 v2.1 标准中所定义的。
 class RSAKeyGenParameterSpec
          此类指定用于生成 RSA 密钥对的参数集。
 class RSAMultiPrimePrivateCrtKeySpec
          如 PKCS#1 v2.1 中所定义的,此类为了提高效率,使用 Chinese Remainder Theorem (CRT) 信息值指定 RSA 多素数专用密钥。
 class RSAOtherPrimeInfo
          此类表示 RSA 的 OtherPrimeInfo 结构中的三元组(素数、指数和素数),如 PKCS#1 v2.1 中所定义的。
 class RSAPrivateCrtKeySpec
          为了提高效率,此类根据 PKCS#1 标准所定义的,使用 Chinese Remainder Theorem(中国剩余定理,CRT)信息值指定一个 RSA 专用密钥。
 class RSAPrivateKeySpec
          此类指定 RSA 专用密钥。
 class RSAPublicKeySpec
          此类指定 RSA 公用密钥。
 class X509EncodedKeySpec
          此类表示根据 ASN.1 类型 SubjectPublicKeyInfo 进行编码的公用密钥的 ASN.1 编码。
 

参数类型为 Objectjava.security.spec 中的方法
 boolean ECFieldF2m.equals(Object obj)
          比较此有限字段与指定对象的相等性。
 boolean ECFieldFp.equals(Object obj)
          比较此素数有限字段与指定对象的相等性。
 boolean ECPoint.equals(Object obj)
          比较此椭圆曲线点与指定对象的相等性。
 boolean EllipticCurve.equals(Object obj)
          比较此椭圆曲线与指定对象的相等性。
 

java.sqlObject 的使用
 

java.sqlObject 的子类
 class BatchUpdateException
          进行批量更新操作期间发生错误时抛出的 SQLException 子类。
 class DataTruncation
          以 DataTruncation 异常形式抛出的异常(写入时),或者由于除数据值超出 MaxFieldSize 之外的某种原因意外地截断该数据值时以 DataTruncation 警告形式报告的异常(读取时)。
 class DriverManager
          管理一组 JDBC 驱动程序的基本服务。
 class DriverPropertyInfo
          用于建立连接的驱动程序属性。
 class SQLClientInfoException
          当无法在 Connection 上设置一个或多个客户端信息属性时,抛出此 SQLException 的子类。
 class SQLDataException
          当 SQLState 类值为“22”时抛出的 SQLException 子类。
 class SQLException
          提供关于数据库访问错误或其他错误信息的异常。
 class SQLFeatureNotSupportedException
          当 SQLState 类值为“0A”(值为“零”A)时抛出的 SQLException 子类。
 class SQLIntegrityConstraintViolationException
          当 SQLState 类值为“23”时抛出的 SQLException 子类。
 class SQLInvalidAuthorizationSpecException
          当 SQLState 类值为“28”时抛出的 SQLException 子类。
 class SQLNonTransientConnectionException
           SQLState 类值为“08”时抛出的 SQLException 子类,表示在失败原因没有纠正的情况下重试操作时,失败的连接操作不会成功。
 class SQLNonTransientException
          重试相同操作将失败(除非纠正了 SQLException 的 cause)的情况下抛出的 SQLException 子类。
 class SQLPermission
          SecurityManager 将用来检查在 applet 中运行的代码何时调用 DriverManager.setLogWriter 方法或 DriverManager.setLogStream(不建议使用)方法的权限。
 class SQLRecoverableException
          应用程序执行某些恢复步骤并重试整个事务或事务分支(在分布式事务中)后,可以成功执行先前失败操作的情况下抛出的 SQLException 子类。
 class SQLSyntaxErrorException
          当 SQLState 类值为“42”时抛出的 SQLException 子类。
 class SQLTimeoutException
          Statement 指定的超时已到期时抛出的 SQLException 子类。
 class SQLTransactionRollbackException
          当 SQLState 类值为“40”时,抛出此 SQLException 的子类。
 class SQLTransientConnectionException
          SQLState 类值为“08”时抛出的 SQLException 子类,表示在没有进行任何应用程序级更改的情况下重试操作时,失败的连接操作可以成功。
 class SQLTransientException
          没有任何应用程序级功能干预时,重试先前失败操作可以成功的情况下抛出的 SQLException 子类。
 class SQLWarning
          提供关于数据库访问警告信息的异常。
 class Time
          一个与 java.util.Date 类有关的瘦包装器 (thin wrapper),它允许 JDBC 将该类标识为 SQL TIME 值。
 class Types
          定义用于标识一般 SQL 类型(称为 JDBC 类型)的常量的类。
 

返回 Objectjava.sql 中的方法
 Object Array.getArray()
          以 Java 编程语言数组的形式获取由此 Array 对象指定的 SQL ARRAY 值的内容。
 Object Array.getArray(long index, int count)
          获取由此 Array 对象指定的 SQL ARRAY 值的一部分,从指定 index 开始,包含 SQL 数组中 count 个连续元素。
 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()
          生成此 Struct 对象所表示的 SQL 结构类型属性的有序值。
 Object[] Struct.getAttributes(Map<String,Class<?>> map)
          生成此 Struct 对象所表示的 SQL 结构类型的属性的有序值。
 Object Ref.getObject()
          获取此 Ref 对象引用的 SQL 结构类型实例。
 Object CallableStatement.getObject(int parameterIndex)
          以 Java 编程语言中 Object 的形式获取指定参数的值。
 Object ResultSet.getObject(int columnIndex)
          以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
 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)
          以 Java 编程语言中 Object 的形式获取参数的值。
 Object ResultSet.getObject(String columnLabel)
          以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
 Object CallableStatement.getObject(String parameterName, Map<String,Class<?>> map)
          返回一个表示 OUT 参数 parameterName 值的对象,并将 map 用于该参数值的自定义映射关系。
 Object ResultSet.getObject(String columnLabel, Map<String,Class<?>> map)
          以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
 Object SQLInput.readObject()
          读取流头中的下一个属性并将其作为 Java 编程语言中的 Object 返回。
 

参数类型为 Objectjava.sql 中的方法
 Array Connection.createArrayOf(String typeName, Object[] elements)
          创建 Array 对象的工厂方法。
 Struct Connection.createStruct(String typeName, Object[] attributes)
          创建 Struct 对象的工厂方法。
 boolean RowId.equals(Object obj)
          将此 RowId 与指定对象比较。
 boolean Timestamp.equals(Object ts)
          测试此对象是否等于给定的 Timestamp 对象。
 void PreparedStatement.setObject(int parameterIndex, Object x)
          使用给定对象设置指定参数的值。
 void PreparedStatement.setObject(int parameterIndex, Object x, int targetSqlType)
          使用给定对象设置指定参数的值。
 void PreparedStatement.setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength)
          使用给定对象设置指定参数的值。
 void Ref.setObject(Object value)
          将此 Ref 对象引用的结构类型值设置为给定的 Object 实例。
 void CallableStatement.setObject(String parameterName, Object x)
          使用给定对象设置指定参数的值。
 void CallableStatement.setObject(String parameterName, Object x, int targetSqlType)
          使用给定对象设置指定参数的值。
 void CallableStatement.setObject(String parameterName, Object x, int targetSqlType, int scale)
          使用给定对象设置指定参数的值。
 void ResultSet.updateObject(int columnIndex, Object x)
          用 Object 值更新指定列。
 void ResultSet.updateObject(int columnIndex, Object x, int scaleOrLength)
          用 Object 值更新指定列。
 void ResultSet.updateObject(String columnLabel, Object x)
          用 Object 值更新指定列。
 void ResultSet.updateObject(String columnLabel, Object x, int scaleOrLength)
          用 Object 值更新指定列。
 

java.textObject 的使用
 

java.textObject 的子类
 class Annotation
          如果文本属性具有 annotation 特征,则 Annotation 对象用作文本属性值的包装器。
static class AttributedCharacterIterator.Attribute
          定义用于标识文本属性的属性键。
 class AttributedString
          AttributedString 保存文本及相关属性信息。
 class Bidi
          此类实现了 Unicode 双向算法 (Unicode Bidirectional Algorithm)。
 class BreakIterator
          BreakIterator 类实现用于查找文本中边界位置的方法。
 class ChoiceFormat
          ChoiceFormat 允许将格式应用到某个范围的数。
 class CollationElementIterator
          CollationElementIterator 类用作一个迭代器,以遍历国际化字符串的每个字符。
 class CollationKey
          CollationKey 表示遵守特定 Collator 对象规则的 String
 class Collator
          Collator 类执行区分语言环境的 String 比较。
 class DateFormat
          DateFormat 是日期/时间格式化子类的抽象类,它以与语言无关的方式格式化并解析日期或时间。
static class DateFormat.Field
          定义了各种常量,这些常量用作 DateFormat.formatToCharacterIterator 所返回的 AttributedCharacterIterator 中的属性键和 FieldPosition 中的字段标识符。
 class DateFormatSymbols
          DateFormatSymbols 是一个公共类,用于封装可本地化的日期-时间格式化数据,如月名、星期几的名称和时区数据。
 class DecimalFormat
          DecimalFormatNumberFormat 的一个具体子类,用于格式化十进制数字。
 class DecimalFormatSymbols
          此类表示了 DecimalFormat 格式化数字所需的符号集(如小数点、组分隔符等等)。
 class FieldPosition
          FieldPositionFormat 及其子类用于在格式输出中标识字段的简单类。
 class Format
          Format 是一个用于格式化语言环境敏感的信息(如日期、消息和数字)的抽象基类。
static class Format.Field
          定义在 AttributedCharacterIterator(从 Format.formatToCharacterIterator 返回)中用作属性键和在 FieldPosition 中用作字段标识符的常量。
 class MessageFormat
          MessageFormat 提供了以与语言无关方式生成连接消息的方式。
static class MessageFormat.Field
          在从 MessageFormat.formatToCharacterIterator 返回的 AttributedCharacterIterator 中定义用作属性键的常量。
 class Normalizer
          此类提供 normalize 方法,它把 Unicode 文本转换为等效的组合或分解形式,允许对文本进行更方便地分类和搜索。
 class NumberFormat
          NumberFormat 是所有数值格式的抽象基类。
static class NumberFormat.Field
          定义将用作从 NumberFormat.formatToCharacterIterator 返回的 AttributedCharacterIterator 中属性键以及 FieldPosition 中字段标识符的常量。
 class ParseException
          表示解析时出现意外错误。
 class ParsePosition
          ParsePositionFormat 及其子类所使用的简单类,用来在解析过程中跟踪当前位置。
 class RuleBasedCollator
          RuleBasedCollator 类是 Collator 的具体子类,它提供了一个简单的、数据驱动的表 collator。
 class SimpleDateFormat
          SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。
 class StringCharacterIterator
          StringCharacterIteratorString 实现 CharacterIterater 协议。
 

返回 Objectjava.text 中的方法
 Object BreakIterator.clone()
          创建此迭代器的副本。
 Object ChoiceFormat.clone()
          重写 Cloneable
 Object StringCharacterIterator.clone()
          创建此迭代器的副本。
 Object RuleBasedCollator.clone()
          标准重写,无语义变化。
 Object Collator.clone()
          重写 Cloneable
 Object DecimalFormat.clone()
          标准重写;没有语义上的变化。
 Object DecimalFormatSymbols.clone()
          标准重写。
 Object NumberFormat.clone()
          重写 Cloneable
 Object DateFormatSymbols.clone()
          重写 Cloneable。
 Object SimpleDateFormat.clone()
          创建此 SimpleDateFormat 的一个副本。
 Object DateFormat.clone()
          重写 Cloneable
 Object MessageFormat.clone()
          创建并返回此对象的一个副本。
 Object Format.clone()
          创建并返回此对象的一个副本。
 Object CharacterIterator.clone()
          创建此迭代器的一个副本
 Object AttributedCharacterIterator.getAttribute(AttributedCharacterIterator.Attribute attribute)
          返回当前字符的命名属性的值。
 Object[] ChoiceFormat.getFormats()
          获取传入构造方法的 format。
 Object Annotation.getValue()
          返回属性值,可能为 null。
 Object[] MessageFormat.parse(String source)
          从给定字符串的开始位置解析文本,以生成一个对象数组。
 Object[] MessageFormat.parse(String source, ParsePosition pos)
          解析字符串。
 Object Format.parseObject(String source)
          从给定字符串的开始处解析文本以生成一个对象。
 Object NumberFormat.parseObject(String source, ParsePosition pos)
          解析字符串中的文本,以生成一个 Number
 Object DateFormat.parseObject(String source, ParsePosition pos)
          解析字符串中的文本,以生成一个 Date
 Object MessageFormat.parseObject(String source, ParsePosition pos)
          解析字符串文本,生成一个对象数组。
abstract  Object Format.parseObject(String source, ParsePosition pos)
          解析字符串文本,生成一个对象。
protected  Object AttributedCharacterIterator.Attribute.readResolve()
          解析将被反序列化为预定义常量的实例。
protected  Object NumberFormat.Field.readResolve()
          将正被反序列化的实例解析为预定义的常量。
protected  Object DateFormat.Field.readResolve()
          将反序列化的实例解析成预定义的常量。
protected  Object MessageFormat.Field.readResolve()
          把正被反序列化的实例解析为预定义的常量。
 

返回变量类型为 Object 的类型的 java.text 中的方法
 Map<AttributedCharacterIterator.Attribute,Object> AttributedCharacterIterator.getAttributes()
          返回具有定义于当前字符上的多个属性的映射。
 

参数类型为 Objectjava.text 中的方法
 void AttributedString.addAttribute(AttributedCharacterIterator.Attribute attribute, Object value)
          将一个属性添加到整个字符串中。
 void AttributedString.addAttribute(AttributedCharacterIterator.Attribute attribute, Object value, int beginIndex, int endIndex)
          将一个属性添加到字符串的子范围。
 int Collator.compare(Object o1, Object o2)
          比较此方法两个参数的顺序。
 boolean AttributedCharacterIterator.Attribute.equals(Object obj)
          比较两个对象的相等性。
 boolean ChoiceFormat.equals(Object obj)
          两个对象之间的相等性比较。
 boolean ParsePosition.equals(Object obj)
          重写 equals
 boolean StringCharacterIterator.equals(Object obj)
          比较两个 StringCharacterIterator 对象的相等性。
 boolean RuleBasedCollator.equals(Object obj)
          比较两个 collation 对象的相等性。
 boolean Collator.equals(Object that)
          比较两个 Collator 的相等性。
 boolean DecimalFormat.equals(Object obj)
          重写 equals
 boolean DecimalFormatSymbols.equals(Object obj)
          重写 equals。
 boolean NumberFormat.equals(Object obj)
          重写 equals
 boolean DateFormatSymbols.equals(Object obj)
          重写 equals。
 boolean SimpleDateFormat.equals(Object obj)
          比较给定对象与此 SimpleDateFormat 的相等性。
 boolean DateFormat.equals(Object obj)
          重写 equals
 boolean FieldPosition.equals(Object obj)
          重写 equals
 boolean MessageFormat.equals(Object obj)
          两个消息格式对象之间的相等性比较
 String Format.format(Object obj)
          格式化一个对象以生成一个字符串。
 StringBuffer MessageFormat.format(Object[] arguments, StringBuffer result, FieldPosition pos)
          格式化一个对象数组,并将 MessageFormat 的模式添加到所提供的 StringBuffer,用格式化后的对象替换格式元素。
 StringBuffer DecimalFormat.format(Object number, StringBuffer toAppendTo, FieldPosition pos)
          格式化一个数,并将所得文本追加到给定的字符串缓冲区。
 StringBuffer NumberFormat.format(Object number, StringBuffer toAppendTo, FieldPosition pos)
          格式化一个数并将所得文本添加到给定字符串缓冲区。
 StringBuffer DateFormat.format(Object obj, StringBuffer toAppendTo, FieldPosition fieldPosition)
          重写 Format。
 StringBuffer MessageFormat.format(Object arguments, StringBuffer result, FieldPosition pos)
          格式化一个对象数组,并将 MessageFormat 的模式添加到所提供的 StringBuffer,用格式化后的对象替换格式元素。
abstract  StringBuffer Format.format(Object obj, StringBuffer toAppendTo, FieldPosition pos)
          格式化一个对象,并将得到的文本添加到给定的字符缓冲区。
static String MessageFormat.format(String pattern, Object... arguments)
          创建具有给定模式的 MessageFormat,并用它来格式化给定的参数。
 AttributedCharacterIterator DecimalFormat.formatToCharacterIterator(Object obj)
          格式化一个 Object,以生成一个 AttributedCharacterIterator
 AttributedCharacterIterator SimpleDateFormat.formatToCharacterIterator(Object obj)
          格式化生成 AttributedCharacterIterator 的对象。
 AttributedCharacterIterator MessageFormat.formatToCharacterIterator(Object arguments)
          格式化一个对象数组,并将它们插入 MessageFormat 的模式中,生成一个 AttributedCharacterIterator
 AttributedCharacterIterator Format.formatToCharacterIterator(Object obj)
          格式化一个对象,生成一个 AttributedCharacterIterator
static void Bidi.reorderVisually(byte[] levels, int levelStart, Object[] objects, int objectStart, int count)
          根据对象的层次,在数组中将对象重新排序为可视顺序。
 

参数类型为 Objectjava.text 中的构造方法
Annotation(Object value)
          构造一条具有给定值(可能为 null)的 annotation 记录。
 

java.text.spiObject 的使用
 

java.text.spiObject 的子类
 class BreakIteratorProvider
          提供 BreakIterator 类具体实现的服务提供者的抽象类。
 class CollatorProvider
          提供 Collator 类具体实现的服务提供者的抽象类。
 class DateFormatProvider
          提供 DateFormat 类具体实现的服务提供者的抽象类。
 class DateFormatSymbolsProvider
          提供 DateFormatSymbols 类实例的服务提供者的抽象类。
 class DecimalFormatSymbolsProvider
          提供 DecimalFormatSymbols 类实例的服务提供者的抽象类。
 class NumberFormatProvider
          提供 NumberFormat 类具体实现的服务提供者的抽象类。
 

java.utilObject 的使用
 

java.utilObject 的子类
 class AbstractCollection<E>
          此类提供 Collection 接口的骨干实现,以最大限度地减少了实现此接口所需的工作。
 class AbstractList<E>
          此类提供 List 接口的骨干实现,以最大限度地减少实现“随机访问”数据存储(如数组)支持的该接口所需的工作。
 class AbstractMap<K,V>
          此类提供 Map 接口的骨干实现,以最大限度地减少实现此接口所需的工作。
static class AbstractMap.SimpleEntry<K,V>
          维护键和值的 Entry。
static class AbstractMap.SimpleImmutableEntry<K,V>
          维护不可变的键和值的 Entry。
 class AbstractQueue<E>
          此类提供某些 Queue 操作的骨干实现。
 class AbstractSequentialList<E>
          此类提供了 List 接口的骨干实现,从而最大限度地减少了实现受“连续访问”数据存储(如链接列表)支持的此接口所需的工作。
 class AbstractSet<E>
          此类提供 Set 接口的骨干实现,从而最大限度地减少了实现此接口所需的工作。
 class ArrayDeque<E>
          Deque 接口的大小可变数组的实现。
 class ArrayList<E>
          List 接口的大小可变数组的实现。
 class Arrays
          此类包含用来操作数组(比如排序和搜索)的各种方法。
 class BitSet
          此类实现了一个按需增长的位向量。
 class Calendar
          Calendar 类是一个抽象类,它为特定瞬间与一组诸如 YEARMONTHDAY_OF_MONTHHOUR日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法。
 class Collections
          此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
 class ConcurrentModificationException
          当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常。
 class Currency
          表示货币。
 class Date
          类 Date 表示特定的瞬间,精确到毫秒。
 class Dictionary<K,V>
          Dictionary 类是任何可将键映射到相应值的类(如 Hashtable)的抽象父类。
 class DuplicateFormatFlagsException
          格式说明符中提供重复标志时抛出的未经检查的异常。
 class EmptyStackException
          该异常由 Stack 类中的方法抛出,以表明堆栈为空。
 class EnumMap<K extends Enum<K>,V>
          与枚举类型键一起使用的专用 Map 实现。
 class EnumSet<E extends Enum<E>>
          与枚举类型一起使用的专用 Set 实现。
 class EventListenerProxy
          将一组附加参数与侦听器关联的 EventListener 类的抽象包装器类。
 class EventObject
           所有事件状态对象都将从其派生的根类。
 class FormatFlagsConversionMismatchException
          转换与标志不兼容时抛出未经检查的异常。
 class FormattableFlags
          将 FomattableFlags 传递给 Formattable.formatTo() 方法,并修改 Formattables 的输出格式。
 class Formatter
          printf 风格的格式字符串的解释程序。
 class FormatterClosedException
          格式器已关闭时抛出的未经检查的异常。
 class GregorianCalendar
          GregorianCalendarCalendar 的一个具体子类,提供了世界上大多数国家/地区使用的标准日历系统。
 class HashMap<K,V>
          基于哈希表的 Map 接口的实现。
 class HashSet<E>
          此类实现 Set 接口,由哈希表(实际上是一个 HashMap 实例)支持。
 class Hashtable<K,V>
          此类实现一个哈希表,该哈希表将键映射到相应的值。
 class IdentityHashMap<K,V>
          此类利用哈希表实现 Map 接口,比较键(和值)时使用引用相等性代替对象相等性。
 class IllegalFormatCodePointException
          将具有 Character.isValidCodePoint(int) 所定义的无效 Unicode 代码点的字符传递给 Formatter 时,抛出未经检查的异常。
 class IllegalFormatConversionException
          当对应于格式说明符的参数为不兼容的类型时,抛出未经检查的异常。
 class IllegalFormatException
          当格式字符串包含非法语法,或者包含与给定参数不兼容的格式说明符时,将抛出未经检查的异常。
 class IllegalFormatFlagsException
          当给出非法组合标志时,抛出未经检查的异常。
 class IllegalFormatPrecisionException
          当精度为除 -1 以外的负值、转换类型不支持某个精度或者值在其他方面不受支持时,将抛出未经检查的异常。
 class IllegalFormatWidthException
          当格式宽度为除 -1 以外的负值或其他不受支持的值时,将抛出未经检查的异常。
 class InputMismatchException
          由 Scanner 抛出,表明获取的标记与期望类型的模式不匹配,或者该标记超出期望类型的范围。
 class InvalidPropertiesFormatException
          当按照 Properties 规范,输入内容不符合属性集的正确 XML 文档类型,从而无法完成操作时,抛出此异常。
 class LinkedHashMap<K,V>
          Map 接口的哈希表和链接列表实现,具有可预知的迭代顺序。
 class LinkedHashSet<E>
          具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
 class LinkedList<E>
          List 接口的链接列表实现。
 class ListResourceBundle
          ListResourceBundleResourceBundle 的一个抽象类,用于管理方便而又易于使用的列表中的语言环境资源。
 class Locale
          Locale 对象表示了特定的地理、政治和文化地区。
 class MissingFormatArgumentException
          如果格式说明符没有相应的参数,或者参数索引引用了不存在的参数时,则抛出未经检查的异常。
 class MissingFormatWidthException
          请求格式宽度时抛出未经检查的异常。
 class MissingResourceException
          缺少资源时抛出此异常。
 class NoSuchElementException
          由 EnumerationnextElement 方法抛出,表明枚举中没有更多的元素。
 class Observable
          此类表示模型视图范例中的 observable 对象,或者说“数据”。
 class PriorityQueue<E>
          一个基于优先级堆的无界优先级队列
 class Properties
          Properties 类表示了一个持久的属性集。
 class PropertyPermission
          此类用于属性权限。
 class PropertyResourceBundle
          PropertyResourceBundleResourceBundle 的一个具体子类,它使用属性文件中的静态字符串集来管理语言环境资源。
 class Random
          此类的实例用于生成伪随机数流。
 class ResourceBundle
          资源包包含特定于语言环境的对象。
static class ResourceBundle.Control
          ResourceBundle.Control 定义一个回调方法集,它在包加载进程中由 ResourceBundle.getBundle 工厂方法调用。
 class Scanner
          一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。
 class ServiceConfigurationError
          在加载服务提供者的过程中出错时抛出的错误。
 class ServiceLoader<S>
          一个简单的服务提供者加载设施。
 class SimpleTimeZone
          SimpleTimeZoneTimeZone 的具体子类,表示一个使用格里高利历的时区。
 class Stack<E>
          Stack 类表示后进先出(LIFO)的对象堆栈。
 class StringTokenizer
          string tokenizer 类允许应用程序将字符串分解为标记。
 class Timer
          一种工具,线程用其安排以后在后台线程中执行的任务。
 class TimerTask
          由 Timer 安排为一次执行或重复执行的任务。
 class TimeZone
          TimeZone 表示时区偏移量,也可以计算夏令时。
 class TooManyListenersException
           TooManyListenersException 异常用作 Java Event 模型的一部分来注释和实现多播 Event Source 的单播特例。
 class TreeMap<K,V>
          基于红黑树(Red-Black tree)的 NavigableMap 实现。
 class TreeSet<E>
          基于 TreeMapNavigableSet 实现。
 class UnknownFormatConversionException
          给定未知的转换时所抛出的未经检查的异常。
 class UnknownFormatFlagsException
          给定未知标志时所抛出的未经检查的异常。
 class UUID
          表示通用唯一标识符 (UUID) 的类。
 class Vector<E>
          Vector 类可以实现可增长的对象数组。
 class WeakHashMap<K,V>
          以弱键 实现的基于哈希表的 Map
 

声明为 Objectjava.util 中的字段
protected  Object[] Vector.elementData
          存储向量组件的数组缓冲区。
protected  Object EventObject.source
          最初发生 Event 的对象。
 

类型参数类型为 Objectjava.util 中的方法
static
<T extends Object & Comparable<? super T>>
T
Collections.max(Collection<? extends T> coll)
          根据元素的自然顺序,返回给定 collection 的最大元素。
static
<T extends Object & Comparable<? super T>>
T
Collections.min(Collection<? extends T> coll)
          根据元素的自然顺序 返回给定 collection 的最小元素。
 

返回 Objectjava.util 中的方法
 Object SimpleTimeZone.clone()
          返回此 SimpleTimeZone 实例的一个副本。
 Object GregorianCalendar.clone()
           
 Object Calendar.clone()
          创建并返回此对象的一个副本。
 Object TreeSet.clone()
          返回 TreeSet 实例的浅表副本。
 Object TimeZone.clone()
          创建此 TimeZone 的一个副本。
 Object Date.clone()
          返回此对象的副本。
 Object IdentityHashMap.clone()
          返回此标识哈希映射的浅表副本:不复制键和值本身。
 Object LinkedList.clone()
          返回此 LinkedList 的浅表副本。
 Object TreeMap.clone()
          返回此 TreeMap 实例的浅表副本。
 Object HashSet.clone()
          返回此 HashSet 实例的浅表副本:并没有复制这些元素本身。
 Object Locale.clone()
          重写 Cloneable。
 Object BitSet.clone()
          复制此 BitSet,生成一个与之相等的新 BitSet
 Object ArrayList.clone()
          返回此 ArrayList 实例的浅表副本。
 Object HashMap.clone()
          返回此 HashMap 实例的浅表副本:并不复制键和值本身。
protected  Object AbstractMap.clone()
          返回此 AbstractMap 实例的浅表副本:不复制键和值本身。
 Object Vector.clone()
          返回向量的一个副本。
 Object Hashtable.clone()
          创建此哈希表的浅表副本。
static
<T> T[]
Arrays.copyOf(T[] original, int newLength)
          复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。
static
<T,U> T[]
Arrays.copyOf(U[] original, int newLength, Class<? extends T[]> newType)
          复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。
static
<T> T[]
Arrays.copyOfRange(T[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。
static
<T,U> T[]
Arrays.copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)
          将指定数组的指定范围复制到一个新数组。
protected abstract  Object[][] ListResourceBundle.getContents()
          返回一个数组,其中 Object 数组中的每个项都是一个对象对。
 Object ResourceBundle.getObject(String key)
          从此资源包或它的某个父包中获取给定键的对象。
 Object EventObject.getSource()
          最初发生 Event 的对象。
 Object PropertyResourceBundle.handleGetObject(String key)
           
 Object ListResourceBundle.handleGetObject(String key)
           
protected abstract  Object ResourceBundle.handleGetObject(String key)
          从此资源包中获取给定键的对象。
 Object StringTokenizer.nextElement()
          除了其声明返回值是 Object 而不是 String 之外,它返回与 nextToken 方法相同的值。
 Object Properties.setProperty(String key, String value)
          调用 Hashtable 的方法 put
 Object[] ArrayDeque.toArray()
          返回一个以恰当顺序包含此双端队列所有元素的数组(从第一个元素到最后一个元素)。
 Object[] PriorityQueue.toArray()
          返回一个包含此队列所有元素的数组。
 Object[] LinkedList.toArray()
          返回以适当顺序(从第一个元素到最后一个元素)包含此列表中所有元素的数组。
 Object[] ArrayList.toArray()
          按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组。
 Object[] Set.toArray()
          返回一个包含 set 中所有元素的数组。
 Object[] Vector.toArray()
          返回一个数组,包含此向量中以恰当顺序存放的所有元素。
 Object[] AbstractCollection.toArray()
          返回包含此 collection 中所有元素的数组。
 Object[] List.toArray()
          返回按适当顺序包含列表中的所有元素的数组(从第一个元素到最后一个元素)。
 Object[] Collection.toArray()
          返回包含此 collection 中所有元素的数组。
<T> T[]
ArrayDeque.toArray(T[] a)
          返回一个以恰当顺序包含此双端队列所有元素的数组(从第一个元素到最后一个元素);返回数组的运行时类型是指定数组的运行时类型。
<T> T[]
PriorityQueue.toArray(T[] a)
          返回一个包含此队列所有元素的数组;返回数组的运行时类型是指定数组的类型。
<T> T[]
LinkedList.toArray(T[] a)
          返回以适当顺序(从第一个元素到最后一个元素)包含此列表中所有元素的数组;返回数组的运行时类型为指定数组的类型。
<T> T[]
ArrayList.toArray(T[] a)
          按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。
<T> T[]
Set.toArray(T[] a)
          返回一个包含此 set 中所有元素的数组;返回数组的运行时类型是指定数组的类型。
<T> T[]
Vector.toArray(T[] a)
          返回一个数组,包含此向量中以恰当顺序存放的所有元素;返回数组的运行时类型为指定数组的类型。
<T> T[]
AbstractCollection.toArray(T[] a)
          返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同。
<T> T[]
List.toArray(T[] a)
          返回按适当顺序(从第一个元素到最后一个元素)包含列表中所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。
<T> T[]
Collection.toArray(T[] a)
          返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同。
 

参数类型为 Objectjava.util 中的方法
static
<T> boolean
Collections.addAll(Collection<? super T> c, T... elements)
          将所有指定元素添加到指定 collection 中。
 boolean Calendar.after(Object when)
          判断此 Calendar 表示的时间是否在指定 Object 表示的时间之后,返回判断结果。
static
<T> List<T>
Arrays.asList(T... a)
          返回一个受指定数组支持的固定大小的列表。
 boolean Calendar.before(Object when)
          判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前,返回判断结果。
static int Arrays.binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
          使用二分搜索法来搜索指定数组的范围,以获得指定对象。
static int Arrays.binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
          使用二分搜索法来搜索指定数组的范围,以获得指定对象。
static int Arrays.binarySearch(Object[] a, Object key)
          使用二分搜索法来搜索指定数组,以获得指定对象。
static int Arrays.binarySearch(Object[] a, Object key)
          使用二分搜索法来搜索指定数组,以获得指定对象。
static
<T> int
Arrays.binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)
          使用二分搜索法来搜索指定数组的范围,以获得指定对象。
static
<T> int
Arrays.binarySearch(T[] a, T key, Comparator<? super T> c)
          使用二分搜索法来搜索指定数组,以获得指定对象。
 boolean ArrayDeque.contains(Object o)
          如果此双端队列包含指定元素,则返回 true
 boolean PriorityQueue.contains(Object o)
          如果此队列包含指定的元素,则返回 true
 boolean TreeSet.contains(Object o)
          如果此 set 包含指定的元素,则返回 true
 boolean LinkedList.contains(Object o)
          如果此列表包含指定元素,则返回 true
 boolean Deque.contains(Object o)
          如果此双端队列包含指定元素,则返回 true
 boolean HashSet.contains(Object o)
          如果此 set 包含指定元素,则返回 true
 boolean ArrayList.contains(Object o)
          如果此列表中包含指定的元素,则返回 true
 boolean Set.contains(Object o)
          如果 set 包含指定的元素,则返回 true
 boolean Vector.contains(Object o)
          如果此向量包含指定的元素,则返回 true
 boolean AbstractCollection.contains(Object o)
          如果此 collection 包含指定的元素,则返回 true
 boolean List.contains(Object o)
          如果列表包含指定的元素,则返回 true
 boolean Collection.contains(Object o)
          如果此 collection 包含指定的元素,则返回 true
 boolean Hashtable.contains(Object value)
          测试此映射表中是否存在与指定值关联的键。
 boolean EnumMap.containsKey(Object key)
          如果此映射包含指定键的映射关系,则返回 true
 boolean IdentityHashMap.containsKey(Object key)
          测试指定的对象引用是否为此标识哈希映射中的键。
 boolean TreeMap.containsKey(Object key)
          如果此映射包含指定键的映射关系,则返回 true
 boolean WeakHashMap.containsKey(Object key)
          如果此映射对于指定的键包含映射关系,则返回 true
 boolean HashMap.containsKey(Object key)
          如果此映射包含对于指定键的映射关系,则返回 true
 boolean AbstractMap.containsKey(Object key)
          如果此映射包含指定键的映射关系,则返回 true
 boolean Hashtable.containsKey(Object key)
          测试指定对象是否为此哈希表中的键。
 boolean Map.containsKey(Object key)
          如果此映射包含指定键的映射关系,则返回 true
 boolean EnumMap.containsValue(Object value)
          如果此映射将一个或多个键映射到指定值,则返回 true
 boolean IdentityHashMap.containsValue(Object value)
          测试指定的对象引用是否为此标识哈希映射中的值。
 boolean TreeMap.containsValue(Object value)
          如果此映射为指定值映射一个或多个键,则返回 true
 boolean WeakHashMap.containsValue(Object value)
          如果此映射将一个或多个键映射到指定值,则返回 true
 boolean LinkedHashMap.containsValue(Object value)
          如果此映射将一个或多个键映射到指定值,则返回 true
 boolean HashMap.containsValue(Object value)
          如果此映射将一个或多个键映射到指定值,则返回 true
 boolean AbstractMap.containsValue(Object value)
          如果此映射将一个或多个键映射到指定值,则返回 true
 boolean Hashtable.containsValue(Object value)
          如果此 Hashtable 将一个或多个键映射到此值,则返回 true。
 boolean Map.containsValue(Object value)
          如果此映射将一个或多个键映射到指定值,则返回 true
 void Vector.copyInto(Object[] anArray)
          将此向量的组件复制到指定的数组中。
static
<T> T[]
Arrays.copyOf(T[] original, int newLength)
          复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。
static
<T,U> T[]
Arrays.copyOf(U[] original, int newLength, Class<? extends T[]> newType)
          复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。
static
<T> T[]
Arrays.copyOfRange(T[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。
static
<T,U> T[]
Arrays.copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)
          将指定数组的指定范围复制到一个新数组。
static boolean Arrays.deepEquals(Object[] a1, Object[] a2)
          如果两个指定数组彼此是深层相等 的,则返回 true
static boolean Arrays.deepEquals(Object[] a1, Object[] a2)
          如果两个指定数组彼此是深层相等 的,则返回 true
static int Arrays.deepHashCode(Object[] a)
          基于指定数组的“深层内容”返回哈希码。
static String Arrays.deepToString(Object[] a)
          返回指定数组“深层内容”的字符串表示形式。
 boolean EnumMap.equals(Object o)
          比较指定对象与此映射的相等性。
 boolean SimpleTimeZone.equals(Object obj)
          比较两个 SimpleTimeZone 对象的相等性。
 boolean UUID.equals(Object obj)
          将此对象与指定对象比较。
 boolean PropertyPermission.equals(Object obj)
          检查两个 PropertyPermission 对象是否相等。
 boolean GregorianCalendar.equals(Object obj)
          比较此 GregorianCalendar 与指定的 Object
 boolean Calendar.equals(Object obj)
          将此 Calendar 与指定 Object 比较。
 boolean Date.equals(Object obj)
          比较两个日期的相等性。
 boolean IdentityHashMap.equals(Object o)
          比较指定对象与此映射的相等性。
 boolean Locale.equals(Object obj)
          如果该 Locale 等于另一个对象,则返回 true。
 boolean BitSet.equals(Object obj)
          将此对象与指定的对象进行比较。
 boolean AbstractSet.equals(Object o)
          比较指定对象与此 set 的相等性。
 boolean Set.equals(Object o)
          比较指定对象与此 set 的相等性。
 boolean AbstractMap.equals(Object o)
          比较指定对象与此映射的相等性。
 boolean AbstractMap.SimpleEntry.equals(Object o)
          比较指定对象与此项的相等性。
 boolean AbstractMap.SimpleImmutableEntry.equals(Object o)
          比较指定对象与此项的相等性。
 boolean Comparator.equals(Object obj)
          指示某个其他对象是否“等于”此 Comparator。
 boolean Vector.equals(Object o)
          比较指定对象与此向量的相等性。
 boolean AbstractList.equals(Object o)
          将指定的对象与此列表进行相等性比较。
 boolean List.equals(Object o)
          比较指定的对象与列表是否相等。
 boolean Collection.equals(Object o)
          比较此 collection 与指定对象是否相等。
 boolean Hashtable.equals(Object o)
          按照 Map 接口的定义,比较指定 Object 与此 Map 是否相等。
 boolean Map.equals(Object o)
          比较指定的对象与此映射是否相等。
 boolean Map.Entry.equals(Object o)
          比较指定对象与此项的相等性。
static boolean Arrays.equals(Object[] a, Object[] a2)
          如果两个指定的 Objects 数组彼此相等,则返回 true
static boolean Arrays.equals(Object[] a, Object[] a2)
          如果两个指定的 Objects 数组彼此相等,则返回 true
static void Arrays.fill(Object[] a, int fromIndex, int toIndex, Object val)
          将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static void Arrays.fill(Object[] a, int fromIndex, int toIndex, Object val)
          将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static void Arrays.fill(Object[] a, Object val)
          将指定的 Object 引用分配给指定 Object 数组的每个元素。
static void Arrays.fill(Object[] a, Object val)
          将指定的 Object 引用分配给指定 Object 数组的每个元素。
 Formatter Formatter.format(Locale l, String format, Object... args)
          使用指定的语言环境、格式字符串和参数,将一个格式化字符串写入此对象的目标文件中。
 Formatter Formatter.format(String format, Object... args)
          使用指定格式字符串和参数将一个格式化字符串写入此对象的目标文件中。
static int Collections.frequency(Collection<?> c, Object o)
          返回指定 collection 中等于指定对象的元素数。
 V EnumMap.get(Object key)
          返回指定键所映射的值,如果此映射不包含此键的映射关系,则返回 null
 V IdentityHashMap.get(Object key)
          返回指定键映射的值;如果映射不包含此键的任何映射关系,则返回 null
 V TreeMap.get(Object key)
          返回指定键所映射的值,如果对于该键而言,此映射不包含任何映射关系,则返回 null
 V WeakHashMap.get(Object key)
          返回指定键所映射的值,如果对于该键来说,此映射不包含任何映射关系,则返回 null
 V LinkedHashMap.get(Object key)
          返回此映射到指定键的值。
 V HashMap.get(Object key)
          返回指定键所映射的值;如果对于该键来说,此映射不包含任何映射关系,则返回 null
 V AbstractMap.get(Object key)
          返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null
 V Hashtable.get(Object key)
          返回指定键所映射到的值,如果此映射不包含此键的映射,则返回 null. 更确切地讲,如果此映射包含满足 (key.equals(k)) 的从键 k 到值 v 的映射,则此方法返回 v;否则,返回 null
abstract  V Dictionary.get(Object key)
          返回此 dictionary 中该键所映射到的值。
 V Map.get(Object key)
          返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null
static int Arrays.hashCode(Object[] a)
          基于指定数组的内容返回哈希码。
 int LinkedList.indexOf(Object o)
          返回此列表中首次出现的指定元素的索引,如果此列表中不包含该元素,则返回 -1。
 int ArrayList.indexOf(Object o)
          返回此列表中首次出现的指定元素的索引,或如果此列表不包含元素,则返回 -1。
 int Vector.indexOf(Object o)
          返回此向量中第一次出现的指定元素的索引,如果此向量不包含该元素,则返回 -1。
 int AbstractList.indexOf(Object o)
          返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1。
 int List.indexOf(Object o)
          返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1。
 int Vector.indexOf(Object o, int index)
          返回此向量中第一次出现的指定元素的索引,从 index 处正向搜索,如果未找到该元素,则返回 -1。
 int LinkedList.lastIndexOf(Object o)
          返回此列表中最后出现的指定元素的索引,如果此列表中不包含该元素,则返回 -1。
 int ArrayList.lastIndexOf(Object o)
          返回此列表中最后一次出现的指定元素的索引,或如果此列表不包含索引,则返回 -1。
 int Vector.lastIndexOf(Object o)
          返回此向量中最后一次出现的指定元素的索引;如果此向量不包含该元素,则返回 -1。
 int AbstractList.lastIndexOf(Object o)
          返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1。
 int List.lastIndexOf(Object o)
          返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1。
 int Vector.lastIndexOf(Object o, int index)
          返回此向量中最后一次出现的指定元素的索引,从 index 处逆向搜索,如果未找到该元素,则返回 -1。
 void Observable.notifyObservers(Object arg)
          如果 hasChanged 方法指示对象已改变,则通知其所有观察者,并调用 clearChanged 方法来指示此对象不再改变。
 boolean ArrayDeque.remove(Object o)
          从此双端队列中移除指定元素的单个实例。
 V EnumMap.remove(Object key)
          从此映射中移除该键的映射关系(如果存在)。
 boolean PriorityQueue.remove(Object o)
          从此队列中移除指定元素的单个实例(如果存在)。
 boolean TreeSet.remove(Object o)
          将指定的元素从 set 中移除(如果该元素存在于此 set 中)。
 V IdentityHashMap.remove(Object key)
          移除映射中此键的映射关系(如果存在的话)。
 boolean LinkedList.remove(Object o)
          从此列表中移除首次出现的指定元素(如果存在)。
 boolean Deque.remove(Object o)
          从此双端队列中移除第一次出现的指定元素。
 V TreeMap.remove(Object key)
          如果此 TreeMap 中存在该键的映射关系,则将其删除。
 V WeakHashMap.remove(Object key)
          从此弱哈希映射中移除键的映射关系(如果存在)。
 boolean HashSet.remove(Object o)
          如果指定元素存在于此 set 中,则将其移除。
 boolean ArrayList.remove(Object o)
          移除此列表中首次出现的指定元素(如果存在)。
 boolean Set.remove(Object o)
          如果 set 中存在指定的元素,则将其移除(可选操作)。
 V HashMap.remove(Object key)
          从此映射中移除指定键的映射关系(如果存在)。
 V AbstractMap.remove(Object key)
          如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
 boolean Vector.remove(Object o)
          移除此向量中指定元素的第一个匹配项,如果向量不包含该元素,则元素保持不变。
 boolean AbstractCollection.remove(Object o)
          从此 collection 中移除指定元素的单个实例,如果存在的话(可选操作)。
 boolean List.remove(Object o)
          从此列表中移除第一次出现的指定元素(如果存在)(可选操作)。
 boolean Collection.remove(Object o)
          从此 collection 中移除指定元素的单个实例,如果存在的话(可选操作)。
 V Hashtable.remove(Object key)
          从哈希表中移除该键及其相应的值。
abstract  V Dictionary.remove(Object key)
          从此 dictionary 中移除 key (及其相应的 value)。
 V Map.remove(Object key)
          如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
 boolean Vector.removeElement(Object obj)
          从此向量中移除变量的第一个(索引最小的)匹配项。
 boolean ArrayDeque.removeFirstOccurrence(Object o)
          移除此双端队列中第一次出现的指定元素(当从头部到尾部遍历双端队列时)。
 boolean LinkedList.removeFirstOccurrence(Object o)
          从此列表中移除第一次出现的指定元素(从头部到尾部遍历列表时)。
 boolean Deque.removeFirstOccurrence(Object o)
          从此双端队列移除第一次出现的指定元素。
 boolean ArrayDeque.removeLastOccurrence(Object o)
          移除此双端队列中最后一次出现的指定元素(当从头部到尾部遍历双端队列时)。
 boolean LinkedList.removeLastOccurrence(Object o)
          从此列表中移除最后一次出现的指定元素(从头部到尾部遍历列表时)。
 boolean Deque.removeLastOccurrence(Object o)
          从此双端队列移除最后一次出现的指定元素。
 int Stack.search(Object o)
          返回对象在堆栈中的位置,以 1 为基数。
static void Arrays.sort(Object[] a)
          根据元素的自然顺序对指定对象数组按升序进行排序。
static void Arrays.sort(Object[] a, int fromIndex, int toIndex)
          根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
static
<T> void
Arrays.sort(T[] a, Comparator<? super T> c)
          根据指定比较器产生的顺序对指定对象数组进行排序。
static
<T> void
Arrays.sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
          根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
<T> T[]
ArrayDeque.toArray(T[] a)
          返回一个以恰当顺序包含此双端队列所有元素的数组(从第一个元素到最后一个元素);返回数组的运行时类型是指定数组的运行时类型。
<T> T[]
PriorityQueue.toArray(T[] a)
          返回一个包含此队列所有元素的数组;返回数组的运行时类型是指定数组的类型。
<T> T[]
LinkedList.toArray(T[] a)
          返回以适当顺序(从第一个元素到最后一个元素)包含此列表中所有元素的数组;返回数组的运行时类型为指定数组的类型。
<T> T[]
ArrayList.toArray(T[] a)
          按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。
<T> T[]
Set.toArray(T[] a)
          返回一个包含此 set 中所有元素的数组;返回数组的运行时类型是指定数组的类型。
<T> T[]
Vector.toArray(T[] a)
          返回一个数组,包含此向量中以恰当顺序存放的所有元素;返回数组的运行时类型为指定数组的类型。
<T> T[]
AbstractCollection.toArray(T[] a)
          返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同。
<T> T[]
List.toArray(T[] a)
          返回按适当顺序(从第一个元素到最后一个元素)包含列表中所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。
<T> T[]
Collection.toArray(T[] a)
          返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同。
static String Arrays.toString(Object[] a)
          返回指定数组内容的字符串表示形式。
 void Observer.update(Observable o, Object arg)
          只要改变了 observable 对象就调用此方法。
 

参数类型为 Objectjava.util 中的构造方法
EventObject(Object source)
          构造一个原型 Event。
 

java.util.concurrentObject 的使用
 

java.util.concurrentObject 的子类
 class AbstractExecutorService
          提供 ExecutorService 执行方法的默认实现。
 class ArrayBlockingQueue<E>
          一个由数组支持的有界阻塞队列
 class BrokenBarrierException
          当某个线程试图等待处于断开状态的 barrier 时,或者 barrier 进入断开状态而线程处于等待状态时,抛出该异常。
 class CancellationException
          如果某项值生成任务(如 FutureTask)的结果因为任务被取消而无法获取到,则抛出该异常。
 class ConcurrentHashMap<K,V>
          支持获取的完全并发和更新的所期望可调整并发的哈希表。
 class ConcurrentLinkedQueue<E>
          一个基于链接节点的无界线程安全队列
 class ConcurrentSkipListMap<K,V>
          可缩放的并发 ConcurrentNavigableMap 实现。
 class ConcurrentSkipListSet<E>
          一个基于 ConcurrentSkipListMap 的可缩放并发 NavigableSet 实现。
 class CopyOnWriteArrayList<E>
          ArrayList 的一个线程安全的变体,其中所有可变操作(addset 等等)都是通过对底层数组进行一次新的复制来实现的。
 class CopyOnWriteArraySet<E>
          对其所有操作使用内部 CopyOnWriteArrayListSet
 class CountDownLatch
          一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。
 class CyclicBarrier
          一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。
 class DelayQueue<E extends Delayed>
          Delayed 元素的一个无界阻塞队列,只有在延迟期满时才能从中提取元素。
 class Exchanger<V>
          可以在对中对元素进行配对和交换的线程的同步点。
 class ExecutionException
          当试图获取已通过抛出异常而中止的任务的结果时,抛出此异常。
 class ExecutorCompletionService<V>
          使用提供的 Executor 来执行任务的 CompletionService
 class Executors
          此包中所定义的 ExecutorExecutorServiceScheduledExecutorServiceThreadFactoryCallable 类的工厂和实用方法。
 class FutureTask<V>
          可取消的异步计算。
 class LinkedBlockingDeque<E>
          一个基于已链接节点的、任选范围的阻塞双端队列
 class LinkedBlockingQueue<E>
          一个基于已链接节点的、范围任意的 blocking queue
 class PriorityBlockingQueue<E>
          一个无界阻塞队列,它使用与类 PriorityQueue 相同的顺序规则,并且提供了阻塞获取操作。
 class RejectedExecutionException
          当无法执行某个任务时,由 Executor 抛出的异常。
 class