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

接口 java.io.Serializable
的使用

使用 Serializable 的软件包
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.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.reflect 提供类和接口，以获得关于类和对象的反射信息。 
java.math 提供用于执行任意精度整数算法 (BigInteger) 和任意精度小数算法 (BigDecimal) 的类。 
java.net 为实现网络应用程序提供类。 
java.nio 定义作为数据容器的缓冲区，并提供其他 NIO 包的概述。 
java.nio.channels 定义了各种通道，这些通道表示到能够执行 I/O 操作的实体（如文件和套接字）的连接；定义了用于多路复用的、非阻塞 I/O 操作的选择器。 
java.nio.charset 定义用来在字节和 Unicode 字符之间转换的 charset、解码器和编码器。 
java.rmi 提供 RMI 包。 
java.rmi.activation 为 RMI 对象激活提供支持。 
java.rmi.dgc 为 RMI 分布式垃圾回收提供了类和接口。 
java.rmi.server 提供支持服务器端 RMI 的类和接口。 
java.security 为安全框架提供类和接口。 
java.security.acl 此包中的类和接口已经被 java.security 包中的类取代。 
java.security.cert 提供用于解析和管理证书、证书撤消列表 (CRL) 和证书路径的类和接口。 
java.security.interfaces 提供的接口用于生成 RSA Laboratory Technical Note PKCS#1 中定义的 RSA（Rivest、Shamir 和 Adleman AsymmetricCipher 算法）密钥，以及 NIST 的 FIPS-186 中定义的 DSA（数字签名算法）密钥。 
java.security.spec 提供密钥规范和算法参数规范的类和接口。 
java.sql 提供使用 JavaTM 编程语言访问并处理存储在数据源（通常是一个关系数据库）中的数据的 API。 
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.zip 提供用于读写标准 ZIP 和 GZIP 文件格式的类。 
javax.activation   
javax.activity 包含解组期间通过 ORB 机制抛出的与 Activity 服务有关的异常。 
javax.annotation   
javax.annotation.processing 用来声明注释处理器并允许注释处理器与注释处理工具环境通信的工具。 
javax.crypto 为加密操作提供类和接口。 
javax.crypto.interfaces 根据 RSA Laboratories' PKCS #3 的定义，提供 Diffie-Hellman 密钥接口。 
javax.crypto.spec 为密钥规范和算法参数规范提供类和接口。 
javax.imageio Java Image I/O API 的主要包。 
javax.imageio.metadata 用于处理读写元数据的 Java Image I/O API 的包。 
javax.jws   
javax.jws.soap   
javax.lang.model 用来为 Java 编程语言建立模型的包的类和层次结构。 
javax.lang.model.element 用于 Java 编程语言的模型元素的接口。 
javax.lang.model.type 用来为 Java 编程语言类型建立模型的接口。 
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.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.CORBA 包含用于 RMI-IIOP 的可移植性 API。 
javax.rmi.ssl 通过安全套接字层 (SSL) 或传输层安全 (TLS) 协议提供 RMIClientSocketFactory 和 RMIServerSocketFactory 的实现。 
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.sasl 包含用于支持 SASL 的类和接口。 
javax.sound.midi 提供用于 MIDI（音乐乐器数字接口）数据的 I/O、序列化和合成的接口和类。 
javax.sound.sampled 提供用于捕获、处理和回放取样的音频数据的接口和类。 
javax.sql 为通过 JavaTM 编程语言进行服务器端数据源访问和处理提供 API。 
javax.sql.rowset JDBC RowSet 实现的标准接口和基类。 
javax.sql.rowset.serial 提供实用工具类，允许 SQL 类型与 Java 编程语言数据类型之间的可序列化映射关系。 
javax.sql.rowset.spi 第三方供应商在其同步提供者的实现中必须使用的标准类和接口。 
javax.swing 提供一组“轻量级”（全部是 Java 语言）组件，尽量让这些组件在所有平台上的工作方式都相同。 
javax.swing.border 提供围绕 Swing 组件绘制特殊边框的类和接口。 
javax.swing.colorchooser 包含供 JColorChooser 组件使用的类和接口。 
javax.swing.event 供 Swing 组件触发的事件使用。 
javax.swing.plaf 提供一个接口和许多抽象类，Swing 用它们来提供自己的可插入外观功能。 
javax.swing.plaf.basic 提供了根据基本外观构建的用户界面对象。 
javax.swing.plaf.metal 提供根据 Java 外观（曾经代称为 Metal）构建的用户界面对象，Java 外观是默认外观。 
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.bind 为包含解组、编组和验证功能的客户端应用程序提供运行时绑定框架。 
javax.xml.bind.annotation 定义将 Java 程序元素定制成 XML 模式映射的注释。 
javax.xml.crypto 用于 XML 加密的通用类。 
javax.xml.crypto.dsig 用于生成和验证 XML 数字签名的类。 
javax.xml.datatype XML/Java 类型映射关系。 
javax.xml.namespace XML 名称空间处理。 
javax.xml.parsers 提供允许处理 XML 文档的类。 
javax.xml.soap 提供用于创建和构建 SOAP 消息的 API。 
javax.xml.stream   
javax.xml.transform 此包定义了用于处理转换指令，以及执行从源到结果的转换的一般 API。 
javax.xml.ws 此包包含核心 JAX-WS API。 
javax.xml.ws.handler 该包定义用于消息处理程序的 API。 
javax.xml.ws.http 该包定义特定于 HTTP 绑定的 API。 
javax.xml.ws.soap 该包定义特定于 SOAP 绑定的 API。 
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.portable 提供输入和输出值类型的各种方法，并包含 org/omg/CORBA/portable 包的其他更新。 
org.omg.CORBA.DynAnyPackage 提供与 DynAny 接口一起使用的异常（InvalidValue、Invalid、InvalidSeq 和 TypeMismatch）。 
org.omg.CORBA.ORBPackage 提供由 ORB.resolve_initial_references 方法抛出的异常 InvalidName，以及由 ORB 类中的动态 Any 创建方法抛出的异常 InconsistentTypeCode。 
org.omg.CORBA.portable 提供可移植性层，即可以使一个供应商生成的代码运行在另一个供应商 ORB 上的 ORB API 集合。 
org.omg.CORBA.TypeCodePackage 提供用户定义的异常 BadKind 和 Bounds，它们将由 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.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.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.SendingContext 为值类型的编组提供支持。 
org.omg.stub.java.rmi 包含用于 java.rmi 包中出现的 Remote 类型的 RMI-IIOP Stub。 
org.w3c.dom 为文档对象模型 (DOM) 提供接口，该模型是 Java API for XML Processing 的组件 API。 
org.w3c.dom.events   
org.w3c.dom.ls   
org.xml.sax 此包提供了核心 SAX API。 
 

java.applet 中 Serializable 的使用
 

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

java.awt 中 Serializable 的使用
 

实现 Serializable 的 java.awt 中的类
 class AWTError
          当发生严重的 Abstract Window Toolkit 错误时，抛出此错误。
 class AWTEvent
          所有 AWT 事件的根事件类。
 class AWTException
          表示发生了 Absract Window Toolkit 异常。
 class AWTKeyStroke
          AWTKeyStroke 表示键盘（或等效输入设备）上的键操作。
 class AWTPermission
          此类用于 AWT 权限。
 class BorderLayout
          这是一个布置容器的边框布局，它可以对容器组件进行安排，并调整其大小，使其符合下列五个区域：北、南、东、西、中。
 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 的内部类。
static class Component.BaselineResizeBehavior
          常见方式的枚举，指示组件的基线可以随大小的更改而更改。
 class ComponentOrientation
          ComponentOrientation 类封装语言敏感的方向，用于排序组件或文本内容。
 class Container
          一般的 Abstract Window Toolkit(AWT) 容器对象是一个可包含其他 AWT 组件的组件。
protected  class Container.AccessibleAWTContainer
          用于对可访问性提供默认支持的 Container 内部类。
 class ContainerOrderFocusTraversalPolicy
          根据 Container 中的子 Component 的顺序确定遍历顺序的 FocusTraversalPolicy。
 class Cursor
          封装鼠标光标的位图表示形式的类。
 class DefaultFocusTraversalPolicy
          根据 Container 中的子 Component 的顺序确定遍历顺序的 FocusTraversalPolicy。
static class Desktop.Action
          表示动作类型。
 class Dialog
          Dialog 是一个带标题和边界的顶层窗口，边界一般用于从用户处获得某种形式的输入。
protected  class Dialog.AccessibleAWTDialog
          此类实现对 Dialog 类的可访问性支持。
static class Dialog.ModalExclusionType
          任何顶层窗口都可以标记为不受模式对话框阻塞。
static class Dialog.ModalityType
          模式对话框阻塞对某些顶层窗口的所有输入。
 class Dimension
          Dimension 类封装单个对象中组件的宽度和高度（精确到整数）。
 class Event
          注：Event 类已废弃，只可用于向后兼容。
 class FileDialog
          FileDialog 类显示一个对话框窗口，用户可以从中选择文件。
 class FlowLayout
          流布局用于安排有向流中的组件，这非常类似于段落中的文本行。
 class Font
          Font 类表示字体，可以使用它以可见方式呈现文本。
 class FontFormatException
          此异常由 Font 类中的 createFont 方法抛出，以指示指定的字体很糟糕。
 class FontMetrics
          FontMetrics 类定义字体规格对象，该对象封装将在特定屏幕上呈现特定字体的有关信息。
 class Frame
          Frame 是带有标题和边框的顶层窗口。
protected  class Frame.AccessibleAWTFrame
          此类实现对 Frame 类的可访问性支持。
 class GraphicsConfigTemplate
          GraphicsConfigTemplate 类用于获得有效的 GraphicsConfiguration。
 class GridBagConstraints
          GridBagConstraints 类指定使用 GridBagLayout 类布置的组件的约束。
 class GridBagLayout
          GridBagLayout 类是一个灵活的布局管理器，它不要求组件的大小相同便可以将组件垂直、水平或沿它们的基线对齐。
 class GridBagLayoutInfo
          GridBagLayoutInfo 是 GridBagLayout 布局管理器的一个实用工具类。
 class GridLayout
          GridLayout 类是一个布局处理器，它以矩形网格形式对容器的组件进行布置。
 class HeadlessException
          在不支持键盘、显示器或鼠标的环境中调用与键盘、显示器或鼠标有关的代码时，被抛出的异常。
 class IllegalComponentStateException
          当 AWT 组件未处于所请求操作的适当状态时，抛出该异常。
 class Insets
          Insets 对象是容器边界的表示形式。
 class Label
          Label 对象是一个可在容器中放置文本的组件。
protected  class Label.AccessibleAWTLabel
          此类实现对 Label 类的可访问性支持。
 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 类。
static class MultipleGradientPaint.ColorSpaceType
          在其中执行渐变插值操作的颜色空间。
static class MultipleGradientPaint.CycleMethod
          在渐变边界以外进行绘制时使用的方法。
 class Panel
          Panel 是最简单的容器类。
protected  class Panel.AccessibleAWTPanel
          此类实现 Panel 类的可访问性支持。
 class Point
          表示 (x,y) 坐标空间中的位置的点，以整数精度指定。
 class Polygon
          Polygon 类封装了坐标空间中封闭的二维区域的描述。
 class PopupMenu
          此类实现能够在组件中的指定位置上动态弹出的菜单。
protected  class PopupMenu.AccessibleAWTPopupMenu
          用于为可访问性提供默认支持的 PopupMenu 的内部类。
 class Rectangle
          Rectangle 指定坐标空间中的一个区域，通过坐标空间中 Rectangle 对象左上方的点 (x,y)、宽度和高度可以定义这个区域。
 class Scrollbar
          Scrollbar 类描述了一个滚动条，这是大家都很熟悉的用户界面对象。
protected  class Scrollbar.AccessibleAWTScrollBar
          此类实现 Scrollbar 类的可访问性支持。
 class ScrollPane
          实现用于单个子组件的自动水平和/或垂直滚动的容器类。
protected  class ScrollPane.AccessibleAWTScrollPane
          此类实现 ScrollPane 类的可访问性支持。
 class ScrollPaneAdjustable
          此类表示 ScrollPane 的水平或垂直滚动条的状态。
 class SystemColor
          封装表示系统中本机 GUI 对象颜色的象征性颜色的类。
 class TextArea
          TextArea 对象是显示文本的多行区域。
protected  class TextArea.AccessibleAWTTextArea
          此类实现 TextArea 类的可访问性支持。
 class TextComponent
          TextComponent 类是所有允许编辑文本的组件的超类。
protected  class TextComponent.AccessibleAWTTextComponent
          此类实现对 TextComponent 类的可访问性支持。
 class TextField
          TextField 对象是允许编辑单行文本的文本组件。
protected  class TextField.AccessibleAWTTextField
          此类实现 TextField 类的可访问性支持。
static class TrayIcon.MessageType
          MessageType 确定哪个图标将显示在消息标题中，以及消息根据显示生成的可能的系统声音。
 class Window
          Window 对象是一个没有边界和菜单栏的顶层窗口。
protected  class Window.AccessibleAWTWindow
          此类实现对 Window 类的可访问性支持。
 

java.awt.color 中 Serializable 的使用
 

实现 Serializable 的 java.awt.color 中的类
 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 对象出现错误时，抛出此异常。
 

java.awt.datatransfer 中 Serializable 的使用
 

实现 Serializable 的 java.awt.datatransfer 中的类
 class DataFlavor
          DataFlavor 提供有关数据的元信息。
 class FlavorEvent
          FlavorEvent 用于通知感兴趣的参与者，可用的 DataFlavor 在 Clipboard（事件源）中已改变。
 class MimeTypeParseException
          对分析相关异常的 MimeType 进行封装的类
 class UnsupportedFlavorException
          在此 flavor 中不支持所请求的数据的信号。
 

java.awt.dnd 中 Serializable 的使用
 

实现 Serializable 的 java.awt.dnd 中的类
 class DragGestureEvent
          当特定的 DragGestureRecognizer 检测到它正在跟踪的 Component 上已发生与平台相关的拖动启动动作时，将 DragGestureEvent 传递给 DragGestureListener 的 dragGestureRecognized() 方法。
 class DragGestureRecognizer
          DragGestureRecognizer 是一个针对与平台相关的侦听器规范的抽象基类，它可以与特定 Component 关联以标识与平台相关的拖动开始动作。
 class DragSource
          DragSource 是负责开始 Drag 和 Drop 操作的实体，可以用在如下场景中： JVM 生命周期中每个 JVM 的一个默认实例。
 class DragSourceContext
          DragSourceContext 类负责管理 Drag 和 Drop 协议的起始端。
 class DragSourceDragEvent
          通过 DragSourceContext，将 DragSourceDragEvent 从 DragSourceContextPeer 传递给向 DragSourceContext 及其关联 DragSource 注册的 DragSourceListener。
 class DragSourceDropEvent
          通过 DragSourceContext，将 DragSourceDropEvent 从 DragSourceContextPeer 传递给向 DragSourceContext 及其关联 DragSource 注册的 DragSourceListener 的 dragDropEnd 方法。
 class DragSourceEvent
          此类是 DragSourceDragEvent 和 DragSourceDropEvent 的基类。
 class DropTarget
          在 Drag 和 Drop 操作期间，当 Component 希望接受 drop 时，DropTarget 与 Component 有关联。
 class DropTargetContext
          每当与 Drag 和 Drop 操作相关的逻辑光标和与 DropTarget 相关的 Component 的可见几何结构重合时，就创建一个 DropTargetContext。
 class DropTargetDragEvent
          通过 dragEnter() 和 dragOver() 方法将 DropTargetDragEvent 发送给 DropTargetListener。
 class DropTargetDropEvent
          通过 DropTargetListener drop() 方法发送 DropTargetDropEvent。
 class DropTargetEvent
          DropTargetEvent 是 DropTargetDragEvent 和 DropTargetDropEvent 的基类。
 class InvalidDnDOperationException
          java.awt.dnd 包中的各种方法都会抛出此异常。
 class MouseDragGestureRecognizer
          DragGestureRecognizer 的抽象子类，它定义了一个基于鼠标动作的 DragGestureRecognizer。
 

java.awt.event 中 Serializable 的使用
 

实现 Serializable 的 java.awt.event 中的类
 class ActionEvent
          指示发生了组件定义的动作的语义事件。
 class AdjustmentEvent
          由 Adjustable 对象所发出的调整事件。
 class ComponentEvent
          指示组件被移动、大小被更改或可见性被更改的低级别事件（它也是其他组件级事件的根类）。
 class ContainerEvent
          指示容器内容因为添加或移除组件而更改的低级别事件。
 class FocusEvent
          指示 Component 已获得或失去输入焦点的低级别事件。
 class HierarchyEvent
          指示 Component 所属的 Component 层次结构发生更改的事件。
 class InputEvent
          所有组件级别输入事件的根事件类。
 class InputMethodEvent
          输入方法事件包含有关使用输入方法进行撰写的文本的信息。
 class InvocationEvent
          当通过 AWT 事件调度线程进行调度时，在 Runnable 上执行 run() 方法的事件。
 class ItemEvent
          指示项被选定或取消选定的语义事件。
 class KeyEvent
          表示组件中发生键击的事件。
 class MouseEvent
          指示组件中发生鼠标动作的事件。
 class MouseWheelEvent
          表示鼠标滚轮在组件中滚动的事件。
 class PaintEvent
          组件级绘制事件。
 class TextEvent
          指示对象文本已改变的语义事件。
 class WindowEvent
          指示窗口状态改变的低级别事件。
 

java.awt.font 中 Serializable 的使用
 

实现 Serializable 的 java.awt.font 中的类
 class NumericShaper
          NumericShaper 类用于将 Latin-1（欧洲语）数字转换成其他 Unicode 十进制数字。
 class TextAttribute
          TextAttribute 类定义用于呈现文本的属性键和属性值。
 class TransformAttribute
          TransformAttribute 类为转换提供一个不可变的包装器，使其可以安全地作为属性使用。
 

java.awt.geom 中 Serializable 的使用
 

实现 Serializable 的 java.awt.geom 中的类
 class AffineTransform
          AffineTransform 类表示 2D 仿射变换，它执行从 2D 坐标到其他 2D 坐标的线性映射，保留了线的“直线性”和“平行性”。
static class Arc2D.Double
          此类定义以 double 精度指定的弧。
static class Arc2D.Float
          此类定义以 float 精度指定的弧。
static class CubicCurve2D.Double
          使用 double 坐标指定的三次参数曲线段。
static class CubicCurve2D.Float
          使用 float 坐标指定的三次参数曲线段。
static class Ellipse2D.Double
          Double 类以 double 精度定义椭圆。
static class Ellipse2D.Float
          Float 类以 float 精度定义椭圆。
 class GeneralPath
          GeneralPath 类表示根据直线、二次曲线和三次 (Bézier) 曲线构造的几何路径。
 class IllegalPathStateException
          对于正在执行的特定操作而言（如将路径段追加到不具有初始 moveto 的 GeneralPath），如果操作在处于非法状态的路径上执行，则 IllegalPathStateException 表示抛出的异常。
static class Line2D.Double
          使用 double 坐标指定的线段。
static class Line2D.Float
          使用 float 坐标指定的线段。
 class NoninvertibleTransformException
          NoninvertibleTransformException 类表示在执行的操作要求 AffineTransform 对象可逆但 AffineTransform 处于不可逆状态时抛出的异常。
static class Path2D.Double
          Double 类定义了一条几何路径，它具有以双精度浮点值形式存储的坐标。
static class Path2D.Float
          Float 类定义了一条几何路径，它具有以单精度浮点值形式存储的坐标。
static class Point2D.Double
          Double 类以 double 精度定义指定的点。
static class Point2D.Float
          Float 类以 float 精度定义指定的点。
static class QuadCurve2D.Double
          使用 double 坐标指定的二次参数曲线段。
static class QuadCurve2D.Float
          使用 float 坐标指定的二次参数曲线段。
static class Rectangle2D.Double
          Double 类定义一个在 double 坐标中指定的矩形。
static class Rectangle2D.Float
          Float 类定义一个在 float 坐标中指定的矩形。
static class RoundRectangle2D.Double
          Double 类定义一个所有圆角都使用 double 坐标指定的矩形。
static class RoundRectangle2D.Float
          Float 类定义一个所有圆角都使用 float 坐标指定的矩形。
 

java.awt.image 中 Serializable 的使用
 

实现 Serializable 的 java.awt.image 中的类
 class ImagingOpException
          如果某个 BufferedImageOp 或 RasterOp 过滤器方法无法处理图像，则抛出 ImagingOpException。
 class RasterFormatException
          如果 Raster 中存在无效的布局信息，则抛出 RasterFormatException。
 

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

实现 Serializable 的 java.awt.image.renderable 中的类
 class ParameterBlock
          ParameterBlock 封装有关 RenderableImageOp 所需的源和参数 (Object) 的所有信息，或者其他处理图像的类。
 

java.awt.print 中 Serializable 的使用
 

实现 Serializable 的 java.awt.print 中的类
 class PrinterAbortException
          PrinterAbortException 类是 PrinterException 的子类，用于指示用户或应用程序在打印过程中终止打印作业。
 class PrinterException
          PrinterException 类及其子类用于指示打印系统中发生的异常情况。
 class PrinterIOException
          PrinterIOException 类是 PrinterException 的子类，用于指示在打印过程中发生了某种 IO 错误。
 

java.beans 中 Serializable 的使用
 

实现 Serializable 的 java.beans 中的类
 class IndexedPropertyChangeEvent
          无论何时遵守 JavaBeans 规范的组件（"bean"）更改绑定 (bound) 索引 (indexed) 属性，都会提交一个 "IndexedPropertyChange" 事件。
 class IntrospectionException
          在 Introspection 期间发生异常时抛出异常。
 class PropertyChangeEvent
          无论 bean 何时更改 "bound" 或 "constrained" 属性，都会提交一个 "PropertyChange" 事件。
 class PropertyChangeSupport
          这是一个实用工具类，支持绑定 (bound) 属性的 bean 可以使用该类。
 class PropertyVetoException
          当某一属性的提议更改表示一个不可接受的值时，将抛出 PropertyVetoException。
 class VetoableChangeSupport
          这是一个实用工具类，支持约束 (constrained) 属性的 bean 可以使用此类。
 

java.beans.beancontext 中 Serializable 的使用
 

实现 Serializable 的 java.beans.beancontext 中的类
 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 static class BeanContextServicesSupport.BCSSServiceProvider
          子类可以为此嵌套类创建子类，以便为每个 BeanContextServicesProvider 添加行为。
 class BeanContextSupport
          此帮助器类提供 java.beans.beancontext.BeanContext 接口的实用工具实现。
protected  class BeanContextSupport.BCSChild
           
 

返回 Serializable 的 java.beans.beancontext 中的方法
protected static Serializable BeanContextSupport.getChildSerializable(Object child)
          获得与指定 Child 相关联的 Serializable（如果有）
 

java.io 中 Serializable 的使用
 

java.io 中 Serializable 的子接口
 interface Externalizable
          Externalizable 实例类的唯一特性是可以被写入序列化流中，该类负责保存和恢复实例内容。
 

实现 Serializable 的 java.io 中的类
 class CharConversionException
          用于字符转换异常的基类。
 class EOFException
          当输入过程中意外到达文件或流的末尾时，抛出此异常。
 class File
          文件和目录路径名的抽象表示形式。
 class FileNotFoundException
          当试图打开指定路径名表示的文件失败时，抛出此异常。
 class FilePermission
          此类表示对文件和目录的访问。
 class InterruptedIOException
          I/O 操作已中断信号，抛出此异常。
 class InvalidClassException
          当 Serialization 运行时检测到某个类具有以下问题之一时，抛出此异常。
 class InvalidObjectException
          指示一个或多个反序列化对象未通过验证测试。
 class IOError
          当发生严重的 I/O 错误时，抛出此错误。
 class IOException
          当发生某种 I/O 异常时，抛出此异常。
 class NotActiveException
          当序列化和反序列化不活动时，抛出此异常。
 class NotSerializableException
          当实例需要具有序列化接口时，抛出此异常。
 class ObjectStreamClass
          类的序列化描述符。
 class ObjectStreamException
          特定于 Object Stream 类的所有异常的超类。
 class OptionalDataException
          指示对象读取操作失败的异常，原因是无法读取流中的基本数据或已序列化对象的数据末尾。
 class SerializablePermission
          此类用于可序列化权限。
 class StreamCorruptedException
          当从对象流中读取的控制信息与内部一致性检查相冲突时，抛出此异常。
 class SyncFailedException
          当 sync 操作失败时，抛出此异常。
 class UnsupportedEncodingException
          不支持字符编码。
 class UTFDataFormatException
          在数据输入流中或由实现该数据输入接口的任何类中以 UTF-8 修改版格式读取错误字符串时，抛出此异常。
 class WriteAbortedException
          在写入操作过程中抛出 ObjectStreamException 之一的信号。
 

java.lang 中 Serializable 的使用
 

实现 Serializable 的 java.lang 中的类
 class AbstractMethodError
          当应用程序试图调用一个抽象方法时，抛出此错误。
 class ArithmeticException
          当出现异常的运算条件时，抛出此异常。
 class ArrayIndexOutOfBoundsException
          用非法索引访问数组时抛出的异常。
 class ArrayStoreException
          试图将错误类型的对象存储到一个对象数组时抛出的异常。
 class AssertionError
          抛出该异常指示某个断言失败。
 class Boolean
          Boolean 类将基本类型为 boolean 的值包装在一个对象中。
 class Byte
          Byte 类将基本类型 byte 的值包装在一个对象中。
 class Character
          Character 类在对象中包装一个基本类型 char 的值。
 class Class<T>
          Class 类的实例表示正在运行的 Java 应用程序中的类和接口。
 class ClassCastException
          当试图将对象强制转换为不是实例的子类时，抛出该异常。
 class ClassCircularityError
          当初始化类时检测到类的循环调用的时候，抛出该错误。
 class ClassFormatError
          当 Java 虚拟机试图读取类文件并确定该文件存在格式错误或无法解释为类文件时，抛出该错误。
 class ClassNotFoundException
          当应用程序试图使用以下方法通过字符串名加载类时，抛出该异常： Class 类中的 forName 方法。
 class CloneNotSupportedException
          当调用 Object 类中的 clone 方法复制对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。
 class Double
          Double 类在对象中包装一个基本类型 double 的值。
 class Enum<E extends Enum<E>>
          这是所有 Java 语言枚举类型的公共基本类。
 class EnumConstantNotPresentException
          当应用程序试图通过名称和枚举类型访问那些不包含具有指定名称的常量的枚举常量时，抛出该异常。
 class Error
          Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。
 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 InstantiationError
          当应用程序试图使用 Java 的 new 结构来实例化一个抽象类或一个接口时，抛出该异常。
 class InstantiationException
          当应用程序试图使用 Class 类中的 newInstance 方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常。
 class Integer
          Integer 类在对象中包装了一个基本类型 int 的值。
 class InternalError
          该异常指示 Java 虚拟机中出现一些意外的内部错误。
 class InterruptedException
          当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时，抛出该异常。
 class LinkageError
          LinkageError 的子类指示一个类在一定程度上依赖于另一个类；但是，在编译前一个类之后，后一个类发生了不相容的改变。
 class Long
          Long 类在对象中包装了基本类型 long 的值。
 class NegativeArraySizeException
          如果应用程序试图创建大小为负的数组，则抛出该异常。
 class NoClassDefFoundError
          当 Java 虚拟机或 ClassLoader 实例试图在类的定义中加载（作为通常方法调用的一部分或者作为使用 new 表达式创建的新实例的一部分），但无法找到该类的定义时，抛出此异常。
 class NoSuchFieldError
          如果应用程序试图访问或修改一个指定的对象字段，而该对象不再包含该字段时，抛出该异常。
 class NoSuchFieldException
          类不包含指定名称的字段时产生的信号。
 class NoSuchMethodError
          当应用程序试图调用类（静态或实例）的指定方法，而该类已不再具有该方法的定义时，抛出该异常。
 class NoSuchMethodException
          无法找到某一特定方法时，抛出该异常。
 class NullPointerException
          当应用程序试图在需要对象的地方使用 null 时，抛出该异常。
 class Number
          抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的超类。
 class NumberFormatException
          当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
 class OutOfMemoryError
          因为内存溢出或没有可用的内存提供给垃圾回收器时，Java 虚拟机无法分配一个对象，这时抛出该异常。
 class RuntimeException
          RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。
 class RuntimePermission
          该类用于运行时权限。
 class SecurityException
          由安全管理器抛出的异常，指示存在安全侵犯。
 class Short
          Short 类在对象中包装基本类型 short 的值。
 class StackOverflowError
          当应用程序递归太深而发生堆栈溢出时，抛出该错误。
 class StackTraceElement
          堆栈跟踪中的元素，它由 Throwable.getStackTrace() 返回。
 class String
          String 类代表字符串。
 class StringBuffer
          线程安全的可变字符序列。
 class StringBuilder
          一个可变的字符序列。
 class StringIndexOutOfBoundsException
          此异常由 String 方法抛出，指示索引或者为负，或者超出字符串的大小。
static class Thread.State
          线程状态。
 class ThreadDeath
          调用 Thread 类中带有零参数的 stop 方法时，受害线程将抛出一个 ThreadDeath 实例。
 class Throwable
          Throwable 类是 Java 语言中所有错误或异常的超类。
 class TypeNotPresentException
          当应用程序试图使用表示类型名称的字符串对类型进行访问，但无法找到带有指定名称的类型定义时，抛出该异常。
 class UnknownError
          当 Java 虚拟机中出现一个未知但严重的异常时，抛出该错误。
 class UnsatisfiedLinkError
          当 Java 虚拟机无法找到声明为 native 的方法的适当本地语言定义时，抛出该错误。
 class UnsupportedClassVersionError
          当 Java 虚拟机试图读取一个类文件，并确定文件的主辅版本号不受支持时，抛出该错误。
 class UnsupportedOperationException
          当不支持请求的操作时，抛出该异常。
 class VerifyError
          当“校验器”检测到一个类文件虽然格式正确，但包含着一些内部不一致性或安全性问题时，抛出该错误。
 class VirtualMachineError
          当 Java 虚拟机崩溃或用尽了它继续操作所需的资源时，抛出该错误。
 

java.lang.annotation 中 Serializable 的使用
 

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

java.lang.instrument 中 Serializable 的使用
 

实现 Serializable 的 java.lang.instrument 中的类
 class IllegalClassFormatException
          当其输入参数无效时，由 ClassFileTransformer.transform 的实现抛出该异常。
 class UnmodifiableClassException
          在无法修改指定类之一时，由 Instrumentation.redefineClasses 的实现抛出此异常。
 

java.lang.management 中 Serializable 的使用
 

实现 Serializable 的 java.lang.management 中的类
 class ManagementPermission
          使用 SecurityManager 运行的代码调用 Java 平台的管理接口中定义的方法时，SecurityManager 将要检查的权限。
 class MemoryType
          内存池的类型。
 

java.lang.reflect 中 Serializable 的使用
 

实现 Serializable 的 java.lang.reflect 中的类
 class GenericSignatureFormatError
          当需要解释类型、方法或构造方法的一般签名信息的反射方法遇到语法错误的签名属性时，抛出该错误。
 class InvocationTargetException
          InvocationTargetException 是一种包装由调用方法或构造方法所抛出异常的经过检查的异常。
 class MalformedParameterizedTypeException
          当反射方法遇到语义错误的参数化类型，而反射方法需要实例化该类型时，抛出该异常。
 class Proxy
          Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。
 class ReflectPermission
          反射操作的 Permission 类。
 class UndeclaredThrowableException
          如果代理实例的调用处理程序的 invoke 方法抛出一个经过检查的异常（不可分配给 RuntimeException 或 Error 的 Throwable），且该异常不可分配给该方法（在代理实例上调用该方法，并将其指派到调用处理程序）的 throws 子句中声明的任何异常类，则由代理实例上的方法调用抛出此异常。
 

java.math 中 Serializable 的使用
 

实现 Serializable 的 java.math 中的类
 class BigDecimal
          不可变的、任意精度的有符号十进制数。
 class BigInteger
          不可变的任意精度的整数。
 class MathContext
          该对象是封装上下文设置的不可变对象，它描述数字运算符的某些规则，例如由 BigDecimal 类实现的规则。
 class RoundingMode
          为可能丢弃精度的数值操作指定一种舍入行为。
 

java.net 中 Serializable 的使用
 

实现 Serializable 的 java.net 中的类
static class Authenticator.RequestorType
          请求验证的实体的类型。
 class BindException
          试图将套接字绑定到本地地址和端口时发生错误的情况下，抛出此异常。
 class ConnectException
          试图将套接字连接到远程地址和端口时发生错误的情况下，抛出此异常。
 class HttpRetryException
          抛出此异常指示 HTTP 请求需要重试，但由于启用了流模式而无法自动重试。
 class Inet4Address
          此类表示 Internet Protocol version 4 (IPv4) 地址。
 class Inet6Address
          此类表示互联网协议第 6 版 (IPv6) 地址。
 class InetAddress
          此类表示互联网协议 (IP) 地址。
 class InetSocketAddress
          此类实现 IP 套接字地址（IP 地址 + 端口号）。
 class MalformedURLException
          抛出这一异常指示出现了错误的 URL。
 class NetPermission
          此类可用于各种网络权限。
 class NoRouteToHostException
          试图将套接字连接到远程地址和端口时发生错误的情况下，抛出此异常。
 class PortUnreachableException
          在连接的数据报上已接收到 ICMP Port Unreachable 消息时，抛出该异常。
 class ProtocolException
          抛出此异常指示在底层协议中存在错误，如 TCP 错误。
static class Proxy.Type
          表示代理类型。
 class SocketAddress
          此类表示不带任何协议附件的 Socket Address。
 class SocketException
          抛出此异常指示在底层协议中存在错误，如 TCP 错误。
 class SocketPermission
          此类表示通过套接字对网络的访问。
 class SocketTimeoutException
          如果在读取或接受套接字时发生超时，则抛出此异常。
 class UnknownHostException
          指示主机 IP 地址无法确定而抛出的异常。
 class UnknownServiceException
          抛出这一异常指示出现了未知服务异常。
 class URI
          表示一个统一资源标识符 (URI) 引用。
 class URISyntaxException
          抛出经过检查的指示字符串不能解析为 URI 引用的异常。
 class URL
          类 URL 代表一个统一资源定位符，它是指向互联网“资源”的指针。
 

java.nio 中 Serializable 的使用
 

实现 Serializable 的 java.nio 中的类
 class BufferOverflowException
          当相关 put 操作达到目标缓冲区限制时，抛出此未经检查的异常。
 class BufferUnderflowException
          当相关 get 操作达到源缓冲区限制时，抛出此未经检查的异常。
 class InvalidMarkException
          当试图重置一个尚未定义其标记的缓冲区时，抛出此未检查的异常。
 class ReadOnlyBufferException
          当在只读缓冲区上调用内容可变（content-mutation）的方法（例如 put 或 compact 方法）时，抛出此未经检查的异常。
 

java.nio.channels 中 Serializable 的使用
 

实现 Serializable 的 java.nio.channels 中的类
 class AlreadyConnectedException
          试图对已经连接的 SocketChannel 进行连接时抛出的未经检查的异常。
 class AsynchronousCloseException
          当在某个信道的 I/O 操作中处于阻塞状态的某个线程被另一个线程关闭了该信道或部分信道时，该信道所接收的经过检查的异常。
 class CancelledKeyException
          当试图使用不再有效的选择键时，抛出此未经检查的异常。
 class ClosedByInterruptException
          当在某个信道的 I/O 操作中处于阻塞状态的某个线程被另一个线程中断时，该线程将收到此经过检查的异常。
 class ClosedChannelException
          当试图对已关闭的、或者至少对某个 I/O 操作已关闭的信道上调用或完成该操作时，抛出此经过检查的异常。
 class ClosedSelectorException
          试图在已关闭的选择器上调用 I/O 操作时抛出的未经检查的异常。
 class ConnectionPendingException
          试图连接一个正在进行非阻塞连接操作的 SocketChannel 时抛出的未经检查的异常。
 class FileLockInterruptionException
          当某个线程正在等待获取文件锁定时被另一个线程中断，则由该线程接收此经过检查的异常。
 class IllegalBlockingModeException
          当以错误的阻塞模式调用特定于某个阻塞模式的操作时，抛出此未经检查的异常。
 class IllegalSelectorException
          试图将一个通道注册到一个不是由创建该通道的提供者所创建的选择器时，抛出此未经检查的异常。
 class NoConnectionPendingException
          在没有首先成功调用 connect 方法的情况下调用 SocketChannel 的 finishConnect 方法时，抛出此未经检查的异常。
 class NonReadableChannelException
          试图对一个最初未允许对其进行读取操作的通道进行读取时，抛出此未经检查的异常。
 class NonWritableChannelException
          试图对一个最初未允许对其进行写入操作的通道进行写入时，抛出此未经检查的异常。
 class NotYetBoundException
          试图在尚未绑定的服务器套接字通道上调用 I/O 操作时，抛出此未经检查的异常。
 class NotYetConnectedException
          试图在尚未连接的套接字通道上调用 I/O 操作时，抛出此未经检查的异常。
 class OverlappingFileLockException
          试图获取某个文件区域上的锁定，而该区域与同一 Java 虚拟机已锁定的某个区域重叠时，或者当另一个线程已经等待锁定同一文件的重叠区域时，抛出此未经检查的异常。
 class UnresolvedAddressException
          试图对未解析的套接字地址调用网络操作时，抛出此未经检查的异常。
 class UnsupportedAddressTypeException
          试图绑定或连接到一个其类型不受支持的套接字地址时，抛出此未经检查的异常。
 

java.nio.charset 中 Serializable 的使用
 

实现 Serializable 的 java.nio.charset 中的类
 class CharacterCodingException
          出现字符编码或解码错误时，抛出此经过检查的异常。
 class CoderMalfunctionError
          当 CharsetDecoder 的 decodeLoop 方法，或 CharsetEncoder 的 encodeLoop 方法抛出不可预料的异常时抛出的错误。
 class IllegalCharsetNameException
          将一个不是合法 charset 名称的字符串用作 charset 名称时，抛出此未经检查的异常。
 class MalformedInputException
          当输入字节序列对于给定 charset 来说是不合法的，或者输入字符序列不是合法的 16 位 Unicode 序列时，抛出此经过检查的异常。
 class UnmappableCharacterException
          当输入字符（或字节）序列有效，但不能被映射为输出字节（或字符）序列时，抛出此经过检查的异常。
 class UnsupportedCharsetException
          当不支持请求的 charset 时，抛出此未经检查的异常。
 

java.rmi 中 Serializable 的使用
 

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

java.rmi.activation 中 Serializable 的使用
 

实现 Serializable 的 java.rmi.activation 中的类
 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。
 

java.rmi.dgc 中 Serializable 的使用
 

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

java.rmi.server 中 Serializable 的使用
 

java.rmi.server 中 Serializable 的子接口
 interface RemoteRef
          RemoteRef 表示远程对象的句柄。
 interface ServerRef
          ServerRef 表示远程对象实现的服务器端句柄。
 

实现 Serializable 的 java.rmi.server 中的类
 class ExportException
          ExportException 是在尝试导出远程对象失败时抛出的 RemoteException。
 class ObjID
          ObjID 是用于标识导出到 RMI 运行时的远程对象。
 class RemoteObject
          该 RemoteObject 类实现远程对象的 java.lang.Object 行为。
 class RemoteObjectInvocationHandler
          与 Java Remote Method Invocation（Java 远程方法调用，即 Java RMI）一起使用的 InvocationHandler 接口的实现。
 class RemoteServer
          该 RemoteServer 类是服务器实现的公共超类，并提供支持大量远程引用语义的框架。
 class RemoteStub
          该 RemoteStub 类是客户机 stub 的公共超类，并提供支持大量远程引用语义的框架。
 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。
 

java.security 中 Serializable 的使用
 

java.security 中 Serializable 的子接口
 interface Key
          Key 是所有密钥的顶层接口。
 interface PrivateKey
          私钥。
 interface PublicKey
          公钥。
 

实现 Serializable 的 java.security 中的类
 class AccessControlException
           此异常由 AccessController 抛出，提示请求的访问（对关键系统资源（如文件系统或网络）的访问）被拒绝。
 class AllPermission
          AllPermission 是暗含所有其他权限的权限。
 class AuthProvider
          此类定义 provider 的登录和注销方法。
 class BasicPermission
          BasicPermission 类扩展 Permission 类，并且可以用作希望与 BasicPermission 遵守相同命名约定的权限的基类。
 class CodeSigner
          此类封装关于代码签名者的信息。
 class CodeSource
          此类扩展 codebase 的概念，不仅可以封装位置 (URL) 而且可以封装用于验证起源于该位置的签名代码的证书链。
 class DigestException
          此为一般 Message Digest 异常。
 class GeneralSecurityException
          GeneralSecurityException 类是一个一般安全异常类，可以为所有从其扩展的与安全有关的异常类提供类型安全。
 class GuardedObject
          GuardedObject 是一个用来保护对另一个对象的访问的对象。
 class Identity
          已过时。 不再使用此类。其功能已经由 java.security.KeyStore、java.security.cert 包和 java.security.Principal 取代。
 class IdentityScope
          已过时。 此类不再被使用。其功能已经由 java.security.KeyStore、java.security.cert 包和 java.security.Principal 取代。
 class InvalidAlgorithmParameterException
          用于无效或不合适的算法参数的异常。
 class InvalidKeyException
          用于无效 Key（无效的编码、错误的长度、未初始化等）的异常。
 class InvalidParameterException
          当将无效参数传递给某个方法时抛出此异常，设计该异常供 JCA/JCE 引擎类使用。
 class KeyException
          此异常是基本的密钥异常。
 class KeyManagementException
          此异常是用于所有处理密钥管理的操作的通用密钥管理异常。
 class KeyPair
          此类是简单的密钥对（公钥和私钥）持有者。
 class KeyRep
          已序列化的 Key 对象的标准表示形式。
static class KeyRep.Type
          Key 类型。
 class KeyStoreException
          这是一般的 KeyStore 异常。
 class NoSuchAlgorithmException
          当请求特定的加密算法而它在该环境中不可用时抛出此异常。
 class NoSuchProviderException
          当请求特定安全性 provider 但它在该环境中不可用时抛出此异常。
 class Permission
          表示访问系统资源的抽象类。
 class PermissionCollection
          表示 Permission 对象集合的抽象类。
 class Permissions
          此类表示一个不同种类的 Permission 集合。
 class PrivilegedActionException
          doPrivileged(PrivilegedExceptionAction) 和 doPrivileged(PrivilegedExceptionAction, AccessControlContext context) 抛出此异常来指示执行的操作抛出了经过检查的异常。
 class Provider
          此类表示 Java 安全 API "provider"，这里 provider 实现了 Java 安全性的一部分或者全部。
 class ProviderException
          用于 Provider 异常(例如误配置错误或不可恢复的内部错误）的运行时异常，Provider 可以为它创建子类以抛出特殊的、特定于 provider 的运行时错误。
 class SecureRandom
          此类提供强加密随机数生成器 (RNG)。
 class SecureRandomSpi
          此类为 SecureRandom 类定义了服务提供者接口 (SPI)。
 class SecurityPermission
          此类用于安全权限。
 class SignatureException
          这是一般的签名异常。
 class SignedObject
           SignedObject 是一个用来创建实际运行时对象的类，在检测不到这些对象的情况下，其完整性不会遭受损害。
 class Signer
          已过时。 将不再使用此类。其功能已由 java.security.KeyStore、java.security.cert 包和 java.security.Principal 所取代。
 class Timestamp
          此类封装有关签署时间戳的信息。
 class UnrecoverableEntryException
          如果 keystore 中的某项无法恢复，则抛出此异常。
 class UnrecoverableKeyException
          如果 keystore 中的密钥无法恢复，则抛出此异常。
 class UnresolvedPermission
          UnresolvedPermission 类用来保持初始化 Policy 时“未解析”的权限。
 

参数类型为 Serializable 的 java.security 中的构造方法
SignedObject(Serializable object, PrivateKey signingKey, Signature signingEngine)
          通过任何可序列化对象构造 SignedObject。
 

java.security.acl 中 Serializable 的使用
 

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

java.security.cert 中 Serializable 的使用
 

实现 Serializable 的 java.security.cert 中的类
 class Certificate
          管理各种身份证书的抽象类。
protected static class Certificate.CertificateRep
          用于序列化的替换 Certificate 类。
 class CertificateEncodingException
          证书编码异常。
 class CertificateException
          此异常指示各种证书问题中的一种。
 class CertificateExpiredException
          证书过期异常。
 class CertificateNotYetValidException
          证书尚无效异常。
 class CertificateParsingException
          证书解析异常。
 class CertPath
          不可变的证书序列（证书路径）。
protected static class CertPath.CertPathRep
          用于序列化的替换 CertPath 类。
 class CertPathBuilderException
          指示在使用 CertPathBuilder 构建证书路径时遇到了某种问题的异常。
 class CertPathValidatorException
          指示在验证一个证书路径时遇到了某种问题的异常。
 class CertStoreException
          指示从 CertStore 中获取证书和 CRL 时遇到了某种问题的异常。
 class CRLException
          CRL（证书撤消列表）异常。
 class X509Certificate
           X.509 证书的抽象类。
 

java.security.interfaces 中 Serializable 的使用
 

java.security.interfaces 中 Serializable 的子接口
 interface DSAPrivateKey
          DSA 专用密钥的标准接口。
 interface DSAPublicKey
          DSA 公用密钥的接口。
 interface ECPrivateKey
          椭圆曲线 (EC) 专用密钥的接口。
 interface ECPublicKey
          椭圆曲线 (EC) 公用密钥的接口。
 interface RSAMultiPrimePrivateCrtKey
          如 PKCS#1 v2.1 中所定义的，使用 Chinese Remainder Theorem (CRT) 信息值的 RSA 多素数专用密钥的接口。
 interface RSAPrivateCrtKey
          如 PKCS#1 标准中所定义的，使用 Chinese Remainder Theorem (CRT) 信息值的 RSA 专用密钥的接口。
 interface RSAPrivateKey
          RSA 专用密钥的接口。
 interface RSAPublicKey
          RSA 公用密钥的接口。
 

java.security.spec 中 Serializable 的使用
 

实现 Serializable 的 java.security.spec 中的类
 class InvalidKeySpecException
          这是针对无效密钥规范的异常。
 class InvalidParameterSpecException
          这是针对无效参数规范的异常。
 

java.sql 中 Serializable 的使用
 

实现 Serializable 的 java.sql 中的类
 class BatchUpdateException
          进行批量更新操作期间发生错误时抛出的 SQLException 子类。
 class ClientInfoStatus
          无法通过调用 Connection.setClientInfo 设置属性的原因状态的枚举。
 class DataTruncation
          以 DataTruncation 异常形式抛出的异常（写入时），或者由于除数据值超出 MaxFieldSize 之外的某种原因意外地截断该数据值时以 DataTruncation 警告形式报告的异常（读取时）。
 class RowIdLifetime
          RowId 生存期值的枚举。
 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 值。
 

java.text 中 Serializable 的使用
 

实现 Serializable 的 java.text 中的类
static class AttributedCharacterIterator.Attribute
          定义用于标识文本属性的属性键。
 class ChoiceFormat
          ChoiceFormat 允许将格式应用到某个范围的数。
 class DateFormat
          DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。
static class DateFormat.Field
          定义了各种常量，这些常量用作 DateFormat.formatToCharacterIterator 所返回的 AttributedCharacterIterator 中的属性键和 FieldPosition 中的字段标识符。
 class DateFormatSymbols
          DateFormatSymbols 是一个公共类，用于封装可本地化的日期-时间格式化数据，如月名、星期几的名称和时区数据。
 class DecimalFormat
          DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。
 class DecimalFormatSymbols
          此类表示了 DecimalFormat 格式化数字所需的符号集（如小数点、组分隔符等等）。
 class Format
          Format 是一个用于格式化语言环境敏感的信息（如日期、消息和数字）的抽象基类。
static class Format.Field
          定义在 AttributedCharacterIterator（从 Format.formatToCharacterIterator 返回）中用作属性键和在 FieldPosition 中用作字段标识符的常量。
 class MessageFormat
          MessageFormat 提供了以与语言无关方式生成连接消息的方式。
static class MessageFormat.Field
          在从 MessageFormat.formatToCharacterIterator 返回的 AttributedCharacterIterator 中定义用作属性键的常量。
static class Normalizer.Form
          此枚举提供在 Unicode Standard Annex #15 — Unicode Normalization Forms 中描述的四个 Unicode 标准化形式的常量，以及访问这些常量的两个方法。
 class NumberFormat
          NumberFormat 是所有数值格式的抽象基类。
static class NumberFormat.Field
          定义将用作从 NumberFormat.formatToCharacterIterator 返回的 AttributedCharacterIterator 中属性键以及 FieldPosition 中字段标识符的常量。
 class ParseException
          表示解析时出现意外错误。
 class SimpleDateFormat
          SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。
 

java.util 中 Serializable 的使用
 

实现 Serializable 的 java.util 中的类
static class AbstractMap.SimpleEntry<K,V>
          维护键和值的 Entry。
static class AbstractMap.SimpleImmutableEntry<K,V>
          维护不可变的键和值的 Entry。
 class ArrayDeque<E>
          Deque 接口的大小可变数组的实现。
 class ArrayList<E>
          List 接口的大小可变数组的实现。
 class BitSet
          此类实现了一个按需增长的位向量。
 class Calendar
          Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
 class ConcurrentModificationException
          当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
 class Currency
          表示货币。
 class Date
          类 Date 表示特定的瞬间，精确到毫秒。
 class DuplicateFormatFlagsException
          格式说明符中提供重复标志时抛出的未经检查的异常。
 class EmptyStackException
          该异常由 Stack 类中的方法抛出，以表明堆栈为空。
 class EnumMap<K extends Enum<K>,V>
          与枚举类型键一起使用的专用 Map 实现。
 class EnumSet<E extends Enum<E>>
          与枚举类型一起使用的专用 Set 实现。
 class EventObject
           所有事件状态对象都将从其派生的根类。
 class FormatFlagsConversionMismatchException
          转换与标志不兼容时抛出未经检查的异常。
static class Formatter.BigDecimalLayoutForm
           
 class FormatterClosedException
          格式器已关闭时抛出的未经检查的异常。
 class GregorianCalendar
          GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。
 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 Locale
          Locale 对象表示了特定的地理、政治和文化地区。
 class MissingFormatArgumentException
          如果格式说明符没有相应的参数，或者参数索引引用了不存在的参数时，则抛出未经检查的异常。
 class MissingFormatWidthException
          请求格式宽度时抛出未经检查的异常。
 class MissingResourceException
          缺少资源时抛出此异常。
 class NoSuchElementException
          由 Enumeration 的 nextElement 方法抛出，表明枚举中没有更多的元素。
 class PriorityQueue<E>
          一个基于优先级堆的无界优先级队列。
 class Properties
          Properties 类表示了一个持久的属性集。
 class PropertyPermission
          此类用于属性权限。
 class Random
          此类的实例用于生成伪随机数流。
 class ServiceConfigurationError
          在加载服务提供者的过程中出错时抛出的错误。
 class SimpleTimeZone
          SimpleTimeZone 是 TimeZone 的具体子类，表示一个使用格里高利历的时区。
 class Stack<E>
          Stack 类表示后进先出（LIFO）的对象堆栈。
 class TimeZone
          TimeZone 表示时区偏移量，也可以计算夏令时。
 class TooManyListenersException
           TooManyListenersException 异常用作 Java Event 模型的一部分来注释和实现多播 Event Source 的单播特例。
 class TreeMap<K,V>
          基于红黑树（Red-Black tree）的 NavigableMap 实现。
 class TreeSet<E>
          基于 TreeMap 的 NavigableSet 实现。
 class UnknownFormatConversionException
          给定未知的转换时所抛出的未经检查的异常。
 class UnknownFormatFlagsException
          给定未知标志时所抛出的未经检查的异常。
 class UUID
          表示通用唯一标识符 (UUID) 的类。
 class Vector<E>
          Vector 类可以实现可增长的对象数组。
 

java.util.concurrent 中 Serializable 的使用
 

实现 Serializable 的 java.util.concurrent 中的类
 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 的一个线程安全的变体，其中所有可变操作（add、set 等等）都是通过对底层数组进行一次新的复制来实现的。
 class CopyOnWriteArraySet<E>
          对其所有操作使用内部 CopyOnWriteArrayList 的 Set。
 class ExecutionException
          当试图获取已通过抛出异常而中止的任务的结果时，抛出此异常。
 class LinkedBlockingDeque<E>
          一个基于已链接节点的、任选范围的阻塞双端队列。
 class LinkedBlockingQueue<E>
          一个基于已链接节点的、范围任意的 blocking queue。
 class PriorityBlockingQueue<E>
          一个无界阻塞队列，它使用与类 PriorityQueue 相同的顺序规则，并且提供了阻塞获取操作。
 class RejectedExecutionException
          当无法执行某个任务时,由 Executor 抛出的异常。
 class Semaphore
          一个计数信号量。
 class SynchronousQueue<E>
          一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。
 class TimeoutException
          阻塞操作超时时，抛出该异常。
 class TimeUnit
          TimeUnit 表示给定单元粒度的时间段，它提供在这些单元中进行跨单元转换和执行计时及延迟操作的实用工具方法。
 

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

实现 Serializable 的 java.util.concurrent.atomic 中的类
 class AtomicBoolean
          可以用原子方式更新的 boolean 值。
 class AtomicInteger
          可以用原子方式更新的 int 值。
 class AtomicIntegerArray
          可以用原子方式更新其元素的 int 数组。
 class AtomicLong
          可以用原子方式更新的 long 值。
 class AtomicLongArray
          可以用原子方式更新其元素的 long 数组。
 class AtomicReference<V>
          可以用原子方式更新的对象引用。
 class AtomicReferenceArray<E>
          可以用原子方式更新其元素的对象引用数组。
 

java.util.concurrent.locks 中 Serializable 的使用
 

实现 Serializable 的 java.util.concurrent.locks 中的类
 class AbstractOwnableSynchronizer
          可以由线程以独占方式拥有的同步器。
 class AbstractQueuedLongSynchronizer
          以 long 形式维护同步状态的一个 AbstractQueuedSynchronizer 版本。
 class AbstractQueuedLongSynchronizer.ConditionObject
          作为 Lock 实现基础的 AbstractQueuedLongSynchronizer 的条件实现。
 class AbstractQueuedSynchronizer
          为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和相关同步器（信号量、事件，等等）提供一个框架。
 class AbstractQueuedSynchronizer.ConditionObject
          AbstractQueuedSynchronizer 的 Condition 实现是 Lock 实现的基础。
 class ReentrantLock
          一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。
 class ReentrantReadWriteLock
          支持与 ReentrantLock 类似语义的 ReadWriteLock 实现。
static class ReentrantReadWriteLock.ReadLock
          ReentrantReadWriteLock.readLock() 方法返回的锁。
static class ReentrantReadWriteLock.WriteLock
          ReentrantReadWriteLock.writeLock() 方法返回的锁。
 

java.util.jar 中 Serializable 的使用
 

实现 Serializable 的 java.util.jar 中的类
 class JarException
          读取或写入 JAR 文件时，如果发生某种错误，则抛出此异常。
 

java.util.logging 中 Serializable 的使用
 

实现 Serializable 的 java.util.logging 中的类
 class Level
          Level 类定义了一组可用来控制日志输出的标准日志级别。
 class LoggingPermission
          当 SecurityManager 运行的代码调用某个日志记录控制方法（如 Logger.setLevel）时，SecurityManager 将要检查的权限。
 class LogRecord
          LogRecord 对象用于在日志框架和单个日志 Handler 之间传递日志请求。
 

java.util.prefs 中 Serializable 的使用
 

实现 Serializable 的 java.util.prefs 中的类
 class BackingStoreException
          抛出该异常表明由于内部存储故障或者不能联系内部存储而无法完成 preferences 操作。
 class InvalidPreferencesFormatException
          抛出此异常表明根据 Preferences 规范，输入内容不符合 preferences 集的正确 XML 文档类型，从而无法完成操作。
 class NodeChangeEvent
          Preferences 节点发出的事件，用于指示已添加或移除该节点的子节点。
 class PreferenceChangeEvent
          Preferences 节点发出的事件，用于指示已经添加或移除首选项，或者首选项的值已被更改。
 

java.util.regex 中 Serializable 的使用
 

实现 Serializable 的 java.util.regex 中的类
 class Pattern
          正则表达式的编译表示形式。
 class PatternSyntaxException
          抛出未经检查的异常，表明正则表达式模式中的语法错误。
 

java.util.zip 中 Serializable 的使用
 

实现 Serializable 的 java.util.zip 中的类
 class DataFormatException
          当数据格式发生错误时，抛出此异常。
 class ZipError
          发生不可恢复的错误时抛出。
 class ZipException
          如果某种 ZIP 异常发生，则抛出此错误。
 

javax.activation 中 Serializable 的使用
 

实现 Serializable 的 javax.activation 中的类
 class ActivationDataFlavor
          ActivationDataFlavor 类是 java.awt.datatransfer.DataFlavor 的一个特殊子类。
 class MimeType
          RFC 2045 和 2046 中定义的多用途 Internet 邮件扩展（Multipurpose Internet Mail Extension，MIME）类型。
 class UnsupportedDataTypeException
          当请求操作不支持请求的数据类型时，抛出此异常。
 

javax.activity 中 Serializable 的使用
 

实现 Serializable 的 javax.activity 中的类
 class ActivityCompletedException
          任何访问 Activity 上下文的方法都可能抛出此异常，它指示不能继续在 Activity 内部执行操作。
 class ActivityRequiredException
          如果方法没有接收到它所要求的 Activity 上下文，则容器将抛出此异常。
 class InvalidActivityException
          任何访问 Activity 上下文的方法都可能抛出此异常，它指示尝试调用或与尝试调用相关的 Activity 上下文与 Activity 的当前状态不兼容。
 

javax.annotation 中 Serializable 的使用
 

实现 Serializable 的 javax.annotation 中的类
static class Resource.AuthenticationType
          资源的两种可能验证类型。
 

javax.annotation.processing 中 Serializable 的使用
 

实现 Serializable 的 javax.annotation.processing 中的类
 class FilerException
          指示一个检测到试图打开某一文件的 Filer，该文件违反 Filer 提供的保证。
 

javax.crypto 中 Serializable 的使用
 

javax.crypto 中 Serializable 的子接口
 interface SecretKey
          秘密（对称）密钥。
 

实现 Serializable 的 javax.crypto 中的类
 class BadPaddingException
          当输入数据期望特定的填充机制而数据又未正确填充时，抛出此异常。
 class ExemptionMechanismException
          此为一般 ExemptionMechanism 异常。
 class IllegalBlockSizeException
          如果提供给块密码的数据长度不正确（即与密码的块大小不匹配），则抛出此异常。
 class NoSuchPaddingException
          当请求特定填充机制但该环境中未提供时，抛出此异常。
 class SealedObject
          此类使程序员能够用加密算法创建对象并保护其机密性。
 class ShortBufferException
          当用户提供的输出缓冲区太小而不能存储操作结果时，抛出此异常。
 

参数类型为 Serializable 的 javax.crypto 中的构造方法
SealedObject(Serializable object, Cipher c)
          从任何 Serializable 对象构造一个 SealedObject。
 

javax.crypto.interfaces 中 Serializable 的使用
 

javax.crypto.interfaces 中 Serializable 的子接口
 interface DHPrivateKey
          Diffie-Hellman 私钥接口。
 interface DHPublicKey
          Diffie-Hellman 公钥接口。
 interface PBEKey
          调用者 PBE 密钥接口。
 

javax.crypto.spec 中 Serializable 的使用
 

实现 Serializable 的 javax.crypto.spec 中的类
 class SecretKeySpec
          此类以与 provider 无关的方式指定一个密钥。
 

javax.imageio 中 Serializable 的使用
 

实现 Serializable 的 javax.imageio 中的类
 class IIOException
          该异常类用于发出关于读取和写入操作的运行时故障的信号。
 

javax.imageio.metadata 中 Serializable 的使用
 

实现 Serializable 的 javax.imageio.metadata 中的类
 class IIOInvalidTreeException
          当 IIOMetadata 对象尝试解析 IIOMetadataNode 的树失败时，将抛出 IIOInvalidTreeException。
 

javax.jws 中 Serializable 的使用
 

实现 Serializable 的 javax.jws 中的类
static class WebParam.Mode
          参数的流向。
 

javax.jws.soap 中 Serializable 的使用
 

实现 Serializable 的 javax.jws.soap 中的类
static class SOAPBinding.ParameterStyle
          参数到 SOAP 消息的映射关系的样式。
static class SOAPBinding.Style
          SOAP 绑定样式。
static class SOAPBinding.Use
          SOAP 绑定的使用。
 

javax.lang.model 中 Serializable 的使用
 

实现 Serializable 的 javax.lang.model 中的类
 class SourceVersion
          Java™ 编程语言的源版本。
 

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

实现 Serializable 的 javax.lang.model.element 中的类
 class ElementKind
          元素的 kind。
 class Modifier
          表示程序元素（如类、方法或字段）上的修饰符。
 class NestingKind
          某一类型元素的嵌套种类 (nesting kind)。
 class UnknownAnnotationValueException
          指示遇到一个未知种类的注释值。
 class UnknownElementException
          指示遇到一个未知种类的元素。
 

javax.lang.model.type 中 Serializable 的使用
 

实现 Serializable 的 javax.lang.model.type 中的类
 class MirroredTypeException
          当应用程序试图访问对应于 TypeMirror 的 Class 对象时，抛出此异常。
 class MirroredTypesException
          当应用程序试图访问每个对应于 TypeMirror 的 Class 对象的序列时，抛出此异常。
 class TypeKind
          类型镜像的种类。
 class UnknownTypeException
          指示遇到未知种类的类型。
 

javax.management 中 Serializable 的使用
 

javax.management 中 Serializable 的子接口
 interface Descriptor
          JMX 元素的附加元数据。
 interface NotificationFilter
          可由作为通知过滤器的任何类来实现。
 interface QueryExp
          表示可在数据库查询“where 子句”中使用的相关约束。
 interface ValueExp
          表示可以作为参数传递给关系表达式的值。
 

实现 Serializable 的 javax.management 中的类
 class Attribute
          通过将 MBean 属性名与其值相关联来表示 MBean 属性。
 class AttributeChangeNotification
          提供 MBean 所发送的属性更改通知的定义。
 class AttributeChangeNotificationFilter
          此类实现 attribute change notification 的 NotificationFilter 接口。
 class AttributeList
          表示 MBean 属性值的列表。
 class AttributeNotFoundException
          指定的属性不存在或无法检索。
 class AttributeValueExp
          表示用作关系约束参数的属性。
 class BadAttributeValueExpException
          向构造的查询方法传递无效的 MBean 属性时，抛出此异常。
 class BadBinaryOpValueExpException
          向构造查询的方法传递无效的表达式时，抛出此异常。
 class BadStringOperationException
          向构造查询的方法传递无效的字符串操作时，抛出此异常。
 class ImmutableDescriptor
          不可变的描述符。
 class InstanceAlreadyExistsException
          已经在存储库中注册了 MBean。
 class InstanceNotFoundException
          存储库中不存在指定的 MBean。
 class InvalidApplicationException
          试图应用下列任一内容时抛出此异常：对 MBean 应用子查询表达式或对错误类的 MBean 应用完全限定属性表达式。
 class InvalidAttributeValueException
          指定的值对该属性无效。
 class JMException
          由 JMX 实现所抛出的异常。
 class JMRuntimeException
          由 JMX 实现所发出的运行时异常。
 class ListenerNotFoundException
          存储库中不存在指定的 MBean 侦听器。
 class MalformedObjectNameException
          字符串的格式不对应于有效的 ObjectName。
 class MBeanAttributeInfo
          描述出于管理目的而公开的 MBean 属性。
 class MBeanConstructorInfo
          描述 MBean 所公开的构造方法。
 class MBeanException
          表示由代理的 MBean 方法所抛出的“用户定义的”异常。
 class MBeanFeatureInfo
          提供 MBean 描述符对象的常规信息。
 class MBeanInfo
          描述由 MBean 公开的管理接口；即描述为管理操作所提供的属性和操作的集合。
 class MBeanNotificationInfo
          MBeanNotificationInfo 类用于描述 MBean 向给定的 Java 通知类发出的不同通知实例的特性。
 class MBeanOperationInfo
          描述由 MBean 公开的管理操作。
 class MBeanParameterInfo
          描述由 MBean 公开的操作的参数。
 class MBeanPermission
          权限控制对 MBeanServer 操作的访问。
 class MBeanRegistrationException
          包装由 MBeanRegistration 接口的 preRegister() 和 preDeregister() 方法所抛出的异常。
 class MBeanServerNotification
          表示 MBean 服务器通过 MBeanServerDelegate MBean 所发出的通知。
 class MBeanServerPermission
          执行与 MBeanServer 关联的操作的 Permission。
 class MBeanTrustPermission
          此权限表示“信任”签名者或代码基。
 class NotCompliantMBeanException
          尝试在 MBean 服务器中注册一个对象，而该对象不是 JMX 兼容的 MBean 时出现此异常。
 class Notification
          Notification 类表示 MBean 所发出的通知。
 class NotificationFilterSupport
          提供 NotificationFilter 接口的实现。
 class ObjectInstance
          用于表示 MBean 对象名及其类名。
 class ObjectName
          表示 MBean 的对象名，或者能够与多个 MBean 名称相匹配的模式。
 class OperationsException
          表示在 MBean 上执行操作时，在 MBean 服务器中抛出的异常。
 class QueryEval
          允许在特定的 MBean 服务器上下文中执行查询。
 class ReflectionException
          表示在使用 java.lang.reflect 类调用 MBean 上的方法时，MBean 服务器中抛出的异常。
 class RuntimeErrorException
          当代理中发生 java.lang.Error 时，必须捕获它并作为 RuntimeErrorException 重新抛出。
 class RuntimeMBeanException
          表示由代理中的 MBean 方法抛出的运行时异常。
 class RuntimeOperationsException
          表示在 MBean 上执行操作时代理中抛出的运行时异常。
 class ServiceNotFoundException
          表示请求的服务不受支持时引发的异常。
 class StringValueExp
          表示作为关系约束变量的字符串。
 

javax.management.loading 中 Serializable 的使用
 

实现 Serializable 的 javax.management.loading 中的类
 class MLet
          允许实例化和注册来自远程 URL 的 MBean 服务器中一个或几个 MBean。
 class PrivateMLet
          不添加到 ClassLoaderRepository 的 MLet。
 

javax.management.modelmbean 中 Serializable 的使用
 

实现 Serializable 的 javax.management.modelmbean 中的类
 class DescriptorSupport
          此类表示 ModelMBean 元素的元数据集。
 class InvalidTargetObjectTypeException
          当指定了无效的目标对象类型时，抛出此异常。
 class ModelMBeanAttributeInfo
          ModelMBeanAttributeInfo 对象描述了 ModelMBean 的属性。
 class ModelMBeanConstructorInfo
          ModelMBeanConstructorInfo 对象描述了 ModelMBean 的一个构造方法。
 class ModelMBeanInfoSupport
          此类表示 ModelMBean 的元数据。
 class ModelMBeanNotificationInfo
          ModelMBeanNotificationInfo 对象描述了由 ModelMBean 发出的通知。
 class ModelMBeanOperationInfo
          ModelMBeanOperationInfo 对象描述了 ModelMBean 的管理操作。
 class XMLParseException
          当将某个 XML 格式的字符串解析为 ModelMBean 对象，或从 ModelMBean 对象创建 XML 格式的字符串时，抛出此异常。
 

javax.management.monitor 中 Serializable 的使用
 

实现 Serializable 的 javax.management.monitor 中的类
 class MonitorNotification
          提供对监视器 MBean 发送的通知的定义。
 class MonitorSettingException
          当监视器设置在运行监视器期间变得无效时由该监视器抛出的异常。
 

javax.management.openmbean 中 Serializable 的使用
 

实现 Serializable 的 javax.management.openmbean 中的类
 class ArrayType<T>
          ArrayType 类是一种开放类型 类，其实例描述了作为开放数据 值的 n 维数组的所有开放数据 值。
 class CompositeDataSupport
          CompositeDataSupport 类是实现 CompositeData 接口的开放数据 类。
 class CompositeType
          CompositeType 类是开放类型 类，它的实例描述了 CompositeData 值的类型。
 class InvalidOpenTypeException
          当开放数据 值的开放类型 不是期望的类型时，抛出此运行时异常。
 class KeyAlreadyExistsException
          当添加到表格数据 实例的行索引已用于引用此表格数据 实例中的另一行时，抛出此运行时异常。
 class OpenDataException
          因为无法满足一个或多个有效性约束，所以无法构造开放类型、开放数据 或 open MBean 元数据信息 实例时，抛出此经过检查的异常。
 class OpenMBeanAttributeInfoSupport
          描述 open MBean 的一个属性。
 class OpenMBeanConstructorInfoSupport
          描述 Open MBean 的构造方法。
 class OpenMBeanInfoSupport
          OpenMBeanInfoSupport 类描述 open MBean 的管理信息：它是 MBeanInfo 的子类，并且实现了 OpenMBeanInfo 接口。
 class OpenMBeanOperationInfoSupport
          描述 Open MBean 的一个操作。
 class OpenMBeanParameterInfoSupport
          描述用于 open MBean 的一个或多个操作或构造方法的参数。
 class OpenType<T>
          OpenType 类是所有类的父抽象类，它描述开放数据值的实际开放类型。
 class SimpleType<T>
          SimpleType 类是开放类型 类，其实例描述所有开放数据 值，这些值既不是数组，也不是 CompositeData 值，更不是 TabularData 值。
 class TabularDataSupport
          TabularDataSupport 类是实现 TabularData 和 Map 接口的开放数据 类，并且在内部它是基于哈希映射数据结构的。
 class TabularType
          TabularType 类是开放类型 类，它的实例描述了 TabularData 值的类型。
 

javax.management.relation 中 Serializable 的使用
 

javax.management.relation 中 Serializable 的子接口
 interface RelationType
          该 RelationType 接口必须由期望表示关系类型的任何类来实现。
 

实现 Serializable 的 javax.management.relation 中的类
 class InvalidRelationIdException
          为关系提供的关系 id 已使用时引发此异常。
 class InvalidRelationServiceException
          提供无效 Relation Service（关系服务）时引发此异常。
 class InvalidRelationTypeException
          无效的关系类型。
 class InvalidRoleInfoException
          在角色信息中，其最小程度大于其最大程度时，引发此异常。
 class InvalidRoleValueException
          角色值无效。
 class MBeanServerNotificationFilter
          MBeanServerNotification 的过滤器。
 class RelationException
          此类是关系管理过程中引发的任何异常的超类。
 class RelationNotFoundException
          Relation Service（关系服务）中不存在给定关系 id 的关系时引发此异常。
 class RelationNotification
          Relation Service（关系服务）中的更改通知。
 class RelationServiceNotRegisteredException
          在对 Relation Service（关系服务）进行访问而该 Relation Service 未注册时引发此异常。
 class RelationTypeNotFoundException
          Relation Service（关系服务）中不存在带给定名称的关系类型时引发此异常。
 class RelationTypeSupport
          RelationTypeSupport 对象实现 RelationType 接口。
 class Role
          表示角色：包括角色名称和引用的 MBean（通过其 ObjectName）。
 class RoleInfo
          RoleInfo 概括介绍关系类型中的角色。
 class RoleInfoNotFoundException
          给定的关系类型中不存在带指定名称的角色信息时引发此异常。
 class RoleList
          RoleList 表示角色（Role 对象）的列表。
 class RoleNotFoundException
          关系中的某个角色不存在，或不可读，或不可设置时，引发此异常。
 class RoleResult
          表示对一个关系的几个角色多个访问的结果（可以是读取，也可以是写入）。
 class RoleUnresolved
          表示未解析的角色：由于存在问题而无法从关系中检索到的角色。
 class RoleUnresolvedList
          RoleUnresolvedList 表示 RoleUnresolved 对象的列表，这些对象代表在试图访问角色（进行读取或写入）时遇到问题而无法从关系检索到的角色。
 

javax.management.remote 中 Serializable 的使用
 

实现 Serializable 的 javax.management.remote 中的类
 class JMXConnectionNotification
          在客户端连接打开或关闭时，或者当通知丢失时发出的通知。
 class JMXPrincipal
          JMX Remote API 的远程客户端的身份。
 class JMXProviderException
          当提供者存在所需的协议但由于某种原因不能使用时由 JMXConnectorFactory 和 JMXConnectorServerFactory 抛出的异常。
 class JMXServerErrorException
          在处理远程 MBean 服务器中的调用的过程中抛出了 Error 时，远程 MBeanServer 方法调用导致抛出的异常。
 class JMXServiceURL
          JMX API 连接器服务器的地址。
 class NotificationResult
          缓存的通知的查询结果。
 class SubjectDelegationPermission
          授权标识表示验证标识执行操作所需的权限。
 class TargetedNotification
          一个 (Notification, Listener ID) 对。
 

javax.management.remote.rmi 中 Serializable 的使用
 

实现 Serializable 的 javax.management.remote.rmi 中的类
 class RMIConnectionImpl_Stub
           
 class RMIConnector
          一个到远程 RMI 连接器的连接。
 class RMIServerImpl_Stub
           
 

javax.management.timer 中 Serializable 的使用
 

实现 Serializable 的 javax.management.timer 中的类
 class TimerNotification
          此类定义了由计时器 MBean 发送的通知。
 

javax.naming 中 Serializable 的使用
 

javax.naming 中 Serializable 的子接口
 interface Name
          Name 接口表示一个一般名称，即一个有序的组件序列。
 

实现 Serializable 的 javax.naming 中的类
 class AuthenticationException
          当访问命名或目录服务发生验证错误时，抛出此异常。
 class AuthenticationNotSupportedException
          当所请求验证的特定 flavor 不受支持时，抛出此异常。
 class BinaryRefAddr
          此类表示通信终端地址的二进制形式。
 class Binding
          此类表示上下文中一个名称到对象的绑定。
 class CannotProceedException
          抛出此异常指示操作到达了名称中的某一点，在该点上操作无法继续进行。
 class CommunicationException
          当客户端无法与目录或命名服务通信时，抛出此异常。
 class CompositeName
          此类表示一个复合名称，即一个跨多个名称空间组件名称的序列。
 class CompoundName
          此类表示一个组合名称，即一个取自层次名称空间的名称。
 class ConfigurationException
          当存在配置问题时，抛出此异常。
 class ContextNotEmptyException
          当试图销毁一个不为空的上下文时，抛出此异常。
 class InsufficientResourcesException
          当无法使用资源完成所请求的操作时，抛出此异常。
 class InterruptedNamingException
          当正被调用的命名操作已经被中断时，抛出此异常。
 class InvalidNameException
          此异常指示被指定的名称不符合命名系统的命名语法。
 class LimitExceededException
          当某一方法因为用户或系统指定的限制而异常终止时，抛出此异常。
 class LinkException
          此异常用于描述解析链接时遇到的问题。
 class LinkLoopException
          当检测到的某个循环试图解析某一链接，或者已达到某一特定于实现的链接计数限制时，抛出此异常。
 class LinkRef
          此类表示一个 Reference，其内容是绑定到上下文中的原子名称的一个名称，称为链接名称 (link name)。
 class MalformedLinkException
          如果在解析或构造链接时遇到错误链接，则抛出此异常。
 class NameAlreadyBoundException
          一些方法抛出此异常来指示因为名称已经绑定到另一个对象而无法添加某一绑定。
 class NameClassPair
          此类表示存在于上下文中的某一绑定的对象名称和类名称对。
 class NameNotFoundException
          当名称的组件由于没有被绑定而无法解析时，抛出此异常。
 class NamingException
          此异常是 Context 和 DirContext 接口中的操作抛出的所有异常的超类。
 class NamingSecurityException
          此异常是 Context 和 DirContext 接口中的操作所抛出的与安全有关的异常的超类。
 class NoInitialContextException
          当不能创建任何初始上下文实现时，抛出此异常。
 class NoPermissionException
          当试图执行某一操作，而客户端没有执行该操作的权限时，抛出此异常。
 class NotContextException
          当命名操作进行到需要上下文来继续该操作的某处，而解析的对象不是一个上下文时，抛出此异常。
 class OperationNotSupportedException
          当上下文实现不支持将调用的操作时，抛出此异常。
 class PartialResultException
          抛出此异常指示结果正在返回或者到目前为止只返回了部分结果，并且操作无法完成。
 class RefAddr
          此类表示通信端点的地址。
 class Reference
          此类表示对存在于命名/目录系统以外的对象的引用。
 class ReferralException
          此抽象类用于表示一个引用异常，该异常是在响应某一引用（比如 LDAP v3 服务器返回的引用）时生成的。
 class ServiceUnavailableException
          当试图与目录或命名服务通信，而该服务不可用时，抛出此异常。
 class SizeLimitExceededException
          当某一方法生成的结果超出与大小有关的限制时，抛出此异常。
 class StringRefAddr
          此类表示通信终端地址的字符串形式。
 class TimeLimitExceededException
          当某一方法没有在指定的时间限制内终止时，抛出此异常。
 

javax.naming.directory 中 Serializable 的使用
 

javax.naming.directory 中 Serializable 的子接口
 interface Attribute
          此接口表示与命名对象关联的属性。
 interface Attributes
          此接口表示属性的集合。
 

实现 Serializable 的 javax.naming.directory 中的类
 class AttributeInUseException
          当操作试图添加已经存在的属性时抛出此异常。
 class AttributeModificationException
          当试图添加、移除或修改与属性的（模式）定义或属性的状态有冲突的属性、属性标识符或属性值时抛出此异常。
 class BasicAttribute
          此类提供 Attribute 接口的基本实现。
 class BasicAttributes
          此类提供 Attributes 接口的基本实现。
 class InvalidAttributeIdentifierException
          在试图用无效的属性标识符创建属性时，抛出此异常。
 class InvalidAttributesException
          在尝试添加或修改不完全或不正确地指定的属性集时，抛出此异常。
 class InvalidSearchControlsException
          在为搜索操作指定的 SearchControls 无效时，抛出此异常。
 class InvalidSearchFilterException
          当指定的搜索过滤器无效时，抛出此异常。
 class ModificationItem
          此类表示修改项。
 class NoSuchAttributeException
          尝试访问不存在的属性时，抛出此异常。
 class SchemaViolationException
          当方法在某些方面违反模式时，抛出此异常。
 class SearchControls
          此类封装确定搜索范围和搜索返回结果的因子。
 class SearchResult
          此类表示作为 DirContext.search() 方法的结果返回的 NamingEnumeration 中的一项。
 

javax.naming.event 中 Serializable 的使用
 

实现 Serializable 的 javax.naming.event 中的类
 class NamingEvent
          此类表示命名/目录服务触发的事件。
 class NamingExceptionEvent
          此类表示用来收集通知 NamingEvent 侦听器的信息的过程/进程抛出 NamingException 时触发的事件。
 

javax.naming.ldap 中 Serializable 的使用
 

javax.naming.ldap 中 Serializable 的子接口
 interface Control
          此接口表示在 RFC 2251 中定义的 LDAPv3 控件。
 interface ExtendedRequest
          此接口表示在 RFC 2251 中定义的 LDAPv3 扩展操作请求。
 interface ExtendedResponse
          此接口表示在 RFC 2251 中定义的 LDAP 扩展操作响应。
 interface UnsolicitedNotification
          此接口表示在 RFC 2251 中定义的未经请求的通知。
 

实现 Serializable 的 javax.naming.ldap 中的类
 class BasicControl
          此类提供 Control 接口的基本实现。
 class LdapName
          此类表示 RFC 2253 指定的标识名。
 class LdapReferralException
          此抽象类用于表示 LDAP 引用异常。
 class ManageReferralControl
          将引用和其他特殊 LDAP 对象作为普通 LDAP 对象处理的请求。
 class PagedResultsControl
          请求由 LDAP 服务器以指定的大小批量返回搜索操作的结果。
 class PagedResultsResponseControl
          指示一批搜索结果的末尾。
 class Rdn
          此类表示相对标识名，或 RDN，它是一个 RFC 2253 指定的标识名组件。
 class SortControl
          请求 LDAP 服务器在返回搜索操作的结果前对这些结果进行排序。
 class SortResponseControl
          指示搜索结果的请求排序是否成功。
 class StartTlsRequest
          此类实现在 Lightweight Directory Access Protocol (v3): Extension for Transport Layer Security 中定义的 StartTLS 的 LDAPv3 扩展请求。
 class StartTlsResponse
          此类实现在 Lightweight Directory Access Protocol (v3): Extension for Transport Layer Security 中定义的 StartTLS 的 LDAPv3 扩展响应。
 class UnsolicitedNotificationEvent
          此类表示为响应 LDAP 服务器发送的未经请求的通知而触发的事件。
 

javax.naming.spi 中 Serializable 的使用
 

实现 Serializable 的 javax.naming.spi 中的类
 class ResolveResult
          此类表示解析某一名称的结果。
 

javax.net.ssl 中 Serializable 的使用
 

实现 Serializable 的 javax.net.ssl 中的类
 class HandshakeCompletedEvent
          此事件指示在给定的 SSL 连接上 SSL 握手结束。
static class SSLEngineResult.HandshakeStatus
          描述此 SSLEngine 的当前握手状态的 SSLEngineResult 枚举。
static class SSLEngineResult.Status
          描述 SSLEngine 操作总体结果的 SSLEngineResult 枚举。
 class SSLException
          指示由 SSL 子系统检测到的某类错误。
 class SSLHandshakeException
          指示客户端和服务器不能就所需安全级别进行协商。
 class SSLKeyException
          报告错误的 SSL 密钥。
 class SSLPeerUnverifiedException
          指示还没有验证同位体的身份。
 class SSLPermission
          此类用于各种网络权限。
 class SSLProtocolException
          报告在 SSL 协议的操作中的错误。
 class SSLSessionBindingEvent
          此事件向 SSLSessionBindingListener 传播。
 

javax.print 中 Serializable 的使用
 

实现 Serializable 的 javax.print 中的类
 class DocFlavor
          类 DocFlavor 封装了一个对象，该对象指定提供给 DocPrintJob 的打印数据的格式。
static class DocFlavor.BYTE_ARRAY
          类 DocFlavor.BYTE_ARRAY 提供了预定义的静态常量 DocFlavor 对象，例如使用 byte 数组 (byte[]) 作为打印数据表示形式类的 DocFlavor。
static class DocFlavor.CHAR_ARRAY
          类 DocFlavor.CHAR_ARRAY 提供了预定义的静态常量 DocFlavor 对象，例如使用字符数组 (char[]) 作为打印数据表示形式类的 DocFlavor。
static class DocFlavor.INPUT_STREAM
          类 DocFlavor.INPUT_STREAM 提供了预定义的静态常量 DocFlavor 对象，例如使用 byte 流 (java.io.InputStream) 作为打印数据表示形式类的 DocFlavor。
static class DocFlavor.READER
          类 DocFlavor.READER 提供了预定义的静态常量 DocFlavor 对象，例如使用字符流 (java.io.Reader) 作为打印数据表示形式类的 DocFlavor。
static class DocFlavor.SERVICE_FORMATTED
          类 DocFlavor.SERVICE_FORMATTED 提供了预定义的静态常量 DocFlavor 对象，例如用于服务格式化打印数据的 DocFlavor。
static class DocFlavor.STRING
          类 DocFlavor.STRING 提供了预定义的静态常量 DocFlavor 对象，例如使用字符串 (java.lang.String) 作为打印数据表示形式类的 DocFlavor。
static class DocFlavor.URL
          类 DocFlavor.URL 提供了预定义的静态常量 DocFlavor 对象。
 class PrintException
          类 PrintException 封装了与打印有关的错误状况，此状况在使用 PrintService 实例时会发生。
 

javax.print.attribute 中 Serializable 的使用
 

javax.print.attribute 中 Serializable 的子接口
 interface DocAttribute
          接口 DocAttribute 是打印属性类实现的一个标记接口，用于指示属性表示文档 (doc) 的设置（“Doc”是一个简短的、容易发音的术语，指“打印数据的片段”。
 interface PrintJobAttribute
          PrintJobAttribute 是打印属性类实现的标记接口，以指示该属性描述“打印作业”的状态或“打印作业”的一些其他特征。
 interface PrintRequestAttribute
          接口 PrintRequestAttribute 是打印属性类实现的标记接口，以指示属性表示用于打印作业的请求设置。
 interface PrintServiceAttribute
          接口 PrintServiceAttribute 是打印属性类实现的标记接口，以指示该属性描述“打印服务”的状态或“打印服务”的一些其他特征。
 interface SupportedValuesAttribute
          接口 SupportedValuesAttribute 是打印属性类实现的标记接口，以指示该属性描述用于其他属性的支持值。
 

实现 Serializable 的 javax.print.attribute 中的类
 class DateTimeSyntax
          类 DateTimeSyntax 是一个抽象的基类，它提供其值是日期和时间的所有属性的公共实现。
 class EnumSyntax
          类 EnumSyntax 是一个抽象的基类，它提供所有“类型安全枚举”对象的公共实现。
 class HashAttributeSet
          类 HashAttributeSet 提供具有哈希映射特征的 AttributeSet 实现。
 class HashDocAttributeSet
          类 HashDocAttributeSet 提供从类 HashAttributeSet 继承其实现的属性集，并强制执行接口 DocAttributeSet 的语义限制。
 class HashPrintJobAttributeSet
          类 HashPrintJobAttributeSet 提供从类 HashAttributeSet 继承其实现的属性集，并强制执行接口 PrintJobAttributeSet 的语义限制。
 class HashPrintRequestAttributeSet
          类 HashPrintRequestAttributeSet 从类 HashAttributeSet 继承其实现，并强制执行接口 PrintRequestAttributeSet 的语义限制。
 class HashPrintServiceAttributeSet
          类 HashPrintServiceAttributeSet 提供从类 HashAttributeSet 继承其实现的属性集，并强制执行接口 PrintServiceAttributeSet 的语义限制。
 class IntegerSyntax
          类 IntegerSyntax 是一个抽象的基类，它提供具有整数值的所有属性的公共实现。
 class ResolutionSyntax
          类 ResolutionSyntax 是一种抽象的基类，它提供表示打印机分辨率的所有属性的公共实现。
 class SetOfIntegerSyntax
          类 SetOfIntegerSyntax 是一种抽象的基类，它提供其值是非负整数集合的所有属性的公共实现。
 class Size2DSyntax
          类 Size2DSyntax 是一种抽象的基类，它提供表示二维大小的所有属性的公共实现。
 class TextSyntax
          类 TextSyntax 是一种抽象的基类，它提供其值是字符串的所有属性的公共实现。
 class UnmodifiableSetException
          当由于设置不可修改而无法执行请求的操作时，抛出该异常。
 class URISyntax
          类 URISyntax 是一种抽象的基类，它提供其值是统一资源标识符 (URI) 的所有属性的公共实现。
 

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

实现 Serializable 的 javax.print.attribute.standard 中的类
 class Chromaticity
          Chromaticity 类是打印属性类，它是一个枚举值，指定单色打印或彩色打印。
 class ColorSupported
          ColorSupported 类是打印属性类，它是一个枚举值，标识了设备是否能够支持任何类型的彩色打印，包括高亮颜色和全处理颜色 (full process color)。
 class Compression
          Compression 类是打印属性类，它是一个枚举值，指定如何压缩打印数据。
 class Copies
          Copies 类是整数值形式的打印属性类，它指定了要打印的份数。
 class CopiesSupported
          CopiesSupported 类是打印属性类，它是一个整数集，给出了支持的 Copies 属性的值。
 class DateTimeAtCompleted
          DateTimeAtCompleted 类是打印属性类，它是一个日期-时间属性，指示 Print Job 完成（或取消或中止）的日期和时间。
 class DateTimeAtCreation
          DateTimeAtCreation 类是打印属性类，它是一个日期-时间属性，指示创建 Print Job 时的日期和时间。
 class DateTimeAtProcessing
          DateTimeAtProcessing 类是打印属性类，它是一个日期-时间属性，指示首次开始处理 Print Job 的日期和时间。
 class Destination
          Destination 类是打印属性类，它是一个 URI，用于指示进入缓冲池的打印机格式的数据的可选目标。
 class DocumentName
          DocumentName 类是打印属性类，它是一个文本属性，指定了文档名称。
 class Fidelity
          Fidelity 类是打印属性类，它是一个枚举值，指示客户机提供的请求属性是否要求具有总体保真度。
 class Finishings
          Finishings 类是打印属性类，它是一个枚举值，标识了打印机是否将某个正在完成的某类绑定操作应用到作业中每个打印文档的每个副本中。
 class JobHoldUntil
          JobHoldUntil 类是打印属性类，它是一个日期-时间属性，指定了作业必须成为候选打印作业的准确日期和时间。
 class JobImpressions
          JobImpressions 类是整数值形式的打印属性类，它指定了正提交的文档（或多个文档）的印张的总大小。
 class JobImpressionsCompleted
          JobImpressionsCompleted 类是整数值形式的打印属性类，它指定了到目前为止已完成作业的印数。
 class JobImpressionsSupported
          JobImpressionsSupported 类是打印属性类，它是一个整数集，给出了支持的 JobImpressions 属性值。
 class JobKOctets
          JobKOctets 类是整数值形式的打印属性类，它指定了以 K 字节为单位的文档总大小，即以要在作业中处理的所请求的 1024 字节为单位。
 class JobKOctetsProcessed
          JobKOctetsProcessed 类是整数值形式的打印属性类，它指定了到目前为止已处理的打印数据字节总数，以 K 字节为单位，即以 1024 字节为单位。
 class JobKOctetsSupported
          JobKOctetsSupported 类是打印属性类，它是一个整数集，给出了支持的 JobKOctets 属性的值。
 class JobMediaSheets
          JobMediaSheets 类是整数值形式的打印属性类，它指定了要为此作业生成的介质纸张总数。
 class JobMediaSheetsCompleted
          JobMediaSheetsCompleted 类是整数值形式的打印属性类，它指定了到目前为止全部作业的已完成标记和堆栈的介质纸张数，不管这些纸张完成的是单面处理还是双面处理。
 class JobMediaSheetsSupported
          Class JobMediaSheetsSupported 类是打印属性类，它是一个整数集，给出了支持的 JobMediaSheets 属性。
 class JobMessageFromOperator
          JobMessageFromOperator 类是打印属性类，它是一个文本属性，提供操作员、系统管理员或“智能”进程传来的消息，向终端用户指示某个作业上的修改或其他管理操作的原因。
 class JobName
          JobName 类是打印属性类，它是一个文本属性，指定了打印作业的名称。
 class JobOriginatingUserName
          JobOriginatingUserName 类是打印属性类，它是一个文本属性，包含提交打印作业的终端用户的名称。
 class JobPriority
          JobPriority 类是整数值形式的打印属性类，它指定了打印作业的优先级。
 class JobPrioritySupported
          JobPrioritySupported 类是整数值形式的打印属性类，它指定了 Print Service 实例是否支持 JobPriority 属性，以及支持的不同作业优先级数目。
 class JobSheets
          JobSheets 类是打印属性类，它是一个枚举值，确定必须打印作业的开始页和结束页（如果有）。
 class JobState
          JobState 是打印属性类，它是一个枚举值，标识了打印作业的当前状态。
 class JobStateReason
          JobStateReason 类是打印属性类，它是一个枚举值，提供了有关作业当前状态的额外信息，例如，扩充作业的 JobState 属性值的信息。
 class JobStateReasons
          JobStateReasons 类是打印属性类，它是一个枚举值集合，提供了有关作业当前状态的额外信息，即扩充作业的 JobState 属性值的信息。
 class Media
          Media 类是打印属性类，它指定了要在其上打印的介质。
 class MediaName
          MediaName 类是 Media 的子类，它是打印属性类（一个枚举），以名称形式指定了打印作业的介质。
 class MediaPrintableArea
          MediaPrintableArea 类是打印属性类，用于区分介质的可打印区域和不可打印区域。
 class MediaSize
          MediaSize 是二维大小值形式的打印属性类，它指示纵向方向中的介质维度，其中 X 维度沿底边计算，Y 维度沿左边计算。
 class MediaSizeName
          MediaSizeName 类是 Media 的子类。
 class MediaTray
          MediaTray 类是 Media 的子类。
 class MultipleDocumentHandling
          MultipleDocumentHandling 类是打印属性类，它是一个枚举值，控制结束操作和一个或多个打印流在印张中和在介质纸张上的布局。
 class NumberOfDocuments
          NumberOfDocuments 类是整数值形式的打印属性类，它指示打印机已接受此作业的单份文档数，而不管文档的打印数据是否已到达打印机。
 class NumberOfInterveningJobs
          NumberOfInterveningJobs 类是整数值形式的打印属性类，它指示在此作业之前的作业数，这些作业按期望完成的相对时间顺序排序（即当前安排的顺序）。
 class NumberUp
          NumberUp 类是整数值形式的打印属性类，它指定了要放置于选中介质的实例单面上的打印流页数。
 class NumberUpSupported
          NumberUpSupported 类是打印属性类，它是一个整数集，给出了支持的 NumberUp 属性值。
 class OrientationRequested
          OrientationRequested 类是打印属性类，它是一种枚举，指示所打印的打印流页的所需方向；但它不描述客户端提供的打印流页的方向。
 class OutputDeviceAssigned
          OutputDeviceAssigned 类是打印属性类，它是一种文本属性，标识了服务将此作业所分配到的输出设备。
 class PageRanges
          PageRanges 类是打印属性类，它是一个整数集，标识 Printer 对象为所要打印的每个文档的每份副本所使用的打印流页范围。
 class PagesPerMinute
          PagesPerMinute 类是一个整数值的打印属性，它指示与此打印机可生成（例如在单工、黑白设置下）的总页数最接近的每分钟可以生成的额定页数。
 class PagesPerMinuteColor
          PagesPerMinuteColor 类是一个整数值的打印属性，它指示与此打印机可生成（例如在单工、彩色设置下）的总页数最接近的每分钟可以生成的额定页数。
 class PDLOverrideSupported
          PDLOverrideSupported 类是打印属性类，它是一种枚举，表示可使用以打印数据外部的属性方式所指定的处理指令，来重写嵌入到文档打印数据中的处理指令。
 class PresentationDirection
          PresentationDirection 类是打印属性类，它是一种枚举，它与 NumberUp 属性结合使用，以指示应用于所选单面介质实例上多个打印流页的布局。
 class PrinterInfo
          PrinterInfo 类是打印属性类，它是一种文本属性，提供了有关打印机的描述性信息。
 class PrinterIsAcceptingJobs
          PrinterIsAcceptingJobs 类是打印属性类，它是一种枚举，指示打印机当前是否能够接受作业。
 class PrinterLocation
          PrinterLocation 类是打印属性类，它是一种文本属性，标识了设备的位置。
 class PrinterMakeAndModel
          PrinterMakeAndModel 类是打印属性类，它是一种文本属性，说明打印机的制造和型号。
 class PrinterMessageFromOperator
          PrinterMessageFromOperator 类是打印属性类，它是一种文本属性，提供操作员、系统管理员或“智能”进程传来的处理中的消息，可向最终用户指示有关打印机状态（如为什么不可用或者希望何时可用）的信息。
 class PrinterMoreInfo
          PrinterMoreInfo 类是打印属性类，它是一种 URI，用来获取有关此特定打印机的更多信息。
 class PrinterMoreInfoManufacturer
          PrinterMoreInfoManufacturer 类是打印属性类，它是一种 URI，用于获取有关此类型设备的更多信息。
 class PrinterName
          PrinterName 类是打印属性类，它是一种文本属性，指定了打印机的名称。
 class PrinterResolution
          PrinterResolution 类是打印属性类，指定了打印机支持的或将用于打印作业的精确分辨率。
 class PrinterState
          PrinterState 类是打印机属性类，它是一种枚举，标识了打印机的当前状态。
 class PrinterStateReason
          PrinterStateReason 类是打印属性类，它是一个枚举值，提供了有关打印机当前状态的附加信息，即扩充了打印机 PrinterState 属性值的信息。
 class PrinterStateReasons
          PrinterStateReasons 类是打印属性类，它是一组枚举值集合，提供了有关打印机当前状态的附加信息，即扩充了打印机 PrinterState 属性值的信息。
 class PrinterURI
          PrinterURI 类是打印属性类，它是一个 URI，指定了全局唯一的打印机名称。
 class PrintQuality
          PrintQuality 类是打印属性类，它是一种枚举，指定了打印机为该作业使用的打印质量。
 class QueuedJobCount
          QueuedJobCount 类是整数值打印属性，它指示了其 JobState 是 PENDING、PENDING_HELD、PROCESSING 或 PROCESSING_STOPPED 的打印机中的作业数。
 class ReferenceUriSchemesSupported
          ReferenceUriSchemesSupported 类是打印属性类，它是一种枚举，指示了“URI 方案”（如 "http:"或 "ftp:"），打印机可使用它来获取存储在 URI 位置的打印数据。
 class RequestingUserName
          RequestingUserName 类是打印属性类，它是一种文本属性，指定了提交打印作业的最终用户的名称。
 class Severity
          Severity 类是打印属性类，它是一种枚举，表示 PrinterStateReason 属性的严重性。
 class SheetCollate
          SheetCollate 类是打印属性类，它是一种枚举，当由 Copies 属性指定了文档的多个副本时，它可以指定作业中每个打印文档的每个副本的介质纸张是否排列有序。
 class Sides
          Sides 类是打印属性类，它是一种枚举，指定了如何将打印流页应用于选定介质实例的各面（即一个印张）。
 

javax.print.event 中 Serializable 的使用
 

实现 Serializable 的 javax.print.event 中的类
 class PrintEvent
          类 PrintEvent 是所有 Print Service API 事件的超类。
 class PrintJobAttributeEvent
          类 PrintJobAttributeEvent 封装 PrintService 报告的事件，以便让客户端知道 PrintJob 的一个或多个打印属性已更改。
 class PrintJobEvent
          类 PrintJobEvent 封装打印作业报告的常见事件，以便让侦听器知道 DocPrintJob 处理的进度。
 class PrintServiceAttributeEvent
          类 PrintServiceAttributeEvent 封装 Print Service 实例报告的事件，以便让客户端知道打印服务状态的更改。
 

javax.rmi.CORBA 中 Serializable 的使用
 

实现 Serializable 的 javax.rmi.CORBA 中的类
 class ClassDesc
          此类用于对 IIOP 上的 java.lang.Class 对象进行编组。
 class Stub
          必须从其继承所有 RMI-IIOP stub 的基类。
 

返回 Serializable 的 javax.rmi.CORBA 中的方法
 Serializable ValueHandler.readValue(InputStream in, int offset, Class clz, String repositoryID, RunTime sender)
          使用 Java 语义从流中读取一个值。
 Serializable ValueHandler.writeReplace(Serializable value)
          如果该值包含 writeReplace 方法，则返回该结果。
 

参数类型为 Serializable 的 javax.rmi.CORBA 中的方法
 Serializable ValueHandler.writeReplace(Serializable value)
          如果该值包含 writeReplace 方法，则返回该结果。
 void ValueHandler.writeValue(OutputStream out, Serializable value)
          使用 Java 语义将一个值写入流。
 void ValueHandlerMultiFormat.writeValue(OutputStream out, Serializable value, byte streamFormatVersion)
          允许 ORB 为 RMI/IDL 自定义值类型传递流格式版本。
 

javax.rmi.ssl 中 Serializable 的使用
 

实现 Serializable 的 javax.rmi.ssl 中的类
 class SslRMIClientSocketFactory
          SslRMIClientSocketFactory 实例由 RMI 运行时使用，以便通过 SSL 获取 RMI 调用的客户端套接字。
 

javax.script 中 Serializable 的使用
 

实现 Serializable 的 javax.script 中的类
 class ScriptException
          脚本 API 的一般 Exception 类。
 

javax.security.auth 中 Serializable 的使用
 

实现 Serializable 的 javax.security.auth 中的类
 class AuthPermission
          此类用于验证权限。
 class DestroyFailedException
          当 destroy 操作失败时，抛出此异常。
 class PrivateCredentialPermission
          此类用来保护对属于特定 Subject 的私有 Credential 的访问。
 class RefreshFailedException
          当 refresh 操作失败时，抛出此异常。
 class Subject
           Subject 表示某一项（如一个人）的一组相关信息。
 

javax.security.auth.callback 中 Serializable 的使用
 

实现 Serializable 的 javax.security.auth.callback 中的类
 class ChoiceCallback
           底层安全服务实例化一个 ChoiceCallback ，并将它传递给 CallbackHandler 的 handle 方法，以显示选项列表并获取选中的选项。
 class ConfirmationCallback
           底层安全服务实例化 ConfirmationCallback，并将其传递到 CallbackHandler 的 handle 方法，以请求 YES/NO、OK/CANCEL、YES/NO/CANCEL 或其他类似的确认信息。
 class LanguageCallback
           底层安全服务实例化一个 LanguageCallback, 并将其传递给 CallbackHandler 的 handle 方法，以获取用于本地化文本的 Locale。
 class NameCallback
           底层安全服务实例化一个 NameCallback 并将其传递给 CallbackHandler 的 handle 方法，以获取名称信息。
 class PasswordCallback
           底层安全服务实例化一个 PasswordCallback 并将其传递给 CallbackHandler 的 handle 方法，以获取密码信息。
 class TextInputCallback
           底层安全服务实例化一个 TextInputCallback 并将其传递给 CallbackHandler 的 handle 方法，以获取普通的文本信息。
 class TextOutputCallback
           底层安全服务实例化一个 TextOutputCallback 并将其传递给 CallbackHandler 的 handle 方法，以显示信息消息、警告消息和错误消息。
 class UnsupportedCallbackException
          在 CallbackHandler 不能识别特定的 Callback 时发出的信号。
 

javax.security.auth.kerberos 中 Serializable 的使用
 

实现 Serializable 的 javax.security.auth.kerberos 中的类
 class DelegationPermission
          此类用于限制 Kerberos 代理模型（即可转发和可代理票据）的使用。
 class KerberosKey
          此类为 Kerberos 主体封装一个长期秘密密钥。
 class KerberosPrincipal
          此类封装 Kerberos 主体。
 class KerberosTicket
          此类封装了 Kerberos 票据和从客户端的视点所观察到的有关信息。
 class ServicePermission
          此类用于保护 Kerberos 服务和访问这些服务所必需的证书。
 

javax.security.auth.login 中 Serializable 的使用
 

实现 Serializable 的 javax.security.auth.login 中的类
 class AccountException
          一般的帐户异常。
 class AccountExpiredException
          当用户帐户到期时抛出此异常。
 class AccountLockedException
          帐户被锁定时抛出此异常。
 class AccountNotFoundException
          未找到帐户时抛出此异常。
 class CredentialException
          一般证书异常。
 class CredentialExpiredException
          当 Credential 到期时抛出此异常。
 class CredentialNotFoundException
          找不到证书时抛出此异常。
 class FailedLoginException
          当用户验证失败时抛出此异常。
 class LoginException
          此异常是基本的登录异常。
 

javax.security.auth.x500 中 Serializable 的使用
 

实现 Serializable 的 javax.security.auth.x500 中的类
 class X500Principal
           此类表示一个 X.500 Principal。
 

javax.security.sasl 中 Serializable 的使用
 

实现 Serializable 的 javax.security.sasl 中的类
 class AuthorizeCallback
          此回调由 SaslServer 使用，以确定某个实体（由已验证的验证 id 所标识）能否代表另一个实体（由授权 id 所标识）。
 class RealmCallback
          SaslClient 和 SaslServer 使用此回调来获取领域信息。
 class RealmChoiceCallback
          SaslClient 和 SaslServer 使用此回调获得给定领域选项列表的领域。
 class SaslException
          此类表示在使用 SASL 时所发生的错误。
 

javax.sound.midi 中 Serializable 的使用
 

实现 Serializable 的 javax.sound.midi 中的类
 class InvalidMidiDataException
          一个 InvalidMidiDataException，指示遇到了不恰当的 MIDI 数据。
 class MidiUnavailableException
          当请求的 MIDI 组件由于不可用而无法打开或创建时，抛出 MidiUnavailableException 异常。
 

javax.sound.sampled 中 Serializable 的使用
 

实现 Serializable 的 javax.sound.sampled 中的类
 class AudioPermission
          AudioPermission 类表示对音频系统资源的访问权限。
 class LineEvent
          LineEvent 类封装某一行每次打开、关闭、启动或停止时向其侦听器发送的信息。
 class LineUnavailableException
          LineUnavailableException 是指示某一行因为不可用而无法打开的异常。
 class UnsupportedAudioFileException
          UnsupportedAudioFileException 是指示因为文件没有包含可识别文件类型和格式的有效数据而致使操作失败的异常。
 

javax.sql 中 Serializable 的使用
 

实现 Serializable 的 javax.sql 中的类
 class ConnectionEvent
          提供关于连接相关事件的源信息的 Event 对象。
 class RowSetEvent
          RowSet 对象发生事件时生成的 Event 对象。
 class StatementEvent
          StatementEvent 被传送给所有用 PooledConnection 注册的 StatementEventListener。
 

javax.sql.rowset 中 Serializable 的使用
 

实现 Serializable 的 javax.sql.rowset 中的类
 class BaseRowSet
          提供一个具有基本功能的 RowSet 对象的抽象类。
 class RowSetMetaDataImpl
          为设置和获取关于 RowSet 对象列的元数据信息的方法提供实现。
 class RowSetWarning
          SQLException 的一个扩展，提供关于在 RowSet 对象上设置的数据库警告的信息。
 

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

实现 Serializable 的 javax.sql.rowset.serial 中的类
 class SerialArray
          序列化的 Array 对象，它是 SQL ARRAY 值在 Java 编程语言中的映射关系。
 class SerialBlob
          SQL BLOB 值在 Java 编程语言中的序列化映射关系。
 class SerialClob
          SQL CLOB 值在 Java 编程语言中的序列化映射关系。
 class SerialDatalink
          SQL DATALINK 值在 Java 编程语言中的序列化映射关系。
 class SerialException
          指示对 SQL 类型 BLOB、CLOB、STRUCT 或 ARRAY 以及 SQL 类型 DATALINK 和 JAVAOBJECT 进行序列化或反序列化时发生的错误。
 class SerialJavaObject
          SQL JAVA_OBJECT 值在 Java 编程语言中的可序列化映射关系。
 class SerialRef
          Ref 对象的序列化映射关系，它是 SQL REF 值在 Java 编码语言中的映射关系。
 class SerialStruct
          SQL 结构类型在 Java 编程语言中的序列化映射关系。
 

javax.sql.rowset.spi 中 Serializable 的使用
 

实现 Serializable 的 javax.sql.rowset.spi 中的类
 class SyncFactoryException
          指示 SyncFactory 机制发生的错误。
 class SyncProviderException
          指示 SyncProvider 机制发生的错误。
 

javax.swing 中 Serializable 的使用
 

实现 Serializable 的 javax.swing 中的类
 class AbstractAction
          此类提供 JFC Action 接口的默认实现。
 class AbstractButton
          定义按钮和菜单项的一般行为。
protected  class AbstractButton.AccessibleAbstractButton
          此类实现对 AbstractButton 类的可访问性支持。
protected  class AbstractButton.ButtonChangeListener
          将 ChangeListener 扩展为可序列化的。
 class AbstractCellEditor
           
 class AbstractListModel
          该数据模型的抽象定义提供一个带内容的 List。
 class ActionMap
          ActionMap 提供从 Object（称为键 或 Action 名）到 Action 的映射。
 class Box
          使用 BoxLayout 对象作为其布局管理器的一个轻量级容器。
protected  class Box.AccessibleBox
          此类实现 Box 类的可访问性支持。
static class Box.Filler
          参与布局但没有视图的轻量级组件的实现。
protected  class Box.Filler.AccessibleBoxFiller
          此类实现 Box.Filler 类的可访问性支持。
 class BoxLayout
          允许垂直或水平布置多个组件的布局管理器。
 class ButtonGroup
          此类用于为一组按钮创建一个多斥（multiple-exclusion）作用域。
 class CellRendererPane
          此类被插入在单元格渲染器与使用它们的组件之间。
protected  class CellRendererPane.AccessibleCellRendererPane
          此类实现 Panel 类的可访问性支持。
 class ComponentInputMap
          ComponentInputMap 是与特定 JComponent 相关联的 InputMap。
 class DefaultBoundedRangeModel
          BoundedRangeModel 的一般实现。
 class DefaultButtonModel
          Button 组件的数据模型的默认实现。
 class DefaultCellEditor
          表单元格和树单元格的默认编辑器。
protected  class DefaultCellEditor.EditorDelegate
          受保护的 (protected) EditorDelegate 类。
 class DefaultComboBoxModel
          组合框的默认模型。
 class DefaultDesktopManager
          此类是 DesktopManager 的实现。
 class DefaultListCellRenderer
          呈现列表中的一个项。
static class DefaultListCellRenderer.UIResource
          实现 UIResource 的 DefaultListCellRenderer 的子类。
 class DefaultListModel
          此类以松散方式实现 java.util.Vector API，它实现 1.1.x 版本的 java.util.Vector，没有 collection 类支持，并且在发生更改时通知 ListDataListener。
 class DefaultListSelectionModel
          列表选择的默认数据模型。
 class DefaultSingleSelectionModel
          SingleSelectionModel 的一般实现。
 class DropMode
          放置模式，用于确定组件在拖放过程中跟踪和指示放置位置 (drop location) 的方法。
static class GroupLayout.Alignment
          ParallelGroup 能够对齐其子元素的可能方式的枚举。
 class ImageIcon
          一个 Icon 接口的实现，它根据 Image 绘制 Icon。
protected  class ImageIcon.AccessibleImageIcon
          此类实现 ImageIcon 类的可访问性支持。
 class InputMap
          InputMap 提供输入事件（目前只使用 KeyStroke）和 Object 之间的绑定。
 class JApplet
          java.applet.Applet 的扩展版，它添加了对 JFC/Swing 组件架构的支持。
protected  class JApplet.AccessibleJApplet
          此类实现对 JApplet 类的可访问性支持。
 class JButton
          "push" 按钮的实现。
protected  class JButton.AccessibleJButton
          此类实现对 JButton 类的可访问性支持。
 class JCheckBox
          复选框的实现，复选框是一个可以被选定和取消选定的项，它将其状态显示给用户。
protected  class JCheckBox.AccessibleJCheckBox
          此类实现对 JCheckBox 类的可访问性支持。
 class JCheckBoxMenuItem
          可以被选定或取消选定的菜单项。
protected  class JCheckBoxMenuItem.AccessibleJCheckBoxMenuItem
          此类实现对 JCheckBoxMenuItem 类的可访问性支持。
 class JColorChooser
          JColorChooser 提供一个用于允许用户操作和选择颜色的控制器窗格。
protected  class JColorChooser.AccessibleJColorChooser
          此类实现对 JColorChooser 类的可访问性支持。
 class JComboBox
          将按钮或可编辑字段与下拉列表组合的组件。
protected  class JComboBox.AccessibleJComboBox
          此类实现 JComboBox 类的可访问性支持。
 class JComponent
          该类是除顶层容器外所有 Swing 组件的基类。
 class JComponent.AccessibleJComponent
          用于为可访问性提供默认支持的 JComponent 内部类。
 class JDesktopPane
          用于创建多文档界面或虚拟桌面的容器。
protected  class JDesktopPane.AccessibleJDesktopPane
          此类实现对 JDesktopPane 类的可访问性支持。
 class JDialog
          创建对话框窗口的主要类。
protected  class JDialog.AccessibleJDialog
          此类实现对 JDialog 类的可访问性支持。
 class JEditorPane
          可编辑各种内容的文本组件。
protected  class JEditorPane.AccessibleJEditorPane
          此类实现对 JEditorPane 类的可访问性支持。
protected  class JEditorPane.AccessibleJEditorPaneHTML
          此类提供了对 AccessibleHypertext 的支持，并且用于这类实例中：在此 JEditorPane 中安装的 EditorKit 是一个 HTMLEditorKit 实例。
protected  class JEditorPane.JEditorPaneAccessibleHypertextSupport
          AccessibleJEditorPaneHTML.getAccessibleText 返回的内容。
 class JFileChooser
          JFileChooser 为用户选择文件提供了一种简单的机制。
protected  class JFileChooser.AccessibleJFileChooser
          此类实现对 JFileChooser 类的可访问性支持。
 class JFormattedTextField
          JFormattedTextField 扩展了 JTextField，添加了对格式化任意值的支持，以及一旦用户编辑了文本就检索特定对象的支持。
static class JFormattedTextField.AbstractFormatter
           JFormattedTextField 所使用的 AbstractFormatter 实例，用于处理从 Object 到 String 和从 String 到 Object 的转换。
 class JFrame
          java.awt.Frame 的扩展版本，该版本添加了对 JFC/Swing 组件架构的支持。
protected  class JFrame.AccessibleJFrame
          此类实现对 JFrame 类的可访问性支持。
 class JInternalFrame
          提供很多本机窗体功能的轻量级对象，这些功能包括拖动、关闭、变成图标、调整大小、标题显示和支持菜单栏。
protected  class JInternalFrame.AccessibleJInternalFrame
          此类实现对 JInternalFrame 类的可访问性支持。
static class JInternalFrame.JDesktopIcon
          此组件表示 JInternalFrame 的图标化版本。
protected  class JInternalFrame.JDesktopIcon.AccessibleJDesktopIcon
          此类实现对 JInternalFrame.JDesktopIcon 类的可访问性支持。
 class JLabel
          用于短文本字符串或图像或二者的显示区。
protected  class JLabel.AccessibleJLabel
          该类用于获得此对象的可访问性职责。
 class JLayeredPane
          JLayeredPane 为 JFC/Swing 容器添加了深度，允许组件在需要时互相重叠。
protected  class JLayeredPane.AccessibleJLayeredPane
          此类实现对 JLayeredPane 类的可访问性支持。
 class JList
          显示对象列表并且允许用户选择一个或多个项的组件。
protected  class JList.AccessibleJList
          此类实现 JList 类的可访问性支持。
 class JMenu
          菜单的该实现是一个包含 JMenuItem 的弹出窗口，用户选择 JMenuBar 上的项时会显示该 JMenuItem。
protected  class JMenu.AccessibleJMenu
          此类实现 JMenu 类的可访问性支持。
protected  class JMenu.WinListener
          观察弹出窗口关闭的侦听器类。
 class JMenuBar
          菜单栏的实现。
protected  class JMenuBar.AccessibleJMenuBar
          此类实现 JMenuBar 类的可访问性支持。
 class JMenuItem
          菜单中的项的实现。
protected  class JMenuItem.AccessibleJMenuItem
          此类实现 JMenuItem 类的可访问性支持。
 class JOptionPane
          JOptionPane 有助于方便地弹出要求用户提供值或向其发出通知的标准对话框。
protected  class JOptionPane.AccessibleJOptionPane
          此类实现对 JOptionPane 类的可访问性支持。
 class JPanel
          JPanel 是一般轻量级容器。
protected  class JPanel.AccessibleJPanel
          此类实现对 JPanel 类的可访问性支持。
 class JPasswordField
          JPasswordField 是一个轻量级组件，允许编辑单行文本，其视图指示键入内容，但不显示原始字符。
protected  class JPasswordField.AccessibleJPasswordField
          此类实现对 JPasswordField 类的可访问性支持。
 class JPopupMenu
          弹出菜单的实现，弹出菜单是一个可弹出并显示一系列选项的小窗口。
protected  class JPopupMenu.AccessibleJPopupMenu
          此类实现 JPopupMenu 类的可访问性支持。
static class JPopupMenu.Separator
          弹出与菜单有关的分隔符。
 class JProgressBar
          以可视化形式显示某些任务进度的组件。
protected  class JProgressBar.AccessibleJProgressBar
          此类实现 JProgressBar 类的可访问性支持。
 class JRadioButton
          实现一个单选按钮，此按钮项可被选择或取消选择，并可为用户显示其状态。
protected  class JRadioButton.AccessibleJRadioButton
          此类实现对 JRadioButton 类的可访问性支持。
 class JRadioButtonMenuItem
          一个单选按钮菜单项的实现。
protected  class JRadioButtonMenuItem.AccessibleJRadioButtonMenuItem
          此类实现对 JRadioButtonMenuItem 类的可访问性支持。
 class JRootPane
          该轻量级容器由 JFrame、JDialog、JWindow、JApplet 和 JInternalFrame 在后台使用。
protected  class JRootPane.AccessibleJRootPane
          此类实现对 JRootPane 类的可访问性支持。
protected  class JRootPane.RootLayout
          该自定义布局管理器负责 layeredPane、glassPane 和 menuBar 的布局。
 class JScrollBar
          滚动条的实现。
protected  class JScrollBar.AccessibleJScrollBar
          此类实现 JScrollBar 类的可访问性支持。
 class JScrollPane
          提供轻量级组件的 scrollable 视图。
protected  class JScrollPane.AccessibleJScrollPane
          此类实现 JScrollPane 类的可访问性支持。
protected  class JScrollPane.ScrollBar
          默认情况下，JScrollPane 创建的滚动条为此类的实例。
 class JSeparator
          JSeparator 为实现分隔线提供了一个通用组件 - 通常用作菜单项之间的分隔符，以便将菜单项分成几个逻辑组。
protected  class JSeparator.AccessibleJSeparator
          此类实现 JSeparator 类的可访问性支持。
 class JSlider
          一个让用户以图形方式在有界区间内通过移动滑块来选择值的组件。
protected  class JSlider.AccessibleJSlider
          此类实现 JSlider 类的可访问性支持。
 class JSpinner
          让用户从一个有序序列中选择一个数字或者一个对象值的单行输入字段。
protected  class JSpinner.AccessibleJSpinner
          AccessibleJSpinner 实现 JSpinner 类的可访问性支持。
static class JSpinner.DateEditor
          其模型为 SpinnerDateModel 的 JSpinner 编辑器。
static class JSpinner.DefaultEditor
          一个针对非常特殊编辑器的简单基类，该类在 JFormattedTextField 中显示模型的当前值的只读视图。
static class JSpinner.ListEditor
          其模型为 SpinnerListModel 的 JSpinner 编辑器。
static class JSpinner.NumberEditor
          其模型为 SpinnerNumberModel 的 JSpinner 编辑器。
 class JSplitPane
          JSplitPane 用于分隔两个（只能两个）Component。
protected  class JSplitPane.AccessibleJSplitPane
          此类实现 JSplitPane 类的可访问性支持。
 class JTabbedPane
          一个组件，它允许用户通过单击具有给定标题和/或图标的选项卡，在一组组件之间进行切换。
protected  class JTabbedPane.AccessibleJTabbedPane
          此类实现对 JTabbedPane 类的可访问性支持。
protected  class JTabbedPane.ModelListener
          将 ModelChanged 事件传递给侦听器，其中选项卡窗格（而不是模型本身）作为侦听器的事件源。
 class JTable
          JTable 用来显示和编辑常规二维单元表。
protected  class JTable.AccessibleJTable
          此类实现对 JTable 类的可访问性支持。
static class JTable.PrintMode
          用于打印 JTable 的打印模式。
 class JTextArea
          JTextArea 是一个显示纯文本的多行区域。
protected  class JTextArea.AccessibleJTextArea
          此类实现对 JTextArea 类的可访问性支持。
 class JTextField
          JTextField 是一个轻量级组件，它允许编辑单行文本。
protected  class JTextField.AccessibleJTextField
          此类实现对 JTextField 类的可访问性支持。
 class JTextPane
          可以用以图形方式表示的属性来标记的文本组件。
 class JToggleButton
          具有两个状态的（two-state）按钮的实现。
protected  class JToggleButton.AccessibleJToggleButton
          此类实现对 JToggleButton 类的可访问性支持。
static class JToggleButton.ToggleButtonModel
          ToggleButton 模型。
 class JToolBar
          JToolBar 提供了一个用来显示常用的 Action 或控件的组件。
protected  class JToolBar.AccessibleJToolBar
          此类实现对 JToolBar 类的可访问性支持。
static class JToolBar.Separator
          一个特定于工具栏的分隔符。
 class JToolTip
          用来显示 Component 的“提示”。
protected  class JToolTip.AccessibleJToolTip
          此类实现对 JToolTip 类的可访问性支持。
 class JTree
          将分层数据集显示为轮廓的控件。
protected  class JTree.AccessibleJTree
          此类实现 JTree 类的可访问性支持。
static class JTree.DynamicUtilTreeNode
          DynamicUtilTreeNode 可以包装 vectors/hashtables/arrays/strings 并根据需要创建适当的子树节点。
protected static class JTree.EmptySelectionModel
          EmptySelectionModel 是一个不允许选择任何内容的 TreeSelectionModel。
protected  class JTree.TreeSelectionRedirector
          使用 JTree 创建一个作为源的新 TreeSelectionEvent 并将其传递到所有侦听器的句柄。
 class JViewport
          用于查看底层信息的“视口”或“观察孔”。
protected  class JViewport.AccessibleJViewport
          此类实现对 JViewport 类的可访问性支持。
protected  class JViewport.ViewListener
          视图的侦听器。
 class JWindow
          JWindow 是一个容器，可以显示在用户桌面上的任何位置。
protected  class JWindow.AccessibleJWindow
          此类实现对 JWindow 类的可访问性支持。
 class KeyStroke
          表示键盘或等效输入设置上的键操作的 KeyStroke。
 class LayoutFocusTraversalPolicy
          根据 Component 的大小、位置和方向对其排序的 SortingFocusTraversalPolicy。
static class LayoutStyle.ComponentPlacement
          ComponentPlacement 是两个组件相对于彼此的可能放置方式的枚举。
 class OverlayLayout
          要在彼此顶部安排组件的布局管理器。
static class RowFilter.ComparisonType
          由某些默认 RowFilter 支持的可能比较值的枚举。
 class ScrollPaneLayout
          JScrollPane 使用的布局管理器。
static class ScrollPaneLayout.UIResource
          ScrollPaneLayout 的 UI 资源版本。
 class SizeRequirements
          为方便布局管理器，计算组件的有关大小和位置信息。
 class SortOrder
          SortOrder 是可能排序顺序的枚举。
 class SpinnerDateModel
          Date 序列的一个 SpinnerModel。
 class SpinnerListModel
          其值由数组或 List 定义的 SpinnerModel 的简单实现。
 class SpinnerNumberModel
          用于数字序列的 SpinnerModel。
static class SwingWorker.StateValue
          state 绑定 (bound) 属性的值。
 class Timer
          在指定时间间隔触发一个或多个 ActionEvent。
 class TransferHandler
          此类用于处理往返于 Swing 组件的 Transferable 的传输。
 class UIDefaults
          Swing 组件的默认值表。
 class UIManager
          UIManager 管理当前外观、可用外观集合、外观更改时被通知的 PropertyChangeListeners、外观默认值以及获取各种默认值的便捷方法。
 class UnsupportedLookAndFeelException
          指示在用户系统上不存在请求的外观管理类的异常。
 class ViewportLayout
          JViewport 的默认布局管理器。
 

javax.swing.border 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.border 中的类
 class AbstractBorder
          实现无大小限制的空边框类。
 class BevelBorder
          该类实现简单的双线斜面边框。
 class CompoundBorder
          一个复合 Border 类，通过将内部 Border 对象嵌套到外部 Border 对象的 insets 中实现将两个 Border 对象合并为一个单个边框。
 class EmptyBorder
          该类提供了一个占用空间但不执行绘制的空透明边框。
 class EtchedBorder
          该类实现简单的浮雕化边框，它既可以是阴刻浮雕化边框，也可以是阳刻浮雕化边框。
 class LineBorder
          实现单色、任意厚度线边框的类。
 class MatteBorder
          该类提供类似衬边的边框，衬边图案既可以是纯色也可以是平铺的图标。
 class SoftBevelBorder
          实现某种斜面的类，这种斜面要么凸出要么凹入且拐角圆滑。
 class TitledBorder
          该类实现在指定位置以指定对齐方式显示字符串标题的任意边框。
 

javax.swing.colorchooser 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.colorchooser 中的类
 class AbstractColorChooserPanel
          这是用于颜色选取器的抽象超类。
 class DefaultColorSelectionModel
          ColorSelectionModel 的一般实现。
 

javax.swing.event 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.event 中的类
 class AncestorEvent
          报告给子组件的事件，该子组件源自组件层次结构中的某个祖先。
 class CaretEvent
          CaretEvent 用于通知感兴趣的参与者事件源中的文本插入符已发生更改。
 class ChangeEvent
          ChangeEvent 用于通知感兴趣的参与者事件源中的状态已发生更改。
 class EventListenerList
          保存 EventListener 列表的类。
 class HyperlinkEvent
          HyperlinkEvent 用于通知感兴趣的参与者发生了与超文本链接有关的事情。
 class InternalFrameEvent
          以事件源的形式添加对 JInternalFrame 对象的支持的 AWTEvent。
 class ListDataEvent
          定义一个封装列表更改的事件。
 class ListSelectionEvent
          表现选择中更改的特征的事件。
 class MenuDragMouseEvent
          MenuDragMouseEvent 用于通知对此进行侦听的参与者在拖动情况下菜单元素已经收到转发给它的 MouseEvent。
 class MenuEvent
          MenuEvent 用于通知感兴趣的参与者作为事件源的菜单已经被发送、选定或取消。
 class MenuKeyEvent
          MenuKeyEvent 用于通知感兴趣的参与者菜单元素已在菜单树中接收转发给它的 KeyEvent。
 class PopupMenuEvent
          PopupMenuEvent 只包含事件源，该事件源是发送事件的 JPoupMenu 警告：此类的序列化对象将与以后的 Swing 版本不兼容。
 class RowSorterEvent
          RowSorterEvent 提供 RowSorter 的更改通知。
static class RowSorterEvent.Type
          RowSorterEvent 类型的枚举。
 class SwingPropertyChangeSupport
          java.beans.PropertyChangeSupport 的这一子类在功能上几乎是等效的。
 class TableColumnModelEvent
          TableColumnModelEvent 用于通知侦听器某一个表的列模型已发生更改，比如添加、移除或移动列。
 class TableModelEvent
          TableModelEvent 用于通知侦听器某一表模型已发生更改。
 class TreeExpansionEvent
          用于标识树中的单个路径的事件。
 class TreeModelEvent
          封装描述树模型更改的信息，并用于通知侦听更改的树模型侦听器。
 class TreeSelectionEvent
          描述当前选择中的更改的事件。
 class UndoableEditEvent
          指示发生了可撤消操作的事件。
 

javax.swing.plaf 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.plaf 中的类
 class ActionMapUIResource
          实现 UIResource 的 javax.swing.ActionMap 的子类。
 class BorderUIResource
           
static class BorderUIResource.BevelBorderUIResource
           
static class BorderUIResource.CompoundBorderUIResource
           
static class BorderUIResource.EmptyBorderUIResource
           
static class BorderUIResource.EtchedBorderUIResource
           
static class BorderUIResource.LineBorderUIResource
           
static class BorderUIResource.MatteBorderUIResource
           
static class BorderUIResource.TitledBorderUIResource
           
 class ColorUIResource
           
 class ComponentInputMapUIResource
          实现 UIResource 的 javax.swing.ComponentInputMap 的子类。
 class DimensionUIResource
           
 class FontUIResource
          实现 UIResource 的 java.awt.Font 的子类。
 class IconUIResource
          实现 UIResource 的 Icon 包装类。
 class InputMapUIResource
          实现 UIResource 的 javax.swing.InputMap 的子类。
 class InsetsUIResource
           
 

javax.swing.plaf.basic 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.plaf.basic 中的类
 class BasicArrowButton
          一个 JButton 对象，它绘制朝某个基本方向的缩放箭头。
static class BasicBorders.ButtonBorder
           
static class BasicBorders.FieldBorder
           
static class BasicBorders.MarginBorder
           
static class BasicBorders.MenuBarBorder
           
static class BasicBorders.RadioButtonBorder
           
static class BasicBorders.RolloverButtonBorder
          用于翻转工具栏按钮的特殊细边框。
static class BasicBorders.ToggleButtonBorder
           
 class BasicComboBoxRenderer
          ComboBox 渲染器 警告：此类的序列化对象将与以后的 Swing 版本不兼容。
static class BasicComboBoxRenderer.UIResource
          实现 UIResource 的 BasicComboBoxRenderer 的子类。
 class BasicComboPopup
          此为 ComboPopup 接口的基本实现。
protected  class BasicDesktopPaneUI.CloseAction
          处理关闭一个内部窗体。
protected  class BasicDesktopPaneUI.MaximizeAction
          处理最大化一个内部窗体。
protected  class BasicDesktopPaneUI.MinimizeAction
          处理最小化一个内部窗体。
protected  class BasicDesktopPaneUI.NavigateAction
          处理导航到下一个内部窗体。
protected  class BasicDesktopPaneUI.OpenAction
          处理恢复一个最小化或最大化的内部窗体。
 class BasicDirectoryModel
          文件列表的基本实现。
protected  class BasicFileChooserUI.ApproveSelectionAction
          响应 Open 或 Save 请求
protected  class BasicFileChooserUI.CancelSelectionAction
          响应取消请求。
protected  class BasicFileChooserUI.ChangeToParentDirectoryAction
           
protected  class BasicFileChooserUI.GoHomeAction
          基于“Home”键事件或等效事件的动作。
protected  class BasicFileChooserUI.NewFolderAction
          创建新文件夹。
protected  class BasicFileChooserUI.UpdateAction
          重新扫描当前目录中的文件。
 class BasicIconFactory
          提供适于基本 L & F 使用的 Icon 的工厂对象。
 class BasicInternalFrameTitlePane
          管理基本标题栏的类 警告：此类的序列化对象将与以后的 Swing 版本不兼容。
 class BasicInternalFrameTitlePane.CloseAction
          此类应视为“受保护”内部类。
 class BasicInternalFrameTitlePane.IconifyAction
          此类应视为“受保护”内部类。
 class BasicInternalFrameTitlePane.MaximizeAction
          此类应视为“受保护”内部类。
 class BasicInternalFrameTitlePane.MoveAction
          此类应视为“受保护”内部类。
 class BasicInternalFrameTitlePane.RestoreAction
          此类应视为“受保护”内部类。
 class BasicInternalFrameTitlePane.SizeAction
          此类应视为“受保护”内部类。
 class BasicInternalFrameTitlePane.SystemMenuBar
          此类应视为“受保护”内部类。
 class BasicLookAndFeel
          为 Swing 创建外观时要使用的基类。
 class BasicSliderUI.ActionScroller
          从 Java 2 平台 v1.3 开始，不再使用这种以前没有记录的类。
 class BasicSplitPaneDivider
          BasicSplitPaneUI 使用的分隔符。
static class BasicTextUI.BasicCaret
           
protected  class BasicToolBarUI.DragWindow
           
 class BasicTreeUI.TreeCancelEditingAction
          执行操作时调用 cancelEditing 的 ActionListener。
 class BasicTreeUI.TreeHomeAction
          TreeHomeAction 用于处理 end/home 动作。
 class BasicTreeUI.TreeIncrementAction
          TreeIncrementAction 用于处理向上/向下操作。
 class BasicTreeUI.TreePageAction
          TreePageAction 处理向上翻页和向下翻页事件。
 class BasicTreeUI.TreeToggleAction
          对于第一个选定行展开将被切换。
 class BasicTreeUI.TreeTraverseAction
          TreeTraverseAction 是用于向左/向右方向键的动作。
 class DefaultMenuLayout
          Popup 菜单和菜单栏的默认布局管理器。
 

javax.swing.plaf.metal 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.plaf.metal 中的类
static class MetalBorders.ButtonBorder
           
static class MetalBorders.Flush3DBorder
           
static class MetalBorders.InternalFrameBorder
           
static class MetalBorders.MenuBarBorder
           
static class MetalBorders.MenuItemBorder
           
static class MetalBorders.OptionDialogBorder
           
static class MetalBorders.PaletteBorder
          Palette 的边框。
static class MetalBorders.PopupMenuBorder
           
static class MetalBorders.RolloverButtonBorder
           
static class MetalBorders.ScrollPaneBorder
           
static class MetalBorders.TableHeaderBorder
          Table Header 的边框
static class MetalBorders.TextFieldBorder
           
static class MetalBorders.ToggleButtonBorder
           
static class MetalBorders.ToolBarBorder
           
 class MetalCheckBoxIcon
          OrganicCheckBoxUI 的 CheckboxIcon 实现 警告：此类的序列化对象与以后的 Swing 版本不兼容。
 class MetalComboBoxButton
          协助 MetalComboBoxUI 的 JButton 子类 警告：此类的已序列化对象与以后的 Swing 版本不兼容。
 class MetalComboBoxIcon
          此实用工具类绘制指示 MetalComboBox 的水平条
 class MetalComboBoxUI.MetalComboPopup
          已过时。 从 Java 2 platform v1.4 开始。
protected  class MetalFileChooserUI.DirectoryComboBoxAction
          当 DirectoryComboBox 已更改所选项时调用。
protected  class MetalFileChooserUI.DirectoryComboBoxModel
          字体选择组合框的数据模型。
protected  class MetalFileChooserUI.FileRenderer
           
protected  class MetalFileChooserUI.FilterComboBoxModel
          字体选择组合框的数据模型。
 class MetalFileChooserUI.FilterComboBoxRenderer
          呈现不同的类型大小和风格。
 class MetalIconFactory
          为 JavaTM 外观 (Metal) 提供 Icon 的工厂对象。
static class MetalIconFactory.FileIcon16
           警告：此类的已序列化对象与以后的 Swing 版本不兼容。
static class MetalIconFactory.FolderIcon16
           警告：此类的已序列化对象与以后的 Swing 版本不兼容。
static class MetalIconFactory.PaletteCloseIcon
          定义一个用于 Palette 关闭的图标
static class MetalIconFactory.TreeControlIcon
           警告：此类的已序列化对象与以后的 Swing 版本不兼容。
static class MetalIconFactory.TreeFolderIcon
           警告：此类的已序列化对象与以后的 Swing 版本不兼容。
static class MetalIconFactory.TreeLeafIcon
           
 class MetalInternalFrameTitlePane
          管理 JLF 标题栏的类
 class MetalLookAndFeel
          Java 外观，也称为 Metal。
 class MetalScrollButton
          Metal 滚动条箭头的 JButton 对象。
 

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

实现 Serializable 的 javax.swing.plaf.synth 中的类
 class SynthLookAndFeel
          SynthLookAndFeel 提供创建定制外观的基础。
 

javax.swing.table 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.table 中的类
 class AbstractTableModel
          此抽象类为 TableModel 接口中的大多数方法提供默认实现。
 class DefaultTableCellRenderer
          呈现（显示） JTable 中每个单元格的标准类。
static class DefaultTableCellRenderer.UIResource
          DefaultTableCellRenderer 的一个子类，它实现 UIResource。
 class DefaultTableColumnModel
          JTable 的标准列处理程序。
 class DefaultTableModel
          这是 TableModel 的一个实现，它使用一个 Vector 来存储单元格的值对象，该 Vector 由多个 Vector 组成。
 class JTableHeader
          这是管理 JTable 的头的对象。
protected  class JTableHeader.AccessibleJTableHeader
          此类实现对 JTableHeader 类的可访问性支持。
 class TableColumn
          TableColumn 表示 JTable 中列的所有属性，如宽度、大小可调整性、最小和最大宽度。
 

javax.swing.text 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.text 中的类
 class AbstractDocument
          文档接口的实现，可作为实现各种文档的基础。
 class AbstractDocument.AbstractElement
          实现元素的抽象部分。
 class AbstractDocument.BranchElement
          实现一个包含其他元素的复合元素。
 class AbstractDocument.DefaultDocumentEvent
          存储修改文档时发生的文档更改。
static class AbstractDocument.ElementEdit
          一个 ElementChange 实现，可将其添加到文档事件中。
 class AbstractDocument.LeafElement
          实现可直接表示某类内容的元素。
 class BadLocationException
          此异常的目的是报告文档模型中的损坏位置（即试图引用一个不存在的位置）。
 class ChangedCharSetException
          顾名思义，ChangedCharSetException 是字符集改变时抛出的异常。
 class DateFormatter
          DateFormatter 是一个 InternationalFormatter，它使用 java.text.DateFormat 的一个实例进行格式处理。
 class DefaultCaret
          插入符的默认实现。
 class DefaultEditorKit
          这是文本组件使编辑器对某些类型 的文本文档合理发挥其作用所需的实现集合。
static class DefaultEditorKit.BeepAction
          创建蜂鸣声。
static class DefaultEditorKit.CopyAction
          复制选定的区域并将其内容放入系统剪贴板中。
static class DefaultEditorKit.CutAction
          剪切选定的区域并将其内容放入系统剪贴板中。
static class DefaultEditorKit.DefaultKeyTypedAction
          如果接收到键输入事件 并且无 keymap 输入，则默认执行该动作。
static class DefaultEditorKit.InsertBreakAction
          在文档中放置行/段落中断。
static class DefaultEditorKit.InsertContentAction
          将内容置于关联的文档中。
static class DefaultEditorKit.InsertTabAction
          将一个制表符置于文档中。
static class DefaultEditorKit.PasteAction
          将系统剪贴板内容粘贴到选定区域，如果未选中任何内容，则粘贴到插入符前面。
 class DefaultFormatter
          DefaultFormatter 格式化任意对象。
 class DefaultFormatterFactory
          JFormattedTextField.AbstractFormatterFactory 的一个实现。
 class DefaultStyledDocument
          能够以类似富文本格式 (Rich Text Format) 的方式对其字符和段落样式进行标记的文档。
static class DefaultStyledDocument.AttributeUndoableEdit
          用于记住 AttributeSet 对 Element 更改的一个 UndoableEdit。
 class DefaultStyledDocument.ElementBuffer
          管理对元素层次结构更改的类。
protected  class DefaultStyledDocument.SectionElement
          文档的默认根元素... 与所包含的段落/行对应。
 class EditorKit
          针对某些类型 的文本内容，建立能够合理发挥编辑器功能的文本组件所需的实现集合。
 class GapContent
          AbstractDocument.Content 接口的一个实现，使用类似于 emacs 使用的间隙缓冲区来实现。
 class InternationalFormatter
          InternationalFormatter 扩展 DefaultFormatter，使用 java.text.Format 的实例处理往返于 String 的转换。
 class JTextComponent
          JTextComponent 是 swing 文本组件的基类。
 class JTextComponent.AccessibleJTextComponent
          此类实现 JTextComponent 类的可访问性支持。
 class MaskFormatter
          MaskFormatter 用于格式化和编辑字符串。
 class NumberFormatter
          添加数字特殊行为的 InternationalFormatter 的子类 NumberFormatter。
 class PlainDocument
          维护无任何字符属性的普通文档。
 class SimpleAttributeSet
          使用哈希表的 MutableAttributeSet 的直接实现。
 class StringContent
          AbstractDocument.Content 接口的一个实现，这是一个对相对于较小的文档和/或调试很有用的强制实现。
 class StyleContext
          样式池及其关联的资源。
 class StyleContext.NamedStyle
          通常用于表示字符和段落样式的属性集合。
 class StyledEditorKit
          这是文本组件针对某些类型 的文本文档要成为合理发挥编辑器功能所需的实现集合。
static class StyledEditorKit.AlignmentAction
          设置段落对齐的操作。
static class StyledEditorKit.BoldAction
          切换粗体属性的操作。
static class StyledEditorKit.FontFamilyAction
          在相关的 JEditorPane 中设置字体系列的操作。
static class StyledEditorKit.FontSizeAction
          设置关联的 JEditorPane 中字体大小的操作。
static class StyledEditorKit.ForegroundAction
          设置前景色的操作。
static class StyledEditorKit.ItalicAction
          切换斜体属性的一种操作。
static class StyledEditorKit.StyledTextAction
          假定是在安装有 StyledEditorKit（或者子类）的 JEditorPane 上触发的操作。
static class StyledEditorKit.UnderlineAction
          切换下划线属性的操作。
 class TabSet
          由许多 TabStop 组成的一个 TabSet。
 class TabStop
          此类封装单个制表位 (tab stop)（基本上是由 RTF 认定的制表位）。
 class TextAction
          用于跨多个不同文本组件共享的键绑定的 Action 实现。
 

javax.swing.text.html 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.text.html 中的类
 class CSS
          将 CSS attributes 集定义为类型安全的枚举。
 class FormSubmitEvent
          FormSubmitEvent 用于通知提交表单所需的参与者。
static class FormSubmitEvent.MethodType
          表示 HTML 表单方法类型。
static class HTML.UnknownTag
           
 class HTMLDocument
          对 HTML 进行建模的文档。
 class HTMLDocument.BlockElement
          表示结构性 HTML 块 的元素。
 class HTMLDocument.RunElement
          表示文本块的元素，该文本块具有一个分配给它的 HTML 字符级的属性集。
 class HTMLEditorKit
          Swing JEditorPane 文本组件通过称为 EditorKit 的插件机制来支持不同种类的内容。
static class HTMLEditorKit.HTMLTextAction
          提供某些便捷方法的抽象 Action，这些便捷方法对于将 HTML 插入现有文档可能很有用。
static class HTMLEditorKit.InsertHTMLTextAction
          InsertHTMLTextAction 可用于将任意 HTML 字符串插入现有 HTML 文档。
static class HTMLEditorKit.LinkController
          此类用于观察关联组件并在适当的时候触发该组件上的超链接事件。
 class HTMLFrameHyperlinkEvent
          HTMLFrameHyperlinkEvent 用于通知感兴趣的参与者框架中的链接已被激活。
 class Option
          用来表示 <option> 元素的 ListModel 值。
 class StyleSheet
          支持定义要呈现的 HTML 视图的可视化特征。
static class StyleSheet.BoxPainter
          可以执行某些 CSS 格式化任务的类。
static class StyleSheet.ListPainter
          要执行某些 CSS 列表格式化任务的类。
 

javax.swing.text.html.parser 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.text.html.parser 中的类
 class ContentModel
          内容模式的表示形式。
 class Element
          使用 ELEMENT 构造在 DTD 中描述的一个元素。
 class ParserDelegator
          负责每次在调用其 parse 方法时启动一个新的 DocumentParser。
 

javax.swing.text.rtf 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.text.rtf 中的类
 class RTFEditorKit
          这是对 RTF 编辑功能的默认实现。
 

javax.swing.tree 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.tree 中的类
 class DefaultMutableTreeNode
          DefaultMutableTreeNode 是树数据结构中的通用节点。
 class DefaultTreeCellEditor.DefaultTextField
          不提供任何编辑器时所使用的 TextField。
 class DefaultTreeCellEditor.EditorContainer
          负责存放 editingComponent 的容器。
 class DefaultTreeCellRenderer
          显示树中的条目。
 class DefaultTreeModel
          使用 TreeNodes 的简单树数据模型。
 class DefaultTreeSelectionModel
          TreeSelectionModel 的默认实现。
 class ExpandVetoException
          用于阻止扩展/折叠发生的异常。
 class TreePath
          表示节点的路径。
 

javax.swing.undo 中 Serializable 的使用
 

实现 Serializable 的 javax.swing.undo 中的类
 class AbstractUndoableEdit
          UndoableEdit 的抽象实现，实现对该接口中所有布尔方法的简单响应。
 class CannotRedoException
          当 UndoableEdit 被通知 redo() 但无法执行时抛出。
 class CannotUndoException
          当 UndoableEdit 被通知 undo() 但无法执行时抛出。
 class CompoundEdit
          AbstractUndoableEdit 的具体子类，用于将一些小的 UndoableEdit 组合到一个大的 UndoableEdit 之中。
 class StateEdit
          StateEdit 是更改状态的对象的通用编辑。
 class UndoManager
          UndoManager 管理 UndoableEdit 列表，提供撤消或恢复适当编辑的方法。
 

javax.tools 中 Serializable 的使用
 

实现 Serializable 的 javax.tools 中的类
static class Diagnostic.Kind
          诊断的种类，例如，错误或者警告。
static class JavaFileObject.Kind
          JavaFileObject 的种类。
 class StandardLocation
          文件对象的标准位置。
 

javax.transaction 中 Serializable 的使用
 

实现 Serializable 的 javax.transaction 中的类
 class InvalidTransactionException
          此异常指示该请求带来了无效的事务上下文。
 class TransactionRequiredException
          此异常指示某个请求带来了 null 事务上下文，但目标对象需要激活的事务。
 class TransactionRolledbackException
          此异常指示与请求处理关联的事务已回滚，或已标记为回滚。
 

javax.transaction.xa 中 Serializable 的使用
 

实现 Serializable 的 javax.transaction.xa 中的类
 class XAException
          资源管理器 (RM) 抛出 XAException，以通知事务管理器涉及的事务遇到错误。
 

javax.xml.bind 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.bind 中的类
 class JAXBElement<T>
          Xml 元素的 JAXB 表示形式。
 class JAXBException
          这是所有 JAXB 异常的根异常类。
 class PropertyException
          此异常指示在获取或设置属性时遇到一个错误。
 class TypeConstraintException
          此异常指示已检测到存在违反动态检查的类型约束的情况。
 class ValidationException
          此异常指示在执行验证操作时发生错误。
 

javax.xml.bind.annotation 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.bind.annotation 中的类
 class XmlAccessOrder
          由 XmlAccessorOrder 使用，用于控制 JAXB 绑定类中属性和字段的排序。
 class XmlAccessType
          由 XmlAccessorType 使用，用于控制字段或属性的序列化。
 class XmlNsForm
          XML 模式名称空间限定的枚举。
 

javax.xml.crypto 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.crypto 中的类
 class KeySelectorException
          指示由 KeySelector 抛出的异常条件。
 class NoSuchMechanismException
          当请求特定 XML 机制但该机制在环境中不可用时，抛出此异常。
 class URIReferenceException
          指示取消引用 URIReference 时抛出的异常条件。
 

javax.xml.crypto.dsig 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.crypto.dsig 中的类
 class TransformException
          指示执行转换算法时出现异常的异常条件。
 class XMLSignatureException
          指示生成或验证 XML 签名过程中发生的异常条件。
 

javax.xml.datatype 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.datatype 中的类
 class DatatypeConfigurationException
          指示严重的配置错误。
 

javax.xml.namespace 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.namespace 中的类
 class QName
          QName 表示 XML 规范中定义的限定名称：XML 模式第二部分：Datatypes specification、Namespaces in XML、Namespaces in XML 勘误表。
 

javax.xml.parsers 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.parsers 中的类
 class FactoryConfigurationError
          当解析器工厂的配置存在问题时抛出该异常。
 class ParserConfigurationException
          指示一个严重的配置错误。
 

javax.xml.soap 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.soap 中的类
 class SOAPException
          当发生 SOAP 异常时，抛出此异常。
 

javax.xml.stream 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.stream 中的类
 class XMLStreamException
          用于不可预料处理错误的基本异常。
 

javax.xml.transform 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.transform 中的类
 class TransformerConfigurationException
          指示严重的配置错误。
 class TransformerException
          此类指定了转换过程中发生的异常条件。
 class TransformerFactoryConfigurationError
          当通过 Transformer Factories 进行的配置存在问题时抛出此异常。
 

javax.xml.ws 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.ws 中的类
static class Service.Mode
          动态客户端或服务的方向。
 class WebServiceException
          WebServiceException 类是所有 JAX-WS API 运行时异常的基本异常类。
 class WebServicePermission
          此类定义 Web 服务权限。
 

javax.xml.ws.handler 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.ws.handler 中的类
static class MessageContext.Scope
          属性作用域。
 

javax.xml.ws.http 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.ws.http 中的类
 class HTTPException
          HTTPException 异常表示一个 XML/HTTP 故障。
 

javax.xml.ws.soap 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.ws.soap 中的类
 class SOAPFaultException
          SOAPFaultException 异常表示一个 SOAP 1.1 或 1.2 故障。
 

javax.xml.xpath 中 Serializable 的使用
 

实现 Serializable 的 javax.xml.xpath 中的类
 class XPathException
          XPathException 表示通用 XPath 异常。
 class XPathExpressionException
          XPathExpressionException 表示 XPath 表达式中的错误。
 class XPathFactoryConfigurationException
          XPathFactoryConfigurationException 表示 XPathFactory 环境中的配置错误。
 class XPathFunctionException
          XPathFunctionException 表示 XPath 函数的错误。
 

org.ietf.jgss 中 Serializable 的使用
 

实现 Serializable 的 org.ietf.jgss 中的类
 class GSSException
          每当发生 GSS-API 错误（包括任何特定于机制的错误）时，都会抛出此异常。
 

org.omg.CORBA 中 Serializable 的使用
 

org.omg.CORBA 中 Serializable 的子接口
 interface Current
          从 Current 接口派生的接口允许 ORB 和 CORBA 服务访问与它们正运行的执行线程关联的信息（上下文）。
 interface DataInputStream
          定义用来从输入流读取基本数据类型的方法，以便解组自定义值类型。
 interface DataOutputStream
          定义用来将基本数据类型写入输出流的方法，以便编组自定义值类型。
 interface DomainManager
          提供用来建立关系并将其导航到高级域和从属域的机制，以及用来创建和访问策略的机制。
 interface IDLType
          由所有表示 OMG IDL 类型的接口存储库（Interface Repository，IR）对象继承的抽象接口。
 interface IRObject
          IRObject IDL 接口表示最一般的接口，其他所有 Interface Repository 接口（甚至包括 Repository 自身）都派生自该接口。
 interface Policy
          派生自 Policy 接口的接口允许 ORB 或 CORBA 服务访问影响其操作的某些选项。
 

实现 Serializable 的 org.omg.CORBA 中的类
 class _IDLTypeStub
          IDLType 的 Stub。
 class _PolicyStub
          Policy 的 Stub。
 class ACTIVITY_COMPLETED
          ACTIVITY_COMPLETED 系统异常可以在任何访问 Activity 上下文的方法上引发。
 class ACTIVITY_REQUIRED
          ACTIVITY_REQUIRED 系统异常可以在任何需要 Activity 上下文的方法上引发。
 class Any
          充当可用 IDL 描述的任何数据或任何 IDL 基本类型的容器。
 class BAD_CONTEXT
          当客户端调用某一操作，但传递的上下文中不包含该操作所需的上下文值时，抛出该异常。
 class BAD_INV_ORDER
          此异常指示调用者按错误顺序调用了操作。
 class BAD_OPERATION
          当对象引用表示某一现有对象，但该对象并不支持调用的操作时，抛出该异常。
 class BAD_PARAM
          当传递给某一调用的参数超出范围或被认为不合法时，抛出该异常。
 class BAD_QOS
          只要对象无法支持调用参数（具有与之关联的服务质量语义的参数）所需的服务质量，就会引发 BAD_QOS 异常。
 class BAD_TYPECODE
          当 ORB 遇到错误的类型代码（例如，具有无效 TCKind 值的类型代码）时，抛出该异常。
 class Bounds
          当参数不在某一方法试图访问的对象的合法范围内时，抛出该用户异常。
 class CODESET_INCOMPATIBLE
          当客户端和服务器本机代码集之间不能进行有意义的通信时，抛出此异常。
 class COMM_FAILURE
          如果某一操作正在进行时失去通信，此时客户端已经发送了请求，但服务器的应答尚未返回到客户端，则引发此异常。
 class CompletionStatus
          指示某一方法抛出 SystemException 时是否已结束运行的对象。
 class DATA_CONVERSION
          如果 ORB 无法将已编组数据的表示形式转换成其本机表示形式，则引发此异常，反之亦然。
 class DefinitionKind
          该类提供用来标识接口存储库 (Interface Repository) 对象类型的常量。
 class FREE_MEM
          当 ORB 试图释放动态内存但却因为某些原因（例如因为堆损坏或内存块被锁定）而失败时，抛出此异常。
 class IMP_LIMIT
          此异常指示在 OBR 运行时超过了某一项实现限制。
 class INITIALIZE
          ORB 在其初始化期间出错（例如无法获得网络资源或检测配置错误）时，抛出此异常。
 class INTERNAL
          此异常指示 ORB 中存在内部错误，例如，在 ORB 检测到其内部数据结构被损坏时将抛出此异常。
 class INTF_REPOS
          当 ORB 无法到达接口存储库，或者检测到其他与接口存储库相关的错误时，引发此异常。
 class INV_FLAG
          在将无效标志传递给某项操作时（例如，在创建 DII 请求时），抛出此异常。
 class INV_IDENT
          此异常指示 IDL 标识符在语法上是无效的。
 class INV_OBJREF
          此异常指示对象引用存在内部错误。
 class INV_POLICY
          当应用于特定调用的 Policy 重写之间不兼容而导致无法进行调用时，抛出此标准异常。
 class INVALID_ACTIVITY
          如果在不同于其处于挂起状态时所在的上下文中恢复事务或 Activity，则在该 Activity 或 Transaction 服务的恢复方法上引发 INVALID_ACTIVITY 系统异常。
 class INVALID_TRANSACTION
          当请求带有无效的事务上下文时，抛出此异常。
 class MARSHAL
          表示网络中传来的请求或应答在结构上无效。
 class NameValuePair
          将某一名称与一个属性为 IDL struct 的值关联，并在 DynStruct API 中使用。
 class NO_IMPLEMENT
          此异常指示，尽管被调用的操作存在（它有一个 IDL 定义），但不存在该操作的实现。
 class NO_MEMORY
          如果 ORB 运行时出现内存不足，则抛出此异常。
 class NO_PERMISSION
          当因为调用者没有足够的权限而导致调用失败时，抛出此异常。
 class NO_RESOURCES
          当 ORB 遇到一些一般资源限制时，抛出此异常。
 class NO_RESPONSE
          如果某客户端试图检索延迟同步调用的结果，但请求的响应尚不可用，则抛出此异常。
 class OBJ_ADAPTER
          此异常通常指示管理方面的不匹配，例如，某台服务器可能试图在实现存储库中使用已经在使用或存储库未知的名称注册它自身。
 class OBJECT_NOT_EXIST
          只要在已删除的对象上执行调用，就会引发此异常。
 class ParameterMode
          Parameter 参数模式的枚举。
 class PERSIST_STORE
          此异常指示一个持久存储错误，例如，无法建立数据库连接或者某个数据库损坏。
 class PolicyError
          发生策略错误时抛出的用户异常。
 class REBIND
          如果当前有效 RebindPolicy 具有 NO_REBIND 或 NO_RECONNECT 值，且对绑定的对象引用执行调用时生成状态为 OBJECT_FORWARD 的 LocateReply 消息或状态为 LOCATION_FORWARD 的 Reply 消息，则将引发 REBIND。
 class ServiceDetail
          表示 ORB 服务的对象：其 service_detail_type 字段包含 ORB 服务的类型，其 service_detail 字段包含 ORB 服务的描述。
 class ServiceInformation
          CORBA 模块中的 IDL struct，用于存储关于 ORB 实现中可用 CORBA 服务的信息，可使用 ORB.get_service_information 方法获取。
 class SetOverrideType
          标记 SET_OVERRIDE 和 ADD_OVERRIDE 的 CORBA enum 的映射，它指示这些策略是应该替换 Object 的现有策略还是应该被添加到现有策略中。
 class StructMember
          描述接口存储库 (Interface Repository) 中一个 IDL struct 成员，包括该 struct 成员的名称、该 struct 成员的类型以及表示该 struct 成员（被描述为 struct 成员对象）IDL 类型的 typedef。
 class SystemException
          所有 CORBA 标准异常的根类。
 class TIMEOUT
          当已超过指定生存时间却没有做出任何交付时，引发 TIMEOUT 异常。
 class TRANSACTION_MODE
          如果客户端 ORB 检测到 IOR 中的 InvocationPolicy 与选中的调用路径（即直接或路由调用）不匹配，则它将抛出 CORBA TRANSACTION_MODE 异常。
 class TRANSACTION_REQUIRED
          此异常指示请求带有一个 null 事务上下文，但需要的是激活的事务。
 class TRANSACTION_ROLLEDBACK
          当与请求处理关联的事务已回滚或已标记为回滚时，抛出此异常。
 class TRANSACTION_UNAVAILABLE
          当由于到事务服务 (Transaction Service) 的连接已异常终止而无法处理事务服务上下文时，由 ORB 抛出 CORBA TRANSACTION_UNAVAILABLE 异常。
 class TRANSIENT
          当 ORB 试图到达某一对象但失败时，抛出此异常。
 class TypeCode
          用于有关特定 CORBA 数据类型的信息的容器。
 class UnionMember
          接口存储库 (Interface Repository) 中关于 IDL union 成员的描述。
 class UNKNOWN
          如果操作实现抛出一个非 CORBA 异常（比如特定于该实现编程语言的异常），或者某一操作引发没有出现在该操作引发表达式中的用户异常，则将引发此异常。
 class UnknownUserException
          包含由服务器返回的用户异常的类。
 class UserException
          CORBA IDL 定义的用户异常的根类。
 class ValueMember
          接口存储库 (Interface Repository) 中关于 value 对象成员的描述。
 class WrongTransaction
          CORBA WrongTransaction 用户定义异常。
 

声明为 Serializable 的 org.omg.CORBA 中的字段
 Serializable ValueBaseHolder.value
          此 ValueBaseHolder 对象保存的 java.io.Serializable 值。
 

返回 Serializable 的 org.omg.CORBA 中的方法
abstract  Serializable Any.extract_Value()
          提取此 Any 对象 value 字段中的 java.io.Serializable 对象。
static Serializable ValueBaseHelper.extract(Any a)
           
 Serializable DynAny.get_val()
          已过时。 检索此 DynAny 对象中包含的 java.io.Serializable 对象。
 Serializable DataInputStream.read_Value()
          从输入流读取 IDL 值类型。
 Serializable StringValueHelper.read_value(InputStream istream)
           
 Serializable WStringValueHelper.read_value(InputStream istream)
           
static Serializable ValueBaseHelper.read(InputStream istream)
           
 

参数类型为 Serializable 的 org.omg.CORBA 中的方法
 void DynAny.insert_val(Serializable value)
          已过时。 插入给定 java.io.Serializable 对象作为此 DynAny 对象的值。
abstract  void Any.insert_Value(Serializable v)
          将给定 java.io.Serializable 对象插入此 Any 对象的 value 字段。
abstract  void Any.insert_Value(Serializable v, TypeCode t)
          将给定 java.io.Serializable 对象插入此 Any 对象的 value 字段。
static void ValueBaseHelper.insert(Any a, Serializable that)
           
 void StringValueHelper.write_value(OutputStream ostream, Serializable value)
           
 void WStringValueHelper.write_value(OutputStream ostream, Serializable value)
           
 void DataOutputStream.write_Value(Serializable value)
          将 IDL value 类型值写入输出流。
static void ValueBaseHelper.write(OutputStream ostream, Serializable value)
           
 

参数类型为 Serializable 的 org.omg.CORBA 中的构造方法
ValueBaseHolder(Serializable initial)
          构造一个新的 ValueBaseHolder 对象，并将其 value 字段初始化为给定的 java.io.Serializable。
 

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

返回 Serializable 的 org.omg.CORBA_2_3.portable 中的方法
 Serializable InputStream.read_value()
          从输入流解组值类型。
 Serializable InputStream.read_value(BoxedValueHelper factory)
          从输入流解组值类型。
 Serializable InputStream.read_value(Class clz)
          从输入流解组值类型。
 Serializable InputStream.read_value(Serializable value)
          从输入流解组值类型。
 Serializable InputStream.read_value(String rep_id)
          从输入流解组值类型。
 

参数类型为 Serializable 的 org.omg.CORBA_2_3.portable 中的方法
 Serializable InputStream.read_value(Serializable value)
          从输入流解组值类型。
 void OutputStream.write_value(Serializable value)
          将值类型编组到输出流中。
 void OutputStream.write_value(Serializable value, BoxedValueHelper factory)
          将值类型编组到输出流中。
 void OutputStream.write_value(Serializable value, Class clz)
          将值类型编组到输出流中。
 void OutputStream.write_value(Serializable value, String repository_id)
          将值类型编组到输出流中。
 

org.omg.CORBA.DynAnyPackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.CORBA.DynAnyPackage 中的类
 class Invalid
          动态 any 操作在传递无效的 DynAny 或 Any 作为其参数时抛出 Invalid。
 class InvalidSeq
          任何有关动态 any 并使用序列（Java 数组）作为参数的操作在该序列无效时抛出 InvalidSeq 异常。
 class InvalidValue
           
 class TypeMismatch
          动态 any 的访问器方法在实际内容的类型与要试图访问的类型不匹配时抛出 TypeMismatch。
 

org.omg.CORBA.ORBPackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.CORBA.ORBPackage 中的类
 class InconsistentTypeCode
          当试图使用与特定的 DynAny 子类不匹配的类型代码创建动态 any 时将抛出 InconsistentTypeCode。
 class InvalidName
          当向 ORB.resolve_initial_references 传递一个没有初始引用的名称时将引发 InvalidName 异常。
 

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

org.omg.CORBA.portable 中 Serializable 的子接口
 interface CustomValue
          通过自定义值类型实现的 ValueBase 扩展。
 interface IDLEntity
          一个不带任何成员的接口，其唯一目的是充当一个标记，用来指示实现类是 IDL 中的 Java 值类型且具有响应的 Helper 类。
 interface StreamableValue
          为所有非自定义编码的非装箱 (boxed) IDL 值类型定义基本类型。
 interface ValueBase
          所生成的对应于 valuetype IDL 类型的 Java 类实现此接口。
 

实现 Serializable 的 org.omg.CORBA.portable 中的类
 class ApplicationException
          此类用来报告 ORB 和 stub 之间的应用程序级异常。
 class IndirectionException
          Indirection 异常是一个特定于 Java 的系统异常。
 class RemarshalException
          此类用来报告本地转发异常，以及发回 ORB 的对象转发 GIOP 信息。
 class UnknownException
          org.omg.CORBA.portable.UnknownException 用来报告 tie 和 ORB 以及 ORB 和 stub 之间的未知异常。
 

返回 Serializable 的 org.omg.CORBA.portable 中的方法
 Serializable BoxedValueHelper.read_value(InputStream is)
           
 Serializable ValueFactory.read_value(InputStream is)
          ORB 运行时在解组值类型的过程中调用此方法。
 

参数类型为 Serializable 的 org.omg.CORBA.portable 中的方法
 void BoxedValueHelper.write_value(OutputStream os, Serializable value)
           
 

org.omg.CORBA.TypeCodePackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.CORBA.TypeCodePackage 中的类
 class BadKind
          当对 TypeCode 对象调用不恰当的操作时将抛出 BadKind 异常。
 

org.omg.CosNaming 中 Serializable 的使用
 

org.omg.CosNaming 中 Serializable 的子接口
 interface BindingIterator
          BindingIterator 接口允许客户端使用 next_one 或 next_n 迭代绑定。
 interface NamingContext
          命名上下文是包含一组名称绑定的对象，在这些名称绑定中，每个名称都是唯一的。
 interface NamingContextExt
          NamingContextExt 是 NamingContext（它包含一组名称绑定，在这些名称绑定中，每个名称都是唯一的）的扩展，并且是互操作命名服务 (Interoperable Naming Service) 的一部分。
 

实现 Serializable 的 org.omg.CosNaming 中的类
 class _BindingIteratorImplBase
           
 class _BindingIteratorStub
          BindingIterator 接口允许客户端使用 next_one 或 next_n 操作在绑定上进行迭代。
 class _NamingContextExtStub
          NamingContextExt 是 NamingContext（它包含一组名称绑定，在这些名称绑定中，每个名称都是唯一的）的扩展，并且是互操作命名服务 (Interoperable Naming Service) 的一部分。
 class _NamingContextImplBase
           
 class _NamingContextStub
          命名上下文是包含一组名称绑定的对象，在这些名称绑定中，每个名称都是唯一的。
 class BindingType
          指定给定的绑定对应于对象（非命名上下文的对象）还是命名上下文。
 class NameComponent
          org/omg/CosNaming/NameComponent.java。
 

org.omg.CosNaming.NamingContextExtPackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.CosNaming.NamingContextExtPackage 中的类
 class InvalidAddress
          org/omg/CosNaming/NamingContextExtPackage/InvalidAddress.java。
 

org.omg.CosNaming.NamingContextPackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.CosNaming.NamingContextPackage 中的类
 class AlreadyBound
          org/omg/CosNaming/NamingContextPackage/AlreadyBound.java。
 class CannotProceed
          org/omg/CosNaming/NamingContextPackage/CannotProceed.java。
 class NotEmpty
          org/omg/CosNaming/NamingContextPackage/NotEmpty.java。
 class NotFound
          org/omg/CosNaming/NamingContextPackage/NotFound.java。
 class NotFoundReason
          指示未能解析的原因。
 

org.omg.Dynamic 中 Serializable 的使用
 

实现 Serializable 的 org.omg.Dynamic 中的类
 class Parameter
          org/omg/Dynamic/Parameter.java。
 

org.omg.DynamicAny 中 Serializable 的使用
 

org.omg.DynamicAny 中 Serializable 的子接口
 interface DynAny
          通过 DynAny 对象可以动态解释（遍历）和构造 Any 值。
 interface DynAnyFactory
          DynAny 对象可以通过调用 DynAnyFactory 对象上的操作来创建。
 interface DynArray
          DynArray 对象支持对 IDL 数组的操作。
 interface DynEnum
          DynEnum 对象支持对 IDL 枚举值的操作。
 interface DynFixed
          DynFixed 对象支持对 IDL 定值 (fixed value) 的操作。
 interface DynSequence
          DynSequence 对象支持对 IDL 序列的操作。
 interface DynStruct
          DynStruct 对象支持对 IDL 结构数据 (struct) 和异常值的操作。
 interface DynUnion
          DynUnion 对象支持对 IDL 联合 (union) 的操作。
 interface DynValue
          DynValue 对象支持对 IDL 非装箱 (non-boxed) 值类型的操作。
 interface DynValueBox
          DynValueBox 对象支持对 IDL 装箱 (boxed) 类型的操作。
 interface DynValueCommon
          DynValueCommon 提供 DynValue 和 DynValueBox 接口都支持的操作。
 

实现 Serializable 的 org.omg.DynamicAny 中的类
 class _DynAnyFactoryStub
          DynAny 对象可以通过调用 DynAnyFactory 对象上的操作来创建。
 class _DynAnyStub
          通过 DynAny 对象可以动态解释（遍历）和构造 Any 值。
 class _DynArrayStub
          DynArray 对象支持对 IDL 数组 (array) 的操作。
 class _DynEnumStub
          DynEnum 对象支持对 IDL 枚举 (enumerated) 值的操作。
 class _DynFixedStub
          DynEnum 对象支持对 IDL 定值 (fixed value) 的操作。
 class _DynSequenceStub
          DynSequence 对象支持对 IDL 序列 (sequence) 的操作。
 class _DynStructStub
          DynStruct 对象支持对 IDL 结构数据 (struct) 和异常值的操作。
 class _DynUnionStub
          DynUnion 对象支持对 IDL 联合数据 (union) 的操作。
 class _DynValueStub
          DynValue 对象支持 IDL non-boxed value 类型的操作。
 class NameDynAnyPair
          org/omg/DynamicAny/NameDynAnyPair.java。
 

返回 Serializable 的 org.omg.DynamicAny 中的方法
 Serializable DynAnyOperations.get_val()
          从此 DynAny 中提取 Serializable 对象。
 Serializable _DynAnyStub.get_val()
          从此 DynAny 中提取 Serializable 对象。
 Serializable _DynArrayStub.get_val()
          从此 DynAny 中提取 Serializable 对象。
 Serializable _DynEnumStub.get_val()
          从此 DynAny 中提取 Serializable 对象。
 Serializable _DynFixedStub.get_val()
          从此 DynAny 中提取 Serializable 对象。
 Serializable _DynSequenceStub.get_val()
          从此 DynAny 中提取 Serializable 对象。
 Serializable _DynStructStub.get_val()
          从此 DynAny 中提取 Serializable 对象。
 Serializable _DynUnionStub.get_val()
          从此 DynAny 中提取 Serializable 对象。
 Serializable _DynValueStub.get_val()
          从此 DynAny 中提取 Serializable 对象。
 

参数类型为 Serializable 的 org.omg.DynamicAny 中的方法
 void DynAnyOperations.insert_val(Serializable value)
          将对 Serializable 对象的引用插入此 DynAny 中。
 void _DynAnyStub.insert_val(Serializable value)
          将对 Serializable 对象的引用插入此 DynAny 中。
 void _DynArrayStub.insert_val(Serializable value)
          将对 Serializable 对象的引用插入此 DynAny 中。
 void _DynEnumStub.insert_val(Serializable value)
          将对 Serializable 对象的引用插入此 DynAny 中。
 void _DynFixedStub.insert_val(Serializable value)
          将对 Serializable 对象的引用插入此 DynAny 中。
 void _DynSequenceStub.insert_val(Serializable value)
          将对 Serializable 对象的引用插入此 DynAny 中。
 void _DynStructStub.insert_val(Serializable value)
          将对 Serializable 对象的引用插入此 DynAny 中。
 void _DynUnionStub.insert_val(Serializable value)
          将对 Serializable 对象的引用插入此 DynAny 中。
 void _DynValueStub.insert_val(Serializable value)
          将对 Serializable 对象的引用插入此 DynAny 中。
 

org.omg.IOP 中 Serializable 的使用
 

org.omg.IOP 中 Serializable 的子接口
 interface Codec
          IOR 组件的格式和 ORB 服务使用的服务上下文数据通常被定义为 CDR 封装，该封装编码用 IDL 定义的数据类型的实例。
 interface CodecFactory
          Codec 可从 CodecFactory 中获得。
 

实现 Serializable 的 org.omg.IOP 中的类
 class Encoding
          org/omg/IOP/Encoding.java。
 class IOR
          org/omg/IOP/IOR.java。
 class ServiceContext
          org/omg/IOP/ServiceContext.java。
 class TaggedComponent
          org/omg/IOP/TaggedComponent.java。
 class TaggedProfile
          org/omg/IOP/TaggedProfile.java。
 

org.omg.IOP.CodecFactoryPackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.IOP.CodecFactoryPackage 中的类
 class UnknownEncoding
          org/omg/IOP/CodecFactoryPackage/UnknownEncoding.java。
 

org.omg.IOP.CodecPackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.IOP.CodecPackage 中的类
 class FormatMismatch
          org/omg/IOP/CodecPackage/FormatMismatch.java。
 class InvalidTypeForEncoding
          org/omg/IOP/CodecPackage/InvalidTypeForEncoding.java。
 

org.omg.PortableInterceptor 中 Serializable 的使用
 

org.omg.PortableInterceptor 中 Serializable 的子接口
 interface ClientRequestInfo
          客户端请求 interceptor 可访问的请求信息。
 interface ClientRequestInterceptor
          客户端 interceptor。
 interface Interceptor
          所有 Portable Interceptor 实现 Interceptor。
 interface IORInfo
          提供服务器端的 ORB 服务，该服务能够在构建 IOR 期间访问适用的策略并添加组件。
 interface IORInterceptor
          Interceptor 用于在 IOR 内部配置文件中建立带标记的组件。
 interface IORInterceptor_3_0
          org/omg/PortableInterceptor/IORInterceptor_3_0.java。
 interface ObjectReferenceFactory
          对象引用工厂。
 interface ObjectReferenceTemplate
          对象引用模板。
 interface ORBInitializer
          便于注册 interceptor 和初始化 ORB。
 interface ORBInitInfo
          传递给每个 ORBInitializer，允许其在初始化 ORB 时注册 interceptor 并执行其他职责。
 interface PolicyFactory
          使得策略类型能够使用 CORBA.ORB.create_policy 来构建。
 interface RequestInfo
          Interceptor 可访问的请求信息。
 interface ServerRequestInfo
          服务器端请求 interceptor 可访问的请求信息。
 interface ServerRequestInterceptor
          服务器端的请求 interceptor。
 

实现 Serializable 的 org.omg.PortableInterceptor 中的类
 class InvalidSlot
          org/omg/PortableInterceptor/InvalidSlot.java。
 

org.omg.PortableInterceptor.ORBInitInfoPackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.PortableInterceptor.ORBInitInfoPackage 中的类
 class DuplicateName
          org/omg/PortableInterceptor/ORBInitInfoPackage/DuplicateName.java。
 

org.omg.PortableServer 中 Serializable 的使用
 

org.omg.PortableServer 中 Serializable 的子接口
 interface AdapterActivator
          一个适配器激活器，它提供具有随需创建子 POA 功能的 POA。
 interface IdAssignmentPolicy
          IdAssignmentPolicy 指定创建的 POA 中的 Object Id 是由应用程序还是由 ORB 生成的。
 interface IdUniquenessPolicy
          IdUniquenessPolicy 指定已创建的 POA 中激活的 servant 是否必须具有唯一的对象身份。
 interface ImplicitActivationPolicy
          此策略指定已创建的 POA 中是否支持隐式激活 servant。
 interface LifespanPolicy
          LifespanPolicy 指定已创建 POA 中实现的对象的生存期。
 interface POA
          POA 对象管理对象集合的实现。
 interface POAManager
          每个 POA 对象都有一个关联的 POAManager 对象。
 interface RequestProcessingPolicy
          此策略指定已创建的 POA 处理请求的方式。
 interface ServantActivator
          POA 具有 RETAIN 策略时使用 ServantActivator 这种 servant 管理器。
 interface ServantLocator
          当 POA 具有 NON_RETAIN 策略时，使用 ServantLocator 这种 servant 管理器。
 interface ServantManager
          servant 管理器提供一个 POA，该 POA 在接受以非激活的对象为目标的请求时能够根据需要激活对象。
 interface ServantRetentionPolicy
          此策略指定已创建的 POA 是否在 Active Object Map 中保留激活的 servant。
 interface ThreadPolicy
          ThreadPolicy 指定已创建的 POA 所使用的线程模型 (threading model)。
 

实现 Serializable 的 org.omg.PortableServer 中的类
 class _ServantActivatorStub
          当 POA 具有 RETAIN 策略时，它使用 ServantActivator 这种 servant 管理器。
 class _ServantLocatorStub
          POA 具有 NON_RETAIN 策略时将使用 ServantLocator 这种 servant 管理器。
 class ForwardRequest
          org/omg/PortableServer/ForwardRequest.java。
 class IdAssignmentPolicyValue
          IdAssignmentPolicyValue 可以具有以下值。
 class IdUniquenessPolicyValue
          IdUniquenessPolicyValue 可以具有以下值。
 class ImplicitActivationPolicyValue
          ImplicitActivationPolicyValue 具有以下语义。
 class LifespanPolicyValue
          LifespanPolicyValue 可以具有以下值。
 class RequestProcessingPolicyValue
          RequestProcessingPolicyValue 可以具有以下值。
 class ServantRetentionPolicyValue
          ServantRetentionPolicyValue 可以具有以下值。
 class ThreadPolicyValue
          ThreadPolicyValue 可以具有以下值。
 

org.omg.PortableServer.CurrentPackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.PortableServer.CurrentPackage 中的类
 class NoContext
          org/omg/PortableServer/CurrentPackage/NoContext.java。
 

org.omg.PortableServer.POAManagerPackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.PortableServer.POAManagerPackage 中的类
 class AdapterInactive
          org/omg/PortableServer/POAManagerPackage/AdapterInactive.java。
 class State
          指定 POAManager 的状态。
 

org.omg.PortableServer.POAPackage 中 Serializable 的使用
 

实现 Serializable 的 org.omg.PortableServer.POAPackage 中的类
 class AdapterAlreadyExists
          org/omg/PortableServer/POAPackage/AdapterAlreadyExists.java。
 class AdapterNonExistent
          org/omg/PortableServer/POAPackage/AdapterNonExistent.java。
 class InvalidPolicy
          org/omg/PortableServer/POAPackage/InvalidPolicy.java。
 class NoServant
          org/omg/PortableServer/POAPackage/NoServant.java。
 class ObjectAlreadyActive
          org/omg/PortableServer/POAPackage/ObjectAlreadyActive.java。
 class ObjectNotActive
          org/omg/PortableServer/POAPackage/ObjectNotActive.java。
 class ServantAlreadyActive
          org/omg/PortableServer/POAPackage/ServantAlreadyActive.java。
 class ServantNotActive
          org/omg/PortableServer/POAPackage/ServantNotActive.java。
 class WrongAdapter
          org/omg/PortableServer/POAPackage/WrongAdapter.java。
 class WrongPolicy
          org/omg/PortableServer/POAPackage/WrongPolicy.java。
 

org.omg.SendingContext 中 Serializable 的使用
 

org.omg.SendingContext 中 Serializable 的子接口
 interface RunTime
          定义表示请求的发送上下文的基类。
 

org.omg.stub.java.rmi 中 Serializable 的使用
 

实现 Serializable 的 org.omg.stub.java.rmi 中的类
 class _Remote_Stub
          此类为 Remote 类型提供 Stub。
 

org.w3c.dom 中 Serializable 的使用
 

实现 Serializable 的 org.w3c.dom 中的类
 class DOMException
          DOM 操作只在 "exceptional" 情况下引发异常，即不能执行操作时（由于逻辑原因，因为丢失数据或因为实现变得不稳定）。
 

org.w3c.dom.events 中 Serializable 的使用
 

实现 Serializable 的 org.w3c.dom.events 中的类
 class EventException
          事件操作可以像在其方法描述中指定的那样抛出 EventException。
 

org.w3c.dom.ls 中 Serializable 的使用
 

实现 Serializable 的 org.w3c.dom.ls 中的类
 class LSException
          如果处理停止，解析或写操作可以抛出 LSException。
 

org.xml.sax 中 Serializable 的使用
 

实现 Serializable 的 org.xml.sax 中的类
 class SAXException
          封装一般的 SAX 错误或警告。
 class SAXNotRecognizedException
          用于未识别的标识符的 Exception 类。
 class SAXNotSupportedException
          用于不被支持的操作的 Exception 类。
 class SAXParseException
          封装 XML 解析错误或警告。
 

概述  软件包  类   使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 6
 上一个   下一个 框架    无框架    
提交错误或意见

版权所有 2008 Sun Microsystems, Inc. 保留所有权利。请遵守GNU General Public License, version 2 only。