This appendix summarizes the classes and interfaces of the Java API. The eight packages of the Java API are presented in alphabetical order.
The java.applet package provides the Applet class and the interfaces needed to support Java applets. It consists of a single Applet class and three interfaces that enable audio playing and applet integration within browsers.
The Applet class is a subclass of the java.awt.Panel class that is used to implement Java applets.
The AppletContext interface provides methods that allow an applet to interact with the context in which it is run, such as a browser, the applet viewer, or an application program.
The AppletStub interface provides methods that are used to implement programs that display an applet.
The AudioClip interface provides methods that are used to implement classes that support the playing of audio clips within applets.
The java.awt package provides the classes that support Java window programming. This package is known as the Abstract Windowing Toolkit.
The BorderLayout class is used to lay out the GUI objects contained within a Container object. It is the default layout for Window, Frame, and Dialog objects.
The Button class implements a clickable button GUI control.
The Canvas class implements a GUI object that supports drawing. Drawing is not implemented on the canvas itself, but on the Graphics object provided by the canvas.
The CardLayout class is used to lay out the objects in a Container object in the form similar to a deck of cards.
The Checkbox class is used to implement checkbox and radio button GUI controls.
The CheckboxGroup class is used with the Checkbox class to implement radio buttons.
The CheckboxMenuItem class is used to implement menu items that can be checked on or off.
The Choice class is used to implement pull-down lists that can be placed within the main area of a window.
The Color class provides a system-independent color implementation and defines several color constants.
The Component class is the superclass of all window GUI controls. It provides a common set of methods that support component organization, display, and event handling.
The Container class is the superclass of window classes that contain other objects and provides a common set of methods to organize and display contained objects.
The Dialog class is used to implement dialog box windows.
The Dimension class is used to represent the width and height of a two-dimensional object.
The Event class is used to encapsulate all events processed by Java window programs.
The FileDialog class is used to construct dialog boxes that support the selection of files for input and output operations.
The FlowLayout class is used to lay out window Container objects. It is the default layout used with the Panel class.
The Font class implements a system-independent set of fonts that control text display.
The FontMetrics class is used to access the specific display properties of a Font class.
The Frame class is used to create and control the main application window of standalone Java window programs.
The Graphics class supports the drawing of graphical objects and text within a window.
The GridBagConstraints class is used to identify the positioning parameters of a component that is contained within an object that is laid out using the GridBagLayout class.
The GridBagLayout class allows a Container object to be laid out in a gridlike fashion with component objects occupying more than one row or column.
The GridLayout class is used to lay out a Container object in a grid where all elements of the grid are the same size.
The Image class provides a content-independent mechanism for implementing graphical images.
The Insets class is used to specify the margins associated with a GUI object.
The Label class is used to display text labels within a window or other GUI container.
The List class implements single- and multiple-selection list GUI controls.
The MediaTracker class provides a set of methods for managing images used to implement multimedia objects.
The Menu class implements a single pull-down menu that is attached to a menu bar or other menu.
The MenuBar class implements a menu bar that is attached to the Frame object of a window program.
The MenuComponent class is the superclass of all menu-related classes and provides a common set of methods used by its subclasses.
The MenuItem class is used to implement items that can be selected from a pull-down menu. It is extended by the Menu and CheckboxMenuItem classes.
The Panel class is used as a container to organize GUI components within a window. Its default layout is FlowLayout.
The Point class is used to represent general, two-dimensional x,y-coordinates.
The Polygon class represents a polygon as a list of x,y-coordinates that identify the polygon's vertices.
The Rectangle class represents a rectangle using the x,y-coordinate of its upper-left corner, its width, and height.
The Scrollbar class is used to implement vertical and horizontal scrollbars.
The TextArea class implements scrollable text-entry objects that span multiple lines and columns.
The TextComponent class is the superclass of all text-based classes. It provides a common set of methods used by the TextArea and TextField classes.
The TextField class implements a one-line text-entry field.
The Toolkit class provides the linkage between the common AWT supported by Java and the platform-dependent implementation of the AWT.
The Window class is the superclass of all window-related classes and provides a common set of methods for organizing and displaying windows.
The LayoutManager interface provides a set of methods that are implemented by classes that control the layout of a container.
The MenuContainer class provides a set of methods that are implemented by classes that contain menus.
The java.awt.image package defines classes and interfaces that support image generation, storage, and processing.
The ColorModel class provides a general framework for representing colors and maps this framework to the RGB color model.
The CropImageFilter class is used to crop images to a specified area.
The DirectColorModel class is used to directly access the color values of a pixel.
The FilteredImageSource class provides the capability to filter an image using an object of class ImageFilter.
The ImageFilter class provides a common set of methods for implementing an image filter.
The IndexColorModel class is a subclass of the ColorModel class that translates fixed colormap pixel values to their RGB component colors.
The MemoryImageSource class is used to create images using an array of pixel values.
The PixelGrabber class is used to capture the pixels of an image and store them in an array.
The RGBImageFilter class is used to create image filters that modify the pixels of the default RGB color model.
The ImageConsumer interface provides a set of methods for accessing image data provided by classes that implement the ImageProducer interface.
The ImageObserver interface provides a set of constants and methods through which objects can be notified about an image that is being constructed.
The ImageProducer interface provides a set of methods for classes that produce images. These methods are used to reconstruct or modify an image being produced.
The java.awt.peer package provides a set of interface definitions that map platform-independent AWT classes to their native platform-dependent implementations.
This package does not have any classes.
The ButtonPeer interface specifies the native methods that are required to support the implementation of the java.awt.Button class.
The CanvasPeer interface specifies the native methods that are required to support the implementation of the java.awt.Canvas class.
The CheckboxMenuItemPeer interface specifies the native methods that are required to support the implementation of the java.awt.CheckboxMenuItem class.
The CheckboxPeer interface specifies the native methods that are required to support the implementation of the java.awt.Checkbox class.
The ChoicePeer interface specifies the native methods that are required to support the implementation of the java.awt.Choice class.
The ComponentPeer interface specifies the native methods that are required to support the implementation of the java.awt.Component class.
The ContainerPeer interface specifies the native methods that are required to support the implementation of the java.awt.Container class.
The DialogPeer interface specifies the native methods that are required to support the implementation of the java.awt.Dialog class.
The FileDialogPeer interface specifies the native methods that are required to support the implementation of the java.awt.FileDialog class.
The FramePeer interface specifies the native methods that are required to support the implementation of the java.awt.Frame class.
The LabelPeer interface specifies the native methods that are required to support the implementation of the java.awt.Label class.
The ListPeer interface specifies the native methods that are required to support the implementation of the java.awt.List class.
The MenuBarPeer interface specifies the native methods that are required to support the implementation of the java.awt.MenuBar class.
The MenuComponentPeer interface specifies the native methods that are required to support the implementation of the java.awt.MenuComponent class.
The MenuItemPeer interface specifies the native methods that are required to support the implementation of the java.awt.MenuItem class.
The MenuPeer interface specifies the native methods that are required to support the implementation of the java.awt.Menu class.
The PanelPeer interface specifies the native methods that are required to support the implementation of the java.awt.Panel class.
The ScrollbarPeer interface specifies the native methods that are required to support the implementation of the java.awt.Scrollbar class.
The TextAreaPeer interface specifies the native methods that are required to support the implementation of the java.awt.TextArea class.
The TextComponentPeer interface specifies the native methods that are required to support the implementation of the java.awt.TextComponent class.
The TextFieldPeer interface specifies the native methods that are required to support the implementation of the java.awt.TextField class.
The WindowPeer interface specifies the native methods that are required to support the implementation of the java.awt.Window class.
The java.io package provides a number of classes that support stream-based I/O. These classes are organized into two main class hierarchies under the InputStream and OutputStream classes.
The BufferedInputStream class provides the capability to implement buffering for an arbitrary InputStream object.
The BufferedOutputStream class provides the capability to implement buffering for an arbitrary OutputStream object.
The ByteArrayInputStream class is used to convert a byte array into an InputStream object.
The ByteArrayOutputStream class is used to convert a byte array into an OutputStream object.
The DataInputStream class provides the capability to read primitive data types and objects from an InputStream object.
The DataOutputStream class provides the capability to write primitive data types and objects to an OutputStream object.
The File class is used to provide system-independent access to a file or directory on the host system.
The FileDescriptor class provides a system-independent implementation of file descriptor objects.
The FileInputStream class allows a File object to be used as the basis for creating an object of class InputStream.
The FileOutputStream class allows a File object to be used to create an object of class OutputStream.
The FilterInputStream class is the superclass of all classes that support input stream filtering.
The FilterOutputStream class
is the superclass of all classes that support output stream
filtering.
The InputStream class is the superclass of all input stream classes. It provides the methods required to implement an input stream of bytes.
The LineNumberInputStream class is used to track the line numbers associated with an InputStream object.
The OutputStream class is the superclass of all output stream classes. It provides the methods required to implement an output stream of bytes.
The PipedInputStream class is used to provide an input stream to a thread so that it can read data written to a PipedOutputStream object by another thread.
The PipedOutputStream class is used to provide an output stream to a thread so that it can send data to another thread that reads the data from a PipedInputStream object.
The PrintStream class provides an output stream that supports a common set of methods for printing objects and primitive data types.
The PushbackInputStream class is used to provide an output stream that is capable of having data written back onto it so that it can be read again.
The RandomAccessFile class implements a file that can be directly read or written to at arbitrary file locations.
The SequenceInputStream class is used to concatenate a sequence of input streams into a single input stream.
The StreamTokenizer class is used to convert an input stream into a stream of tokens for processing by an input parser.
The StringBufferInputStream class is used to convert a StringBuffer object for use as an InputStream object.
The DataInput interface provides a set of methods for constructing a system-independent implementation of an input stream.
The DataOutput interface provides a set of methods for constructing a system-independent implementation of an output stream.
The FilenameFilter interface provides the accept() method for determining whether a filename should be included in a filtered list of filenames.
The java.lang package provides the core set of classes that are used in applets, console programs, and window programs. The fundamental classes of the Java class hierarchy are defined within this package. Some java.lang classes also provide access to system-specific information.
The Boolean class provides a class wrapper that is used to access the boolean primitive data type as a Java object.
The Character class provides a class wrapper that is used to access the char primitive data type as a Java object.
The Class class provides
runtime information about other classes in the form of a class
descriptor.
The ClassLoader class is used to define policies for loading classes into the runtime environment.
The Compiler class is used to provide access to the Java compiler.
The Double class provides a class wrapper that is used to access the double primitive data type as a Java object.
The Float class provides a class wrapper that is used to access the float primitive data type as a Java object.
The Integer class provides a class wrapper that is used to access the int primitive data type as a Java object.
The Long class provides a class wrapper that is used to access the long primitive data type as a Java object.
The Math class provides a standard library of mathematical functions.
The Number class is the superclass of all integer and floating-point classes. It can be used to convert a numeric value from one class to another.
The Object class is the superclass of all Java classes and provides methods that are inherited by all Java classes.
The Process class is used to provide system-independent access to processes that are executed using the exec() method of the System class.
The Runtime class provides access to the underlying Java runtime system.
The SecurityManager class is used to implement a security policy for the execution of untrusted classes.
The String class is used to implement constant character strings.
The StringBuffer class is used to implement growable character strings.
The System class provides system-independent access to important system resources such as stdin, stdout, and stderr.
The Thread class is used to implement multithreaded Java programs.
The ThreadGroup class is used to organize and control a set of threads as a single entity.
The Throwable class is the superclass of all Java errors and exceptions.
The Cloneable interface is implemented by classes that can be copied or cloned.
The Runnable interface is implemented by classes that can be executed. It is used to implement threads that are not a subclass of the Thread class.
The java.net package provides a set of classes that implement socket-based client/server networking.
The ContentHandler class is used to extract and process an object that is read from an URLConnection object.
The DatagramPacket class encapsulates a datagram object that is read or written from a UDP socket.
The DatagramSocket class is used to implement a UDP socket for the transmission and reception of datagrams.
The InetAddress class provides an encapsulation of an Internet host and IP address.
The ServerSocket provides the capability to create TCP sockets that can be used to implement a server application.
The Socket class is used to implement a socket used by a client program.
The SocketImpl class is used to tailor the implementation of Java socket classes to a specific platform or network environment.
The URL class encapsulates URLs and provides a common set of methods for accessing the network resources referenced by an URL.
The URLConnection class is used to manage the HTTP connection created with the resource specified by an URL.
The URLEncoder class is used to encode information in a format that is suitable for communication via an URL.
The URLStreamHandler class is used to implement an URLConnection for different protocol types.
The ContentHandlerFactory interface is used to associate ContentHandler objects with MIME types.
The SocketImplFactory interface is used to create objects of the SocketImpl class.
The URLStreamHandlerFactory interface is used to associate an URLStreamHandler object with a protocol type.
The java.util package provides a collection of classes that support a variety of common programming functions.
The BitSet class is used to implement a compact set of bits that can be individually or collectively accessed.
The Date class provides access to the current date and time in a system-independent manner.
The Dictionary class is used to create data container objects that enable data values to be accessed by their associated keys.
The Hashtable class is a subclass of the Dictionary class that allows a collection of objects to be accessed by a hash code value.
The Observable class enables objects to be constructed that inform observer objects as they are updated. The observer objects must implement the Observer interface.
The Properties class is a subclass of Hashtable that can be saved or loaded from a stream.
The Random class is used to implement random number generators.
The Stack class is used to create a stack of objects.
The StringTokenizer class is used to parse a String object into a set of tokens.
The Vector class implements a growable array.
The Enumeration interface provides a set of methods for indexing through a set of objects.
The Observer interface is implemented by classes that observe objects of the Observable class.