This appendix describes the packages of the JDK 1.2 API in terms of their interfaces, classes, exceptions, and errors. Also, hierarchical relationships between package elements are identified.
java.applet java.lang.reflect
java.awt java.math
com.sun.java.accessibility java.net
java.awt.colorjava.rmi java.rmi.activation
java.awt.datatransfer java.rmi.dgc
java.awt.dnd java.rmi.registry
java.awt.event java.rmi.server
java.awt.font java.security
java.awt.geom java.security.acl
java.awt.im java.security.cert
java.awt.image java.security.interfaces
com.sun.java.image.codec.jpeg java.security.spec
java.awt.image.renderable java.sql
java.awt.print java.text
com.sun.java.swing java.util
com.sun.java.swing.border java.util.jar
com.sun.java.swing.event java.util.mime
com.sun.java.swing.plaf java.util.zip
com.sun.java.swing.table org.omg.CORBA
com.sun.java.swing.text org.omg.CORBA.ContainedPackage
com.sun.java.swing.text.html org.omg.CORBA.ContainerPackage
com.sun.java.swing.text.rtf org.omg.CORBA.InterfaceDefPackage
com.sun.java.swing.tree org.omg.CORBA.ORBPackage
com.sun.java.swing.undog org.omg.CORBA.TypeCodePackage
java.beans org.omg.CORBA.portable
java.beans.beancontext org.omg.CosNamin
java.io org.omg.CosNaming.NamingContextPackage
java.lang javax.servlet
java.lang.ref javax.servlet.http
The java.applet package is one of the smallest packages in the Core API. It consists of one class and three interfaces that provide the basic functionality needed to implement applets.
The AppletContext interface defines methods that allow an applet to access the context in which it is being run.
The AppletStub interface supports communication between an applet and its browser environment and is used to develop custom applet viewers.
The AudioClip interface provides methods that support the playing of audio clips.
The Applet class is the superclass of all applets. It provides methods to display images, play audio files, respond to events, and obtain information about an applet's execution environment. The Applet class is a subclass of java.awt.panel.
None.
The java.awt package implements the core classes and interfaces of the Abstract Windowing Toolkit (AWT). It is a large package, containing 63 classes and 14 interfaces. These classes and interfaces provide the standard AWT GUI controls, as well as drawing, printing, and other capabilities. The java.awt package is covered in Chapter 5, "JDK 1.2 Applet Writing Basics."
The ActiveEvent interface defines methods that are implemented by event classes that are self-dispatching.
The Adjustable interface is implemented by classes, such as sliders and scrollbars, that allow a value to be selected from a range of values.
The Composite interface defines methods that are implemented by classes that allow drawing to be composed with an underlying graphics area.
The CompositeContext interface defines methods for classes that provide a context for compositing drawing operations.
The ItemSelectable interface is implemented by classes whose objects, such as choices or lists, may contain selectable items.
The LayoutManager interface is implemented by classes that can lay out Container objects.
The LayoutManager2 interface extends the LayoutManager interface to provide support for layout constraints.
The MenuContainer interface defines methods for classes that may contain Menu objects.
The Paint interface extends the Transparency interface, providing support for defining color patterns for use in graphics operations.
The PaintContext interface provides methods that define the context for paint operations.
The PrintGraphics interface defines a graphics context for printing a single page.
The Shape interface defines methods that are implemented by classes that encapsulate geometric shapes.
The Stroke interface provides methods that are implemented by classes that define pen strokes.
The Transparency interface defines methods for classes that support transparency- related graphics operations.
The AWTEvent class is a subclass of java.util.EventObject that serves as the base class for all AWT-related events.
The AWTEventMulticaster class is a subclass of Object that provides thread-safe multicast event dispatching capabilities. It implements the following interfaces of the java.awt.event package: ActionListener, AdjustmentListener, ComponentListener, ContainerListener, FocusListener, InputMethodListener, ItemListener, KeyListener, MouseListener, MouseMotionListener, TextListener, and WindowListener.
The AWTPermission class is a subclass of java.security.BasicPermission that implements security permissions for a variety of AWT-related operations.
The AlphaComposite class is a subclass of Object that implements alpha compositing rules for combining source and destination image pixels. It implements the Composite interface.
The BasicStroke class is a subclass of Object that provides a set of properties for a basic implementation of the Stroke interface.
The BorderLayout class is a subclass of Object that is used to lay out the components of a container along the container's border. It implements the LayoutManager2 and java.lang.Serializable interfaces.
The Button class is a subclass of Component that encapsulates a GUI text-labeled pushbutton.
The Canvas class is a subclass of Component that provides a rectangular drawing area.
The CardLayout class is a subclass of Object that provides the capability to lay out a Container object in a card-like fashion. It implements the LayoutManager2 and java.io.Serializable interfaces.
The Checkbox class is a subclass of Container that provides the capability to display and work with checkbox and radio button GUI controls. It implements the ItemSelectable interface.
The CheckboxGroup class is a subclass of Object that is used to group Checkbox objects together as a set of radio buttons. It implements the java.io.Serializable interface.
The CheckboxMenuItem class is a subclass of MenuItem that is used to create a menu item that may be in an on or off state. It implements the ItemSelectable interface.
The Choice class is a subclass of Component that provides a pop-up menu of choices. It implements the ItemSelectable interface.
The Color class is a subclass of Object that is used to define colors within a particular color space. It implements the Paint and java.io.Serializable interfaces.
The Component class is a subclass of Object that provides the base class for the development of GUI components. It implements the MenuContainer, java.awt.imaga.ImageObserver, and java.io.Serializable interfaces.
The ComponentOrientation class is a subclass of Object that encapsulates the language-specific orientation of a Component. It implements the java.io.Serializable interface.
The Container class is a subclass of Component that acts as a container for other GUI components.
The Cursor class is a subclass of Object that encapsulates a changeable cursor associated with a pointing device. It implements the java.io.Serializable interface.
The Dialog class is a subclass of Window that provides a base class for the development of dialog boxes.
The Dimension class is a subclass of java.awt.geom.Dimension2D that provides the capability to specify the height and width of an object. It implements the java.io.Serializable interface.
The Event class is a subclass of Object that provides the base class for implementing events in the JDK 1.0 event model. It implements the java.io.Serializable interface.
The EventQueue class is a subclass of Object that implements the system event queue.
The FileDialog class is a subclass of Dialog that encapsulates a file system dialog box.
The FlowLayout class is a subclass of Object that is used to lay out Container objects in a left-to-right and top-to-bottom fashion. It implements the LayoutManager and java.io.Serializable interfaces.
The Font class is a subclass of Object that encapsulates text fonts. It implements the java.io.Serializable interface.
The FontMetrics class is a subclass of Object that provides information about the properties of a font. It implements the java.io.Serializable interface.
The Frame class is a subclass of Window that provides a top-level application window. It implements the MenuContainer interface.
The GradientPaint class is a subclass of Object that provides the capability to fill a drawing area with a linear gradient color fill. It implements the Paint interface.
The Graphics class is a subclass of Object that is the base class for the development of graphics drawing contexts.
The Graphics2D class is a subclass of Graphics that serves as the basic graphics context for the Java 2D API.
The GraphicsConfigTemplate class is a subclass of Object that is used as a template for the creation of GraphicsConfiguration objects. It implements the java.io.Serializable interface.
The GraphicsConfiguration class is a subclass of Object that specifies the physical characteristics of a graphics display device.
The GraphicsDevice class is a subclass of Object that describes the graphics display devices available to the system.
The GraphicsEnvironment class is a subclass of Object that describes the entire graphics environment available to the system, including all of the accessible GraphicsDevice objects.
The GridBagConstraints class is a subclass of Object that is used to specify how containers are to be laid out using GridBagLayout objects. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The GridBagLayout class is a subclass of Object that is used to lay out a container according to the properties of a GridBagConstraints object. It implements the LayoutManager2 and java.io.Serializable interfaces.
The GridLayout class is a subclass of Object that is used to lay out a container in a grid-like fashion. It implements the LayoutManager and java.io.Serializable interfaces.
The Image class is a subclass of Object that encapsulates a displayable image.
The Insets class is a subclass of Object that specifies the border of a GUI component. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The Label class is a subclass of Component that implements a GUI text label.
The List class is a subclass of Component that encapsulates a scrollable list GUI control. It implements the ItemSelectable interface.
The MediaTracker class is a subclass of Object that is used to track the loading status of multimedia objects. It implements the java.io.Serializable interface.
The Menu class is a subclass of MenuItem that encapsulates a pull-down menu. It implements the MenuContainer interface.
The MenuBar class is a subclass of MenuComponent that provides the capability to attach a menu bar to a Frame object. It implements the MenuContainer interface.
The MenuComponent class is a subclass of Object that is the base class for all other AWT menu-related classes. It implements the java.io.Serializable interface.
The MenuItem class is a subclass of MenuComponent that implements a menu item value that is selectable from a Menu object.
The MenuShortcut class is a subclass of Object that provides the capability to associate a keyboard accelerator with a MenuItem object. It implements the java.io.Serializable interface.
The Panel class is a subclass of Container that provides a rectangular container for other GUI components.
The Point class is a subclass of java.awt.geom.Point2D that encapsulates a point in the xy-plane. It implements the java.io.Serializable interface.
The Polygon class is a subclass of Object that is used to describe a mathematical polygon. It implements the Shape and java.io.Serializable interfaces.
The PopupMenu class is a subclass of Menu that provides a menu that can be popped up at a specific location within a component.
The PrintJob class is a subclass of Object that is used to implement a system-specific printing request.
Rectangle
The Rectangle class is a subclass of java.awt.geom.Rectangle2D that encapsulates a mathematical rectangle. It implements the Shape and java.io.Serializable interfaces.
The RenderingHints class is a subclass of Object that provides hints for rendering on a Graphics2D object. It implements the java.lang.Cloneable interface.
The ScrollPane class is a subclass of Container that provides a combination of a panel and vertical and horizontal scrollbars.
The Scrollbar class is a subclass of Component that provides a GUI scrollbar component. It implements the Adjustable interface.
The SystemColor class is a subclass of Color that is used to specify the color scheme used with GUI components. It implements the java.io.Serializable interface.
The TextArea class is a subclass of TextComponent that provides a GUI text area control.
The TextComponent class is a subclass of Component that is the base class for TextField and TextArea.
The TextField class is a subclass of TextComponent that implements a GUI text input field.
The TexturePaint class is a subclass of Object that provides the capability to fill a geometrical shape with a texture image. It implements the Paint interface.
The Toolkit class is a subclass of Object that provides access to implementation- specific AWT resources.
The Window class is a subclass of Container that provides a basic window object.
The AWTError class is a subclass of java.lang.Error that is thrown when a fundamental error occurs in the AWT operation.
The AWTException class is a subclass of java.lang.Exception that signals the occurrence of an AWT-specific exception.
The IllegalComponentStateException class is a subclass of java.lang.IllegalStateException that identifies that an AWT component is in the wrong state for a particular operation.
The com.sun.java.accessibility package provides seven classes and seven interfaces that support the use of assistive technologies for disabled users. It is covered in Chapter 9, "Creating Window Applications."
The Accessible interface is implemented by all components that support accessibility. It defines the single getAccessibleContext() method to return an object that implements the AccessibleContext interface.
The AccessibleAction interface defines methods that can be used to determine which actions are supported by a component. It also provides methods for accessing these actions.
The AccessibleComponent interface defines methods for controlling the behavior and display of GUI components that support assistive technologies.
The AccessibleHypertext interface extends AccessibleText and provides accessibility support for hypertext display.
The AccessibleSelection interface provides support for determining which subcomponents of a GUI component have been selected and for controlling the selection status of those components.
The AccessibleText interface provides constants and methods for use with GUI components that display text. It allows assistive technologies to control the content, attributes, and layout of displayed text.
The AccessibleValue interface is implemented by GUI components that support the selection of a numerical value from a range of values, such as a scrollbar. This interface provides methods for getting and setting the numerical value and for determining the range of values.
The AccessibleBundle class is a subclass of Object that provides access to resource bundles and supports string conversions.
The AccessibleContext class is a core accessibility API class and provides access to other assistive technology objects. It defines the information that is used by all accessible objects and is subclassed by objects that implement assistive technologies. It is a subclass of Object.
The AccessibleHyperlink class is a subclass of Object that provides accessibility support for hyperlinks. It implements the AccessibleAction interface.
The AccessibleResourceBundle class is a subclass of java.util.ListResourceBundle that implements a resource bundle for assistive technology applications. It provides localized accessibility properties for a particular locale.
The AccessibleRole class is a subclass of AccessibleBundle that provides constants that describe the role of an accessibility GUI component, such as LIST, MENU, and CHECK_BOX.
The AccessibleState class is a subclass of AccessibleBundle that describes the state of an accessibility object. AccessibleState objects are contained in AccessibleStateSet objects. The AccessibleState class provides constants that define common object states, such as BUSY, CHECKED, and ENABLED.
The AccessibleStateSet class is a subclass of Object that implements a collection of AccessibleState objects. AccessibleStateSet objects are used to define the overall state of an accessibility object.
None.
The java.awt.color package is part of the Java 2D API. It provides five classes that support the capability to work with different color models. The java.awt.color package is covered in Chapter 20, "Working with 2D and 3D Graphics."
None.
The ColorSpace class is an abstract subclass of Object that specifies the color space used with other objects. It provides constants that define popular color spaces and methods for converting colors between color spaces.
The ICC_ColorSpace class is a subclass of ColorSpace that provides a non-abstract implementation of the ColorSpace methods. It represents color spaces in accordance with the ICC Profile Format Specification, Version 3.4, August 15, 1997, from the International Color Consortium. For more information, refer to http://www.color.org.
The ICC_Profile class is a subclass of Object that provides a representation of color profile data for color spaces based on the ICC Profile Format Specification. Color profiles represent transformations from the color space of a device, such as a monitor, to a profile connection space, as defined by the ICC Profile Format Specification.
The ICC_ProfileGray class is a subclass of ICC_Profile that supports color conversion to monochrome color spaces.
The ICC_ProfileRGB class is a subclass of ICC_Profile that supports color conversion between RGB and CIEXYZ color spaces.
The CMMException class is a subclass of java.lang.RuntimeException that defines an exception that is thrown when the color model manager returns an error.
The ProfileDataException class is a subclass of java.lang.RuntimeException that defines an exception that is thrown when an error occurs in accessing or processing an ICC_Profile object.
The java.awt.datatransfer package provides four classes and three interfaces that support clipboard operations. It is covered in Chapter 15, "Using the Clipboard."
The ClipboardOwner interface defines the lostOwnership() method, which is invoked to notify an object that it has lost ownership of a clipboard. This interface is implemented by classes that copy data to a clipboard.
The FlavorMap interface maps native types to MIME types.
The Transferable interface defines methods that support the transfer of data via the clipboard or other mechanisms. It is implemented by classes that support clipboard- related data transfers.
The Clipboard class is a subclass of Object that provides access to system- and user-defined clipboards. It provides methods for getting and setting the contents of a clipboard and retrieving the name of a clipboard.
The DataFlavor class is a subclass of Object that defines the types of data available for a transfer operation (such as those that take place via a clipboard). Flavors are implemented as MIME types. The DataFlavor class provides methods for reading and writing objects to be transferred and for accessing MIME type information. It implements the java.io.Serializable and java.lang.Cloneable interfaces.
The StringSelection class is a subclass of Object that supports the transfer of String objects as plain text. It provides methods for working with string-related data flavors. It implements the Transferable and ClipboardOwner interfaces.
SystemFlavorMap
The SystemFlavorMap class is a subclass of Object that provides a default implementation of the FlavorMap interface.
The UnsupportedFlavorException class is a subclass of java.lang.Exception that is used to signal that transferable data is not supported in a particular flavor.
The java.awt.dnd package supports the new JDK 1.2 drag-and-drop capability. It contains 15 classes and four interfaces and is covered in Chapter 16, "Working with Drag and Drop."
The Autoscroll interface provides methods that support automatic scrolling through GUI components in support of drag-and-drop operations.
The DragGestureListener interface extends the EventListener interface to handle events associated with the initiation of a drag-and-drop operation.
The DragSourceListener interface extends the java.util.EventListener interface to define methods that are implemented by objects that originate drag-and-drop operations. These methods track the state of drag-and-drop operations and enable feedback to be provided to the user.
The DropTargetListener interface extends the java.util.EventListener interface to define methods that are implemented by objects that are the target of drag-and-drop operations.
The DnDConstants class is a subclass of Object that defines constants that are used in drag-and-drop operations.
The DragGestureEvent class extends java.util.EventObject to signal the initiation of a drag-and-drop operation.
The DragGestureRecognizer class is a subclass of Object that provides support for handling the occurrence of a DragGestureEvent.
The DragSource class is a subclass of Object that implements the source originator of a drag-and-drop operation. It defines several java.awt.Cursor objects that define the cursor state during drag-and-drop. Its startDrag() method is used to initiate drag-and-drop.
The DragSourceContext class is a subclass of Object that is used to manage the source-side of drag-and-drop operations. It manages events associated with the drag source and implements the DragSourceListener interface.
The DragSourceDragEvent class is a subclass of DragSourceEvent. It implements the event that is handled by a DragSourceListener during the dragging stage of a drag-and-drop operation.
The DragSourceDropEvent class is a subclass of DragSourceEvent. It implements the event that is handled by a DragSourceListener during the dropping stage of a drag-and-drop operation.
The DragSourceEvent class is a subclass of java.util.EventObject that is used as the base class for DragSourceDragEvent and DragSourceDropEvent.
The DropTarget class is a subclass of Object that is used to implement the target of a drag-and-drop operation. Objects of DropTarget are associated with components that function as drop targets. These objects are typically GUI components. DropTarget implements the DropTargetListener and java.io.Serializable interfaces.
The DropTargetContext class is a subclass of Object that is used to implement the context of a drop operation. Objects of this class are dynamically created when an object is dragged over a potential drop target. This class is used by the drop target to provide feedback to the user and to initiate the data transfer associated with the drag-and-drop operation.
The DropTargetDragEvent class is a subclass of DropTargetEvent that informs DropTargetListener objects of the dragging state of a drag-and-drop operation.
The DropTargetDropEvent class is a subclass of DropTargetEvent that informs DropTargetListener objects of the dropping state of a drag-and-drop operation.
The DropTargetEvent class is a subclass of java.util.EventObject that serves as the base class for DropTargetDragEvent and DropTargetDropEvent.
The MouseDragGestureRecognizer class extends DragGestureRecognizer to provide mouse support. It implements the MouseListener and MouseMotionListener interfaces.
The InvalidDnDOperationException class is a subclass of java.lang.IllegalStateException that signals that a drag-and-drop operation cannot be carried out.
The java.awt.event package provides the foundation for JDK 1.1-style event processing. It contains 21 classes and 13 interfaces and is covered in Chapter 6, "GUI Building."
The ActionListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle ActionEvent events.
The AdjustmentListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle AdjustmentEvent events.
The ComponentListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle ComponentEvent events.
The ContainerListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle ContainerEvent events.
The EventQueueListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that monitor the event queue.
The FocusListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle FocusEvent events.
The InputMethodListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle InputMethodEvent events.
The ItemListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle Item events.
The KeyListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle KeyEvent events.
The MouseListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle MouseEvent events.
The MouseMotionListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle MouseEvent events.
The TextListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle TextEvent events.
The WindowListener interface extends the java.util.EventListener interface and defines methods that are implemented by classes that handle WindowEvent events.
The ActionEvent class is a subclass of java.awt.AWTEvent that implements an event generated by user interface actions, such as clicking on a button or selecting a menu item.
The AdjustmentEvent class is a subclass of java.awt.AWTEvent that implements an event generated by scrolling actions.
The ComponentAdapter class is a subclass of Object that provides a basic implementation of the ComponentListener interface.
The ComponentEvent class is a subclass of java.awt.AWTEvent that implements an event generated by changes to the position, focus, or sizing of a window component, or by a keyboard input or other mouse action.
The ContainerAdapter class is a subclass of Object that provides a basic implementation of the ContainerListener interface.
The ContainerEvent class is a subclass of java.awt.ComponentEvent that implements an event generated by adding and removing components from a container.
The FocusAdapter class is a subclass of Object that provides a basic implementation of the FocusListener interface.
The FocusEvent class is a subclass of ComponentEvent that implements an event generated by a change in the status of a component's input focus.
The InputEvent class is a subclass of ComponentEvent that is the base class for defining events generated by user keyboard and mouse actions.
The InputMethodEvent class is a subclass of java.awt.AWTEvent that implements an event generated by changes to the text being entered via an input method.
The InvocationEvent class extends AWTEvent to support multithreading operations. It implements the java.awt.ActionEvent interface.
The ItemEvent class is a subclass of AWTEvent that implements an event generated by a component state change, such as selecting an item from a list.
The KeyAdapter class is a subclass of Object that provides a basic implementation of the KeyListener interface.
The KeyEvent class is a subclass of InputEvent that implements an event generated by user keyboard actions.
The MouseAdapter class is a subclass of Object that provides a basic implementation of the MouseListener interface.
The MouseEvent class is a subclass of InputEvent that implements an event generated by low-level mouse actions.
The MouseMotionAdapter class is a subclass of Object that provides a basic implementation of the MouseMotionListener interface.
The PaintEvent class is a subclass of ComponentEvent that implements an event generated by the painting/repainting of a window.
The TextEvent class is a subclass of java.awt.AWTEvent that implements an event generated by text-related events, such as changing the value of a text field.
The WindowAdapter class is a subclass of Object that provides a basic implementation of the WindowListener interface.
The WindowEvent class is a subclass of ComponentEvent that implements an event generated by events such as the opening, closing, and minimizing of a window.
None.
The java.awt.font package is new to JDK 1.2. It provides 13 classes and two interfaces that support advanced font capabilities. The java.awt.font package is covered in Chapter 20.
The MultipleMaster interface defines methods that are implemented by classes that support Type 1 Multiple Master fonts.
The OpenType interface defines methods that are implemented by classes that support Open Type and True Type fonts.
The FontRenderContext class extends Object to provide support for context-based font rendering.
The GlyphJustificationInfo class is a subclass of Object that provides information about the justification of a glyph.
The GlyphMetrics class is a subclass of Object that defines the properties of a single glyph.
The GlyphVector class is a subclass of Object that represents text as a collection of glyph codes. It implements the java.lang.Cloneable interface.
The GraphicAttribute class is a subclass of Object that is used to identify a graphic that is embedded in text.
The ImageGraphicAttribute class is a subclass of GraphicAttribute that is used to identify an image that is embedded in text.
The LineBreakMeasurer class is a subclass of Object that organizes lines of text according to a wrapping width.
The LineMetrics class is a subclass of Object that provides support for text layout.
The ShapeGraphicAttribute class is a subclass of GraphicAttribute that is used to identify a Shape object that is embedded in text.
The TextAttribute class is a subclass of java.text.AttributedCharacterIterator.Attribute that maintains a set of attributes about text.
The TextHitInfo class is a subclass of Object that is used to specify a position within text.
The TextLayout class is a subclass of Object that provides support for laying out styled text. It implements the java.lang.Cloneable interface.
The TextLayout.CaretPolicy class is an inner class of TextLayout that specifies how the caret should be used with a TextLayout object. It is a subclass of Object.
The TextLine.TextLineMetrics class is a subclass of Object that supports the layout of lines of text.
The TransformAttribute class is a subclass of Object that allows transforms to be used as text attributes. It implements the java.io.Serializable interface.
None.
The java.awt.geom package is a new JDK 1.2 package that is part of the Java 2D API. It provides 30 classes and one interface that support standard geometrical objects and transformations. The java.awt.geom package is covered in Chapter 20.
The PathIterator interface provides constants and methods for iterating over the points in a path.
The AffineTransform class is a subclass of Object that provides the capability to compute two-dimensional affine transformations. It implements the java.lang.Cloneable interface.
The Arc2D class is a subclass of RectangularShape that defines an arc within a bounding rectangle.
The Arc2D.Double class is an inner class of Arc2D that specifies the arc in double precision.
The Arc2D.Float class is an inner class of Arc2D that specifies the arc in float precision.
The Area class is a subclass of Object that encapsulates an arbitrary 2D area. It implements the java.awt.Shape and java.lang.Cloneable interfaces.
The CubicCurve2D class is a subclass of Object that encapsulates a cubic curve.
The CubicCurve2D.Double class is an inner class of CubicCurve2D that specifies the curve in double precision.
The CubicCurve2D.Float class is an inner class of CubicCurve2D that specifies the curve in float precision.
The Dimension2D class is a subclass of Object that encapsulates width and height dimensions. It implements the java.lang.Cloneable interface.
The Ellipse2D class is a subclass of RectangularShape that represents an ellipse.
The Ellipse2D.Double class is an inner class of Ellipse2D that specifies the ellipse in double precision.
The Ellipse2D.Float class is an inner class of Ellipse2D that specifies the ellipse in float precision.
The FlatteningPathIterator class is a subclass of Object that is used to flatten a path. It implements the PathIterator interface.
The GeneralPath class is a subclass of Object that represents a general 2D path. It implements the java.awt.Shape and java.lang.Cloneable interfaces.
The Line2D class is a subclass of Object that encapsulates a 2D line. It implements the java.awt.Shape and java.lang.Cloneable interfaces.
The Line2D.Double class is an inner class of Line2D that specifies the line in double precision.
The Line2D.Float class is an inner class of Line2D that specifies the line in float precision.
The Point2D class is a subclass of Object that represents a 2D point. It implements the java.lang.Cloneable interface.
The Point2D.Double class is an inner class of Point2D that specifies the point in double precision.
The Point2D.Float class is an inner class of Point2D that specifies the point in float precision.
The QuadCurve2D class is a subclass of Object that encapsulates a 2D quadratic curve. It implements the java.awt.Shape and java.lang.Cloneable interfaces.
The QuadCurve2D.Double class is an inner class of QuadCurve2D that specifies the curve using a double value.
The QuadCurve2D.Float class is an inner class of QuadCurve2D that specifies the curve using a float value.
The Rectangle2D class is a subclass of RectangularShape that encapsulates a 2D rectangle.
The Rectangle2D.Double class is an inner class of Rectangle2D that specifies the rectangle using double values.
The Rectangle2D.Float class is an inner class of Rectangle2D that specifies the rectangle using float values.
The RectangularShape class is a subclass of Object that is the base class for other rectangular shapes. It implements the java.awt.Shape and java.lang.Cloneable interfaces.
The RoundRectangle2D class is a subclass of RectangularShape that defines a rectangle with rounded corners.
The RoundRectangle2D.Double class is an inner class of RoundRectangle2D that specifies the rectangle using double values.
The RoundRectangle2D.Float class is an inner class of RoundRectangle2D that specifies the rectangle using float values.
The IllegalPathStateException class is a subclass of java.lang.RuntimeException that signals an attempt to perform an operation on a path when it is in the incorrect state for that operation.
The NoninvertibleTransformException class is a subclass of java.lang.Exception indicating that an operation requiring an invertible transform was performed using a noninvertible transform.
The java.awt.im package is a new package that supports the Input Method API. It contains two classes and one interface. The Input Method API is covered in Chapter 19, "Internationalization."
The InputMethodRequests interface defines methods that must be implemented by an input handling class in order to function within the Input Method API. These methods are used to obtain information about the text being entered by the user.
The InputContext class is a subclass of Object that is used to implement the connection between text editing components and input methods. It does this by generating events that are handled by the text editing components and input methods.
The InputMethodHighlight class is a subclass of Object that supports the highlighting and conversion of text that is input via an input method.
None.
The java.awt.image package is a Java 2D API package that supports image processing. It provides 38 classes and 8 interfaces that support common image filters. The java.awt.image package is covered in Chapter 20.
The BufferedImageOp interface defines methods for classes that perform operations on BufferedImage objects.
The ImageConsumer interface defines methods for classes that receive image data from ImageProducer objects.
The ImageObserver interface defines methods for classes that observe the loading/construction of Image objects.
The ImageProducer interface defines methods for classes that produce image data for use by ImageConsumer objects.
The RasterOp interface is implemented by classes that support operations on Raster objects.
The RenderedImage interface is implemented by classes that produce image data in the form of Raster objects.
The TileObserver interface defines methods for handling events generated by changes to tiles of an image.
The WritableRenderedImage interface defines methods for classes that implement images that can be overwritten.
The AffineTransformOp class is a subclass of Object that performs a 2D affine transform between two images. It implements the BufferedImageOp and RasterOp interfaces.
The AreaAveragingScaleFilter class is a subclass of ReplicateScaleFilter that supports image resizing using an area-averaging algorithm.
The BandCombineOp class is a subclass of Object that performs operations that combine bands in a Raster object. It implements the RasterOp interface.
The BandedSampleModel class is a subclass of SampleModel that provides advanced band control.
The BufferedImage class is a subclass of Image that provides access to buffered image data. It implements the WritableRenderedImage interface.
The BufferedImageFilter class is a subclass of ImageFilter that supports BufferedImage objects. It implements the RasterImageConsumer and java.lang.Cloneable interfaces.
The ByteLookupTable class is a subclass of LookupTable that supports byte data.
The ColorConvertOp class is a subclass of Object that supports pixel-by-pixel color conversions. It implements the BufferedImageOp and RasterOp interfaces.
The ColorModel class is a subclass of Object that provides the base class for the development of a variety of color models. It implements the Transparency interface.
The ComponentColorModel class is a subclass of ColorModel that provides support for a variety of color spaces.
The ComponentSampleModel class is a subclass of SampleModel that supports the separate storage of color component data.
The ConvolveOp class is a subclass of Object that supports convolution operations on image data. It implements the BufferedImageOp and RasterOp interfaces.
The CropImageFilter class is a subclass of ImageFilter that supports image cropping.
The DataBuffer class is a subclass of Object that supports the buffering of image data.
The DataBufferByte class is a subclass of DataBuffer that supports byte-oriented image buffering.
The DataBufferInt class is a subclass of DataBuffer that supports int-oriented image buffering.
The DataBufferShort class is a subclass of DataBuffer that supports short-oriented image buffering.
The DataBufferUShort class is a subclass of DataBuffer that supports unsigned short image buffering.
The DirectColorModel class is a subclass of PackedColorModel that supports direct RGB pixel colors.
The FilteredImageSource class is a subclass of Object that combines an ImageProducer with an ImageFilter. It implements the ImageProducer interface.
The ImageFilter class is a subclass of Object that supports general image filtering operations. It implements the ImageConsumer and java.lang.Cloneable interfaces.
The IndexColorModel class is a subclass of ColorModel that represents pixels as indices into a color map.
The Kernel class is a subclass of Object that defines matrices for filtering operations.
The LookupOp class is a subclass of Object that supports image lookup operations. It implements the BufferedImageOp and RasterOp interfaces.
The LookupTable class is a subclass of Object that defines a lookup table for use in imaging operations.
The MemoryImageSource class is a subclass of Object that provides image data from a memory source. It implements the ImageProducer interface.
The MultiPixelPackedSampleModel class is a subclass of SampleModel that supports the processing of multiple one-sample pixels.
The PackedColorModel class is a subclass of ColorModel that represents color values directly within pixel data.
The PixelGrabber class is a subclass of Object that is used to retrieve a subset of the pixels of an image. It implements the ImageConsumer interface.
The PixelInterleavedSampleModel class is a subclass of ComponentSampleModel that supports the interleaved pixel color values.
The Raster class is a subclass of Object that implements a rectangular array of pixels.
The ReplicateScaleFilter class is a subclass of ImageFilter that implements a simple scaling algorithm.
The RescaleOp class is a subclass of Object that supports image-rescaling operations. It implements the BufferedImageOp and RasterOp interfaces.
The RGBImageFilter class is a subclass of ImageFilter that supports the filtering of RGB color values.
The SampleModel class is a subclass of Object that provides a base class for developing approaches to sampling image data.
The ShortLookupTable class is a subclass of LookupTable that supports short-valued data.
The SinglePixelPackedSampleModel class is a subclass of SampleModel that packs single-pixel samples in a single data element.
The WritableRaster class is a subclass of Raster that provides support for image updating.
The ImagingOpException class is a subclass of java.lang.RuntimeException that indicates errors encountered during filtering operations.
The RasterFormatException class is a subclass of java.lang.RuntimeException that indicates format errors in Raster objects.
The com.sun.java.image.codec.jpeg package provides three classes and four interfaces that support JPEG image compression. It is covered in Chapter 20.
The JPEGDecodeParam interface provides access to parameters needed for JPEG image decoding.
The JPEGEncodeParam interface provides access to parameters needed for JPEG image encoding.
The JPEGImageDecoder interface defines methods to be implemented by JPEG image decoding classes.
The JPEGImageEncoder interface defines methods to be implemented by JPEG image encoding classes.
The JPEGHuffmanTable class is a subclass of Object that implements a Huffman table used in JPEG encoding/decoding.
The JPEGCodec class is a subclass of Object that provides a factory for JPEG image encoders and decoders.
The JPEGQTable class is a subclass of Object that implements a JPEG quantization table.
The ImageFormatException class is a subclass of java.lang.RuntimeException that is used to signal that an image formatting error has been encountered.
The TruncatedFileException is a subclass of java.lang.RuntimeException that indicates that a truncated image file was encountered.
The java.awt.image.renderable package provides four classes and three interfaces that support image rendering. It is covered in Chapter 20.
The ContextualRenderedImageFactory interface extends the RenderedImageFactory interface to provide methods that support rendering-independent operations. It is implemented by subclasses of RenderableImageOp.
The RenderableImage interface provides a common set of methods for rendering- independent images. These methods support image operations that are independent of any specific image rendering.
The RenderedImageFactory interface defines the create() method for use by classes that provide different image renderings, depending on a particular set of rendering parameters.
The ParameterBlock class is a subclass of Object that provides a common set of parameters for use with RenderableImageOp objects. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The RenderContext class is a subclass of Object that specifies contextual information for rendering a RenderableImage object. This contextual information includes the area of interest, transforms, and rendering hints. It implements the java.lang.Cloneable interface.
The RenderableImageOp class is a subclass of Object that supports context-specific image rendering. It implements the RenderableImage interface.
The RenderableImageProducer class is a subclass of Object that supports the asynchronous production of a RenderableImage object. It implements the java.awt.image.ImageProducer and java.lang.Runnable interfaces.
None.
The java.awt.print package is a Java 2D API package that supports the printing of text and graphics. It contains four classes and three interfaces. This package is covered in Chapter 18, "Printing."
The PrinterGraphics interface defines the getPrinterJob method to provide access to current printer jobs.
The Pageable interface specifies methods used for objects that represent a set of pages to be printed. These methods retrieve the number of pages to be printed and a specific page from within the page list.
The Printable interface defines the print() method for printing a page on a Graphics object.
The Book class is a subclass of Object that maintains a list of pages to be printed. It provides methods for adding and managing pages. It implements the Pageable interface.
The PageFormat class is a subclass of Object that specifies the size and orientation of a page to be printed. It provides methods for setting the Paper object to be used and the page orientation. It also provides methods for switching the drawing space between portrait and landscape mode and for retrieving the characteristics of the drawing area. It implements the java.lang.Cloneable interface.
The Paper class is a subclass of Object that specifies the physical characteristics of the paper used for printing. It provides methods for getting and setting the paper size and the drawing area.
The PrinterJob class is a subclass of Object that initiates, manages, and controls a printing request. It provides methods for printing Pageable objects and specifying print properties.
The PrinterException class is a subclass of java.lang.Exception that indicates errors in a print operation.
The PrinterAbortException class is a subclass of PrinterException that indicates errors that cause the aborting of a print operation.
The PrinterIOException class is a subclass of PrinterException that indicates I/O errors in a print operation.
The com.sun.java.swing package is the core Swing package. It contains 90 classes and 23 interfaces that provide the foundation for the Swing API. This package is introduced in Chapter 12, "Introducing Swing."
The Action interface extends the java.awt.ActionListener interface defines methods for defining, enabling, and disabling a unit of program operation.
The BoundedRangeModel interface defines a data model used for range-bounded components, such as sliders and progress bars.
The ButtonModel interface extends the java.awt.ItemSelectable interface to provide methods that define the state of a button.
The CellEditor interface defines methods that are used to edit the cell values of GUI components, such as tables.
The ComboBoxEditor interface defines methods for editing combo boxes.
The ComboBoxModel interface extends the ListModel interface and defines methods for supporting the data model of a combo box.
The DesktopManager interface provides methods that are implemented by classes that support a Java-based desktop.
The Icon interface defines methods that are implemented by classes that provide desktop and application icons.
The JComboBox.KeySelectionManager interface defines a key for selecting items from a combo box.
The ListCellRenderer interface defines methods for painting the cells in a JList object.
The ListModel interface defines methods that support the data model for a list.
The ListSelectionModel interface defines methods for selecting elements from a list.
The MenuElement interface defines methods that are implemented by items that are placed in a menu.
The MutableComboBoxModel interface extends the ComboBoxModel interface and defines methods for updating the data model of a combo box.
The Renderer interface defines methods for obtaining access to and setting the value of GUI components.
The RootPaneContainer interface defines methods that are implemented by top-level window components.
The ScrollPaneConstants interface defines constants that are used by scrollable pane classes.
The Scrollable interface defines methods that are implemented by scrollable container classes.
The SingleSelectionModel interface defines methods for selecting a single item from a list of items.
The SwingConstants interface defines constants for laying out GUI components.
The UIDefaults.ActiveValue interface supports an active (preset) approach to defining user interface default values.
The UIDefaults.LazyValue interface supports a lazy (as-needed) approach to defining user interface default values.
The WindowConstants interface defines constants that are used in window operations.
The AbstractAction class is a subclass of Object that provides a default implementation of the Action interface. It also implements the java.lang.Cloneable and java.io.Serializable interfaces.
The AbstractButton class is a subclass of JComponent that serves as a base class for developing other JFC buttons. It implements the SwingConstants and java.awt.ItemSelectable interfaces.
The AbstractListModel class is a subclass of Object that provides an abstract data model for list-related classes. It implements the ListModel and java.io.Serializable interfaces.
The BorderFactory class is a subclass of Object that provides support for creating Border objects.
The Box class is a subclass of java.awt.Container that lays out components in a BoxLayout. It implements the com.sun.java.accessibility.Accessible interface.
The Box.Filler class is an inner class of Box that supports the layout of Box objects. It is a subclass of java.awt.Component.
The BoxLayout class is a subclass of Object that supports the layout of containers in a box-like, top-to-bottom, left-to-right fashion. It implements the java.awt.LayoutManager2 and java.io.Serializable interfaces.
The ButtonGroup class is a subclass of Object that supports the development of radio button-like button groups in which only one button in the group can be selected at a time. It implements the java.io.Serializable interface.
The CellRendererPane class is a subclass of java.awt.Container that supports the organization of cell-oriented components, such as lists and tables. It implements the com.sun.java.accessibility.Accessible interface.
The DebugGraphics class is a subclass of java.awt.Graphics that provides debugging support.
The DefaultBoundedRangeModel class is a subclass of Object that provides a default implementation of the BoundedRangeModel interface. It also implements the java.io.Serializable interface.
The DefaultButtonModel class is a subclass of Object that provides a default implementation of the ButtonModel interface. It also implements the java.io.Serializable interface.
The DefaultCellEditor class is a subclass of Object that provides a default implementation of the com.sun.java.swing.table.TableCellEditor and com.sun.java.swing.tree.TreeCellEditor interfaces. It also implements the java.io.Serializable interface.
The DefaultComboBoxModel class is a subclass of AbstractListModel and implements the MutableComboBoxModel and java.io.Serializable interfaces.
The DefaultDesktopManager class is a subclass of Object that provides a default implementation of the DesktopManager interface.
The DefaultFocusManager class is a subclass of FocusManager that provides support for accessing the components governed by the focus manager.
The DefaultListModel class is a subclass of AbstractListModel that provides support for managing the addition and deletion of list elements.
The DefaultListSelectionModel class is a subclass of Object that provides a default implementation of the ListSelectionModel interface. It also implements the java.lang.Cloneable and java.io.Serializable interfaces.
The DefaultSingleSelectionModel class is a subclass of Object that provides a default implementation of the SingleSelectionModel interface. It also implements the java.io.Serializable interface.
The FocusManager class is a subclass of Object that is used to manage the current input focus.
The GrayFilter class is a subclass of java.awt.image.RGBImageFilter that provides a grayscale rendering of an image.
The ImageIcon class is a subclass of Object that provides a default implementation of the Icon interface. It also implements the java.io.Serializable interface.
The JApplet class is a subclass of java.applet.Applet that provides Swing support. It implements the com.sun.java.accessibility.Accessible and RootPaneContainer interfaces.
The JButton class is a subclass of AbstractButton that provides a Swing pushbutton. It implements the java.awt.accessibility.Accessible interface.
The JCheckBox class is a subclass of JToggleButton that provides a Swing checkbox. It implements the com.sun.java.accessibility.Accessible interface.
The JCheckBoxMenuItem class is a subclass of JMenuItem that implements a checkbox that can be used as a menu item. It implements the SwingConstants and com.sun.java.accessibility.Accessible interfaces.
The JComboBox class is a subclass of JComponent that provides a combo box GUI component. It implements the java.awt.ItemSelectable, java.awt.event.ActionListener, com.sun.java.swing.event.ListDataListener, and com.sun.java.accessibility.Accessible interfaces.
The JComponent class is a subclass of java.awt.Container that is the base class for all Swing components. It implements the java.io.Serializable interface.
The JDesktopPane class is a subclass of JLayeredPane that supports the implementation of a desktop manager. It implements the java.awt.accessibility.Accessible interface.
The JDialog class is a subclass of java.awt.Dialog that provides a Swing dialog box. It implements the RootPaneContainer, WindowConstants, and com.sun.java.accessibility.Accessible interface.
The JEditorPane class is a subclass of JTextComponent that supports text editing.
The JFrame class is a subclass of java.awt.Frame that adds Swing support. It implements the RootPaneContainer, WindowConstants, and com.sun.java.accessibility.Accessible interfaces.
The JInternalFrame class is a subclass of JComponent that provides a frame that can be used within a JDesktopPane object. It implements the RootPaneContainer, WindowConstants, com.sun.java.accessibility.Accessible, java.awt.event.ComponentListener, java.awt.event.MouseListener, and java.awt.event.MouseMotionListener interfaces.
The JInternalFrame.JDesktopIcon class is an inner class of JInternalFrame that provides an icon for use with the JInternalFrame object. It is a subclass of JComponent and implements the com.sun.java.accessibility.Accessible interface.
The JLabel class is a subclass of JComponent that provides a Swing label (text or image). It implements the SwingConstants and com.sun.java.accessibility.Accessible interfaces.
The JLayeredPane class is a subclass of JComponent that provides a multi-layered pane. It implements the com.sun.java.accessibility.Accessible interface.
The JList class is a subclass of JComponent that provides a basic list component. It implements the Scrollable and com.sun.java.accessibility.Accessible interfaces.
The JMenu class is a subclass of JMenuItem that provides a Swing menu. It implements the MenuElement and com.sun.java.accessibility.Accessible interfaces.
The JMenuBar class is a subclass of JComponent that provides a Swing menu bar. It implements the MenuElement and com.sun.java.accessibility.Accessible interfaces.
The JMenuItem class is a subclass of AbstractButton that provides a Swing menu item. It implements the MenuElement and com.sun.java.accessibility.Accessible interfaces.
The JOptionPane class is a subclass of JComponent that provides support for option dialog boxes.
The JPanel class is a subclass of JComponent that provides a generic Swing panel. It implements the com.sun.java.accessibility.Accessible interface.
The JPasswordField class is a subclass of JTextField that provides the capability to enter a password without it being displayed.
The JPopupMenu class is a subclass of JComponent that provides a popup menu capability. It implements the com.sun.java.accessibility.Accessible and MenuElement interfaces.
The JProgressBar class is a subclass of JComponent that provides a vertical or horizontal progress bar. It implements the SwingConstants and com.sun.java.accessibility.Accessible interfaces.
The JRadioButton class is a subclass of JToggleButton that provides a basic radio button. It implements the com.sun.java.accessibility.Accessible interface.
The JRadioButtonMenuItem class is a subclass of JMenuItemu that can be used as a menu item. It implements the com.sun.java.accessibility.Accessible interface.
The JRootPane class is a subclass of JComponent that provides the root pane for window container operations. It implements the com.sun.java.accessibility.Accessible interface.
The JScrollBar class is a subclass of JComponent that provides a basic scrollbar. It implements the java.awt.Adjustible and com.sun.java.accessibility.Accessible interfaces.
The JScrollPane class is a subclass of JComponent that provides a scrollable panel. It implements the ScrollPaneConstants and com.sun.java.accessibility.Accessible interfaces.
The JSeparator class is a subclass of JComponent that provides a menu separator. It implements the com.sun.java.accessibility.Accessible interface.
The JSlider class is a subclass of JComponent that provides a slider control. It implements the SwingConstants and com.sun.java.accessibility.Accessible interfaces.
The JSplitPane class is a subclass of JComponent that is used to split exactly two components. It implements the com.sun.java.accessibility.Accessible interface.
The JTabbedPane class is a subclass of JComponent that provides a tabbed multi-layer pane. It implements the SwingConstants, java.io.Serializable, and com.sun.java.accessibility.Accessible interfaces.
The JTable class is a subclass of JComponent that provides a basic table implementation. It implements the Scrollable, com.sun.java.accessibility.Accessible, com.sun.java.swing.event.TableModelListener, com.sun.java.swing.event.TableColumnModelListener, com.sun.java.swing.event.ListSelectionListener, and com.sun.java.swing.event.CellEditorListener interfaces.
The JTextArea class is a subclass of JTextComponent that provides a Swing text area component.
The JTextField class is a subclass of JTextComponent that provides a Swing text field. It implements the SwingConstants interface.
The JTextPane class is a subclass of JEditorPane that supports styled text.
The JToggleButton class is a subclass of AbstractButton that supports a two-state button. It implements the com.sun.java.accessibility.Accessible interface.
The JToggleButton.ToggleButtonModel class is an inner class of JToggleButton that supports button configuration. It is a subclass of DefaultButtonModel.
The JToolBar class is a subclass of JComponent that provides a basic tool bar. It implements the com.sun.java.accessibility.Accessible interface.
The JToolBar.Separator class is an inner class of JToolBar that acts as a toolbar separator. It is a subclass of java.awt.Component.
The JToolTip class is a subclass of JComponent that provides a popup ToolTip. It implements the com.sun.java.accessibility.Accessible interface.
The JTree class is a subclass of JComponent that provides a basic tree component. It implements the Scrollable and com.sun.java.accessibility.Accessible interfaces.
The JTree.DynamicUtilTreeNode class is an inner class of JTree that supports dynamic tree node management. It is a subclass of DefaultMutableTreeNode.
The JTree.EmptySelectionModel class is an inner class of JTree that supports tree selection. It is a subclass of DefaultTreeSelectionModel.
The JViewport class is a subclass of JComponent that acts as a porthole for viewing displayed information. It implements the com.sun.java.accessibility.Accessible interface.
The JWindow class is a subclass of java.awt.Window that provides Swing support. It implements the RootPaneContainer and com.sun.java.accessibility.Accessible interfaces.
The KeyStroke class is a subclass of Object that implements a user-typed keystroke. It implements the java.io.Serializable interface.
The LookAndFeel class is a subclass of Object that supports pluggable look and feel.
The MenuSelectionManager class is a subclass of Object that supports the management of menu selections.
The OverlayLayout class is a subclass of Object that supports overlay-type container layout. It implements the java.awt.LayoutManager2 and java.io.Serializable interfaces.
The ProgressMonitor class is a subclass of Object that supports the monitoring of an operation in progress.
The ProgressMonitorInputStream class is a subclass of java.io.FilterInputStream that supports the monitoring of data that is read from an input stream.
The RepaintManager class is a subclass of Object that supports the repainting of JComponent objects.
The ScrollPaneLayout class is a subclass of Object that is used to lay out a JScrollPane object. It implements the ScrollPaneConstants, java.awt.LayoutManager, and java.io.Serializable interfaces.
The SizeRequirements class is a subclass of Object that provides information used by layout managers. It implements the java.io.Serializable interface.
The SwingUtilities class is a subclass of Object that provides general static methods that are used by Swing components. It implements the SwingConstants interface.
The Timer class is a subclass of Object that provides a timer/event generator. It implements the java.io.Serializable interface.
The ToolTipManager class is a subclass of java.awt.event.MouseAdapter that is used to provide ToolTip support. It implements the java.awt.event.MouseMotionListener interface.
The UIDefaults class is a subclass of java.util.Hashtable that supports the storage of user interface parameter information.
The UIManager class is a subclass of Object that supports look and feel management. It implements the java.io.Serializable interface.
The UIManager.LookAndFeelInfo class is an inner class of UIManager that supports the storage of look and feel information. It is a subclass of Object.
The ViewportLayout class is a subclass of Object that supports the layout of JViewport objects. It implements the java.awt.LayoutManager and java.io.Serializable interfaces.
The UnsupportedLookAndFeelException class is a subclass of java.lang.Exception that signals that an unsupported look and feel has been selected.
The com.sun.java.swing.border package provides nine classes and one interface that implement borders and border styles. It is covered in Chapter 13, "Working with Swing Components."
The Border interface provides methods for rendering a border around a Swing component.
The AbstractBorder class is a subclass of Object that provides an abstract base class used to implement other com.sun.java.swing.border classes. It implements the Border and java.io.Serializable interfaces.
The BevelBorder class is a subclass of AbstractBorder that implements a two-line bevel border.
The CompoundBorder class is a subclass of AbstractBorder that combines two Border objects into a single border.
The EmptyBorder class is a subclass of AbstractBorder that implements an empty, spaceless border. It implements the java.io.Serializable interface.
The EtchedBorder class is a subclass of AbstractBorder that implements an etched border. The border can be etched either in or out.
The LineBorder class is a subclass of AbstractBorder that draws a line border around an object. The line thickness and color of the border may be specified.
The MatteBorder class is a subclass of EmptyBorder that implements a matte-like border. The border can consist of a specified color or a com.sun.java.swing.Icon object.
The SoftBevelBorder class is a subclass of BevelBorder that implements a bevel border with softened (rounded) corners. The beveling may be raised or lowered.
The TitledBorder class is a subclass of AbstractBorder that specifies a text tile at a specified position on the border.
None.
The com.sun.java.swing.event package provides 23 classes and 23 interfaces that implement Swing events and event listeners. It is covered in Chapters 12 and 13.
The AncestorListener interface extends the java.util.EventListener interface to support handling of the AncestorEvent.
The CaretListener interface extends the java.util.EventListener interface to support handling of the CaretEvent.
The CellEditorListener interface extends the java.util.EventListener interface to support table cell editing by the handling of the ChangeEvent.
The ChangeListener interface extends the java.util.EventListener interface to support general handling of the ChangeEvent.
The DocumentEvent interface provides methods for handling document change notifications.
The DocumentEvent.ElementChange interface provides methods for handling changes made to a document element.
The DocumentListener interface extends the java.util.EventListener interface to support handling of the DocumentEvent.
The HyperlinkListener interface extends the java.util.EventListener interface to support handling of the HyperlinkEvent.
The InternalFrameListener interface extends the java.util.EventListener interface to support handling of the InternalFrameEvent.
The Listener interface extends the java.util.EventListener interface to support handling of the ListDataEvent.
The ListSelectionListener interface extends the java.util.EventListener interface to support handling of the ListSelectionEvent.
The MenuListener interface extends the java.util.EventListener interface to support handling of the MenuEvent.
The PopupMenuListener interface extends the java.util.EventListener interface to support handling of the PopupMenuEvent.
The TableColumnModelListener interface extends the java.util.EventListener interface to support handling of the TableColumnModelEvent.
The TableModelListener interface extends the java.util.EventListener interface to support handling of the TableModelEvent.
The TreeExpansionListener interface extends the java.util.EventListener interface to support handling of the TreeExpansionEvent.
The TreeModelListener interface extends the java.util.EventListener interface to support handling of the TreeModelEvent.
The TreeSelectionListener interface extends the java.util.EventListener interface to support handling of the TreeSelectionEvent.
The UndoableEditListener interface extends the java.util.EventListener interface to support handling of the UndoableEditEvent.
The AncestorEvent class is a subclass of java.AWT.AWTEvent that indicates changes in a component's ancestor.
The CaretEvent class is a subclass of java.util.EventObject that indicates a change in the text caret.
The ChangeEvent class is a subclass of java.util.EventObject that indicates a change in the state of a component.
The DocumentEvent.EventType class is a subclass of Object that is used to enumerate the types of document events.
The EventListenerList class is a subclass of Object that provides a list of EventListener objects. It implements the java.io.Serializable interface.
The HyperlinkEvent class is a subclass of java.util.EventObject that indicates an action with respect to a hypertext link.
The HyperlinkEvent.EventType class is an inner class of HyperlinkEvent that enumerates the types of hyperlink events.
The InternalFrameAdapter class is a subclass of Object that provides a default implementation of the InternalFrameListener interface.
The InternalFrameEvent class is a subclass of java.awt.AWTEvent that provides events related to com.sun.java.swing.JInternalFrame objects.
The ListDataEvent class is a subclass of java.util.EventObject that identifies changes in list-type components.
The ListSelectionEvent class is a subclass of java.util.EventObject that identifies changes in the current list selection.
The MenuEvent class is a subclass of java.util.EventObject that is used to signal menu-related events.
The PopupMenuEvent class is a subclass of java.util.EventObject that is used to signal popup menu-related events.
The TableColumnModelEvent class is a subclass of java.util.EventObject that is used to identify changes in a table column model.
The TableModelEvent class is a subclass of java.util.EventObject that is used to identify changes in a table model.
The TreeExpansionEvent class is a subclass of java.util.EventObject that indicates that a tree has been expanded.
The TreeModelEvent class is a subclass of java.util.EventObject that is used to signal a change in a tree model.
The TreeSelectionEvent class is a subclass of java.util.EventObject that is used to signal a change in the current tree selection. It implements the java.lang.Cloneable interface.
The UndoableEditEvent class is a subclass of java.util.EventObject indicating that an operation that can be undone has been performed.
None.
The com.sun.java.swing.plaf package provides 42 classes and one interface that support the use of pluggable look and feel. It is covered in Chapter 14, "Changing the Look and Feel of Your Swing Components."
The UIResource interface is used to identify objects that are created by ComponentUI delegates.
The BorderUIResource class is a subclass of Object that provides pluggable look and feel support for border properties.
The ButtonUI class is a subclass of ComponentUI that provides pluggable look and feel support for JButton objects.
The ColorChooserUI class is a subclass of ComponentUI that provides pluggable look and feel support for JColorChooser objects.
The ColorUIResource class is a subclass of java.awt.Color that provides pluggable look and feel support for color properties.
The ComboBoxUI class is a subclass of ComponentUI that provides pluggable look and feel support for JComboBox objects.
The ComponentUI class is a subclass of Object that provides pluggable look and feel support for JComponent objects.
The DesktopIconUI class is a subclass of ComponentUI that provides pluggable look and feel support for JDektopIcon objects.
The DesktopPaneUI class is a subclass of ComponentUI that provides pluggable look and feel support for JDesktopPanel objects.
The DimensionUIResource class is a subclass of Dimension that provides pluggable look and feel support for dimension properties.
The FileChooserUI class is a subclass of ComponentUI that provides pluggable look and feel support for JFileChoose objects.
The FontUIResource class is a subclass of Font that provides pluggable look and feel support for font properties.
The IconUIResource class is a subclass of Object that provides pluggable look and feel support for icon properties.
The InsetsUIResource class is a subclass of Insets that provides pluggable look and feel support for insets properties.
The InternalFrameUI class is a subclass of ComponentUI that provides pluggable look and feel support for JInternalFrame objects.
The LabelUI class is a subclass of ComponentUI that provides pluggable look and feel support for JLabel objects.
The ListUI class is a subclass of ComponentUI that provides pluggable look and feel support for JList objects.
The MenuBarUI class is a subclass of ComponentUI that provides pluggable look and feel support for JMenuBar objects.
The MenuItemUI class is a subclass of ButtonUI that provides pluggable look and feel support for JMenuItem objects.
The OptionPaneUI class is a subclass of ComponentUI that provides pluggable look and feel support for JOptionPane objects.
The PanelUI class is a subclass of ComponentUI that provides pluggable look and feel support for JPanel objects.
The PopupMenuUI class is a subclass of ComponentUI that provides pluggable look and feel support for JPopupMenu objects.
The ProgressBarUI class is a subclass of ComponentUI that provides pluggable look and feel support for JProgressBar objects.
The ScrollBarUI class is a subclass of ComponentUI that provides pluggable look and feel support for JScrollBar objects.
The ScrollPaneUI class is a subclass of ComponentUI that provides pluggable look and feel support for JScrollPane objects.
The SeparatorUI class is a subclass of ComponentUI that provides pluggable look and feel support for JSeparator objects.
The SliderUI class is a subclass of ComponentUI that provides pluggable look and feel support for JSlider objects.
The SplitPaneUI class is a subclass of ComponentUI that provides pluggable look and feel support for JSplitPane objects.
The TabbedPaneUI class is a subclass of ComponentUI that provides pluggable look and feel support for JTabbedPane objects.
The TableHeaderUI class is a subclass of ComponentUI that provides pluggable look and feel support for JTableHeader objects.
The TableUI class is a subclass of ComponentUI that provides pluggable look and feel support for JTable objects.
The TextUI class is a subclass of ComponentUI that provides pluggable look and feel support for text objects.
The ToolBarUI class is a subclass of ComponentUI that provides pluggable look and feel support for JToolBar objects.
The ToolTipUI class is a subclass of ComponentUI that provides pluggable look and feel support for JToolTip objects.
The TreeUI class is a subclass of ComponentUI that provides pluggable look and feel support for JTree objects.
The ViewportUI class is a subclass of ComponentUI that provides pluggable look and feel support for JViewport objects.
None.
The com.sun.java.swing.table package provides seven classes and four interfaces that implement the Swing table component. It is covered in Chapter 13.
The TableCellEditor interface extends the com.sun.java.swing.CellEditor interface to provide support for the text editing of table cells.
The TableCellRenderer interface defines methods for rendering the cells of JTable objects.
The TableColumnModel interface defines methods for manipulating the rows of a table.
The TableModel interface defines methods that are implemented by a data model that provides data for a JTable object.
The AbstractTableModel class is a subclass of Object that provides an abstract implementation of the TableModel interface. It also implements the java.io.Serializable interface.
The DefaultTableCellRenderer class is a subclass of com.sun.java.swing.JLabel that is used to render the individual cells of a table. It implements the TableCellRenderer and java.io.Serializable interfaces.
The DefaultTableCellRenderer.UIResource class is an inner class of DefaultTableCellRenderer that provides support for cell rendering.
The DefaultTableColumnModel class is a subclass of Object that provides a default implementation to the TableColumnModel interface. It also implements the java.beans.PropertyChangeListener, com.sun.java.swing.event.ListSelectionListener, and java.io.Serializable interfaces.
The DefaultTableModel class is a subclass of AbstractTableModel that organizes its data using java.util.Vector objects. It implements the java.io.Serializable interface.
The JTableHeader class is a subclass of com.sun.java.swing.JComponent that encapsulates the column header of a JTable object. It implements the TableColumnModelListener and com.sun.java.accessibility.Accessible interfaces.
The TableColumn class is a subclass of Object that defines the properties of a column in a JTable object. It implements the java.io.Serializable interface.
None.
The com.sun.java.swing.text package provides 59 classes and 21 interfaces that implement text-processing components. It is covered in Chapter 12.
The AbstractDocument.AttributeContext interface supports attribute compression.
The AbstractDocument.Content interface describes a sequence of editable content.
The AttributeSet interface defines a read-only set of text attributes.
The AttributeSet.CharacterAttribute interface defines an attribute type signature.
The AttributeSet.ColorAttribute interface defines a color type signature.
The AttributeSet.FontAttribute interface defines a font type signature.
The AttributeSet.ParagraphAttribute interface defines a paragraph type signature.
The Caret interface defines a document insertion point caret.
The Document interface defines a container for editable text.
The Element interface defines a structural piece of a Document object.
The Highlighter interface provides support for highlighted text.
The Highlighter.Highlight interface defines the location of highlighted text.
The Highlighter.HighlightPainter interface defines the manner in which highlighted text is to be painted.
The Keymap interface binds keystrokes to actions.
The MutableAttributeSet interface extends the AttributeSet interface to provide methods for updating the set of attributes.
The Position interface defines a location within a Document object.
The Style interface defines text, paragraph, and other document-related styles.
The StyledDocument interface extends the Document interface to provide style support.
The TabExpander interface provides support for tab settings.
The TabableView interface provides support for viewing expanded tabs within a document.
The ViewFactory interface provides support for creating different views of a document.
The AbstractDocument class is a subclass of Object that provides a basic implementation of the Document interface. It also implements the java.io.Serializable interface.
The AbstractDocument.ElementEdit class is an inner class of AbstractDocument that provides undo/redo support. It is a subclass of com.sun.java.swing.undo.AbstractUndoableEdit.
The BoxView class is a subclass of CompositeView that provides a box-like organization of document content.
The ComponentView class is a subclass of View that provides a view of a single document component.
The CompositeView class is a subclass of View that provides a view of multiple document components.
The DefaultCaret class is a subclass of Object that provides a default implementation of the Caret interface. It also implements the java.awt.event.FocusListener, java.awt.event.MouseListener, java.awt.event.MouseMotionListener, and java.io.Serializable interfaces.
The DefaultEditorKit class is a subclass of EditorKit that provides a basic text editing capability.
The DefaultEditorKit.BeepAction class is an inner class of DefaultEditorKit that creates a beep sound. It is a subclass of Object.
The DefaultEditorKit.CopyAction class is an inner class of DefaultEditorKit that copies data to the clipboard. It is a subclass of Object.
The DefaultEditorKit.CutAction class is an inner class of DefaultEditorKit that cuts data to the clipboard. It is a subclass of Object.
The DefaultEditorKit.DefaultKeyTypedAction class is an inner class of DefaultEditorKit that handles key presses. It is a subclass of Object.
The DefaultEditorKit.InsertBreakAction class is an inner class of DefaultEditorKit that inserts a line break into a document. It is a subclass of Object.
The DefaultEditorKit.InsertContentAction class is an inner class of DefaultEditorKit that inserts content into a document. It is a subclass of Object.
The DefaultEditorKit.InsertTabAction class is an inner class of DefaultEditorKit that inserts a tab into a document. It is a subclass of Object.
The DefaultEditorKit.PasteAction class is an inner class of DefaultEditorKit that pastes content into a document from the clipboard. It is a subclass of Object.
The DefaultHighlighter class is a subclass of Object that provides a default implementation of the Highlighter interface.
The DefaultHighlighter.DefaultHighlightPainter class is an inner class of DefaultHighlighter that implements the Highlighter.HighlightPainter interface. It is a subclass of Object.
The DefaultStyledDocument class is a subclass of AbstractDocument and implements the StyledDocument interface.
The DefaultStyledDocument.ElementSpec class is an inner class of DefaultStyledDocument that supports the building of document elements. It is a subclass of Object.
The DefaultTextUI class is a subclass of com.sun.java.swing.plaf.TextUI that provides a default implementation of the ViewFactory interface. It also implements the java.io.Serializable interface.
The EditorKit class is a subclass of Object that provides a base class for developing a text editor. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The FieldView class is a subclass of PlainView that supports a single-line editing view.
The IconView class is a subclass of View that provides support for viewing an icon.
The JTextComponent class is a subclass of com.sun.java.swing.JComponent that provides the base class for Swing text components. It implements the com.sun.java.swing.Scrollable and java.awt.accessibility.Accessible interfaces.
The JTextComponent.KeyBinding class is an inner class of JTextComponent that provides key binding support. It is a subclass of Object.
The LabelView class is a subclass of View that implements the TabableView interface.
The ParagraphView class is a subclass of BoxView that provides the capability to display styled paragraphs. It implements the TabExpander interface.
The PasswordView class is a subclass of FieldView that provides password-hiding support.
The PlainDocument class is a subclass of AbstractDocument that supports one text font and color.
The PlainView class is a subclass of View that supports the display of one font and one color. It implements the TabExpander interface.
The Segment class is a subclass of Object that represents a text fragment.
The SimpleAttributeSet class is a subclass of Object that provides a default implementation of the MutableAttributeSet interface. It also implements the java.io.Serializable interface.
The StringContent class is a subclass of Object that provides a default implementation of the AbstractDocument.Content interface. It also implements the java.io.Serializable interface.
The StyleConstants class is a subclass of Object that provides constants and methods for implementing text, paragraph, and document styles.
The StyleConstants.CharacterConstants class is an inner class of StyleConstants that supports character styles. It is a subclass of Object and implements the AttributeSet.CharacterAttribute interface.
The StyleConstants.ColorConstants class is an inner class of StyleConstants that supports text colors. It is a subclass of Object and implements the AttributeSet.ColorAttribute and AttributeSet.CharacterAttribute interfaces.
The StyleConstants.FontConstants class is an inner class of StyleConstants that supports fonts. It is a subclass of Object and implements the AttributeSet.FontAttribute and AttributeSet.CharacterAttribute interfaces.
The StyleConstants.ParagraphConstants class is an inner class of StyleConstants that supports paragraph styles. It is a subclass of Object and implements the AttributeSet.ParagraphAttribute interface.
The StyleContext class is a subclass of Object that provides style constants and resources. It implements the java.io.Serializable and AbstractDocument.AttributeContext interfaces.
The StyledEditorKit class is a subclass of DefaultEditorKit that provides a text editor that supports text styles.
The StyledEditorKit.AlignmentAction class is an inner class of StyledEditorKit that supports paragraph alignment. It is a subclass of StyledEditorKit.StyledTextAction.
The StyledEditorKit.BoldAction class is an inner class of StyledEditorKit that supports text bolding. It is a subclass of StyledEditorKit.StyledTextAction.
The StyledEditorKit.FontFamilyAction class is an inner class of StyledEditorKit that supports the use of fonts. It is a subclass of StyledEditorKit.StyledTextAction.
The StyledEditorKit.FontSizeAction class is an inner class of StyledEditorKit that supports the control of text font size. It is a subclass of StyledEditorKit.StyledTextAction.
The StyledEditorKit.ForegroundAction class is an inner class of StyledEditorKit that supports the setting of text foreground color. It is a subclass of StyledEditorKit.StyledTextAction.
The StyledEditorKit.ItalicAction class is an inner class of StyledEditorKit that supports the use of italics. It is a subclass of StyledEditorKit.StyledTextAction.
The StyledEditorKit.StyledTextAction class is an inner class of StyledEditorKit that supports text operations. It is a subclass of TextAction.
The StyledEditorKit.UnderlineAction class is an inner class of StyledEditorKit that supports underlining. It is a subclass of StyledEditorKit.StyledTextAction.
The TabSet class is a subclass of Object that defines a set of tab stops. It implements the java.io.Serializable interface.
The TabStop class is a subclass of Object that encapsulates a single tab stop. It implements the java.io.Serializable interface.
The TableView class is a subclass of BoxView that provides table support.
The TextAction class is a subclass of AbstractAction that is used to define key mappings for text operations.
The Utilities class is a subclass of Object that provides utility methods for text operations.
The View class is a subclass of Object that defines a view of part of a document.
The WrappedPlainView class is a subclass of BoxView that supports wrapped plain text. It implements the TabExpander interface.
The BadLocationException class is a subclass of java.lang.Exception that identifies errors in Document objects.
The com.sun.java.swing.text.html package consists of 22 classes that provide basic HTML editing capabilities. This package is covered in Chapter 12.
None.
The BlockView class is a subclass of com.sun.java.text.BoxView that supports the display of a box according to the Cascading Style Sheets (CSS) specification.
The CSS class is a subclass of Object that implements a set of CSS attributes.
The CSS.Attribute class is a subclass of Object that identifies a CSS attribute.
The HTML class is a subclass of Object that provides HTML tag and attribute definitions.
The HTML.Attribute class is a subclass of Object that supports HTML attributes.
HTML.Tag
The HTML.Tag class is a subclass of Object that supports HTML tags.
The HTML.UnknownTag class is a subclass of HTML.Tag that supports unknown HTML tags.
The HTMLDocument class is a subclass of com.sun.java.text.DefaultStyledDocument that encapsulates an HTML document.
The HTMLDocument.Iterator class is a subclass of Object that supports iteration over an HTML tag.
The HTMLEditorKit class is a subclass of com.sun.java.swing.text.StyledEditorKit that provides a basic HTML editing capability.
The HTMLEditorKit.HTMLFactory class is a subclass of Object that provides a factory for build HTML view fragments.
The HTMLEditorKit.LinkController class is an inner class of HTMLWriter that provides basic mouse event-handling support. It is a subclass of java.awt.event.MouseAdapter.
The HTMLEditorKit.Parser class is a subclass of Object that encapsulates an HTML parser.
The HTMLEditorKit.ParserCallback class is a subclass of Object that provides a callback capability for HTML parsers.
The HTMLWriter class is a subclass of com.sun.java.text.AbstractWriter that is used to write an HTML document to a stream.
The InlineView class is a subclass of com.sun.java.text.LabelView that supports CSS inline element styles.
The ListView class is a subclass of BlockView that supports the display of HTML lists.
The MinimalHTMLWriter class is a subclass of com.sun.java.text.AbstractWriter that supports the writing of minimal HTML documents.
The ParagraphView class is a subclass of com.sun.java.text.ParagraphView that displays a paragraph using CSS attributes.
The StyleSheet class is a subclass of com.sun.java.text.StyleContent that implements a CSS style sheet.
The StyleSheet.BoxPainter class is a subclass of Object that supports CSS box formatting.
The StyleSheet.ListPainter class is a subclass of Object that supports CSS list formatting.
None.
The com.sun.java.swing.text.rtf package consists of a single class, RTFEditorKit, which provides the capability to edit Rich Text Format (RTF) documents. It is covered in Chapter 12.
None.
The RTFEditorKit class is a subclass of com.sun.java.swing.text.StyledEditorKit that provides a basic Rich Text Format editing capability.
None.
The com.sun.java.swing.tree package includes four classes and seven interfaces that provide the capability to work with com.sun.java.swing.JTree components. The JTree component is a GUI component that displays a set of hierarchical data as an outline. The com.sun.java.swing.tree package is covered in Chapter 13.
The MutableTreeNode interface extends the TreeNode interface to provide methods for modifying the properties of a TreeNode object.
The RowMapper interface is used to identify the row corresponding to a TreeNode object.
The TreeCellEditor interface extends the com.sun.java.swing.CellEditor interface to support the editing of tree elements.
The TreeCellRenderer interface is used to render the nodes of a tree.
The TreeModel interface is used to model the data used to build a tree.
The TreeNode interface defines methods for classes that implement the nodes of a tree.
The TreeSelectionModel interface defines constants and methods for working with the current selection state of the nodes of a tree.
The DefaultMutableTreeNode class is a subclass of Object that provides a default, modifiable tree node. It implements the MutableTreeNode, java.lang.Cloneable, and java.io.Serializable interfaces.
The DefaultTreeModel class is a subclass of Object that provides a default TreeModel implementation. It also implements the java.io.Serializable interface.
The DefaultTreeSelectionModel class is a subclass of Object that provides a default TreeSelectionModel implementation. It also implements the java.lang.Cloneable and java.io.Serializable interfaces.
The TreePath class is a subclass of Object that identifies a path to a node of a tree. It implements the java.io.Serializable interface.
None.
The com.sun.java.swing.undo package provides five classes and two interfaces that support the implementation of undo and redo capabilities. It is covered in Chapter 13.
The StateEditable interface is implemented by classes whose state can be undone or redone by the StateEdit class.
The UndoableEdit interface is implemented by classes that support the undoing or redoing of edit operations.
The AbstractUndoableEdit class is a subclass of Object that provides an abstract implementation of the UndoableEdit interface.
The CompoundEdit class is a subclass of AbstractUndoableEdit that provides the capability to implement compound undo/redo operations.
The StateEdit class is a subclass of AbstractUndoableEdit that supports undo/redo operations on objects that change state.
The UndoManager class is a subclass of CompoundEdit that provides for thread-safe undo/redo operations. It implements the com.sun.java.swing.event.UndoableEditListener interface.
The UndoableEditSupport class is a subclass of Object that supports the management of undoable editing operations.
The CannotRedoException class is a subclass of RuntimeException that indicates a redo operation cannot be performed.
The CannotUndoException class is a subclass of RuntimeException that indicates an undo operation cannot be performed.
The java.beans package contains 15 classes and eight interfaces that provide the basic JavaBeans functionality. The java.beans package is covered in Part VII, "Creating JavaBeans."
The AppletInitializer interface provides support for initializing beans that are also applets.
The BeanInfo interface is used to provide explicit information about a bean.
The Customizer interface provides methods for customizing a bean's GUI.
The DesignMode interface is used to signal that a bean is in design (as opposed to execution) mode.
The PropertyChangeListener interface defines methods for handling events that result from changes to bound bean properties. It extends java.util.EventListener.
The PropertyEditor interface provides support for changing the properties of a bean.
The VetoableChangeListener interface extends java.util.EventListener to provide support for handing constrained property change events.
The Visibility interface is used to signal whether a bean needs a GUI to perform its processing.
The BeanDescriptor class is a subclass of FeatureDescriptor that provides global information about a bean.
The Beans class is a subclass of Object that provides general-purpose bean support.
The EventSetDescriptor class is a subclass of FeatureDescriptor that describes the events supported by a bean.
The FeatureDescriptor class is a subclass of Object that serves as a base class for explicit bean descriptions.
The IndexedPropertyDescriptor class is a subclass of PropertyDescriptor that supports indexed property descriptions.
The Introspector class is a subclass of Object that provides static methods for obtaining information about a bean.
The MethodDescriptor class is a subclass of FeatureDescriptor that provides information about a bean's methods.
The ParameterDescriptor class is a subclass of FeatureDescriptor that describes the parameters supported by a bean method.
The PropertyChangeEvent class is a subclass of java.util.EventObject that signals a change in a bean's properties.
The PropertyChangeSupport class is a subclass of Object that provides support for PropertyChangeEvent handling. It implements the java.io.Serializable interface.
The PropertyDescriptor class is a subclass of FeatureDescriptor that describes a bean property.
The PropertyEditorManager class is a subclass of Object that is used to access bean property editors.
The PropertyEditorSupport class is a subclass of Object that provides a basic implementation of the PropertyEditor interface.
The SimpleBeanInfo class is a subclass of Object that provides a basic implementation of the BeanInfo interface.
The VetoableChangeSupport class is a subclass of Object that provides support for property change event handling. It implements the java.io.Serializable interface.
The IntrospectionException class is a subclass of java.lang.Exception that indicates that an exception occurred during introspection.
The PropertyVetoException class is a subclass of java.lang.Exception that indicates an invalid property change.
The java.beans.beancontext package provides 11 classes and eight interfaces that implement an execution context for beans. The java.beans.beancontext package is covered in Chapter 29, "Glasgow Developments."
The BeanContext interface is implemented by classes that act as containers for other beans. It extends the BeanContextChild, java.util.Collection, java.beans.DesignMode, and java.beans.Visibility interfaces.
The BeanContextChild interface defines methods that allow classes to access their execution environment.
The BeanContextContainer interface provides access to a bean's AWT Container object if the bean is contained in an AWT container.
The BeanContextMembershipListener interface defines methods for handling events associated with changes in membership in a bean context. It extends the java.util.EventListener interface.
The BeanContextServiceProvider interface defines methods that are used to provide services to a bean context.
The BeanContextServiceRevokedListener interface supports the handling of events associated with revocation of a service to a bean context. It extends the java.util.EventListener interface.
The BeanContextServices interface defines methods that allow a BeanContext object to make services available to its contained BeanContextChild objects. It extends the BeanContext and BeanContextServicesListener interfaces.
The BeanContextServicesListener interface defines methods for handling events associated with a service becoming available to a bean context. It extends the BeanContextServiceRevokedListener interface.
The BeanContextAddedEvent class is a subclass of BeanContextMembershipEvent that defines the event generated when a bean is added to a bean context.
The BeanContextChildSupport class is a subclass of Object that provides a basic implementation of the BeanContextChild interface. It also implements the BeanContextServicesListener and java.io.Serializable interfaces.
The BeanContextEvent class is a subclass of java.util.EventObject that serves as the base class for bean context-related events.
The BeanContextMembershipEvent class is a subclass of BeanContextEvent that is used to signal a change in the set of beans that is contained in a bean context.
The BeanContextRemovedEvent class is a subclass of BeanContextMembershipEvent that indicates that a bean has been removed from a bean context.
The BeanContextServiceAvailableEvent class is a subclass of BeanContextEvent that indicates that a service has been made available to a bean context.
The BeanContextServiceRevokedEvent class is a subclass of BeanContextEvent that indicates that a service is no longer available to a bean context.
The BeanContextServicesSupport class is a subclass of BeanContextSupport that provides a basic implementation of the BeanContextServices interface.
The BeanContextServicesSupport.BCSSServiceProvider class is an inner class of BeanContextServicesSupport that is used to specify the behavior of a BeanContextServicesProvider object. It is a subclass of Object that implements the java.io.Serializable interface.
The BeanContextSupport class is a subclass of BeanContextChildSupport that provides a basic implementation of the BeanContext interface. It also implements the java.beans.PropertyChangeListener, java.beans.VetoableChangeListener, and java.io.Serializable interfaces.
The BeanContextSupport.BCSIterator class is an inner class of BeanContextSupport that is used as an iterator within its parent. It is a subclass of Object that implements the java.util.Iterator interface.
None.
The java.io package provides 50 classes and 10 interfaces that implement stream-based input and output. Chapter 17, "Input/Output Streams," shows how to use java.io to perform a wide variety of input and output.
The DataInput interface provides methods for reading primitive types from a byte stream.
The DataOutput interface provides methods for writing primitive types to a byte stream.
The Externalizable interface extends the Serializable interface to provide methods for writing objects to a stream and for reading them back from a stream.
The FileFilter interface provides the capability to filter file names during file name selection.
The FilenameFilter interface provides the capability to filter file names during file name selection.
The ObjectInput interface extends the DataInput interface to support the reading of objects from input streams.
The ObjectInputValidation interface supports the validation of objects within a graph.
The ObjectOutput interface extends the DataOutput interface to support the writing of objects to output streams.
The ObjectStreamConstants interface provides constants that are used to perform object-based input and output.
The Serializable interface identifies an object as being capable of being written to and read from a stream.
The BufferedInputStream class is a subclass of FilterInputStream that supports input buffering.
The BufferedOutputStream class is a subclass of FilterOutputStream that supports output buffering.
The BufferedReader class is a subclass of Reader that supports input buffering.
The BufferedWriter class is a subclass of Writer that supports output buffering.
The ByteArrayInputStream class is a subclass of InputStream that supports input from a byte array.
The ByteArrayOutputStream class is a subclass of OutputStream that supports output to a byte array.
The CharArrayReader class is a subclass of Reader that supports input from a character array.
The CharArrayWriter class is a subclass of Writer that supports output to a character array.
The DataInputStream class is a subclass of FilterInputStream that allows primitive types to be read from an input stream. It implements the DataInput interface.
The DataOutputStream class is a subclass of FilterOutputStream that allows primitive types to be written to an output stream. It implements the DataOutput interface.
The File class is a subclass of Object that encapsulates a disk file. It implements the Serializabe and java.lang.Comparable interfaces.
The FileDescriptor class is a subclass of Object that encapsulates a file descriptor.
The FileInputStream class is a subclass of InputStream that supports file-based input.
The FileOutputStream class is a subclass of OutputStream that supports file-based output.
The FilePermission class is a subclass of java.security.Permission that is used to control access to files. It implements the Serializable interface.
The FileReader class is a subclass of InputStreamReader that supports file-based input.
The FileWriter class is a subclass of OutputStreamWriter that supports file-based output.
The FilterInputStream class is a subclass of InputStream that is used to filter data that is being read from a stream.
The FilterOutputStream class is a subclass of OutputStream that is used to filter data that is being written to a stream.
The FilterReader class is a subclass of Reader that allows filtering of data that is being read.
The FilterWriter class is a subclass of Writer that allows filtering of data that is being written.
The InputStream class is a subclass of Object that provides the base class for all stream-based input.
The InputStreamReader class is a subclass of Reader that is used to read a stream using a Reader object.
The LineNumberInputStream class is a subclass of FilterInputStream that supports line number identification.
The LineNumberReader class is a subclass of BufferedReader that supports line number identification.
The ObjectInputStream class is a subclass of InputStream that supports the reading of objects from streams. It implements the ObjectInput and ObjectStreamConstants interfaces.
The ObjectInputStream.GetField class is an inner class of ObjectInputStream that provides support for the reading of individual object fields. It is a subclass of Object.
The ObjectOutputStream class is a subclass of OutputStream that supports the writing of objects to streams. It implements the ObjectOutput and ObjectStreamConstants interfaces.
The ObjectOutputStream.PutField class is an inner class of ObjectOutputStream that allows individual object fields to be accessed. It is a subclass of Object.
The ObjectStreamClass class is a subclass of Object that describes a serialized class. It implements the Serializable interface.
The ObjectStreamField class is a subclass of Object that describes a field of a serialized class. It implements the java.lang.Comparable interface.
The OutputStream class is a subclass of Object that provides the basis for stream-based output.
The OutputStreamWriter class is a subclass of Writer that allows output streams to be accessed as Writer objects.
The PipedInputStream class is a subclass of InputStream that supports communication between threads.
The PipedOutputStream class is a subclass of OutputStream that supports communication between threads.
The PipedReader class is a subclass of Reader that supports communication between threads.
The PipedWriter class is a subclass of Writer that supports communication between threads.
The PrintStream class is a subclass of FilterOutputStream that supports printing to the standard output stream.
The PrintWriter class is a subclass of Writer that supports printing to the standard output stream.
The PushbackInputStream class is a subclass of FilterInputStream that allows data that is read in to be pushed back onto the input stream.
The PushbackReader class is a subclass of FilterReader that allows data that is read in to be pushed back onto the input source.
The RandomAccessFile class is a subclass of Object that supports random file input and output. It implements the DataInput and DataOutput interfaces.
The Reader class is a subclass of Object that provides the basis for Unicode character input.
The SequenceInputStream class is a subclass of InputStream that supports the concatenation of two or more input streams.
The SerializablePermission class is a subclass of java.security.BasicPermission that controls access to object serialization.
The StreamTokenizer class is a subclass of Object that supports input stream parsing.
The StringBufferInputStream class is a subclass of InputStream that supports input from String objects.
The StringReader class is a subclass of Reader that supports input from String objects.
The StringWriter class is a subclass of Writer that supports output to String objects.
The Writer class is a subclass of Object that provides the basis for Unicode character-based output.
The CharConversionException class is a subclass of IOException that signals that an error occurred during character conversion.
The EOFException class is a subclass of IOException that signals that the end of a file has been encountered.
The FileNotFoundException class is a subclass of IOException that signals that a file cannot be located.
The IOException class is a subclass of java.lang.Exception that serves as the base class for defining I/O-based exceptions.
The InterruptedIOException class is a subclass of IOException signals that an I/O operation has been interrupted.
The InvalidClassException class is a subclass of ObjectStreamException that signals that an invalid class was encountered during object serialization.
The InvalidObjectException class is a subclass of ObjectStreamException that signals that an invalid object was encountered during object serialization.
The NotActiveException class is a subclass of ObjectStreamException that signals that serialization is not active.
The NotSerializableException class is a subclass of ObjectStreamException that signals that an object is not serializable.
The ObjectStreamException class is a subclass of IOException that serves as a base class for defining exceptions that occur during object I/O.
The OptionalDataException class is a subclass of ObjectStreamException that signals that additional data was encountered when reading an object from an input stream.
The StreamCorruptedException class is a subclass of ObjectStreamException that signals that an object stream contains errors.
The SyncFailedException class is a subclass of IOException that signals that synchronization of I/O could not take place.
The UTFDataFormatException class is a subclass of IOException that signals that an invalid UTF-8 string was read.
The UnsupportedEncodingException class is a subclass of IOException that identifies the use of unsupported data encoding.
The WriteAbortedException class is a subclass of ObjectStreamException indicating that the writing of an object was aborted.
The java.lang package provides 29 classes and three interfaces that implement fundamental Java objects. Because of its importance, the java.lang package is included with all Java platforms, ranging from EmbeddedJava to the full-blown JDK. The java.lang package is covered in Chapter 10, "Writing Console Applications."
The Cloneable interface identifies a class as being cloneable by the clone() method of the Object class.
The Comparable interface provides the compareTo() method for ordering the objects of a class.
The Runnable interface identifies a class as being runnable as a separate thread.
The Boolean class is a subclass of Object that wraps the primitive boolean type as a class. It implements the java.io.Serializable interface.
The Byte class is a subclass of Number that encapsulates a byte value. It implements the Comparable interface.
The Character class is a subclass of Object that encapsulates a two-byte Unicode character value. It implements the Comparable and java.io.Serializable interfaces.
The Character.Subset class is an inner class of Character that defines Unicode constants. It is a subclass of Object.
The Class class is a subclass of Object that is used to refer to classes as objects. It implements the java.io.Serializable interface.
The ClassLoader class is a subclass of Object that is the base class for implementing custom class loaders for use with the runtime system.
The Compiler class is a subclass of Object that is used to implement Just-In-Time (JIT) compilation.
The Double class is a subclass of Number that encapsulates the double primitive type. It implements the Comparable interface.
The Float class is a subclass of Number that encapsulates the float primitive type. It implements the Comparable interface.
The Integer class is a subclass of Number that encapsulates the int primitive type. It implements the Comparable interface.
The Math class is a subclass of Number that encapsulates the long primitive type. It implements the Comparable interface.
The Math class is a subclass of Object that provides access to mathematical constants and functions.
The Number class is a subclass of Object that is used as the base class for the wrapping of primitive numerical types. It implements the java.io.Serializable interface.
The Object class is the highest class in the Java class hierarchy. It provides methods that are inherited by all Java classes.
The Package class is a subclass of Object that is used to provide version information about a Java package.
The Process class is a subclass of Object that is used to control external processes that are executed from within the Java runtime environment.
The Runtime class is a subclass of Object that provides access to the Java runtime environment.
RuntimePermission
The RuntimePermission class is a subclass of java.security.BasicPermission that is used to control access to the runtime environment.
The SecurityManager class is a subclass of Object that is used to implement a Java security policy.
The Short class is a subclass of Number that encapsulates a short integer value. It implements the Comparable interface.
The String class is a subclass of Object that encapsulates a growable Unicode text string. It implements the Comparable and java.io.Serializable interfaces.
The StringBuffer class is a subclass of Object that provides a buffer for the implementation of String objects. It implements the java.io.Serializable interface.
The System class is a subclass of Object that provides access to operating system- specific resources.
The Thread class is a subclass of Object that provides the capability to create objects that run as separate threads. It implements the Runnable interface.
The ThreadGroup class is a subclass of Object that represents a collection of Thread objects.
The ThreadLocal class is a subclass of Object that provides variables that are local to a specific thread instance.
The Throwable class is a subclass of Object that is the base class for all Java errors and exceptions. It implements the java.io.Serializable interface.
The ArithmeticException class is a subclass of Object that represents the class of the void primitive type.
The AbstractMethodError class is a subclass of IncompatibleClassChangeError that indicates an attempt to invoke an abstract method.
The ArithmeticException class is a subclass of RuntimeException that is used to signal an arithmetic error, such as divide by zero.
The ArrayIndexOutOfBoundsException class is a subclass of IndexOutOfBoundsException that indicates that an array index has exceeded its legal range.
The ArrayStoreException class is a subclass of RuntimeException that indicates an attempt to store the wrong type of object in an array.
The ClassCastException class is a subclass of RuntimeException that indicates an attempt to perform an illegal object cast.
ClassCircularityError
The ClassCircularityError class is a subclass of LinkageError that indicates a circularity in a class definition.
The ClassFormatError class is a subclass of LinkageError that indicates an error in the format of a class's bytecode file.
The ClassNotFoundException class is a subclass of Exception that signals that the class loader is unable to locate a particular class.
The CloneNotSupportedException class is a subclass of Exception that signals an attempt to clone an object that does not implement the Cloneable interface.
The Error class is a subclass of Throwable that is the base class of all Java error classes.
The Exception class is a subclass of Throwable that is the base class of all Java exception classes.
The ExceptionInInitializerError class is a subclass of LinkageError that indicates the occurrence of an unexpected exception.
The IllegalAccessError class is a subclass of IncompatibleClassChangeError that indicates an attempt to access a field or method that violates the access modifier assigned to the field or method.
The IllegalAccessException class is a subclass of Exception that signals an illegal attempt to load a class.
The IllegalArgumentException class is a subclass of RuntimeException that indicates an illegal attempt to pass an argument.
The IllegalMonitorStateException class is a subclass of RuntimeException that signals an attempt to use a monitor without owning it.
The IllegalStateException class is a subclass of RuntimeException that signals that a method invocation occurred while the runtime environment was not in an appropriate state for the method invocation.
The IllegalThreadStateException class is a subclass of IllegalArgumentException that signals that a thread is not in an appropriate state for a requested operation.
The IncompatibleClassChangeError class is a subclass of LinkageError that indicates an incompatible change to a class definition has occurred.
The IndexOutOfBoundsException class is a subclass of RuntimeException that indicates an index has exceeded its range.
The InstantiationError class is a subclass of IncompatibleClassChangeError indicating that an attempt to instantiate an abstract class or interface has occurred.
The InstantiationException class is a subclass of Exception that indicates an attempt to instantiate an abstract class or interface.
The InternalError class is a subclass of VirtualMachineError that indicates an unexpected internal error has occurred in the virtual machine.
The InterruptedException class is a subclass of Exception that is thrown when a thread is interrupted.
The LinkageError class is a subclass of Error that indicates a class has changed in such a way that dependencies on that class are no longer valid.
The NegativeArraySizeException class is a subclass of RuntimeException that is thrown as the result of attempting to allocate an array of negative size.
The NoClassDefFoundError class is a subclass of LinkageError that indicates that a class definition cannot be found.
The NoSuchFieldError class is a subclass of IncompatibleClassChangeError that indicates an attempt to access a field that no longer exists.
The NoSuchFieldException class is a subclass of Exception that indicates that a referenced field name does not exist.
The NoSuchMethodError class is a subclass of IncompatibleClassChangeError that indicates an attempt to access a method that no longer exists.
The NoSuchMethodException class is a subclass of Exception indicating that a referenced method name does not exist.
The NullPointerException class is a subclass of RuntimeException that is thrown by the use of a null reference.
The NumberFormatException class is a subclass of IllegalArgumentException that is thrown when an attempt is made to convert a String object to a number and the object does not have a valid numeric representation.
The OutOfMemoryError class is a subclass of VirtualMachineError that indicates that the JVM is out of memory and no memory could be made available.
The RuntimeException class is a subclass of Exception that serves as the base class for defining exceptions that occur at runtime during normal JVM operation.
The SecurityException class is a subclass of RuntimeException that is thrown by a security policy violation.
The StackOverflowError class is a subclass of VirtualMachineError that indicates that a stack overflow has occurred.
The StringIndexOutOfBoundsException class is a subclass of IndexOutOfBoundsException that indicates an attempt to access an element of a String object that is outside the string's bounds.
ThreadDeath
The ThreadDeath class is a subclass of Error that is thrown after a thread is stopped.
The UnknownError class is a subclass of VirtualMachineError that indicates that an unknown error occurred in the JVM.
The UnsatisfiedLinkError class is a subclass of LinkageError that signals an attempt to access a nonexistent native method.
The UnsupportedOperationException class is a subclass of RuntimeException that is thrown by an object to indicate that it does not support a particular method.
The VerifyError class is a subclass of LinkageError that is thrown when the verifier encounters an inconsistency in a class file that it is verifying.
The VirtualMachineError class is a subclass of Error that indicates that the virtual machine is incapable of further processing.
The java.lang.ref package provides five classes that implement the new JDK 1.2 reference object capability. Reference objects are objects that are used to refer to other objects. They are similar to C and C++ pointers. The java.lang.ref package is covered in Chapter 10.
None.
The PhantomReference class is a subclass of Reference. When the referent of a registered PhantomReference object is no longer strongly, guardedly, or weakly reachable, the PhantomReference object is cleared and added to the ReferenceQueue to which it is registered.
The Reference class is a subclass of Object that implements a reference to another object.
The ReferenceQueue class is a subclass of Object that is used to collect Reference objects whose reachability has changed.
The SoftReference class is a subclass of Reference. An instance of this class is automatically cleared when memory is low and its referent is reachable only via soft references.
The WeakReference class is a subclass of Reference. When the referent of a registered WeakReference object is no longer strongly or guardedly reachable, the WeakReference object is cleared and added to the ReferenceQueue to which it is registered. The referent is then subject to finalization.
None.
The java.lang.reflect package contains seven classes and one interface that provide the capability to implement runtime discovery of information about an object's class. The java.lang.reflect package is covered in Chapter 10.
The Member interface is used to provide information that is reflected about a Field, Constructor, or Method.
The AccessibleObject class is a subclass of Object that is the superclass of the Constructor, Field, and Method classes. It was added to the class hierarchy in JDK 1.2 to provide the capability to specify whether an object suppresses reflection access control checks.
The Array class is a subclass of Object that is used to obtain information about, create, and manipulate arrays.
The Constructor class is a subclass of AccessibleObject that is used to obtain information about class constructors. It implements the Member interface.
The Field class is a subclass of AccessibleObject that is used to obtain information about and access the field variables of a class. It implements the Member interface.
The Method class is a subclass of Object that is used to obtain information about and access the methods of a class. It implements the Member interface.
The Modifier class is a subclass of Object that is used to decode integers that represent the modifiers of classes, interfaces, field variables, constructors, and methods.
The ReflectPermission class is a subclass of java.security.BasicPermission that is used to specify whether the default language access checks should be suppressed for reflected objects.
The InvocationTargetException class is a subclass of java.lang.Exception that wraps an exception thrown by an invoked method or constructor.
The java.math package provides two classes, BigDecimal and BigInteger, that provide the capability to perform arbitrary-precision arithmetic. This package is covered in Chapter 11, "Using the Utility and Math Packages."
None.
The BigDecimal class is a subclass of java.lang.Number that provides the capability to perform arbitrary-precision decimal arithmetic. It implements the java.lang.Comparable interface.
The BigInteger class is a subclass of java.lang.Number that provides the capability to perform arbitrary-length integer arithmetic. It implements the java.lang.Comparable interface.
None.
The java.net package provides 20 classes and five interfaces for TCP/IP network programming. Six new classes are introduced with JDK 1.2. The java.net package is covered in Part VIII, "Network Programming."
ContentHandlerFactory
The ContentHandlerFactory interface is implemented by classes that create ContentHandler objects.
The FileNameMap interface is implemented by classes that map file names to MIME types.
The SocketImplFactory interface is implemented by classes that create SocketImpl objects.
The SocketOptions interface provides constants and methods for setting TCP socket options.
The URLStreamHandlerFactory interface is implemented by classes that create URLStreamHandler objects.
The Authenticator class is a subclass of Object that is used to authenticate a network connection.
The ContentHandler class is a subclass of Object that is used to handle downloaded content based on its MIME type.
The DatagramPacket class is a subclass of Object that is used to implement UDP socket communication.
The DatagramSocket class is a subclass of Object that is used for UDP communication.
The DatagramSocketImpl class is a subclass of Object that is a base class for implementing connectionless socket-based communication.
The HttpURLConnection class is a subclass of URLConnection that supports the Hypertext Transfer Protocol (HTTP).
The InetAddress class is a subclass of Object that encapsulates an IP address.
The JarURLConnection class is a subclass of URLConnection that is used to access a JAR file via a network connection.
The MulticastSocket class is a subclass of DatagramSocket that supports multicast communication.
The NetPermission class is a subclass of java.security.BasicPermission that supports network security policy implementation.
The PasswordAuthentication class is a subclass of Object that supports network authentication by password.
ServerSocket
The ServerSocket class is a subclass of Object that is used to implement the server side of client/server applications.
The Socket class is a subclass of Object that provides an encapsulation of the client side of TCP and UDP sockets.
The SocketImpl class is a subclass of Object that is used to create custom socket implementations.
The SocketPermission class is a subclass of java.security.Permission that is used to define socket-level access controls. It implements the java.io.Serializable interface.
The URL class is a subclass of Object that encapsulates a uniform resource locator (URL). It implements the java.lang.Comparable and java.io.Serializable interfaces.
The URLClassLoader class is a subclass of java.security.SecureClassLoader that is used to load classes from a location specified by a URL.
The URLConnection class is a subclass of Object that is used as a base class for implementing TCP connections to a URL-referenced resource.
The URLDecoder class is a subclass of Object that supports x-www-form-urlencoded decoding.
The URLEncoder class is a subclass of Object that supports x-www-form-urlencoded encoding.
The URLStreamHandler class is a subclass of Object that is used to support the development of stream-based protocol handlers.
The BindException class is a subclass of SocketException that indicates that an error occurred during socket binding.
The ConnectException class is a subclass of SocketException that indicates that an error occurred during socket connection.
The MalformedURLException class is a subclass of java.io.IOException that identifies the use of an incorrectly formed URL.
The NoRouteToHostException class is a subclass of SocketException that indicates that the network was not able to establish a route to a remote host.
The ProtocolException class is a subclass of java.io.IOException indicating that an error occurred in the protocol stack.
The SocketException class is a subclass of java.io.IOException that indicates that an error occurred in the underlying socket implementation.
UnknownHostException
The UnknownHostException class is a subclass of java.io.IOException that is thrown by a reference to a host whose IP address could not be resolved.
The UnknownServiceException class is a subclass of java.io.IOException that is thrown by an attempt to use a network service that is unknown to the requestor.
The java.rmi package provides three classes and one interface that support basic remote method invocation (RMI) capabilities. It is covered in Chapter 38, "Building Distributed Applications with the java.rmi Packages," and Chapter 39, "Working with Remote Objects."
The Remote interface is used to identify an object as being remotely accessible. It does not define any constants or methods.
The MarshalledObject class is a subclass of Object that supports object persistence for remote object activation by representing method arguments and return values as serialized byte streams. It implements the java.io.Serializable interface.
The Naming class is a subclass of Object that provides static methods for accessing remote objects via RMI URLs. It is used to bind object names to the remote objects they represent.
The RMISecurityManager class is a subclass of java.lang.SecurityManager that defines the default security policy used with remote objects. This class can be extended to implement custom RMI security policies.
The AccessException class is a subclass of RemoteException that is used to signal an access violation.
The AlreadyBoundException class is a subclass of java.lang.Exception that is used to signal that a name has already been bound.
The ConnectException class is a subclass of RemoteException that signals that a connection was refused by the remote host.
The ConnectIOException class is a subclass of RemoteException that signals that an I/O error occurred during connection establishment.
The MarshalException class is a subclass of RemoteException that identifies that an error in object marshalling occurred.
The NoSuchObjectException class is a subclass of RemoteException that identifies an attempt to invoke a method on an object that is no longer available.
The NotBoundException class is a subclass of java.lang.Exception that identifies an attempt to look up a name that has not been bound.
The RMISecurityException class is a subclass of java.lang.SecurityException that identifies that a security exception has occurred during RMI.
RemoteException
The RemoteException class is a subclass of java.io.IOException that serves as a base class for RMI-related exceptions.
The ServerError class is a subclass of RemoteException that identifies that an error occurred on a remote server as the result of processing a method invocation.
The ServerException class is a subclass of RemoteException that identifies that an exception occurred on a remote server as the result of processing a method invocation.
The ServerRuntimeException class is a subclass of RemoteException that identifies that a runtime exception occurred on a remote server as the result of processing a method invocation.
The StubNotFoundException class is a subclass of RemoteException that identifies that the stub of a requested remote object has not been exported.
The UnexpectedException class is a subclass of RemoteException that identifies that an exception occurred during a remote method invocation that was not specified in the method's signature.
The UnknownHostException class is a subclass of RemoteException that identifies an attempt to access the registry of an unknown host.
The UnmarshalException class is a subclass of RemoteException that identifies that an error occurred in the unmarshalling of a marshalled object.
The java.rmi.activation package supports persistent object references and remote object activation. It contains seven classes and four interfaces. Chapter 39 shows how to work with these classes and interfaces.
The ActivationInstantiator interface is implemented by classes that create remotely activatable objects. It extends the Remote interface.
The ActivationMonitor interface is implemented by classes that monitor the activation status of an ActivationGroup object. The ActivationGroup object notifies its ActivationMonitor when objects in the group change their activation status or when the group as a whole becomes inactive. ActivationMonitor extends the Remote interface.
The ActivationSystem interface is implemented by classes that support the registration of activatable objects and ActivationGroup objects. It extends the Remote interface.
The Activator interface is implemented by a class that activates classes whose objects are remotely activatable. The system Activator object is invoked by a faulting remote reference. It then initiates the activation of the object needed to complete the remote reference. It extends the Remote interface.
The Activatable class is a subclass of RemoteServer that is the base class for developing remotely activatable classes. It is extended by classes that require remote activation or object persistence.
The ActivationDesc class is a subclass of Object that encapsulates the information needed to activate a remotely activatable object. This information includes the object's class name, activation group, code location, and initialization data. The ActivationDesc class implements the java.io.Serializable interface.
The ActivationGroup class is a subclass of UnicastRemoteObject that is used to manage a group of activatable objects. It implements the ActivationInstantiator interface.
The ActivationGroupDesc class is a subclass of Object that encapsulates the information needed to activate an ActivationGroup object. This information includes the object's class name, code location, and initialization data. The ActivationGroupDesc class implements the java.io.Serializable interface.
The ActivationGroupDesc.CommandEnvironment class is a subclass of Object that contains startup information needed to activate an ActivationGroup object. It implements the java.io.Serializable interface.
The ActivationGroupID class is a subclass of Object that uniquely identifies an ActivationGroup object as well as its ActivationSystem object. It implements the java.io.Serializable interface.
The ActivationID class is a subclass of Object that uniquely identifies a remotely activatable object as well as its Activator object. It implements the java.io.Serializable interface.
The ActivateFailedException class is a subclass of java.rmi.RemoteException that identifies the failure to activate a remotely activatable object.
The ActivationException class is a subclass of java.lang.Exception that is the superclass of UnknownGroupException and UnknownObjectException.
The UnknownGroupException class is a subclass of ActivationException that is generated by an attempt to activate an object from an unknown ActivationGroup object.
The UnknownObjectException class is a subclass of ActivationException that is generated by an attempt to activate an object that is unknown to an Activator object.
The java.rmi.dgc package supports distributed garbage collection. It contains two classes and one interface and is covered in Chapter 38.
The DGC interface is implemented by the server side of the distributed garbage collector. It defines the clean() and dirty() methods for keeping track of which objects should be garbage-collected.
The Lease class is a subclass of Object that creates objects that are used to keep track of object references. It implements the java.io.Serializable interface.
The VMID class is a subclass of Object that implements an ID that uniquely identifies a Java virtual machine on a particular host. It implements the java.io.Serializable interface.
None.
The java.rmi.registry package supports distributed registry operations. It contains one class and two interfaces. It is covered in Chapter 38.
Registry
The Registry interface provides methods for associating names with remotely accessible objects. It is implemented by classes that provide the RMI registry. It extends the Remote interface.
The RegistryHandler interface provides methods for accessing a Registry implementation. These methods have been deprecated in JDK 1.2.
The LocateRegistry class is a subclass of Object that provides methods for accessing the RMI registry on a particular host.
None.
The java.rmi.server package provides the low-level classes and interfaces that implement RMI. It contains 11 classes and seven interfaces. It is covered in Chapter 38.
The LoaderHandler interface provides methods for working with RMI class loaders.
The RMIClientSocketFactory interface provides the createSocket() method for creating a client-side RMI socket.
The RMIServerSocketFactory interface provides the createServerSocket() method for creating a server-side RMI socket.
The RMIFailureHandler interface defines methods for handling RMI failure events.
The RemoteCall interface defines methods for supporting a remote method invocation.
The RemoteRef interface extends the java.io.Externalizable interface and provides methods for implementing a reference to a remote object.
The ServerRef interface extends the RemoteRef interface to provide a server-side reference to a remote object.
The Skeleton interface provides methods that are implemented by server-side skeletons.
The Unreferenced interface provides methods that are implemented by a remote object to determine when the object is no longer remotely referenced.
The LogStream class is a subclass of java.io.PrintStream that supports the logging of RMI errors.
ObjID
The ObjID class is a subclass of Object that uniquely identifies a remote object. It implements the java.io.Serializable interface.
The Operation class is a subclass of Object that encapsulates a remote method.
The RMIClassLoader class is a subclass of Object that supports class loading during RMI.
The RMISocketFactory class is a subclass of Object that is used to load custom RMI socket implementations.
The RemoteObject class is a subclass of Object that is the base class for developing remote objects. It implements the Remote and java.io.Serializable interfaces.
The RemoteServer class is a subclass of RemoteObject that is the base class for implementing an RMI server.
The RemoteStub class is a subclass of RemoteObject that is the base class of all RMI stubs.
The UID class is a subclass of Object that uniquely identifies an object on a particular host. It implements the java.io.Serializable interface.
The UnicastRemoteObject class is a subclass of RemoteServer that provides a default RMI server implementation.
The ExportException class is a subclass of java.rmi.RemoteException indicating that an error occurred during object export.
The ServerCloneException class is a subclass of java.rmi.RemoteException that indicates an attempt to clone a non-cloneable remote object.
The ServerNotActiveException class is a subclass of java.lang.Exception that indicates that the remote server is not currently active.
The SkeletonMismatchException class is a subclass of java.rmi.RemoteException indicating that the skeleton of a remote object is inappropriate for the object being referenced.
The SkeletonNotFoundException class is a subclass of java.rmi.RemoteException that signals that the skeleton of a remote object cannot be located.
The SocketSecurityException class is a subclass of ExportException that signals a socket operation that violates the current security policy.
The java.security package provides 39 classes and eight interfaces that provide the foundation for the Security API. Refer to Chapter 3 and Chapter 8.
Interfaces
The Certificate interface is a deprecated interface that provides support for digital certificates.
The Guard interface defines methods for objects that protect other objects.
The Key interface extends the java.io.Serializable interface to encapsulate a cryptographic key.
The Principal interface provides methods for a subject that may have an identity.
The PrivateKey interface extends the Key interface to provide support for a private key.
The PrivilegedAction interface defines the run() method for use with operations that have privileges enabled.
The PrivilegedException interface defines the run() method for use with operations that have privileges enabled. This interface allows checked exceptions to be thrown.
The PublicKey interface extends the Key interface to provide support for a public key.
The AccessControlContext class is a subclass of Object that is used to make access control decisions.
The AccessController class is a subclass of Object that implements security access controls.
The AlgorithmParameterGenerator class is a subclass of Object that generates parameters for use with cryptographic algorithms.
The AlgorithmParameterGeneratorSpi class is a subclass of Object that defines a service provider interface for an AlgorithmParameterGenerator class.
The AlgorithmParameters class is a subclass of Object that encapsulates parameters used with cryptographic algorithms.
The AlgorithmParametersSpi class is a subclass of Object that provides a service provider interface for an AlgorithmParameters class.
The AllPermission class is a subclass of Permission that implies all other permissions.
The BasicPermission class is a subclass of Permission that provides a base class for implementing permissions that use the same naming approach. It implements the java.io.Serializable interface.
The CodeSource class is a subclass of Object that identifies the location from which code is loaded. It implements the java.io.Serializable interface.
The DigestInputStream class is a subclass of java.io.FilterInputStream that is used to read a message digest.
The DigestOutputStream class is a subclass of java.io.FilterOutputStream that is used to write a message digest.
The GuardedObject class is a subclass of Object that is used to protect other objects. It implements the java.io.Serializable interface.
The Identity class is a subclass of Object that implements an identity used for making access control decisions. It implements the Principal and java.io.Serializable interfaces.
The IdentityScope class is a subclass of Identity that defines the scope of an identity.
The KeyFactory class is a subclass of Object that is used to create Key objects.
The KeyFactorySpi class is a subclass of Object that provides a service provider interface to a KeyFactory class.
The KeyPair class is a subclass of Object that encapsulates a public-private key pair.
The KeyPairGenerator class is a subclass of KeyPairGeneratorSpi that is used to create key pairs.
The KeyPairGeneratorSpi class is a subclass of Object that provides a service provider interface to a KeyPairGenerator object.
The KeyStore class is a subclass of Object that supports the management of cryptographic keys.
The KeyStoreSpi class is a subclass of Object that defines the service provider interface for the KeyPairGenerator class.
The MessageDigest class is a subclass of MessageDigestSpi that implements a message digest.
The MessageDigestSpi class is a subclass of Object that provides a service provider interface to a MessageDigest class.
The Permission class is a subclass of Object that defines a permission to a protected resource. It implements the Guard and java.io.Serializable interfaces.
PermissionCollection
The PermissionCollection class is a subclass of Object that implements a collection of Permission objects. It implements the java.io.Serializable interface.
The Permissions class is a subclass of PermissionCollection that supports a mixed collection of Permission objects. It implements the java.io.Serializable interface.
The Policy class is a subclass of Object that implements a Java security policy.
The ProtectionDomain class is a subclass of Object that identifies a set of classes with the same permissions.
The Provider class is a subclass of java.util.Properties that implements a service provider.
The SecureClassLoader class is a subclass of java.lang.ClassLoader that supports secure class loading.
The SecureRandom class is a subclass of java.util.Random that provides secure random-number generation capabilities.
The SecureRandomSpi class is a subclass of Object that defines the service provider interface for the SecureRandom class.
The Security class is a subclass of Object that provides common access to security-related objects.
The SecurityPermission class is a subclass of BasicPermission that defines security-related permissions.
The Signature class is a subclass of SignatureSpi that provides digital signature support.
The SignatureSpi class is a subclass of Object that provides a service provider interface to a Signature class.
The SignedObject class is a subclass of Object that represents an object that has been signed. It implements the java.io.Serializable interface.
The Signer class is a subclass of Identity that is capable of signing a signature-related object.
The UnresolvedPermission class is a subclass of Permission that does not have an accessible permission class. It implements the java.io.Serializable interface.
The AccessControlException class is a subclass of SecurityException that indicates a violation of security access controls.
DigestException
The DigestException class is a subclass of GeneralSecurityException that is thrown by errors in message digest calculation.
The GeneralSecurityException class is a subclass of java.lang.Exception that is used as the base class for defining the security-related exceptions.
The InvalidAlgorithmParameterException class is a subclass of GeneralSecurityException that indicates that an invalid parameter was supplied to a cryptographic algorithm.
The InvalidKeyException class is a subclass of KeyException that indicates that an invalid key was supplied to a cryptographic algorithm.
The InvalidParameterException class is a subclass of IllegalArgumentException indicating that an invalid parameter was supplied to a cryptographic algorithm.
The KeyException class is a subclass of GeneralSecurityException that identifies an exception related to a cryptographic key.
The KeyManagementException class is a subclass of KeyException that identifies an exception in the management of keys.
The KeyStoreException class is a subclass of GeneralSecurityException that identifies an exception in the storage of keys.
The NoSuchAlgorithmException class is a subclass of GeneralSecurityException indicating that a requested algorithm does not exist.
The NoSuchProviderException class is a subclass of GeneralSecurityException indicating that a requested service provider does not exist.
The ProviderException class is a subclass of java.lang.RuntimeException that is generated by a service provider.
The SignatureException class is a subclass of GeneralSecurityException that identifies an exception occurring during signature calculation.
The UnrecoverableKeyException class is a subclass of GeneralSecurityException that signals that a key cannot be recovered from a key store.
The java.security.acl package provides five interfaces that provide the basic elements for implementing security access controls. This package is covered in Chapter 8.
The Acl interface extends the Owner interface to define methods for classes that implement access control lists. An Acl object consists of zero or more AclEntry objects.
The AclEntry interface defines methods for an entry in an access control list. It identifies a set of permissions for a principal. It extends the java.lang.Cloneable interface.
The Group interface extends the java.security.Principal interface to provide methods for working with a group of Principal objects. A Group object may also contain other Group objects.
The Owner interface defines methods for working with the owners of an access control list.
The Permission interface defines methods for implementing permissions to access- protected resources.
None.
The AclNotFoundException class is a subclass of java.lang.Exception that signals a reference to a nonexistent access control list.
The LastOwnerException class is a subclass of java.lang.Exception that signals an attempt to delete the last owner of an access control list.
The NotOwnerException class is a subclass of java.lang.Exception that signals an attempt to modify an access control list by an object that is not its owner.
The java.security.cert package provides seven classes and one interface that implement digital certificates. It is covered in Chapter 8.
The X509Extension interface provides methods that encapsulate extensions defined for X.509 v3 certificates and v2 certificate revocation lists.
The Certificate class is a subclass of Object that provides an abstract base class for implementing identity certificates.
The CertificateFactory class extends Object to provide a factory for the generation of certificates.
The CertificateFactorySpi class extends Object to define the service provider interface for the CertificateFactory class.
The X509CRLEntry class extends Object to define an abstract class for an entry in a certificate revocation list. It implements the X509Extension interface.
The X509CRL class is a subclass of Object that implements an X.509 certificate revocation list. It implements the X509Extension interface.
The X509Certificate class is a subclass of Certificate that provides an abstract base class for implementing X.509 digital certificates.
Exceptions and Errors
The CRLException class is a subclass of java.security.GeneralSecurityException that identifies an exception occurring in the processing of a certificate revocation list.
The CertificateEncodingException class is a subclass of CertificateException that identifies that an exception occurred during the encoding of a certificate.
The CertificateException class is a subclass of java.security.GeneralSecurityException that acts as a base class for other certificate-related exceptions.
The CertificateExpiredException class is a subclass of CertificateException that identifies that an expired certificate has been encountered.
The CertificateNotYetValidException class is a subclass of CertificateException that identifies that a certificate has been processed before its valid date range.
The CertificateParsingException class is a subclass of CertificateException that indicates that an error occurred in the parsing of a certificate.
The X509ExtensionException class is a subclass of java.security.GeneralSecurityException that an exception occurred in the processing of an X.509 extension.
The java.security.interfaces package provides eight interfaces that support implementation of the NIST digital signature algorithm. It is covered in Chapter 8.
The DSAKey interface defines the getParams() method for accessing a Digital Signature Algorithm (DSA) public or private key.
The DSAKeyPairGenerator interface is implemented by objects that can generate DSA key pairs.
The DSAParams interface defines methods for accessing a set of DSA key parameters.
The DSAPrivateKey interface extends the DSAKey and java.security.PrivateKey interfaces to provide access to a DSA private key.
The DSAPublicKey interface extends the DSAKey and java.security.PublicKey interfaces to provide access to a DSA public key.
The RSAPrivateCrtKey interface extends RSAPrivateKey to provide access to an RSA private key that uses the Chinese Remainder Theorem.
The RSAPrivateKey interface extends PrivateKey to provide access to an RSA private key.
The RSAPublicKey interface extends PublicKey to provide access to an RSA private key.
None.
None.
The java.security.spec package provides nine classes and two interfaces that provide specifications for cryptographic keys. It is covered in Chapter 8.
The AlgorithmParameterSpec interface provides no constants or methods. It is used to identify an object that provides cryptographic algorithm parameters.
The KeySpec interface provides no constants or methods. It is used to identify an object that is a key for a cryptographic algorithm.
The DSAParameterSpec class is a subclass of Object that provides parameters for a Digital Signature Algorithm (DSA) implementation. It implements the AlgorithmParameterSpec and java.security.interfaces.DSAParams interfaces.
The DSAPrivateKeySpec class is a subclass of Object that implements a private DSA key. It implements the KeySpec interface.
The DSAPublicKeySpec class is a subclass of Object that implements a public DSA key. It implements the KeySpec interface.
The EncodedKeySpec class is a subclass of Object that implements an encoded public or private key. It implements the KeySpec interface.
The PKCS8EncodedKeySpec class is a subclass of EncodedKeySpec that represents the PKCS #8 standard encoding of a private key.
The RSAPrivateCrtKeySpec class extends RSAPrivateKeySpec to implement an RSA private key that uses the Chinese Remainder Theorem.
The RSAPrivateKeySpec class extends Object to encapsulate an RSA private key. It implements the KeySpec interface.
The RSAPublicKeySpec class extends Object to encapsulate an RSA public key. It implements the KeySpec interface.
The X509EncodedKeySpec class is a subclass of EncodedKeySpec that represents the X.509 standard encoding of a public or private key.
The InvalidKeySpecException class is a subclass of java.security.GeneralSecurityException that identifies an invalid key specification.
The InvalidParameterSpecException class is a subclass of java.security.GeneralSecurityException that identifies an invalid parameter specification.
The java.sql package provides six classes and 16 interfaces that provide Java database connectivity. This package is covered in Part X, "Database Programming."
The ArrayLocator interface provides a reference to an array that is stored by the database server.
The Blob interface provides a reference to a binary large object that is stored by the database server.
The CallableStatement interface extends the PreparedStatement interface to provide support for stored procedures.
The Clob interface provides a reference to a character large object that is stored by the database server.
The Connection interface encapsulates a database connection.
The DatabaseMetaData interface provides access to information about the database itself.
The Driver interface encapsulates a database driver.
The PreparedStatement interface provides access to precompiled, stored SQL statements.
The Ref interface provides a reference to a stored SQL value.
The ResultSet interface encapsulates the results of a database query.
The ResultSetMetaData interface provides information about a ResultSet object.
The SQLData interface provides support for mapping SQL and Java data types.
The SQLInput interface represents an input stream of a SQL UDT instance.
The SQLOutput interface represents a SQL UDT output stream.
The Statement interface provides support for executing SQL statements.
The Struct interface encapsulates a SQL structured type.
The Date class is a subclass of java.util.Date that supports SQL date objects.
The DriverManager class is a subclass of Object that is used to manage database drivers.
The DriverPropertyInfo class is a subclass of Object that provides information about a database driver.
The Time class is a subclass of java.util.Time that supports SQL time objects.
The Timestamp class is a subclass of Object that encapsulates a SQL time stamp.
The Types class is a subclass of Object that defines constants for use with SQL types.
The BatchUpdateException class is a subclass of SQLException that signals the occurrence of errors during batch update operations.
The DataTruncation class is a subclass of SQLWarning that indicates that a date value has been truncated.
The SQLException class is a subclass of java.lang.Exception that serves as a base class for database exceptions.
The SQLWarning class is a subclass of SQLException that signals warnings about database operations.
The java.text package provides 20 classes and two interfaces that support internationalization. The java.text package is covered in Chapter 19.
The AttributedCharacterIterator interface extends the CharacterIterator interface to provide support for iterating through text that is associated with style, internationalization, or other attributes.
The CharacterIterator interface provides internationalization support for bidirectional text iteration.
The Annotation class is a subclass of Object that is used to work with text attribute values.
The AttributedCharacterIterator.Attribute class extends Object to define the keys used with text attributes. It implements the java.io.Serializable interface.
The AttributedString class is a subclass of Object that encapsulates text and related attribute information.
The BreakIterator class is a subclass of Object that provides support for identifying text-break boundaries. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The ChoiceFormat class is a subclass of NumberFormat that allows number formatting to be associated with a range of numbers.
The CollationElementIterator class is a subclass of Object that is used to iterate through international text strings.
The CollationKey class is a subclass of Object that is used to compare two Collator objects. It implements the java.lang.Comparable interface.
The Collator class is a subclass of Object that supports locale-specific string comparisons. It implements the java.lang.Comparable, java.lang.Cloneable, and java.io.Serializable interfaces.
The DateFormat class is a subclass of Format that provides international date formatting support.
The DateFormatSymbols class is a subclass of Object that provides support for locale-specific date formatting information. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The DecimalFormat class is a subclass of Object that provides international decimal point formatting support.
The DecimalFormatSymbols class is a subclass of Object that provides locale-specific decimal formatting information. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The FieldPosition class is a subclass of Object that is used to identify fields in formatted output.
The Format class is a subclass of Object that is the base class for international formatting support. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The MessageFormat class is a subclass of Format that supports international message concatenation.
The NumberFormat class is a subclass of Format that provides international number formatting support.
The ParsePosition class is a subclass of Object that is used to keep track of the current parsing position.
The RuleBasedCollator class is a subclass of Collator that supports rule-based sorting.
The SimpleDateFormat class is a subclass of DateFormat that supports basic international date formatting.
The StringCharacterIterator class is a subclass of Object that provides a basic implementation of the CharacterIterator interface. It also implements the java.io.Serializable interface.
The ParseException class is a subclass of java.lang.Exception that signals a parsing error.
The java.util package, like java.lang and java.io, is fundamental to any Java platform. It provides 34 classes and 13 interfaces that cover a wide variety of common programming needs. Most of the new classes and interfaces support the Collections API. The java.util package is covered in Chapter 11.
The Collection interface defines methods for working with arbitrary collections of objects.
The Comparator interface defines methods for implementing a comparison function.
The Enumeration interface defines methods for working with an ordered collection of objects.
The EventListener interface provides the basic interface to support Java event handling.
The Iterator interface defines methods for iterating through an ordered collection.
The List interface extends the Collection interface to an ordered list of objects.
The ListIterator interface extends the Iterator interface to support iteration through a List object.
The Map interface provides methods for mapping between two object sets.
The Map.Entry interface defines methods for a single mapping element.
Observer
The Observer interface defines methods for observing the occurrence of an event, action, or processing.
The Set interface extends the Collection interface to implement a collection in which each element occurs only once.
The SortedMap interface extends the Map interface to identify an ordering between the map elements.
The SortedSet interface extends the Set interface to order the collection of set elements.
The AbstractCollection class is a subclass of Object that provides an abstract implementation of the Collection interface.
The AbstractList class is a subclass of AbstractCollection that provides an abstract implementation of the List interface.
The AbstractMap class is a subclass of Object that provides an abstract implementation of the Map interface.
The AbstractSequentialList class is a subclass of AbstractList that provides a sequential access data store.
The AbstractSet class is a subclass of AbstractCollection that provides an abstract implementation of the Set interface.
The ArrayList class is a subclass of AbstractList that is implemented in terms of an array. It implements the List, java.lang.Cloneable, and java.io.Serializable interfaces.
The Arrays class is a subclass of Object that provides support for array manipulation.
The BitSet class is a subclass of Object that provides a growable vector of bits. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The Calendar class is a subclass of Object that provides basic support for date, time, and calendar functions. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The Collections class is a subclass of Object that provides static methods for working with collections of objects.
The Date class is a subclass of Object that provides basic date/time support. It implements the java.lang.Comparable, java.lang.Cloneable, and java.io.Serializable interfaces.
The Dictionary class is a subclass of Object that maps names to values.
The EventObject class is a subclass of Object that provides the basic class from which most Java events are derived. It implements the java.io.Serializable interface.
The GregorianCalendar class is a subclass of Calendar that implements a Gregorian calendar.
The HashMap class is a subclass of AbstractMap that provides an implementation of the Map interface using a hash table. It implements the Map, java.lang.Cloneable, and java.io.Serializable interfaces.
The HashSet class is a subclass of AbstractSet that implements the Set interface using a hash table. It implements the Set, java.lang.Cloneable, and java.io.Serializable interfaces.
The Hashtable class is a subclass of Dictionary that maps keys to their values. It implements the Map, java.lang.Cloneable, and java.io.Serializable interfaces.
The LinkedList class is a subclass of AbstractSequentialList that encapsulates a linked list data structure. It implements the List, java.lang.Cloneable, and java.io.Serializable interfaces.
The ListResourceBundle class is a subclass of ResourceBundle that provides internationalization in the form of a list.
The Locale class is a subclass of Object that encapsulates a local region for internationalization purposes. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The Observable class is a subclass of Object that represents observable data in the model-view paradigm.
The Properties class is a subclass of Hashtable that represents a set of properties and property values.
The PropertyPermission class is a subclass of java.security.BasicPermission that implements access controls on system properties.
The PropertyResourceBundle class is a subclass of ResourceBundle that manages internationalization resources using properties.
The Random class is a subclass of Object that provides random-number generation capabilities. It implements the java.io.Serializable interface.
The ResourceBundle class is a subclass of Object that is used to manage internationalization resources.
The SimpleTimeZone class is a subclass of TimeZone that provides basic time zone information.
The Stack class is a subclass of Vector that implements a stack data structure.
The StringTokenizer class is a subclass of Object that supports the parsing of strings. It implements the Enumeration interface.
The TimeZone class is a subclass of Object that encapsulates the notion of a time zone. It implements the java.lang.Cloneable and java.io.Serializable interfaces.
The TreeMap class is a subclass of AbstractMap that provides a tree-based implementation of the Map interface. It implements the SortedMap, java.lang.Cloneable, and java.io.Serializable interfaces.
The TreeSet class is a subclass of AbstractSet that provides a tree-based implementation of the Set interface. It implements the SortedSet, java.lang.Cloneable, and java.io.Serializable interfaces.
The Vector class is a subclass of AbstractList that provides a growable array of objects. It implements the List, java.lang.Cloneable, and java.io.Serializable interfaces.
The WeakHashMap class extends AbstractMap to implement a hashtable based on weak (garbage-collectable) keys. It implements the Map interface.
The ConcurrentModificationException class is a subclass of java.lang.RuntimeException that identifies invalid concurrent accesses to collections objects.
The EmptyStackException class is a subclass of java.lang.RuntimeException that signals an attempt to pop an object from an empty stack.
The MissingResourceException class is a subclass of java.lang.RuntimeException that signals an access to a missing resource.
The NoSuchElementException class is a subclass of java.lang.RuntimeException that indicates an Enumeration contains no more elements.
The TooManyListenersException class is a subclass of java.lang.Exception indicating that too many event listeners are associated with an event.
The java.util.jar package provides seven classes for working with JAR files. It is covered in Chapter 11. Chapter 8 shows how to use the jar tool to create JAR files.
None.
The Attributes class is a subclass of Object that maps Manifest attribute names to string values. It implements the java.util.Map and java.lang.Cloneable interfaces.
The Attributes.Name class is an inner class of Attributes that represents a specific attribute name of the Attributes map. It is a subclass of Object.
The JarEntry class is a subclass of java.util.zip.ZipEntry that represents an entry in a JAR file. It provides methods for reading the attributes and identities of JAR file entries.
The JarFile class is a subclass of java.util.zip.ZipFile that is used to read JAR files. It supports reading of the manifest as well as individual JAR file entries.
The JarInputStream class is a subclass of java.util.zip.ZipInputStream that is used to read a JAR file from an input stream.
The JarOutputStream class is a subclass of java.util.zip.ZipOutputStream that is used to write the contents of a JAR file to an output stream.
The Manifest class is a subclass of Object that implements a JAR file manifest. It provides methods for accessing manifest names and their attributes. It implements the java.lang.Cloneable interface.
The JarException class is a subclass of java.util.zip.ZipException that is used to report errors that occur in the reading or writing of a JAR file.
The java.util.mime package provides two classes for working with MIME types. It is covered in Chapter 11.
None.
The MimeType class is a subclass of Object that provides an object representation of a MIME type. It implements the java.lang.Cloneable and java.io.Externalizable interfaces.
The MimeTypeParameterList class is a subclass of Object that provides the capability to work with a MIME type's parameters. It implements the java.lang.Cloneable interface.
The MimeTypeParseException class is a subclass of java.lang.Exception that identifies that an exception has occurred during MIME type parsing.
The java.util.zip package provides 14 classes and one interface for working with compressed files. It is covered in Chapter 11.
The Checksum interface provides a common set of methods for classes that compute a checksum.
The Adler32 class is a subclass of Object that computes an Adler-32 checksum on an input stream. It implements the Checksum interface.
The CRC32 class is a subclass of Object that computes an CRC-32 checksum on an input stream. It implements the Checksum interface.
The CheckedInputStream class is a subclass of java.io.FilterInputStream that computes a checksum of the data being read.
The CheckedOutputStream class is a subclass of java.io.FilterOutputStream that computes a checksum of the data being written.
The Deflater class is a subclass of Object that supports compression using the ZLIB compression library.
The DeflaterOutputStream class is a subclass of java.io.FilterOutputStream that compresses stream output using the deflate format of the ZLIB compression library.
The GZIPInputStream class is a subclass of InflatorInputStream that supports the reading of GZIP-compressed data.
The GZIPOutputStream class is a subclass of DeflatorOutputStream that supports the writing of GZIP-compressed data.
The Inflater class is a subclass of Object that supports decompression using the ZLIB compression library.
The InflaterInputStream class is a subclass of java.io.FilterIntputStream that decompresses stream input using the inflate format of the ZLIB compression library.
The ZipEntry class is a subclass of Object that encapsulates a ZIP file entry. It implements the java.lang.Cloneable interface.
The ZipFile class is a subclass of Object that supports the reading of ZipEntry objects from ZIP files.
The ZipInputStream class is a subclass of InflaterInputStream that is used for reading streams that are in the compressed or uncompressed ZIP format.
The ZipOutputStream class is a subclass of DeflaterOutputStream that is used to write compressed and uncompressed ZIP file entries to an output stream.
The DataFormatException class is a subclass of java.lang.Exception that is used to identify the occurrence of a data format error during compression or decompression.
The ZipException class is a subclass of java.io.IOException that signals an error in the reading or writing of a ZIP file or stream.
The org.omg.CORBA package consists of 57 classes and 42 interfaces that implement the foundation for supporting Java-CORBA integration.
The ARG_IN interface identifies a method input argument.
The ARG_INOUT interface identifies an argument that may be used as both an input and an output in a method invocation.
The ARG_OUT interface identifies a method output argument.
The AliasDef interface encapsulates an IDL AliasDef. It extends the Object and TypedefDef interfaces.
The ArrayDef interface encapsulates an IDL ArrayDef. It extends the Object and IDLType interfaces.
The AttributeDef interface encapsulates an IDL AttributeDef. It extends the Object and Contained interfaces.
The CTX_RESTRICT_SCOPE interface is used as a flag to restrict the search scope of the get_values() method.
The ConstantDef interface encapsulates an IDL ConstantDef. It extends the Object and Contained interfaces.
The Contained interface encapsulates an IDL Contained object. It extends the Object and IRObject interfaces.
The Container interface encapsulates an IDL Container object. It extends the Object and IRObject interfaces.
The ConstructionPolicy interface extends the Object and Policy interfaces to allow user-specified construction policies.
The DomainManager interface extends the Object interface to support the management of a domain's policy objects.
The DynAny interface extends the Object interface to support access to CORBA Any objects.
The DynArray interface extends the Object and DynAny interfaces to support arrays.
The DynEnum interface extends the Object and DynAny interfaces to support IDL enum types.
The DynFixed interface extends the Object and DynAny interfaces to support IDL fixed types.
The DynSequence interface extends the Object and DynAny interfaces to support IDL sequence types.
The DynStruct interface extends the Object and DynAny interfaces to support IDL struct types.
The DynUnion interface extends the Object and DynAny interfaces to support IDL union types.
The DynValue interface extends the Object and DynAny interfaces to support IDL values.
The EnumDef interface encapsulates an IDL EnumDef. It extends the Object and TypedefDef interfaces.
The ExceptionDef interface encapsulates an IDL ExceptionDef. It extends the Object, Container, and Contained interfaces.
The IDLType interface encapsulates an IDL IDLType. It extends the Object and IRObject interfaces.
The IRObject interface encapsulates an interface repository object. It extends the Object interface.
The ImplementationDef interface encapsulates an IDL ImplementationDef. It extends the Object interface.
The InterfaceDef interface encapsulates an IDL InterfaceDef. It extends the Object, Container, Contained, and IDLType interfaces.
The InitializerDef interface extends the Object and Contained interfaces to support initializer definitions.
The ModuleDef interface encapsulates an IDL ModuleDef. It extends the Object, Container, and Contained interfaces.
The Object interface represents a CORBA object reference.
The OperationDef interface encapsulates an IDL OperationDef. It extends the Object and Contained interfaces.
The Policy interface extends the Object interface to support policy specification.
The PrimitiveDef interface encapsulates an IDL PrimitiveDef. It extends the Object and IDLType interfaces.
The Repository interface encapsulates the IDL object repository.
The SequenceDef interface encapsulates an IDL SequenceDef. It extends the Object and IDLType interfaces.
The StringDef interface encapsulates an IDL StringDef. It extends the Object and IDLType interfaces.
The StructDef interface encapsulates an IDL StructDef. It extends the Object, TypedefDef, and Container interfaces.
The TypedefDef interface encapsulates an IDL TypedefDef. It extends the Object, IDLType, and Contained interfaces.
The UnionDef interface encapsulates an IDL UnionDef. It extends the Object, TypedefDef, and Container interfaces.
The ValueBoxDef interface extends the Object and IDLType interfaces to support value box definitons.
The ValueDef interface extends the Object, Container, Contained, and IDLType interfaces to support value definitions.
The ValueMemberDef interface extends the Object and Contained interfaces to support value member definitions.
The Any class is a subclass of Object that acts as a container for data of any primitive IDL type.
The AnyHolder class is a subclass of Object that acts as a holder for Any objects used as INOUT and OUT method parameters.
The AttributeDescription class is a subclass of Object that is used to describe an IDL type attribute.
The AttributeMode class is a subclass of Object that is used to describe an IDL type mode.
The BooleanHolder class is a subclass of Object that is used to hold boolean values for use as INOUT and OUT arguments.
The ByteHolder class is a subclass of Object that is used to hold byte values for use as INOUT and OUT arguments.
The CharHolder class is a subclass of Object that is used to hold char values for use as INOUT and OUT arguments.
The CompletionStatus class is a subclass of Object that identifies the completion status of a method that throws a SystemException.
The ConstantDescription class is a subclass of Object that is used to define a constant value.
The Context class is a subclass of Object that provides information about the context in which a method invocation request takes place.
The ContextList class is a subclass of Object that specifies properties associated with a Context object.
The Current class is a subclass of org.omg.CORBA.portable.ObjectImpl that is used to access information about an execution thread.
The DefinitionKind class is a subclass of Object that is used to hold boolean types for use as INOUT and OUT arguments.
The DoubleHolder class is a subclass of Object that is used to hold double values for use as INOUT and OUT arguments.
The DynamicImplementation class is a subclass of org.omg.CORBA.portable.ObjectImpl that provides support for the dynamic servant interface.
The Environment class is a subclass of Object that is used to make exceptions available to the client that requested a method invocation.
The ExceptionDescription class is a subclass of Object that is used to describe a CORBA exception.
The ExceptionList class is a subclass of Object that lists the exceptions that can be thrown by a method.
The FloatHolder class is a subclass of Object that is used to hold float values for use as INOUT and OUT arguments.
The Initializer class is a subclass of Object that supports member initialization.
The IntHolder class is a subclass of Object that is used to hold int values for use as INOUT and OUT arguments.
The InterfaceDescription class is a subclass of Object that provides a description of a CORBA interface.
The LongHolder class is a subclass of Object that is used to hold long values for use as INOUT and OUT arguments.
The ModuleDescription class is a subclass of Object that describes a CORBA module.
The NameValuePair class is a subclass of Object that holds the name and value of an IDL construct.
The NVList class is a subclass of Object that provides a list of NamedValue objects.
The NamedValue class is a subclass of Object that is used to describe method arguments and return values.
The ORB class is a subclass of Object that serves as the CORBA object request broker.
The ObjectHolder class is a subclass of Object that is used to hold object references for use as INOUT and OUT arguments.
The OperationDescription class is a subclass of Object that describes a CORBA operation.
The OperationMode class is a subclass of Object that describes a CORBA operation mode.
The ParameterDescription class is a subclass of Object that describes a CORBA parameter.
The ParameterMode class is a subclass of Object that describes a CORBA parameter mode.
The PrimitiveKind class is a subclass of Object that provides static methods that define primitive IDL types.
The Principal class is a subclass of Object that identifies a client making a remote method invocation request.
The PrincipalHolder class is a subclass of Object that is used to hold Principal objects for use as INOUT and OUT arguments.
The PRIVATE class is a subclass of Object that support the implementation of private values.
The PUBLIC class is a subclass of Object that support the implementation of public values.
The Request class is a subclass of Object that encapsulates a client request to invoke a remote method.
The ServerRequest class is a subclass of Object that encapsulates a dynamic skeleton interface request.
The ShortHolder class is a subclass of Object that is used to hold short values for use as INOUT and OUT arguments.
The StringHolder class is a subclass of Object that is used to hold String objects for use as INOUT and OUT arguments.
The StructMember class is a subclass of Object that describes a member of a CORBA data structure.
The TCKind class is a subclass of Object that encapsulates the IDL TCKind object.
The TypeCode class is a subclass of Object that is used to identify a primitive IDL value type.
The TypeCodeHolder class is a subclass of Object that is used to hold TypeCode objects for use as INOUT and OUT arguments.
The TypeDescription class is a subclass of Object that describes an IDL type.
The UnionMember class is a subclass of Object that provides support for IDL union constructs.
The BAD_CONTEXT class is a subclass of SystemException that supports the CORBA BAD_CONTEXT exception.
The BAD_INV_ORDER class is a subclass of SystemException that supports the CORBA BAD_INV_ORDER exception.
The BAD_OPERATION class is a subclass of SystemException that supports the CORBA BAD_OPERATION exception.
The BAD_PARAM class is a subclass of SystemException that supports the CORBA BAD_PARAM exception.
The BAD_TYPECODE class is a subclass of SystemException that supports the CORBA BAD_TYPECODE exception.
The Bounds class is a subclass of UserException that provides support for the user-defined bounds exception.
The COMM_FAILURE class is a subclass of SystemException that supports the CORBA COMM_FAILURE exception.
The DATA_CONVERSION class is a subclass of SystemException that supports the CORBA DATA_CONVERSION exception.
The FREE_MEM class is a subclass of SystemException that supports the CORBA FREE_MEM exception.
The IMP_LIMIT class is a subclass of SystemException that supports the CORBA IMP_LIMIT exception.
The INITIALIZE class is a subclass of SystemException that supports the CORBA INITIALIZE exception.
The INTERNAL class is a subclass of SystemException that supports the CORBA INTERNAL exception.
The INTF_REPOS class is a subclass of SystemException that supports the CORBA INTF_REPOS exception.
The INVALID_TRANSACTION class is a subclass of SystemException that supports the CORBA INVALID_TRANSACTION exception.
The INV_FLAG class is a subclass of SystemException that supports the CORBA INV_FLAG exception.
The INV_IDENT class is a subclass of SystemException that supports the CORBA INV_IDENT exception.
The INV_OBJREF class is a subclass of SystemException that supports the CORBA INV_OBJREF exception.
The MARSHAL class is a subclass of SystemException that supports the CORBA MARSHAL exception.
The NO_IMPLEMENT class is a subclass of SystemException that supports the CORBA NO_IMPLEMENT exception.
The NO_MEMORY class is a subclass of SystemException that supports the CORBA NO_MEMORY exception.
The NO_PERMISSION class is a subclass of SystemException that supports the CORBA NO_PERMISSION exception.
The NO_RESOURCES class is a subclass of SystemException that supports the CORBA NO_RESOURCES exception.
The NO_RESPONSE class is a subclass of SystemException that supports the CORBA NO_RESPONSE exception.
The OBJECT_NOT_EXIST class is a subclass of SystemException that supports the CORBA OBJECT_NOT_EXIST exception.
The OBJ_ADAPTER class is a subclass of SystemException that supports the CORBA OBJ_ADAPTER exception.
The PERSIST_STORE class is a subclass of SystemException that supports the CORBA PERSIST_STORE exception.
The SystemException class is a subclass of java.lang.RuntimeException that serves as the base class for implementing CORBA exceptions.
The TRANSACTION_REQUIRED class is a subclass of SystemException that supports the CORBA TRANSACTION_REQUIRED exception.
The TRANSACTION_ROLLEDBACK class is a subclass of SystemException that supports the CORBA TRANSACTION_ROLLEDBACK exception.
The TRANSIENT class is a subclass of SystemException that supports the CORBA TRANSIENT exception.
The UNKNOWN class is a subclass of SystemException that supports the CORBA UNKNOWN exception.
The UnknownUserException class is a subclass of UserException that identifies an unknown user exception returned by the remote server.
The UserException class is a subclass of java.lang.Exception that supports the implementation of IDL-defined user exceptions.
The WrongTransaction class is a subclass of UserException that identifies a requested transaction as being from an incorrect transaction scope.
The org.omg.CORBA.ContainedPackage package contains a single class, Description, that describes the type and value of a contained object.
None.
The Description class is a subclass of Object that is used to describe a contained object.
None.
The org.omg.CORBA.ContainerPackage package contains a single class, Description, that describes the type, value, and object contained in a container object.
None.
The Description class is a subclass of Object that is used to describe a contained object.
None.
The org.omg.CORBA.InterfaceDefPackage package contains a single class, FullInterfaceDescription, that describes an interface definition.
None.
The FullInterfaceDescription class is a subclass of Object that is used to describe a contained object.
None.
The org.omg.CORBA.ORBPackage package defines the InvalidName exception, which is raised when an invalid name is passed to an object request broker.
None.
None.
The InvalidName class is a subclass of org.omg.CORBA.UserException that indicates that the ORB was passed a name for which there is no initial reference.
The org.omg.CORBA.TypeCodePackage package defines the BadKind and Bounds exceptions, which are used to signal exceptions related to type usage and constraints.
None.
None.
The BadKind class is a subclass of org.omg.CORBA.UserException that indicates that an inappropriate operation was attempted on an org.omg.CORBA.TypeCode object.
The Bounds class is a subclass of org.omg.CORBA.UserException that indicates that an out-of-bounds exception occurred as the result of an operation on an org.omg.CORBA.TypeCode object.
The org.omg.CORBA.portable package consists of five classes and three interfaces that are used to support vendor-specific CORBA implementations.
The InvokeHandler interface provides support for ORB request dispatch processing.
The ResponseHandler interface provides support for returning responses back to the ORB.
The Streamable interface provides methods for marshalling and unmarshalling holders to and from streams.
The Delegate class is a subclass of Object that specifies a portable API for ORB- vendor-specific implementation of the org.omg.CORBA.Object methods.
The InputStream class is a subclass of Object that provides methods for reading IDL types from streams.
The ObjectImpl class is a subclass of Object that provides a default implementation of the org.omg.CORBA.Object interface.
The OutputStream class is a subclass of Object that provides methods for writing IDL types to streams.
The ServantObject class extends Object to encapsulate a CORBA servant object.
None.
The org.omg.CosNaming package consists of 20 classes and two interfaces that implement a tree-structured naming service.
The BindingIterator interface extends the org.omg.CORBA.Object interface and provides the capability to iterate through a list of name-object bindings.
The NamingContext interface extends the org.omg.CORBA.Object interface and provides access to the naming service.
The Binding class is a subclass of Object that associates a name with an object.
The BindingHelper class is a subclass of Object that provides static methods for manipulating bindings.
The BindingHolder class is a subclass of Object that holds the value of a Binding object.
The BindingIteratorHelper class is a subclass of Object that provides static methods for manipulating binding iterators.
The BindingIteratorHolder class is a subclass of Object that holds the value of a binding iterator.
The BindingListHelper class is a subclass of Object that provides static methods for manipulating binding lists.
The BindingListHolder class is a subclass of Object that holds the value of a binding list.
The BindingType class is a subclass of Object that identifies the type of a Binding object.
The BindingTypeHelper class is a subclass of Object that provides static methods for manipulating binding types.
The BindingTypeHolder class is a subclass of Object that holds the value of a binding type.
The IstringHelper class is a subclass of Object that provides static methods for manipulating strings.
The NameComponent class is a subclass of Object that is used to build hierarchical names.
The NameComponentHelper class is a subclass of Object that provides static methods for manipulating name components.
The NameComponentHolder class is a subclass of Object that holds the value of a name component. It implements the org.omg.CORBA.portable.Streamable interface.
The NameHelper class is a subclass of Object that provides static methods for manipulating names.
The NameHolder class is a subclass of Object that holds the value of a name. It implements the org.omg.CORBA.portable.Streamable interface.
The NamingContextHelper class is a subclass of Object that provides static methods for manipulating name contexts.
The NamingContextHolder class is a subclass of Object that holds the value of a naming context. It implements the org.omg.CORBA.portable.Streamable interface.
The _BindingIteratorImplBase class is a subclass of org.omg.CORBA.DynamicImplementation that supports the implementation of binding iterators. It implements the BindingIterator interface.
The _NamingContextImplBase class is a subclass of org.omg.CORBA.DynamicImplementation that supports the implementation of naming contexts. It implements the NamingContext interface.
None.
The org.omg.CosNaming.NamingContextPackage package consists of 13 classes that implement aspects of the naming service's name context. The name context implements nodes within the tree-structured naming scheme.
None.
The AlreadyBoundHelper class is a subclass of Object that provides support for the AlreadyBound exception.
The AlreadyBoundHolder class is a subclass of Object that provides support for the AlreadyBound exception. It implements the org.omg.CORBA.portable.Streamable interface.
The CannotProceedHelper class is a subclass of Object that provides support for the CannotProceed exception.
The CannotProceedHolder class is a subclass of Object that provides support for the CannotProceed exception. It implements the org.omg.CORBA.portable.Streamable interface.
The InvalidNameHelper class is a subclass of Object that provides support for the InvalidName exception.
The InvalidNameHolder class is a subclass of Object that provides support for the InvalidName exception. It implements the org.omg.CORBA.portable.Streamable interface.
The NotEmptyHelper class is a subclass of Object that provides support for the NotEmpty exception.
The NotEmptyHolder class is a subclass of Object that provides support for the NotEmpty exception. It implements the org.omg.CORBA.portable.Streamable interface.
The NotFoundHelper class is a subclass of Object that provides support for the NotFound exception.
The NotFoundHolder class is a subclass of Object that provides support for the NotFound exception.
The NotFoundReason class is a subclass of Object that provides support for the NotFound exception.
The NotFoundReasonHelper class is a subclass of Object that provides support for the NotFoundReason object.
The NotFoundReasonHolder class is a subclass of Object that provides storage for a NotFoundReason object. It implements the org.omg.CORBA.portable.Streamable interface.
The AlreadyBound class is a subclass of org.omg.CORBA.UserException that identifies a name as being already bound with an object.
The CannotProceed class is a subclass of org.omg.CORBA.UserException that signals that the CORBA implementation has come to a standstill.
The InvalidName class is a subclass of org.omg.CORBA.UserException that indicates that an invalid name has been used.
The NotEmpty class is a subclass of org.omg.CORBA.UserException that signals a non-empty reference was encountered when one was not expected.
The NotFound class is a subclass of org.omg.CORBA.UserException that signals that a referenced name cannot be found.
© Copyright, Macmillan Computer Publishing. All rights reserved.