JavaTM 2 Platform
Standard Edition

Uses of Interface
java.io.Serializable

Packages that use Serializable
java.applet Provides the classes necessary to create an applet and the classes an applet uses to communicate with its applet context. 
java.awt Contains all of the classes for creating user interfaces and for painting graphics and images. 
java.awt.color Provides classes for color spaces. 
java.awt.datatransfer Provides interfaces and classes for transferring data between and within applications. 
java.awt.dnd Drag and Drop is a direct manipulation gesture found in many Graphical User Interface systems that provides a mechanism to transfer information between two entities logically associated with presentation elements in the GUI. 
java.awt.event Provides interfaces and classes for dealing with different types of events fired by AWT components. 
java.awt.font Provides classes and interface relating to fonts. 
java.awt.geom Provides the Java 2D classes for defining and performing operations on objects related to two-dimensional geometry. 
java.awt.image Provides classes for creating and modifying images. 
java.awt.image.renderable Provides classes and interfaces for producing rendering-independent images. 
java.awt.print Provides classes and interfaces for a general printing API. 
java.beans Contains classes related to Java Beans development. 
java.beans.beancontext Provides classes and interfaces relating to bean context. 
java.io Provides for system input and output through data streams, serialization and the file system. 
java.lang Provides classes that are fundamental to the design of the Java programming language. 
java.lang.reflect Provides classes and interfaces for obtaining reflective information about classes and objects. 
java.math Provides classes for performing arbitrary-precision integer arithmetic (BigInteger) and arbitrary-precision decimal arithmetic (BigDecimal). 
java.net Provides the classes for implementing networking applications. 
java.rmi Provides the RMI package. 
java.rmi.activation Provides support for RMI Object Activation. 
java.rmi.dgc Provides classes and interface for RMI distributed garbage-collection (DGC). 
java.rmi.server Provides classes and interfaces for supporting the server side of RMI. 
java.security Provides the classes and interfaces for the security framework. 
java.security.acl The classes and interfaces in this package have been superseded by classes in the java.security package. 
java.security.cert Provides classes and interfaces for parsing and managing certificates. 
java.security.interfaces Provides interfaces for generating RSA (Rivest, Shamir and Adleman AsymmetricCipher algorithm) keys as defined in the RSA Laboratory Technical Note PKCS#1, and DSA (Digital Signature Algorithm) keys as defined in NIST's FIPS-186. 
java.security.spec Provides classes and interfaces for key specifications and algorithm parameter specifications. 
java.sql Provides the JDBC package. 
java.text Provides classes and interfaces for handling text, dates, numbers, and messages in a manner independent of natural languages. 
java.util Contains the collections framework, legacy collection classes, event model, date and time facilities, internationalization, and miscellaneous utility classes (a string tokenizer, a random-number generator, and a bit array). 
java.util.jar Provides classes for reading and writing the JAR (Java ARchive) file format, which is based on the standard ZIP file format with an optional manifest file. 
java.util.zip Provides classes for reading and writing the standard ZIP and GZIP file formats. 
javax.swing Provides a set of "lightweight" (all-Java language) components that, to the maximum degree possible, work the same on all platforms. 
javax.swing.border Provides classes and interface for drawing specialized borders around a Swing component. 
javax.swing.colorchooser Contains classes and interfaces used by the JColorChooser component. 
javax.swing.event Provides for events fired by Swing components. 
javax.swing.plaf Provides one interface and many abstract classes that Swing uses to provide its pluggable look-and-feel capabilities. 
javax.swing.plaf.basic Provides user interface objects built according to the Basic look-and-feel. 
javax.swing.plaf.metal Provides user interface objects built according to the ``metal'' look-and-feel. 
javax.swing.table Provides classes and interfaces for dealing with java.awt.swing.JTable. 
javax.swing.text Provides classes and interfaces that deal with editable and noneditable text components. 
javax.swing.text.html Provides the class HTMLEditorKit and supporting classes for creating HTML text editors. 
javax.swing.text.html.parser   
javax.swing.text.rtf Provides a class (RTFEditorKit) for creating Rich-Text-Format text editors. 
javax.swing.tree Provides classes and interfaces for dealing with java.awt.swing.JTree. 
javax.swing.undo Provides support for undo/redo capabilities in an application such as a text editor. 
org.omg.CORBA Provides the mapping of the OMG CORBA APIs to the JavaTM programming language, including the class ORB, which is implemented so that a programmer can use it as a fully-functional Object Request Broker (ORB). 
org.omg.CORBA.DynAnyPackage Provides the exceptions used with the DynAny interface (InvalidValue, Invalid, InvalidSeq, and TypeMismatch). 
org.omg.CORBA.ORBPackage Provides the exception InvalidName, which is thrown by the method ORB.resolve_initial_references and the exception InconsistentTypeCode, which is thrown by the Dynamic Any creation methods in the ORB class. 
org.omg.CORBA.portable Provides a portability layer, that is, a set of ORB APIs that makes it possible for code generated by one vendor to run on another vendor's ORB. 
org.omg.CORBA.TypeCodePackage Provides the user-defined exceptions BadKind and Bounds, which are thrown by methods in in the class TypeCode
org.omg.CosNaming Provides the naming service for Java IDL. 
org.omg.CosNaming.NamingContextPackage Provides the exceptions used in the package org.omg.CosNaming (AlreadyBound, CannotProceed, InvalidName, NotEmpty, and NotFound) and also the Helper and Holder classes for those exceptions. 
 

Uses of Serializable in java.applet
 

Classes in java.applet that implement Serializable
 class Applet
          An applet is a small program that is intended not to be run on its own, but rather to be embedded inside another application.
 

Uses of Serializable in java.awt
 

Classes in java.awt that implement Serializable
 interface AWTError
          Thrown when a serious Abstract Window Toolkit error has occurred.
 class AWTEvent
          The root event class for all AWT events.
 interface AWTException
          Signals that an Absract Window Toolkit exception has occurred.
 class AWTPermission
          This class is for AWT permissions.
 class BorderLayout
          A border layout lays out a container, arranging and resizing its components to fit in five regions: north, south, east, west, and center.
 class Button
          This class creates a labeled button.
 class Canvas
          A Canvas component represents a blank rectangular area of the screen onto which the application can draw or from which the application can trap input events from the user.
 class CardLayout
          A CardLayout object is a layout manager for a container.
 class Checkbox
          A check box is a graphical component that can be in either an "on" (true) or "off" (false) state.
 class CheckboxGroup
          The CheckboxGroup class is used to group together a set of Checkbox buttons.
 class CheckboxMenuItem
          This class represents a check box that can be included in a menu.
 class Choice
          The Choice class presents a pop-up menu of choices.
 class Color
          A class to encapsulate colors in the default sRGB color space or colors in arbitrary color spaces identified by a ColorSpace.
 class Component
          A component is an object having a graphical representation that can be displayed on the screen and that can interact with the user.
 class ComponentOrientation
          The ComponentOrientation class encapsulates the language-sensitive orientation that is to be used to order the elements of a component or of text.
 class Container
          A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT components.
 class Cursor
          A class to encapsulate the bitmap representation of the mouse cursor.
 class Dialog
          A Dialog is a top-level window with a title and a border that is typically used to take some form of input from the user.
 class Dimension
          The Dimension class encapsulates the width and height of a component (in integer precision) in a single object.
 class Event
          Event is a platform-independent class that encapsulates events from the platform's Graphical User Interface in the Java 1.0 event model.
 class FileDialog
          The FileDialog class displays a dialog window from which the user can select a file.
 class FlowLayout
          A flow layout arranges components in a left-to-right flow, much like lines of text in a paragraph.
 class Font
          The Font class represents fonts.
 class FontMetrics
          The FontMetrics class defines a font metrics object, which encapsulates information about the rendering of a particular font on a particular screen.
 class Frame
          A Frame is a top-level window with a title and a border.
 class GraphicsConfigTemplate
          The GraphicsConfigTemplate class is used to obtain a valid GraphicsConfiguration.
 class GridBagConstraints
          The GridBagConstraints class specifies constraints for components that are laid out using the GridBagLayout class.
 class GridBagLayout
          The GridBagLayout class is a flexible layout manager that aligns components vertically and horizontally, without requiring that the components be of the same size.
 class GridLayout
          The GridLayout class is a layout manager that lays out a container's components in a rectangular grid.
 interface IllegalComponentStateException
          Signals that an AWT component is not in an appropriate state for the requested operation.
 class Insets
          An Insets object is a representation of the borders of a container.
 class Label
          A Label object is a component for placing text in a container.
 class List
          The List component presents the user with a scrolling list of text items.
 class MediaTracker
          The MediaTracker class is a utility class to track the status of a number of media objects.
 class Menu
          A Menu object is a pull-down menu component that is deployed from a menu bar.
 class MenuBar
          The MenuBar class encapsulates the platform's concept of a menu bar bound to a frame.
 class MenuComponent
          The abstract class MenuComponent is the superclass of all menu-related components.
 class MenuItem
          All items in a menu must belong to the class MenuItem, or one of its subclasses.
 class MenuShortcut
          A class which represents a keyboard accelerator for a MenuItem.
 class Panel
          Panel is the simplest container class.
 class Point
          A point representing a location in (x, y) coordinate space, specified in integer precision.
 class Polygon
          The Polygon class encapsulates a description of a closed, two-dimensional region within a coordinate space.
 class PopupMenu
          A class that implements a menu which can be dynamically popped up at a specified position within a component.
 class Rectangle
          A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's top-left point (xy) in the coordinate space, its width, and its height.
 class Scrollbar
          The Scrollbar class embodies a scroll bar, a familiar user-interface object.
 class ScrollPane
          A container class which implements automatic horizontal and/or vertical scrolling for a single child component.
 class SystemColor
          A class to encapsulate symbolic colors representing the color of GUI objects on a system.
 class TextArea
          A TextArea object is a multi-line region that displays text.
 class TextComponent
          The TextComponent class is the superclass of any component that allows the editing of some text.
 class TextField
          A TextField object is a text component that allows for the editing of a single line of text.
 class Window
          A Window object is a top-level window with no borders and no menubar.
 

Uses of Serializable in java.awt.color
 

Classes in java.awt.color that implement Serializable
 interface CMMException
          This exception is thrown if the native CMM returns an error.
 interface ProfileDataException
          This exception is thrown when an error occurs in accessing or processing an ICC_Profile object.
 

Uses of Serializable in java.awt.datatransfer
 

Classes in java.awt.datatransfer that implement Serializable
 class DataFlavor
          Each instance represents the opaque concept of a data format as would appear on a clipboard, during drag and drop, or in a file system.
 interface UnsupportedFlavorException
          Signals that the requested data is not supported in this flavor.
 

Uses of Serializable in java.awt.dnd
 

Classes in java.awt.dnd that implement Serializable
 class DragGestureEvent
          A DragGestureEvent is passed to DragGestureListener's dragGestureRecognized() method when a particular DragGestureRecognizer detects that a platform dependent drag initiating gesture has occurred on the Component that it is tracking.
 class DragSourceDragEvent
          The DragSourceDragEvent is delivered from the DragSourceContextPeer, via the DragSourceContext, to the currently registered DragSourceListener.
 class DragSourceDropEvent
          The DragSourceDropEvent is delivered from the DragSourceContextPeer, via the DragSourceContext, to its currently registered DragSourceListener's dragDropEnd() method.
 class DragSourceEvent
          This class is the base class for DragSourceDragEvent and DragSourceDropEvent.
 class DropTarget
          The DropTarget is associated with a Component when that Component wishes to accept drops during Drag and Drop operations.
 class DropTargetDragEvent
          The DropTargetDragEvent is delivered to a DropTargetListener via its dragEnter() and dragOver() methods.
 class DropTargetDropEvent
          The DropTargetDropEvent is delivered via the DropTargetListener drop() method.
 class DropTargetEvent
          The DropTargetEvent is the base class for both the DropTargetDragEvent and the DropTargetDropEvent.
 interface InvalidDnDOperationException
          This exception is thrown by various methods in the java.awt.dnd package.
 

Uses of Serializable in java.awt.event
 

Classes in java.awt.event that implement Serializable
 class ActionEvent
          A semantic event which indicates that a component-defined action occured.
 class AdjustmentEvent
          The adjustment event emitted by Adjustable objects.
 class ComponentEvent
          A low-level event which indicates that a component moved, changed size, or changed visibility (also, the root class for the other component-level events).
 class ContainerEvent
          A low-level event which indicates that a container's contents changed because a component was added or removed.
 class FocusEvent
          A low-level event which indicates that a component has gained or lost the keyboard focus.
 class InputEvent
          The root event class for all component-level input events.
 class InputMethodEvent
          Input method events contain information about text that is being composed using an input method.
 class InvocationEvent
          An event which executes the run() method on a Runnable when dispatched by the AWT event dispatcher thread.
 class ItemEvent
          A semantic event which indicates that an item was selected or deselected.
 class KeyEvent
          An event which indicates that a keystroke occurred in a component.
 class MouseEvent
          /** An event which indicates that a mouse action occurred in a component.
 class PaintEvent
          The component-level paint event.
 class TextEvent
          A semantic event which indicates that an object's text changed.
 class WindowEvent
          A low-level event which indicates that a window has changed its status.
 

Uses of Serializable in java.awt.font
 

Classes in java.awt.font that implement Serializable
 class TextAttribute
          The TextAttribute class defines attribute keys and attribute values used for text rendering.
 class TransformAttribute
          The TransformAttribute class provides an immutable wrapper for a transform so that it is safe to use as an attribute.
 

Uses of Serializable in java.awt.geom
 

Classes in java.awt.geom that implement Serializable
 class AffineTransform
          The AffineTransform class represents a 2D affine transform that performs a linear mapping from 2D coordinates to other 2D coordinates that preserves the "straightness" and "parallelness" of lines.
 interface IllegalPathStateException
          The IllegalPathStateException represents an exception that is thrown if an operation is performed on a path that is in an illegal state with respect to the particular operation being performed, such as appending a path segment to a GeneralPath without an initial moveto.
 interface NoninvertibleTransformException
          The NoninvertibleTransformException class represents an exception that is thrown if an operation is performed requiring the inverse of an AffineTransform object but the AffineTransform is in a non-invertible state.
 

Uses of Serializable in java.awt.image
 

Classes in java.awt.image that implement Serializable
 interface ImagingOpException
          The ImagingOpException is thrown if one of the BufferedImageOp or RasterOp filter methods cannot process the image.
 interface RasterFormatException
          The RasterFormatException is thrown if there is invalid layout information in the Raster.
 

Uses of Serializable in java.awt.image.renderable
 

Classes in java.awt.image.renderable that implement Serializable
 class ParameterBlock
          A ParameterBlock encapsulates all the information about sources and parameters (Objects) required by a RenderableImageOp, or other classes that process images.
 

Uses of Serializable in java.awt.print
 

Classes in java.awt.print that implement Serializable
 interface PrinterAbortException
          The PrinterAbortException class is a subclass of PrinterException and is used to indicate that a user or application has terminated the print job while it was in the process of printing.
 interface PrinterException
          The PrinterException class and its subclasses are used to indicate that an exceptional condition has occurred in the print system.
 interface PrinterIOException
          The PrinterIOException class is a subclass of PrinterException and is used to indicate that an IO error of some sort has occurred while printing.
 

Uses of Serializable in java.beans
 

Classes in java.beans that implement Serializable
 interface IntrospectionException
          Thrown when an exception happens during Introspection.
 class PropertyChangeEvent
          A "PropertyChange" event gets delivered whenever a bean changes a "bound" or "constrained" property.
 class PropertyChangeSupport
          This is a utility class that can be used by beans that support bound properties.
 interface PropertyVetoException
          A PropertyVetoException is thrown when a proposed change to a property represents an unacceptable value.
 class VetoableChangeSupport
          This is a utility class that can be used by beans that support constrained properties.
 

Uses of Serializable in java.beans.beancontext
 

Classes in java.beans.beancontext that implement Serializable
 class BeanContextChildSupport
           This is a general support class to provide support for implementing the BeanContextChild protocol.
 class BeanContextEvent
           BeanContextEvent is the abstract root event class for all events emitted from, and pertaining to the semantics of, a BeanContext.
 class BeanContextMembershipEvent
           Compliant BeanContexts fire events on this interface when state maintained by the BeanContext, for some or all of its "children", changes, to all BeanContextListeners that register themselves with a particular BeanContext.
 class BeanContextServiceAvailableEvent
           This event type is used by the BeanContextServicesListener in order to identify the service being registered.
 class BeanContextServiceRevokedEvent
           This event type is used by the BeanContextServicesListener in order to identify the service being revoked.
 class BeanContextServicesSupport
           This helper class provides a utility implementation of the java.beans.beancontext.BeanContextServices interface.
protected  class BeanContextServicesSupport.BCSSChild
           
protected static class BeanContextServicesSupport.BCSSServiceProvider
          subclasses may subclass this nested class to add behaviors for each BeanContextServicesProvider.
 class BeanContextSupport
           This helper class provides a utility implementation of the java.beans.beancontext.BeanContext interface.
protected  class BeanContextSupport.BCSChild
           
 

Methods in java.beans.beancontext that return Serializable
protected static Serializable BeanContextSupport.getChildSerializable(Object child)
           
 

Uses of Serializable in java.io
 

Subinterfaces of Serializable in java.io
 interface Externalizable
          Only the identity of the class of an Externalizable instance is written in the serialization stream and it is the responsibility of the class to save and restore the contents of its instances.
 

Classes in java.io that implement Serializable
 interface CharConversionException
          base class for character conversion exceptions
 interface EOFException
          Signals that an end of file or end of stream has been reached unexpectedly during input.
 class File
          An abstract representation of file and directory pathnames.
 interface FileNotFoundException
          Signals that an attempt to open the file denoted by a specified pathname has failed.
 class FilePermission
          This class represents access to a file or directory.
 interface InterruptedIOException
          Signals that an I/O operation has been interrupted.
 interface InvalidClassException
          Thrown when the Serialization runtime detects one of the following problems with a Class.
 interface InvalidObjectException
          Indicates that one or more deserialized objects failed validation tests.
 interface IOException
          Signals that an I/O exception of some sort has occurred.
 interface NotActiveException
          Thrown when serialization or deserialization is not active.
 interface NotSerializableException
          Thrown when an instance is required to have a Serializable interface.
 class ObjectStreamClass
          Serialization's descriptor for classes.
 interface ObjectStreamException
          Superclass of all exceptions specific to Object Stream classes.
 interface OptionalDataException
          Unexpected data appeared in an ObjectInputStream trying to read an Object.
 class SerializablePermission
          This class is for Serializable permissions.
 interface StreamCorruptedException
          Thrown when control information that was read from an object stream violates internal consistency checks.
 interface SyncFailedException
           
 interface UnsupportedEncodingException
          The Character Encoding is not supported
 interface UTFDataFormatException
          Signals that a malformed UTF-8 string has been read in a data input stream or by any class that implements the data input interface.
 interface WriteAbortedException
           
 

Uses of Serializable in java.lang
 

Classes in java.lang that implement Serializable
 interface AbstractMethodError
          Thrown when an application tries to call an abstract method.
 interface ArithmeticException
          Thrown when an exceptional arithmetic condition has occurred.
 interface ArrayIndexOutOfBoundsException
          Thrown to indicate that an array has been accessed with an illegal index.
 interface ArrayStoreException
          Thrown to indicate that an attempt has been made to store the wrong type of object into an array of objects.
 class Boolean
          The Boolean class wraps a value of the primitive type boolean in an object.
 class Byte
          The Byte class is the standard wrapper for byte values.
 class Character
          The Character class wraps a value of the primitive type char in an object.
 class Class
          Instances of the class Class represent classes and interfaces in a running Java application.
 interface ClassCastException
          Thrown to indicate that the code has attempted to cast an object to a subclass of which it is not an instance.
 interface ClassCircularityError
          Thrown when a circularity has been detected while initializing a class.
 interface ClassFormatError
          Thrown when the Java Virtual Machine attempts to read a class file and determines that the file is malformed or otherwise cannot be interpreted as a class file.
 interface ClassNotFoundException
          Thrown when an application tries to load in a class through its string name using: The forName method in class Class.
 interface CloneNotSupportedException
          Thrown to indicate that the clone method in class Object has been called to clone an object, but that the object's class does not implement the Cloneable interface.
 class Double
          The Double class wraps a value of the primitive type double in an object.
 interface Error
          An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.
 interface Exception
          The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch.
 interface ExceptionInInitializerError
          Signals that an unexpected exception has occurred in a static initializer.
 class Float
          The Float class wraps a value of primitive type float in an object.
 interface IllegalAccessError
          Thrown if an application attempts to access or modify a field, or to call a method that it does not have access to.
 interface IllegalAccessException
          Thrown when an application tries to load in a class through its string name using: The forName method in class Class.
 interface IllegalArgumentException
          Thrown to indicate that a method has been passed an illegal or inappropriate argument.
 interface IllegalMonitorStateException
          Thrown to indicate that a thread has attempted to wait on an object's monitor or to notify other threads waiting on an object's monitor without owning the specified monitor.
 interface IllegalStateException
          Signals that a method has been invoked at an illegal or inappropriate time.
 interface IllegalThreadStateException
          Thrown to indicate that a thread is not in an appropriate state for the requested operation.
 interface IncompatibleClassChangeError
          Thrown when an incompatible class change has occurred to some class definition.
 interface IndexOutOfBoundsException
          Thrown to indicate that an index of some sort (such as to an array, to a string, or to a vector) is out of range.
 interface InstantiationError
          Thrown when an application tries to use the Java new construct to instantiate an abstract class or an interface.
 interface InstantiationException
          Thrown when an application tries to create an instance of a class using the newInstance method in class Class, but the specified class object cannot be instantiated because it is an interface or is an abstract class.
 class Integer
          The Integer class wraps a value of the primitive type int in an object.
 interface InternalError
          Thrown to indicate some unexpected internal error has occurred in the Java Virtual Machine.
 interface InterruptedException
          Thrown when a thread is waiting, sleeping, or otherwise paused for a long time and another thread interrupts it using the interrupt method in class Thread.
 interface LinkageError
          Subclasses of LinkageError indicate that a class has some dependency on another class; however, the latter class has incompatibly changed after the compilation of the former class.
 class Long
          The Long class wraps a value of the primitive type long in an object.
 interface NegativeArraySizeException
          Thrown if an application tries to create an array with negative size.
 interface NoClassDefFoundError
          Thrown if the Java Virtual Machine or a classloader tries to load in the definition of a class (as part of a normal method call or as part of creating a new instance using the new expression) and no definition of the class could be found.
 interface NoSuchFieldError
          Thrown if an application tries to access or modify a specified field of an object, and that object no longer has that field.
 interface NoSuchFieldException
          Signals that the class doesn't have a field of a specified name.
 interface NoSuchMethodError
          Thrown if an application tries to call a specified method of a class (either static or instance), and that class no longer has a definition of that method.
 interface NoSuchMethodException
          Thrown when a particular method cannot be found.
 interface NullPointerException
          Thrown when an application attempts to use null in a case where an object is required.
 class Number
          The abstract class Number is the superclass of classes Byte, Double, Float, Integer, Long, and Short.
 interface NumberFormatException
          Thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.
 interface OutOfMemoryError
          Thrown when the Java Virtual Machine cannot allocate an object because it is out of memory, and no more memory could be made available by the garbage collector.
 interface RuntimeException
          RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
 class RuntimePermission
          This class is for runtime permissions.
 interface SecurityException
          Thrown by the security manager to indicate a security violation.
 class Short
          The Short class is the standard wrapper for short values.
 interface StackOverflowError
          Thrown when a stack overflow occurs because an application recurses too deeply.
 class String
          The String class represents character strings.
 class StringBuffer
          A string buffer implements a mutable sequence of characters.
 interface StringIndexOutOfBoundsException
          Thrown by the charAt method in class String and by other String methods to indicate that an index is either negative or greater than or equal to the size of the string.
 interface ThreadDeath
          An instance of ThreadDeath is thrown in the victim thread when the stop method with zero arguments in class Thread is called.
 class Throwable
          The Throwable class is the superclass of all errors and exceptions in the Java language.
 interface UnknownError
          Thrown when an unknown but serious exception has occurred in the Java Virtual Machine.
 interface UnsatisfiedLinkError
          Thrown if the Java Virtual Machine cannot find an appropriate native-language definition of a method declared native.
 interface UnsupportedClassVersionError
          Thrown when the Java Virtual Machine attempts to read a class file and determines that the major and minor version numbers in the file are not supported.
 interface UnsupportedOperationException
          Thrown to indicate that the requested operation is not supported.
 interface VerifyError
          Thrown when the "verifier" detects that a class file, though well formed, contains some sort of internal inconsistency or security problem.
 interface VirtualMachineError
          Thrown to indicate that the Java Virtual Machine is broken or has run out of resources necessary for it to continue operating.
 

Uses of Serializable in java.lang.reflect
 

Classes in java.lang.reflect that implement Serializable
 interface InvocationTargetException
          InvocationTargetException is a checked exception that wraps an exception thrown by an invoked method or constructor.
 class ReflectPermission
          The Permission class for reflective operations.
 

Uses of Serializable in java.math
 

Classes in java.math that implement Serializable
 class BigDecimal
          Immutable, arbitrary-precision signed decimal numbers.
 class BigInteger
          Immutable arbitrary-precision integers.
 

Uses of Serializable in java.net
 

Classes in java.net that implement Serializable
 interface BindException
          Signals that an error occurred while attempting to bind a socket to a local address and port.
 class InetAddress
          This class represents an Internet Protocol (IP) address.
 interface MalformedURLException
          Thrown to indicate that a malformed URL has occurred.
 class NetPermission
          This class is for various network permissions.
 interface NoRouteToHostException
          Signals that an error occurred while attempting to connect a socket to a remote address and port.
 interface ProtocolException
          Thrown to indicate that there is an error in the underlying protocol, such as a TCP error.
 interface SocketException
          Thrown to indicate that there is an error in the underlying protocol, such as a TCP error.
 class SocketPermission
          This class represents access to a network via sockets.
 interface UnknownHostException
          Thrown to indicate that the IP address of a host could not be determined.
 interface UnknownServiceException
          Thrown to indicate that an unknown service exception has occurred.
 class URL
          Class URL represents a Uniform Resource Locator, a pointer to a "resource" on the World Wide Web.
 

Uses of Serializable in java.rmi
 

Classes in java.rmi that implement Serializable
 interface AccessException
          An AccessException is thrown by certain methods of the java.rmi.Naming class (specifically bind, rebind, and unbind) and methods of the java.rmi.activation.ActivationSystem interface to indicate that the caller does not have permission to perform the action requested by the method call.
 interface AlreadyBoundException
          An AlreadyBoundException is thrown if an attempt is made to bind an object in the registry to a name that already has an associated binding.
 interface ConnectException
          A ConnectException is thrown if a connection is refused to the remote host for a remote method call.
 interface ConnectIOException
          A ConnectIOException is thrown if an IOException occurs while making a connection to the remote host for a remote method call.
 interface MarshalException
          A MarshalException is thrown if a java.io.IOException occurs while marshalling the remote call header, arguments or return value for a remote method call.
 class MarshalledObject
          A MarshalledObject contains a byte stream with the serialized representation of an object given to its constructor.
 interface NoSuchObjectException
          A NoSuchObjectException is thrown if an attempt is made to invoke a method on an object that no longer exists in the remote virtual machine.
 interface NotBoundException
          A NotBoundException is thrown if an attempt is made to lookup or unbind in the registry a name that has no associated binding.
 interface RemoteException
          A RemoteException is the common superclass for a number of communication-related exceptions that may occur during the execution of a remote method call.
 interface RMISecurityException
          Deprecated. no replacement. RMISecurityManager no longer throws this subclass of java.lang.SecurityException.
 interface ServerError
          A ServerError is thrown as a result of a remote method call if the execution of the remote method on the server machine throws a java.lang.Error.
 interface ServerException
          A ServerException is thrown as a result of a remote method call if the execution of the remote method on the server machine throws a RemoteException.
 interface ServerRuntimeException
          Deprecated. no replacement
 interface StubNotFoundException
          A StubNotFoundException is thrown if a valid stub class could not be found for a remote object when it is exported.
 interface UnexpectedException
          An UnexpectedException is thrown if the client of a remote method call receives, as a result of the call, a checked exception that is not among the checked exception types declared in the throws clause of the method in the remote interface.
 interface UnmarshalException
          An UnmarshalException can be thrown while unmarshalling the parameters or results of a remote method call if any of the following conditions occur: if an exception occurs while unmarshalling the call header if the protocol for the return value is invalid if a java.io.IOException occurs unmarshalling parameters (on the server side) or the return value (on the client side).
 

Uses of Serializable in java.rmi.activation
 

Classes in java.rmi.activation that implement Serializable
 class Activatable
          The Activatable class provides support for remote objects that require persistent access over time and that can be activated by the system.
 interface ActivateFailedException
          This exception is thrown by the RMI runtime when activation fails during a remote call to an activatable object.
 class ActivationDesc
          An activation descriptor contains the information necessary to activate an object: the object's group identifier, the object's class name, the object's code location (the location of the class), and a "marshalled" object that can contain object specific initialization data.
 interface ActivationException
          General exception used by the activation interfaces.
 class ActivationGroup
          An ActivationGroup is responsible for creating new instances of "activatable" objects in its group, informing its ActivationMonitor when either: its object's become active or inactive, or the group as a whole becomes inactive.
 class ActivationGroupDesc
          An activation group descriptor contains the information necessary to create/recreate an activation group in which to activate objects.
static class ActivationGroupDesc.CommandEnvironment
          Startup options for ActivationGroup implementations.
 class ActivationGroupID
          The identifier for a registered activation group serves several purposes: identifies the group uniquely within the activation system, and contains a reference to the group's activation system so that the group can contact its activation system when necessary.
 class ActivationID
          Activation makes use of special identifiers to denote remote objects that can be activated over time.
 interface UnknownGroupException
          An UnknownGroupException is thrown by methods of classes and interfaces in the java.rmi.activation package when the ActivationGroupID parameter to the method is determined to be invalid, i.e., not known by the ActivationSystem.
 interface UnknownObjectException
          An UnknownObjectException is thrown by methods of classes and interfaces in the java.rmi.activation package when the ActivationID parameter to the method is determined to be invalid.
 

Uses of Serializable in java.rmi.dgc
 

Classes in java.rmi.dgc that implement Serializable
 class Lease
          A lease contains a unique VM identifier and a lease duration.
 class VMID
          A VMID is a identifier that is unique across all Java virtual machines.
 

Uses of Serializable in java.rmi.server
 

Subinterfaces of Serializable in java.rmi.server
 interface RemoteRef
          RemoteRef represents the handle for a remote object.
 interface ServerRef
          A ServerRef represents the server-side handle for a remote object implementation.
 

Classes in java.rmi.server that implement Serializable
 interface ExportException
          An ExportException is a RemoteException thrown if an attempt to export a remote object fails.
 class ObjID
          An ObjID is used to identify remote objects uniquely in a VM over time.
 class RemoteObject
          The RemoteObject class implements the java.lang.Object behavior for remote objects.
 class RemoteServer
          The RemoteServer class is the common superclass to server implementations and provides the framework to support a wide range of remote reference semantics.
 class RemoteStub
          The RemoteStub class is the common superclass to client stubs and provides the framework to support a wide range of remote reference semantics.
 interface ServerCloneException
          A ServerCloneException is thrown if a remote exception occurs during the cloning of a UnicastRemoteObject.
 interface ServerNotActiveException
          An ServerNotActiveException is an Exception thrown during a call to RemoteServer.getClientHost if the getClientHost method is called outside of servicing a remote method call.
 interface SkeletonMismatchException
          Deprecated. no replacement. Skeletons are no longer required for remote method calls in JDK1.2 and greater.
 interface SkeletonNotFoundException
          Deprecated. no replacement. Skeletons are no longer required for remote method calls in JDK1.2 and greater.
 interface SocketSecurityException
          A SocketSecurityException is thrown during remote object export if the code exporting the remote object (either by construction or by explicit call to the exportObject method of UnicastRemoteObject or java.rmi.activation.Activatable) does not have permission to create a java.net.ServerSocket on the port number specified during remote object export.
 class UID
          Abstraction for creating identifiers that are unique with respect to the the host on which it is generated.
 class UnicastRemoteObject
          The UnicastRemoteObject class defines a non-replicated remote object whose references are valid only while the server process is alive.
 

Uses of Serializable in java.security
 

Subinterfaces of Serializable in java.security
 interface Key
          The Key interface is the top-level interface for all keys.
 interface PrivateKey
          A private key.
 interface PublicKey
          A public key.
 

Classes in java.security that implement Serializable
 interface AccessControlException
           This exception is thrown by the AccessController to indicate that a requested access (to a critical system resource such as the file system or the network) is denied.
 class AllPermission
          The AllPermission is a permission that implies all other permissions.
 class BasicPermission
          The BasicPermission class extends the Permission class, and can be used as the base class for permissions that want to follow the same naming convention as BasicPermission.
 class CodeSource
          This class extends the concept of a codebase to encapsulate not only the location (URL) but also the certificate(s) that were used to verify signed code originating from that location.
 interface DigestException
          This is the generic Message Digest exception.
 interface GeneralSecurityException
          This is the general security exception class, which serves to group all the exception classes of the java.security package that extend from it.
 class GuardedObject
          A GuardedObject is an object that is used to protect access to another object.
 class Identity
          Deprecated. This class is no longer used. Its functionality has been replaced by java.security.KeyStore, the java.security.cert package, and java.security.Principal.
 class IdentityScope
          Deprecated. This class is no longer used. Its functionality has been replaced by java.security.KeyStore, the java.security.cert package, and java.security.Principal.
 interface InvalidAlgorithmParameterException
          This is the exception for invalid or inappropriate algorithm parameters.
 interface InvalidKeyException
          This is the exception for invalid Keys (invalid encoding, wrong length, uninitialized, etc).
 interface InvalidParameterException
          This exception is thrown when an invalid parameter is passed to a method.
 interface KeyException
          This is the basic key exception.
 interface KeyManagementException
          This is the general key management exception, for all operations dealing with key management.
 class KeyPair
          This class is a simple holder for a key pair (a public key and a private key).
 interface KeyStoreException
          This is the generic KeyStore exception.
 interface NoSuchAlgorithmException
          This exception is thrown when a particular cryptographic algorithm is requested but is not available in the environment.
 interface NoSuchProviderException
          This exception is thrown when a particular security provider is requested but is not available in the environment.
 class Permission
          Abstract class for representing access to a system resource.
 class PermissionCollection
          Abstract class representing a collection of Permission objects.
 class Permissions
          This class represents a heterogeneous collection of Permissions.
 interface PrivilegedActionException
          This exception is thrown by doPrivileged(PrivilegedExceptionAction) and doPrivileged(PrivilegedExceptionAction, AccessControlContext context) to indicate that the action being performed threw a checked exception.
 class Provider
          This class represents a "provider" for the Java Security API, where a provider implements some or all parts of Java Security, including: Algorithms (such as DSA, RSA, MD5 or SHA-1).
 interface ProviderException
          A runtime exception for Provider exceptions (such as misconfiguration errors), which may be subclassed by Providers to throw specialized, provider-specific runtime errors.
 class SecureRandom
          This class provides a cryptographically strong pseudo-random number generator (PRNG).
 class SecureRandomSpi
          This class defines the Service Provider Interface (SPI) for the SecureRandom class.
 class SecurityPermission
          This class is for security permissions.
 interface SignatureException
          This is the generic Signature exception.
 class SignedObject
           SignedObject is a class for the purpose of creating authentic runtime objects whose integrity cannot be compromised without being detected.
 class Signer
          Deprecated. This class is no longer used. Its functionality has been replaced by java.security.KeyStore, the java.security.cert package, and java.security.Principal.
 interface UnrecoverableKeyException
          This exception is thrown if a key in the keystore cannot be recovered.
 class UnresolvedPermission
          The UnresolvedPermission class is used to hold Permissions that were "unresolved" when the Policy was initialized.
 

Constructors in java.security with parameters of type Serializable
SignedObject.SignedObject(Serializable object, PrivateKey signingKey, Signature signingEngine)
          Constructs a SignedObject from any Serializable object.
 

Uses of Serializable in java.security.acl
 

Classes in java.security.acl that implement Serializable
 interface AclNotFoundException
          This is an exception that is thrown whenever a reference is made to a non-existent ACL (Access Control List).
 interface LastOwnerException
          This is an exception that is thrown whenever an attempt is made to delete the last owner of an Access Control List.
 interface NotOwnerException
          This is an exception that is thrown whenever the modification of an object (such as an Access Control List) is only allowed to be done by an owner of the object, but the Principal attempting the modification is not an owner.
 

Uses of Serializable in java.security.cert
 

Classes in java.security.cert that implement Serializable
 interface CertificateEncodingException
          Certificate Encoding Exception.
 interface CertificateException
          This exception indicates one of a variety of certificate problems.
 interface CertificateExpiredException
          Certificate Expired Exception.
 interface CertificateNotYetValidException
          Certificate is not yet valid exception.
 interface CertificateParsingException
          Certificate Parsing Exception.
 interface CRLException
          CRL (Certificate Revocation List) Exception
 

Uses of Serializable in java.security.interfaces
 

Subinterfaces of Serializable in java.security.interfaces
 interface DSAPrivateKey
          The standard interface to a DSA private key.
 interface DSAPublicKey
          The interface to a DSA public key.
 interface RSAPrivateCrtKey
          The interface to an RSA private key, as defined in the PKCS#1 standard, using the Chinese Remainder Theorem (CRT) information values.
 interface RSAPrivateKey
          The interface to an RSA private key.
 interface RSAPublicKey
          The interface to an RSA public key.
 

Uses of Serializable in java.security.spec
 

Classes in java.security.spec that implement Serializable
 interface InvalidKeySpecException
          This is the exception for invalid key specifications.
 interface InvalidParameterSpecException
          This is the exception for invalid parameter specifications.
 

Uses of Serializable in java.sql
 

Classes in java.sql that implement Serializable
 interface BatchUpdateException
          JDBC 2.0
 interface DataTruncation
          An exception that reports a DataTruncation warning (on reads) or throws a DataTruncation exception (on writes) when JDBC unexpectedly truncates a data value.
 interface SQLException
          An exception that provides information on a database access error.
 interface SQLWarning
          An exception that provides information on database access warnings.
 class Time
          A thin wrapper around java.util.Date that allows JDBC to identify this as a SQL TIME value.
 class Timestamp
          This class is a thin wrapper around java.util.Date that allows JDBC to identify this as a SQL TIMESTAMP value.
 

Uses of Serializable in java.text
 

Classes in java.text that implement Serializable
static class AttributedCharacterIterator.Attribute
          Defines attribute keys that are used to identify text attributes.
 class ChoiceFormat
          A ChoiceFormat allows you to attach a format to a range of numbers.
 class DateFormat
          DateFormat is an abstract class for date/time formatting subclasses which formats and parses dates or time in a language-independent manner.
 class DateFormatSymbols
          DateFormatSymbols is a public class for encapsulating localizable date-time formatting data, such as the names of the months, the names of the days of the week, and the time zone data.
 class DecimalFormat
          DecimalFormat is a concrete subclass of NumberFormat for formatting decimal numbers.
 class DecimalFormatSymbols
          This class represents the set of symbols (such as the decimal separator, the grouping separator, and so on) needed by DecimalFormat to format numbers.
 class Format
          Format is an abstract base class for formatting locale-sensitive information such as dates, messages, and numbers.
 class MessageFormat
          MessageFormat provides a means to produce concatenated messages in language-neutral way.
 class NumberFormat
          NumberFormat is the abstract base class for all number formats.
 interface ParseException
          Signals that an error has been reached unexpectedly while parsing.
 class SimpleDateFormat
          SimpleDateFormat is a concrete class for formatting and parsing dates in a locale-sensitive manner.
 

Uses of Serializable in java.util
 

Classes in java.util that implement Serializable
 class ArrayList
          Resizable-array implementation of the List interface.
 class BitSet
          This class implements a vector of bits that grows as needed.
 class Calendar
          Calendar is an abstract base class for converting between a Date object and a set of integer fields such as YEAR, MONTH, DAY, HOUR, and so on.
 interface ConcurrentModificationException
          This exception may be thrown by methods that have detected concurrent modification of a backing object when such modification is not permissible.
 class Date
          The class Date represents a specific instant in time, with millisecond precision.
 interface EmptyStackException
          Thrown by methods in the Stack class to indicate that the stack is empty.
 class EventObject
           The Event class is the abstract root class from which all event state objects shall be derived.
 class GregorianCalendar
          GregorianCalendar is a concrete subclass of Calendar and provides the standard calendar used by most of the world.
 class HashMap
          Hash table based implementation of the Map interface.
 class HashSet
          This class implements the Set interface, backed by a hash table (actually a HashMap instance).
 class Hashtable
          This class implements a hashtable, which maps keys to values.
 class LinkedList
          Linked list implementation of the List interface.
 class Locale
          A Locale object represents a specific geographical, political, or cultural region.
 interface MissingResourceException
          Signals that a resource is missing.
 interface NoSuchElementException
          Thrown by the nextElement method of an Enumeration to indicate that there are no more elements in the enumeration.
 class Properties
          The Properties class represents a persistent set of properties.
 class PropertyPermission
          This class is for property permissions.
 class Random
          An instance of this class is used to generate a stream of pseudorandom numbers.
 class SimpleTimeZone
          SimpleTimeZone is a concrete subclass of TimeZone that represents a time zone for use with a Gregorian calendar.
 class Stack
          The Stack class represents a last-in-first-out (LIFO) stack of objects.
 class TimeZone
          TimeZone represents a time zone offset, and also figures out daylight savings.
 interface TooManyListenersException
           The TooManyListenersException Exception is used as part of the Java Event model to annotate and implement a unicast special case of a multicast Event Source.
 class TreeMap
          Red-Black tree based implementation of the SortedMap interface.
 class TreeSet
          This class implements the Set interface, backed by a TreeMap instance.
 class Vector
          The Vector class implements a growable array of objects.
 

Uses of Serializable in java.util.jar
 

Classes in java.util.jar that implement Serializable
 interface JarException
          Signals that an error of some sort has occurred while reading from or writing to a JAR file.
 

Uses of Serializable in java.util.zip
 

Classes in java.util.zip that implement Serializable
 interface DataFormatException
          Signals that a data format error has occurred.
 interface ZipException
           
 

Uses of Serializable in javax.swing
 

Classes in javax.swing that implement Serializable
 class AbstractAction
          This class provides default implementations for the JFC Action interface.
 class AbstractButton
          Defines the common behaviors for the JButton, JToggleButton, JCheckbox, and the JRadioButton classes.
protected  class AbstractButton.AccessibleAbstractButton
          Accessiblity support.
protected  class AbstractButton.ButtonChangeListener
          Extend ChangeListener to be serializable
 class AbstractListModel
          The Abstract definition for the data model the provides a List with its contents.
 class Box
          A lightweight container that uses a BoxLayout object as its layout manager.
protected  class Box.AccessibleBox
           
static class Box.Filler
          An implementation of a lightweight component that participates in layout but has no view.
protected  class Box.Filler.AccessibleBoxFiller
           
 class BoxLayout
          A layout manager that allows multiple components to be layed out either vertically or horizontally.
 class ButtonGroup
          This class is used to create a multiple-exclusion scope for a set of buttons.
 class CellRendererPane
          This class is inserted in between cell renderers and the components that use them.
protected  class CellRendererPane.AccessibleCellRendererPane
           
 class DefaultBoundedRangeModel
          A generic implementation of BoundedRangeModel.
 class DefaultButtonModel
          The default implementation of a Button component's data model.
 class DefaultCellEditor
          The default editor for table and tree cells.
protected  class DefaultCellEditor.EditorDelegate
           
 class DefaultComboBoxModel
          The default model for combo boxes.
 class DefaultDesktopManager
          This is an implementaion of the DesktopManager.
 class DefaultListCellRenderer
          Renders an item in a list.
static class DefaultListCellRenderer.UIResource
          A subclass of DefaultListCellRenderer that implements UIResource.
 class DefaultListModel
          This class implements the java.util.Vector API and notifies the ListDataListeners when changes occur.
 class DefaultListSelectionModel
          Default data model for list selections.
 class DefaultSingleSelectionModel
          A generic implementation of SingleSelectionModel.
 class ImageIcon
          An implementation of the Icon interface that paints Icons from Images.
 class JApplet
          An extended version of java.applet.Applet that adds support for interposing input and painting behavior in front of the applets children (see glassPane), support for special children that are managed by a LayeredPane (see rootPane) and for Swing MenuBars.
protected  class JApplet.AccessibleJApplet
           
 class JButton
          An implementation of a "push" button.
protected  class JButton.AccessibleJButton
          The class used to obtain the accessible role for this object.
 class JCheckBox
          An implementation of a CheckBox -- an item that can be selected or deselected, and which displays its state to the user.
protected  class JCheckBox.AccessibleJCheckBox
          The class used to obtain the accessible role for this object.
 class JCheckBoxMenuItem
          A menu item that can be selected or deselected.
protected  class JCheckBoxMenuItem.AccessibleJCheckBoxMenuItem
          The class used to obtain the accessible role for this object.
 class JColorChooser
          JColorChooser provides a pane of controls designed to allow a user to manipulate and select a color.
protected  class JColorChooser.AccessibleJColorChooser
          The class used to obtain the accessible context for this object.
 class JComboBox
          Swing's implementation of a ComboBox -- a combination of a text field and drop-down list that lets the user either type in a value or select it from a list that is displayed when the user asks for it.
protected  class JComboBox.AccessibleJComboBox
          The class used to obtain the accessible role for this object.
 class JComponent
          The base class for the Swing components.
 class JComponent.AccessibleJComponent
          Inner class of JComponent used to provide default support for accessibility.
 class JDesktopPane
          A container used to create a multiple-document interface or a virtual desktop.
protected  class JDesktopPane.AccessibleJDesktopPane
          The class used to obtain the accessible role for this object.
 class JDialog
          The main class for creating a dialog window.
protected  class JDialog.AccessibleJDialog
          The class used to obtain the AccessibleRole for this object.
 class JEditorPane
          A text component to edit various kinds of content.
protected  class JEditorPane.AccessibleJEditorPane
          The class used to obtain the accessible role for this object.
protected  class JEditorPane.AccessibleJEditorPaneHTML
          This class provides support for AccessibleHypertext, and is used in instances where the EditorKit installed in this JEditorPane is an instance of HTMLEditorKit.
protected  class JEditorPane.JEditorPaneAccessibleHypertextSupport
          What's returned by AccessibleJEditorPaneHTML.getAccessibleText() Provides support for AccessibleHypertext in case there is an HTML document being displayed in this JEditorPane.
 class JFileChooser
          JFileChooser provides a simple mechanism for the user to chooser a file.
protected  class JFileChooser.AccessibleJFileChooser
          The class used to obtain the accessible context for this object.
 class JFrame
          An extended version of java.awt.Frame that adds support for interposing input and painting behavior in front of the frame's children (see glassPane), support for special children that are managed by a LayeredPane (see rootPane) and for Swing MenuBars.
protected  class JFrame.AccessibleJFrame
          The class used to obtain the AccessibleRole for this object.
 class JInternalFrame
          A lightweight object that provides many of the features of a native frame, including dragging, closing, becoming an icon, resizing, title display, and support for a menu bar.
protected  class JInternalFrame.AccessibleJInternalFrame
          The class used to obtain the accessible role for this object.
static class JInternalFrame.JDesktopIcon
          This component represents an iconified version of a JInternalFrame.
protected  class JInternalFrame.JDesktopIcon.AccessibleJDesktopIcon
          The class used to obtain the accessible role for this object.
 class JLabel
          A display area for a short text string or an image, or both.
protected  class JLabel.AccessibleJLabel
          The class used to obtain the accessible role for this object.
 class JLayeredPane
          JLayeredPane adds depth to a JFC/Swing container, allowing components to overlap each other when needed.
protected  class JLayeredPane.AccessibleJLayeredPane
          The class used to obtain the accessible role for this object.
 class JList
          A component that allows the user to select one or more objects from a list.
protected  class JList.AccessibleJList
          The class used to obtain the accessible role for this object.
 class JMenu
          An implementation of a menu -- a popup window containing JMenuItems that is displayed when the user selects an item on the JMenuBar.
protected  class JMenu.AccessibleJMenu
          The class used to obtain the accessible role for this object.
protected  class JMenu.WinListener
          A listener class that watches for a popup window closing.
 class JMenuBar
          An implementation of a MenuBar.
protected  class JMenuBar.AccessibleJMenuBar
          The class used to obtain the accessible role for this object.
 class JMenuItem
          An implementation of a MenuItem.
protected  class JMenuItem.AccessibleJMenuItem
          The class used to obtain the accessible role for this object.
 class JOptionPane
          JOptionPane makes it easy to pop up a standard dialog box that prompts users for a value or informs them of something.
protected  class JOptionPane.AccessibleJOptionPane
          Accessiblity support.
 class JPanel
          JPanel is a generic lightweight container.
protected  class JPanel.AccessibleJPanel
          The class used to obtain the accessible role for this object.
 class JPasswordField
          JPasswordField is a lightweight component that allows the editing of a single line of text where the view indicates something was typed, but does not show the original characters.
protected  class JPasswordField.AccessibleJPasswordField
          The class used to obtain the accessible role for this object.
 class JPopupMenu
          An implementation of a Popup Menu -- a small window which pops up and displays a series of choices.
protected  class JPopupMenu.AccessibleJPopupMenu
           
static class JPopupMenu.Separator
          A popupmenu-specific separator.
 class JProgressBar
          A component that displays an integer value within a bounded interval.
protected  class JProgressBar.AccessibleJProgressBar
          The class used to obtain the accessible role for this object.
 class JRadioButton
          An implementation of a radio button -- an item that can be selected or deselected, and which displays its state to the user.
protected  class JRadioButton.AccessibleJRadioButton
          The class used to obtain the accessible role for this object.
 class JRadioButtonMenuItem
          An implementation of a RadioButtonMenuItem.
protected  class JRadioButtonMenuItem.AccessibleJRadioButtonMenuItem
          The class used to obtain the accessible role for this object.
 class JRootPane
          The fundamental component in the container hierarchy.
protected  class JRootPane.AccessibleJRootPane
          The class used to obtain the accessible role for this object.
protected  class JRootPane.RootLayout
          A custom layout manager that is responsible for the layout of layeredPane, glassPane, and menuBar.
 class JScrollBar
          An implementation of a scrollbar.
protected  class JScrollBar.AccessibleJScrollBar
          The class used to obtain the accessible role for this object.
 class JScrollPane
          A specialized container that manages a viewport, optional vertical and horizontal scrollbars, and optional row and column heading viewports.
protected  class JScrollPane.AccessibleJScrollPane
          The class used to obtain the accessible role for this object.
protected  class JScrollPane.ScrollBar
          By default JScrollPane creates scrollbars that are instances of this class.
 class JSeparator
          An implementation of a Menu Separator -- a divider between menu items that breaks them up into logical groupings.
protected  class JSeparator.AccessibleJSeparator
          The class used to obtain the accessible role for this object.
 class JSlider
          A component that lets the user graphically select a value by slding a knob within a bounded interval.
protected  class JSlider.AccessibleJSlider
          The class used to obtain the accessible role for this object.
 class JSplitPane
          JSplitPane is used to divide two (and only two) Components.
protected  class JSplitPane.AccessibleJSplitPane
          The class used to obtain the accessible role for this object.
 class JTabbedPane
          A component which lets the user switch between a group of components by clicking on a tab with a given title and/or icon.
protected  class JTabbedPane.AccessibleJTabbedPane
          The class used to obtain the accessible role for this object.
protected  class JTabbedPane.ModelListener
          We pass ModelChanged events along to the listeners with the tabbedpane (instead of the model itself) as the event source.
 class JTable
          JTable is a user-interface component that presents data in a two-dimensional table format.
protected  class JTable.AccessibleJTable
          The class used to obtain the accessible role for this object.
 class JTextArea
          A TextArea is a multi-line area that displays plain text.
protected  class JTextArea.AccessibleJTextArea
          The class used to obtain the accessible role for this object.
 class JTextField
          JTextField is a lightweight component that allows the editing of a single line of text.
protected  class JTextField.AccessibleJTextField
          The class used to obtain the accessible role for this object.
 class JTextPane
          A text component that can be marked up with attributes that are represented graphically.
 class JToggleButton
          An implementation of a two-state button.
protected  class JToggleButton.AccessibleJToggleButton
          The class used to obtain the accessible role for this object.
static class JToggleButton.ToggleButtonModel
          The ToggleButton model
 class JToolBar
          JToolBar provides a component which is useful for displaying commonly used Actions or controls.
protected  class JToolBar.AccessibleJToolBar
          The class used to obtain the accessible role for this object.
static class JToolBar.Separator
          A toolbar-specific separator.
 class JToolTip
          Used to display a "Tip" for a Component.
protected  class JToolTip.AccessibleJToolTip
          The class used to obtain the accessible role for this object.
 class JTree
          A control that displays a set of hierarchical data as an outline.
protected  class JTree.AccessibleJTree
          The class used to obtain the accessible role for this object.
static class JTree.DynamicUtilTreeNode
          DynamicUtilTreeNode can wrap vectors/hashtables/arrays/strings and create the appropriate children tree nodes as necessary.
protected static class JTree.EmptySelectionModel
          EmptySelectionModel is a TreeSelectionModel that does not allow anything to be selected.
protected  class JTree.TreeSelectionRedirector
          Handles creating a new TreeSelectionEvent with the JTree as the source and passing it off to all the listeners.
 class JViewport
          The "viewport" or "porthole" through which you see the underlying information.
protected  class JViewport.AccessibleJViewport
          The class used to obtain the accessible role for this object.
protected  class JViewport.ViewListener
          A listener for the view.
 class JWindow
          A JWindow is a container that can be displayed anywhere on the user's desktop.
protected  class JWindow.AccessibleJWindow
          The class used to obtain the AccessibleRole for this object.
 class KeyStroke
          A KeyStroke instance represents a key being typed on the keyboard -- it contains both a char code for the key and a modifier (alt, shift, ctrl, meta, or a combination).
 class OverlayLayout
          A layout manager to arrange components over the top of each other.
 class ScrollPaneLayout
          The layout manager used by JScrollPane.
static class ScrollPaneLayout.UIResource
          The UI resource version of ScrollPaneLayout.
 class SizeRequirements
          For the convenience of layout managers, calculates information about the size and position of components.
 class Timer
          Object subclass that causes an action to occur at a predefined rate.
 class UIDefaults
          A table of defaults for Swing components.
 class UIManager
          This class keeps track of the current look and feel and its defaults.
 interface UnsupportedLookAndFeelException
          An exception that indicates the request look & feel management classes are not present on the user's system.
 class ViewportLayout
          The default layout manager for JViewport.
 

Uses of Serializable in javax.swing.border
 

Classes in javax.swing.border that implement Serializable
 class AbstractBorder
          A class which implements an empty border with no size.
 class BevelBorder
          A class which implements a simple 2 line bevel border.
 class CompoundBorder
          A composite Border class used to compose two Border objects into a single border by nesting an inside Border object within the insets of an outside Border object.
 class EmptyBorder
          A class which provides an empty, transparent border which takes up space but does no drawing.
 class EtchedBorder
          A class which implements a simple etched border which can either be etched-in or etched-out.
 class LineBorder
          A class which implements a line border of arbitrary thickness and of a single color.
 class MatteBorder
          A class which provides a matte-like border of either a solid color or a tiled icon.
 class SoftBevelBorder
          A class which implements a raised or lowered bevel with softened corners.
 class TitledBorder
          A class which implements an arbitrary border with the addition of a String title in a specified position and justification.
 

Uses of Serializable in javax.swing.colorchooser
 

Classes in javax.swing.colorchooser that implement Serializable
 class AbstractColorChooserPanel
          The is the abstract superclass for color choosers.
 class DefaultColorSelectionModel
          A generic implementation of ColorSelectionModel.
 

Uses of Serializable in javax.swing.event
 

Classes in javax.swing.event that implement Serializable
 class AncestorEvent
          An event reported to a child component that originated from an ancestor in the component hierarchy.
 class CaretEvent
          CaretEvent is used to notify interested parties that the text caret has changed in the event source.
 class ChangeEvent
          ChangeEvent is used to notify interested parties that state has changed in the event source.
 class EventListenerList
          A class which holds a list of EventListeners.
 class HyperlinkEvent
          HyperlinkEvent is used to notify interested parties that something has happened with respect to a hypertext link.
 class InternalFrameEvent
          InternalFrameEvent: an AWTEvent which adds support for JInternalFrame objects as the event source.
 class ListDataEvent
          Defines an event that encapsulates changes to a list.
 class ListSelectionEvent
          An event that characterizes a change in the current selection.
 class MenuDragMouseEvent
          MenuDragMouseEvent is used to notify interested parties that the menu element has received a MouseEvent forwarded to it under drag conditions.
 class MenuEvent
          MenuEvent is used to notify interested parties that the menu which is the event source has been posted, selected, or canceled.
 class MenuKeyEvent
          MenuKeyEvent is used to notify interested parties that the menu element has received a KeyEvent forwarded to it in a menu tree.
 class PopupMenuEvent
          PopupMenuEvent only contains the source of the event which is the JPoupMenu sending the event
 class SwingPropertyChangeSupport
          This subclass of java.beans.PropertyChangeSupport is identical in functionality -- it sacrifices thread-safety (not a Swing concern) for reduce memory consumption, which helps performance (both big Swing concerns).
 class TableColumnModelEvent
          TableColumnModelEvent is used to notify listeners that a table column model has changed, such as a column was added, removed, or moved.
 class TableModelEvent
          TableModelEvent is used to notify listeners that a table model has changed.
 class TreeExpansionEvent
          An event used to identify a single path in a tree.
 class TreeModelEvent
          Encapsulates information describing changes to a tree model, and used to notify tree model listeners of the change.
 class TreeSelectionEvent
          An event that characterizes a change in the current selection.
 class UndoableEditEvent
          An event indicating that an operation which can be undone has occurred.
 

Uses of Serializable in javax.swing.plaf
 

Classes in javax.swing.plaf that implement Serializable
 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 DimensionUIResource
           
 class FontUIResource
          A subclass of java.awt.Font that implements UIResource.
 class IconUIResource
           
 class InsetsUIResource
           
 

Uses of Serializable in javax.swing.plaf.basic
 

Classes in javax.swing.plaf.basic that implement Serializable
 class BasicArrowButton
          JButton object that draws a scaled Arrow in one of the cardinal directions.
static class BasicBorders.ButtonBorder
           
static class BasicBorders.FieldBorder
           
static class BasicBorders.MarginBorder
           
static class BasicBorders.MenuBarBorder
           
static class BasicBorders.RadioButtonBorder
           
static class BasicBorders.ToggleButtonBorder
           
 class BasicComboBoxRenderer
          ComboBox renderer
static class BasicComboBoxRenderer.UIResource
          A subclass of BasicComboBoxRenderer that implements UIResource.
 class BasicComboPopup
          This is an implementation of the ComboPopup interface.
protected  class BasicDesktopPaneUI.CloseAction
           
protected  class BasicDesktopPaneUI.MaximizeAction
           
protected  class BasicDesktopPaneUI.MinimizeAction
           
protected  class BasicDesktopPaneUI.NavigateAction
           
 class BasicDirectoryModel
          Basic implementation of a file list.
protected  class BasicFileChooserUI.ApproveSelectionAction
          Responds to an Open or Save request
protected  class BasicFileChooserUI.CancelSelectionAction
          Responds to a cancel request.
protected  class BasicFileChooserUI.ChangeToParentDirectoryAction
           
protected  class BasicFileChooserUI.GoHomeAction
          Acts on the "home" key event or equivalent event.
protected  class BasicFileChooserUI.NewFolderAction
          Creates a new folder.
protected  class BasicFileChooserUI.UpdateAction
          Rescans the files in the current directory
 class BasicIconFactory
          Factory object that can vend Icons appropriate for the basic L & F.
 class BasicInternalFrameTitlePane
          The class that manages a basic title bar
 class BasicInternalFrameTitlePane.CloseAction
          This inner class is marked "public" due to a compiler bug.
 class BasicInternalFrameTitlePane.IconifyAction
          This inner class is marked "public" due to a compiler bug.
 class BasicInternalFrameTitlePane.MaximizeAction
          This inner class is marked "public" due to a compiler bug.
 class BasicInternalFrameTitlePane.MoveAction
          This inner class is marked "public" due to a compiler bug.
 class BasicInternalFrameTitlePane.RestoreAction
          This inner class is marked "public" due to a compiler bug.
 class BasicInternalFrameTitlePane.SizeAction
          This inner class is marked "public" due to a compiler bug.
 class BasicInternalFrameTitlePane.SystemMenuBar
          This inner class is marked "public" due to a compiler bug.
 class BasicLookAndFeel
          Implements the a standard base LookAndFeel class from which standard desktop LookAndFeel classes (JLF, Mac, Windows, etc.) can be derived.
 class BasicSliderUI.ActionScroller
          Defines the action to take when scrolled.
 class BasicSplitPaneDivider
          Divider used by BasicSplitPaneUI.
static class BasicTextUI.BasicCaret
           
protected  class BasicToolBarUI.DragWindow
           
 class BasicTreeUI.TreeCancelEditingAction
          ActionListener that invokes cancelEditing when action performed.
 class BasicTreeUI.TreeHomeAction
          TreeHomeAction is used to handle end/home actions.
 class BasicTreeUI.TreeIncrementAction
          TreeIncrementAction is used to handle up/down actions.
 class BasicTreeUI.TreePageAction
          TreePageAction handles page up and page down events.
 class BasicTreeUI.TreeToggleAction
          For the first selected row expandedness will be toggled.
 class BasicTreeUI.TreeTraverseAction
          TreeTraverseAction is the action used for left/right keys.
 class DefaultMenuLayout
          The default layout manager for Popup menus and menubars.
 

Uses of Serializable in javax.swing.plaf.metal
 

Classes in javax.swing.plaf.metal that implement Serializable
static class MetalBorders.ButtonBorder
           
static class MetalBorders.Flush3DBorder
           
static class MetalBorders.InternalFrameBorder
           
static class MetalBorders.MenuBarBorder
           
static class MetalBorders.MenuItemBorder
           
static class MetalBorders.PopupMenuBorder
           
static class MetalBorders.RolloverButtonBorder
           
static class MetalBorders.ScrollPaneBorder
           
static class MetalBorders.TextFieldBorder
           
static class MetalBorders.ToolBarBorder
           
 class MetalCheckBoxIcon
          CheckboxIcon implementation for OrganicCheckBoxUI
 class MetalComboBoxButton
          JButton subclass to help out MetalComboBoxUI
 class MetalComboBoxIcon
          This utility class draws the horizontal bars which indicate a MetalComboBox
 class MetalComboBoxUI.MetalComboPopup
          This inner class is marked "public" due to a compiler bug.
protected  class MetalFileChooserUI.DirectoryComboBoxAction
          Acts when DirectoryComboBox has changed the selected item.
protected  class MetalFileChooserUI.DirectoryComboBoxModel
          Data model for a type-face selection combo-box.
protected  class MetalFileChooserUI.FileRenderer
           
protected  class MetalFileChooserUI.FilterComboBoxModel
          Data model for a type-face selection combo-box.
 class MetalFileChooserUI.FilterComboBoxRenderer
          Render different type sizes and styles.
 class MetalIconFactory
          Factory object that can vend Icons appropriate for Metal.
static class MetalIconFactory.FileIcon16
           Warning: Serialized objects of this class will not be compatible with future Swing releases.
static class MetalIconFactory.FolderIcon16
           Warning: Serialized objects of this class will not be compatible with future Swing releases.
static class MetalIconFactory.TreeControlIcon
           Warning: Serialized objects of this class will not be compatible with future Swing releases.
static class MetalIconFactory.TreeFolderIcon
           Warning: Serialized objects of this class will not be compatible with future Swing releases.
static class MetalIconFactory.TreeLeafIcon
           
 class MetalLookAndFeel
          Implements The Metal Look and Feel.
 class MetalScrollButton
          JButton object for Metal scrollbar arrows.
 

Uses of Serializable in javax.swing.table
 

Classes in javax.swing.table that implement Serializable
 class AbstractTableModel
          This abstract class provides default implementations for most of the methods in the TableModel interface.
 class DefaultTableCellRenderer
          The standard class for rendering (displaying) individual cells in a JTable.
static class DefaultTableCellRenderer.UIResource
          A subclass of DefaultTableCellRenderer that implements UIResource.
 class DefaultTableColumnModel
          The standard column-handler for a JTable.
 class DefaultTableModel
          This is an implementation of TableModel that uses a Vector of Vectors to store the cell value objects.
 class JTableHeader
          This is the column header part of a JTable.
protected  class JTableHeader.AccessibleJTableHeader
          The class used to obtain the accessible role for this object.
 class TableColumn
          A TableColumn represents all the attributes of a column in a JTable, such as width, resizibility, minimum and maximum width.
 

Uses of Serializable in javax.swing.text
 

Classes in javax.swing.text that implement Serializable
 class AbstractDocument
          An implementation of the document interface to serve as a basis for implementing various kinds of documents.
 class AbstractDocument.AbstractElement
          Implements the abstract part of an element.
 class AbstractDocument.BranchElement
          Implements a composite element that contains other elements.
 class AbstractDocument.DefaultDocumentEvent
          Stores document changes as the document is being modified.
static class AbstractDocument.ElementEdit
          An implementation of ElementChange that can be added to the document event.
 class AbstractDocument.LeafElement
          Implements an element that directly represents content of some kind.
 interface BadLocationException
          This exception is to report bad locations within a document model (that is, attempts to reference a location that doesn't exist).
 interface ChangedCharSetException
          ChangedCharSetException as the name indicates is an exception thrown when the charset is changed.
 class DefaultCaret
          A default implementation of Caret.
 class DefaultEditorKit
          This is the set of things needed by a text component to be a reasonably functioning editor for some type of text document.
static class DefaultEditorKit.BeepAction
          Creates a beep.
static class DefaultEditorKit.CopyAction
          Coies the selected region and place its contents into the system clipboard.
static class DefaultEditorKit.CutAction
          Cuts the selected region and place its contents into the system clipboard.
static class DefaultEditorKit.DefaultKeyTypedAction
          The action that is executed by default if a key typed event is received and there is no keymap entry.
static class DefaultEditorKit.InsertBreakAction
          Places a line/paragraph break into the document.
static class DefaultEditorKit.InsertContentAction
          Places content into the associated document.
static class DefaultEditorKit.InsertTabAction
          Places a tab character into the document.
static class DefaultEditorKit.PasteAction
          Pastes the contents of the system clipboard into the selected region, or before the caret if nothing is selected.
 class DefaultStyledDocument
          A document that can be marked up with character and paragraph styles in a manner similar to the Rich Text Format.
static class DefaultStyledDocument.AttributeUndoableEdit
          An UndoableEdit used to remember AttributeSet changes to an Element.
 class DefaultStyledDocument.ElementBuffer
          Class to manage changes to the element hierarchy.
protected  class DefaultStyledDocument.SectionElement
          Default root element for a document...
 class EditorKit
          Establishes the set of things needed by a text component to be a reasonably functioning editor for some type of text content.
 class GapContent
          An implementation of the AbstractDocument.Content interface implemented using a gapped buffer similar to that used by emacs.
(package private)  class javax.swing.text.GapVector
          An implementation of a gapped buffer similar to that used by emacs.
 class JTextComponent
          JTextComponent is the base class for swing text components.
 class JTextComponent.AccessibleJTextComponent
          Accessibility implementation for JTextComponent.
 class PlainDocument
          A plain document that maintains no character attributes.
 class SimpleAttributeSet
          A straightforward implementation of MutableAttributeSet using a hash table.
 class StringContent
          An implementation of the AbstractDocument.Content interface that is a brute force implementation that is useful for relatively small documents and/or debugging.
 class StyleContext
          A pool of styles and their associated resources.
 class StyleContext.NamedStyle
          A collection of attributes, typically used to represent character and paragraph styles.
 class StyledEditorKit
          This is the set of things needed by a text component to be a reasonably functioning editor for some type of text document.
static class StyledEditorKit.AlignmentAction
          An action to set paragraph alignment.
static class StyledEditorKit.BoldAction
          An action to toggle the bold attribute.
static class StyledEditorKit.FontFamilyAction
          An action to set the font family in the associated JEditorPane.
static class StyledEditorKit.FontSizeAction
          An action to set the font size in the associated JEditorPane.
static class StyledEditorKit.ForegroundAction
          An action to set foreground color.
static class StyledEditorKit.ItalicAction
          An action to toggle the italic attribute.
static class StyledEditorKit.StyledTextAction
          An action that assumes it's being fired on a JEditorPane with a StyledEditorKit (or subclass) installed.
static class StyledEditorKit.UnderlineAction
          An action to toggle the underline attribute.
 class TabSet
          A TabSet is comprised of many TabStops.
 class TabStop
          This class encapsulates a single tab stop (basically as tab stops are thought of by RTF).
 class TextAction
          An Action implementation useful for key bindings that are shared across a number of different text components.
 

Uses of Serializable in javax.swing.text.html
 

Classes in javax.swing.text.html that implement Serializable
static class HTML.UnknownTag
           
 class HTMLDocument
          A document that models html.
 class HTMLDocument.BlockElement
          An element that represents a structual block of html.
 class HTMLDocument.RunElement
          An element that represents a chunk of text that has a set of html character level attributes assigned to it.
 class HTMLEditorKit
          The Swing JEditorPane text component supports different kinds of content via a plug-in mechanism called an EditorKit.
static class HTMLEditorKit.HTMLTextAction
          An abstract Action providing some convenience methods that may be useful in inserting HTML into an existing document.
static class HTMLEditorKit.InsertHTMLTextAction
          InsertHTMLTextAction can be used to insert an arbitrary string of HTML into an existing HTML document.
static class HTMLEditorKit.LinkController
          Class to watch the associated component and fire hyperlink events on it when appropriate.
 class HTMLFrameHyperlinkEvent
          HTMLFrameHyperlinkEvent is used to notify interested parties that link was activated in a frame.
 class StyleSheet
          Support for defining the visual characteristics of html views being rendered.
static class StyleSheet.BoxPainter
          Class to carry out some of the duties of css formatting.
static class StyleSheet.ListPainter
          class to carry out some of the duties of css list formatting.
 

Uses of Serializable in javax.swing.text.html.parser
 

Classes in javax.swing.text.html.parser that implement Serializable
 class AttributeList
          This class defines the attributes of an SGML element as described in a DTD using the ATTLIST construct.
 class ContentModel
          A representation of a content model.
 class Element
          An element as described in a DTD using the ELEMENT construct.
 

Uses of Serializable in javax.swing.text.rtf
 

Classes in javax.swing.text.rtf that implement Serializable
 class RTFEditorKit
          This is the default implementation of RTF editing functionality.
 

Uses of Serializable in javax.swing.tree
 

Classes in javax.swing.tree that implement Serializable
 class DefaultMutableTreeNode
          A DefaultMutableTreeNode is a general-purpose node in a tree data structure.
 class DefaultTreeCellEditor.DefaultTextField
          TextField used when no editor is supplied.
 class DefaultTreeCellEditor.EditorContainer
          Container responsible for placing the editingComponent.
 class DefaultTreeCellRenderer
          Displays an entry in a tree.
 class DefaultTreeModel
          A simple tree data model that uses TreeNodes.
 class DefaultTreeSelectionModel
          Implementation of TreeSelectionModel.
 interface ExpandVetoException
          Exception used to stop and expand/collapse from happening.
 class TreePath
          Represents a path to a node.
 

Uses of Serializable in javax.swing.undo
 

Classes in javax.swing.undo that implement Serializable
 class AbstractUndoableEdit
          An abstract implementation of UndoableEdit, implementing simple responses to all boolean methods in that interface.
 interface CannotRedoException
          Thrown when an UndoableEdit is told to redo() and can't.
 interface CannotUndoException
          Thrown when an UndoableEdit is told to undo() and can't.
 class CompoundEdit
          A concrete subclass of AbstractUndoableEdit, used to assemble little UndoableEdits into great big ones.
 class StateEdit
          StateEdit is a general edit for objects that change state.
 class UndoManager
          Concrete subclass of CompoundEdit which can serve as an UndoableEditListener, consolidating the UndoableEditEvents from a variety of sources, and undoing or redoing them one at a time.
 

Uses of Serializable in org.omg.CORBA
 

Subinterfaces of Serializable in org.omg.CORBA
 interface IDLType
          An abstract interface inherited by all Interface Repository (IR) objects that represent OMG IDL types.
 interface IRObject
          An IRObject IDL interface represents the most generic interface from which all other Interface Repository interfaces are derived, even the Repository itself.
 

Classes in org.omg.CORBA that implement Serializable
 class Any
          Serves as a container for any data that can be described in IDL or for any IDL primitive type.
 interface BAD_CONTEXT
          The CORBA BAD_CONTEXT exception, which is thrown when there is an error processing a context object.
 interface BAD_INV_ORDER
          The CORBA BAD_INV_ORDER exception, which is thrown when methods are called out of order.
 interface BAD_OPERATION
          The CORBA BAD_OPERATION exception, which is thrown when a method is invalid.
 interface BAD_PARAM
          The CORBA BAD_PARAM exception, which is thrown when an invalid parameter is passed to a method.
 interface BAD_TYPECODE
          The CORBA BAD_TYPECODE exception, which is thrown when the specified typecode is invalid.
 interface Bounds
           
 interface COMM_FAILURE
          The CORBA COMM_FAILURE exception, which is thrown when there is a communication failure.
 class CompletionStatus
          An object that indicates whether a method had completed running when a SystemException was thrown.
 interface DATA_CONVERSION
          The CORBA DATA_CONVERSION exception, which is thrown when there is a data conversion error.
 class DefinitionKind
          This class defines the constants used to identify the type of an Interface Repository object.
 interface FREE_MEM
          The CORBA FREE_MEM exception, which is thrown when the system is unable to free memory.
 interface IMP_LIMIT
          The CORBA IMP_LIMIT exception, which is thrown when the implementation limit has been violated.
 interface INITIALIZE
          The CORBA INITIALIZE exception, which is thrown when there is an ORB initialization error.
 interface INTERNAL
          The CORBA INTERNAL exception, which is thrown when there is an ORB internal error.
 interface INTF_REPOS
          The CORBA INTF_REPOS exception, which is thrown when there is an error accessing the interface repository.
 interface INV_FLAG
          The CORBA INV_FLAG exception, which is thrown when an invalid flag is specified.
 interface INV_IDENT
          The CORBA INV_IDENT exception, which is thrown when identifier syntax is invalid.
 interface INV_OBJREF
          The CORBA INV_OBJREF exception, which is thrown when an invalid object reference is specified.
 interface INV_POLICY
          The CORBA INV_POLICY standard exception, which is thrown when an invocation cannot be made because of an incompatibility between Policy overrides.
 interface INVALID_TRANSACTION
          The CORBA INVALID_TRANSACTION exception, which is thrown when there is a transaction error.
 interface MARSHAL
          The CORBA MARSHAL exception, which is thrown when the ORB has a problem marshalling or unmarshalling parameters.
 class NameValuePair
          The NameValuePair interface associates a name with a value that is an attribute of an IDL struct.
 interface NO_IMPLEMENT
          The CORBA NO_IMPLEMENT exception, which is thrown when the implementation for a method is not available.
 interface NO_MEMORY
          The CORBA NO_MEMORY exception, which may be thrown by either the client or the server when there is not enough memory for a dynamic memory allocation.
 interface NO_PERMISSION
          The CORBA NO_PERMISSION exception, which is thrown if the client does not have permission to perform the request.
 interface NO_RESOURCES
          The CORBA NO_RESOURCES exception, which is thrown when either the client or the server does not have sufficient resources to perform the request.
 interface NO_RESPONSE
          The CORBA NO_RESPONSE exception, which is thrown when a response to the request is not yet available.
 interface OBJ_ADAPTER
          The CORBA OBJ_ADAPTER exception, which is thrown by the object adapter on the server to indicate some error.
 interface OBJECT_NOT_EXIST
          The CORBA OBJECT_NOT_EXIST exception, which is usually thrown from the server to indicate that the target object does not exist.
 interface PERSIST_STORE
          The CORBA PERSIST_STORE exception, which is thrown when there is an error with the persistent storage on the server.
 interface PolicyError
          An exception carrying one of the following policy error reason codes defined in the org.omg.CORBA package: BAD_POLICY, BAD_POLICY_TYPE, BAD_POLICY_VALUE, UNSUPPORTED_POLICY, UNSUPPORTED_POLICY_VALUE
 class ServiceDetail
           
 class ServiceInformation
          ServiceInformation is an IDL struct in the CORBA module.
 class SetOverrideType
           
 class StructMember
          A description of a member of an IDL struct.
 interface SystemException
          The root class for all CORBA standard exceptions.
 interface TRANSACTION_REQUIRED
          The CORBA TRANSACTION_REQUIRED exception, which is thrown by the ORB on the client or server during the processing of a request that is required to be enclosed in a transaction.
 interface TRANSACTION_ROLLEDBACK
          The CORBA TRANSACTION_ROLLEDBACK exception, which is thrown when a transactional operation did not complete because the transaction was rolled back.
 interface TRANSIENT
          The CORBA TRANSIENT exception, which is thrown by the server to signal a transient failure that might not occur again if the request is retried.
 class TypeCode
          A container for information about a specific CORBA data type.
 class UnionMember
          A description in the Interface Repository of a member of an IDL union.
 interface UNKNOWN
          The CORBA UNKNOWN exception, which is thrown when there is an error whose cause is unknown to the ORB.
 interface UnknownUserException
          A class that contains user exceptions returned by the server.
 interface UserException
          The root class for CORBA IDL-defined user exceptions.
 class ValueMember
          A description in the Interface Repository of a member of a value object.
 interface WrongTransaction
          The CORBA WrongTransaction user-defined exception.
 

Methods in org.omg.CORBA that return Serializable
 Serializable DynAny.get_val()
          Retrieves the java.io.Serializable object contained in this DynAny object.
 Serializable Any.extract_Value()
          Extracts the java.io.Serializable object in this Any object's value field.
 

Methods in org.omg.CORBA with parameters of type Serializable
 void DynAny.insert_val(Serializable value)
          Inserts the given java.io.Serializable object as the value for this DynAny object.
 void Any.insert_Value(Serializable v)
          Inserts the given java.io.Serializable object into this Any object's value field.
 void Any.insert_Value(Serializable v, TypeCode t)
          Inserts the given java.io.Serializable object into this Any object's value field.
 

Uses of Serializable in org.omg.CORBA.DynAnyPackage
 

Classes in org.omg.CORBA.DynAnyPackage that implement Serializable
 interface Invalid
          Invalid is thrown by dynamic any operations when a bad DynAny or Any is passed as a parameter.
 interface InvalidSeq
          The InvalidSeq exception is thrown by all operations on dynamic anys that take a sequence (Java array) as an argument, when that sequence is invalid.
 interface InvalidValue
           
 interface TypeMismatch
          TypeMismatch is thrown by dynamic any accessor methods when type of the actual contents do not match what is trying to be accessed.
 

Uses of Serializable in org.omg.CORBA.ORBPackage
 

Classes in org.omg.CORBA.ORBPackage that implement Serializable
 interface InconsistentTypeCode
          InconsistentTypeCode is thrown when an attempt is made to create a dynamic any with a type code that does not match the particular subclass of DynAny.
 interface InvalidName
          The InvalidName exception is raised when ORB.resolve_initial_references is passed a name for which there is no initial reference.
 

Uses of Serializable in org.omg.CORBA.portable
 

Subinterfaces of Serializable in org.omg.CORBA.portable
 interface IDLEntity
          An interface with no members whose only purpose is to serve as a marker indicating that an implementing class is a Java value type from IDL that has a corresponding Helper class.
 

Classes in org.omg.CORBA.portable that implement Serializable
 interface ApplicationException
          This class is used for reporting application level exceptions between ORBs and stubs.
 interface RemarshalException
          This class is used for reporting locate forward exceptions and object forward GIOP messages back to the ORB.
 

Uses of Serializable in org.omg.CORBA.TypeCodePackage
 

Classes in org.omg.CORBA.TypeCodePackage that implement Serializable
 interface BadKind
          The exception BadKind is thrown when an inappropriate operation is invoked on a TypeCode object.
 

Uses of Serializable in org.omg.CosNaming
 

Subinterfaces of Serializable in org.omg.CosNaming
 interface BindingIterator
          The BindingIterator interface allows a client to iterate through the bindings using the next_one or next_n operations.
 interface NamingContext
          A naming context is an object that contains a set of name bindings in which each name is unique.
 

Classes in org.omg.CosNaming that implement Serializable
 class _BindingIteratorImplBase
           
 class _BindingIteratorStub
           
 class _NamingContextImplBase
           
 class _NamingContextStub
           
 class Binding
           
 class BindingType
           
 class NameComponent
           
 

Uses of Serializable in org.omg.CosNaming.NamingContextPackage
 

Classes in org.omg.CosNaming.NamingContextPackage that implement Serializable
 interface AlreadyBound
           
 interface CannotProceed
           
 interface NotEmpty
           
 interface NotFound
           
 class NotFoundReason
           
 


JavaTM 2 Platform
Standard Edition

Submit a bug or feature
Java, Java 2D, and JDBC are a trademarks or registered trademarks of Sun Microsystems, Inc. in the US and other countries.
Copyright 1993-1999 Sun Microsystems, Inc. 901 San Antonio Road,
Palo Alto, California, 94303, U.S.A. All Rights Reserved.