Java 1.4 Doc Inverted Index

Java 1.4 Class Documentation Inverted Index

Inverted Index: R

`org.w3c.dom.DOMException`	DOMException: DOM operations only	raise exceptions in "exceptional" circumstances, i.e., when an operation is impossible to perform either for logical reasons, because data is lost, or because the implementation has become unstable .
`java.util.AbstractList`	AbstractList: This class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface backed by a	"random access" data store such as an array .
`java.io.RandomAccessFile`	RandomAccessFile: Instances of this class support both reading and writing to a	random access file.
`java.util.RandomAccess`	RandomAccess: Marker interface used by List implementations to indicate that they support fast generally constant time	random access.
`java.util.RandomAccess`		RandomAccess: Marker interface used by List implementations to indicate that they support fast generally constant time random access.
`javax.imageio.stream.FileImageOutputStream`	FileImageOutputStream: An implementation of ImageOutputStream that writes its output directly to a File or	RandomAccessFile.
`java.io.RandomAccessFile`		RandomAccessFile: Instances of this class support both reading and writing to a random access file.
`java.awt.font.TextMeasurer`	The TextMeasurer class provides the primitive operations needed for line break: measuring up to a given advance, determining the advance of a	range of characters, and generating a TextLayout for a range of characters.
`java.text.ChoiceFormat`	A ChoiceFormat allows you to attach a format to a	range of numbers.
`java.rmi.server.RemoteStub`	The RemoteStub class is the common superclass to client stubs and provides the framework to support a wide	range of remote reference semantics.
`java.awt.Adjustable`	Adjustable: The interface for objects which have an adjustable numeric value contained within a bounded	range of values.
`javax.print.attribute.standard.PageRanges`	Class PageRanges is a printing attribute class, a set of integers, that identifies the	range s of print-stream pages that the Printer object uses for each copy of each document which are to be printed.
`java.lang.IndexOutOfBoundsException`	IndexOutOfBoundsException: Thrown to indicate that an index of some sort such as to an array, to a string, or to a vector is out of	range.
`java.awt.image.RasterOp`	RasterOp: This interface describes single-input/single-output operations performed on	Raster objects.
`java.awt.image.AffineTransformOp`	AffineTransformOp: This class uses an affine transform to perform a linear mapping from 2D coordinates in the source image or	Raster to 2D coordinates in the destination image or Raster.
`java.awt.image.WritableRaster`	This class extends	Raster to provide pixel writing capabilities.
`java.awt.image.BandCombineOp`	BandCombineOp: This class performs an arbitrary linear combination of the bands in a	Raster, using a specified matrix.
`java.awt.image.RasterFormatException`	The RasterFormatException is thrown if there is invalid layout information in the {@link	Raster}.
`java.awt.image.RasterFormatException`	The	RasterFormatException is thrown if there is invalid layout information in the {@link Raster}.
`java.awt.image.RasterOp`		RasterOp: This interface describes single-input/single-output operations performed on Raster objects.
`java.awt.image.ImagingOpException`	The ImagingOpException is thrown if one of the {@link BufferedImageOp} or {@link	RasterOp} filter methods cannot process the image.
`java.awt.image.WritableRenderedImage`	WriteableRenderedImage is a common interface for objects which contain or can produce image data in the form of	Rasters and which can be modified and/or written over.
`java.awt.image.RenderedImage`	RenderedImage is a common interface for objects which contain or can produce image data in the form of	Rasters.
`java.awt.DisplayMode`	The DisplayMode class encapsulates the bit depth, height, width, and refresh	rate of a GraphicsDevice.
`java.applet.Applet`	An applet is a small program that is intended not to be run on its own, but	rather to be embedded inside another application.
`java.lang.ref.ReferenceQueue`	ReferenceQueue: Reference queues, to which registered reference objects are appended by the garbage collector after the appropriate	reachability changes are detected.
`javax.naming.CannotProceedException`	This exception is thrown to indicate that the operation	reached a point in the name where the operation cannot proceed any further.
`...print.attribute.standard.NumberOfDocuments`	Class NumberOfDocuments is an integer valued printing attribute that indicates the number of individual docs the printer has accepted for this job, regardless of whether the docs' print data has	reached the printer or not.
`java.io.EOFException`	EOFException: Signals that an end of file or end of stream has been	reached unexpectedly during input.
`java.text.ParseException`	ParseException: Signals that an error has been	reached unexpectedly while parsing.
`javax.naming.LinkLoopException`	LinkLoopException: This exception is thrown when a loop was detected will attempting to resolve a link, or an implementation specific limit on link counts has been	reached.
`java.nio.BufferUnderflowException`	BufferUnderflowException: Unchecked exception thrown when a relative get operation	reaches the source buffer's limit.
`java.nio.BufferOverflowException`	BufferOverflowException: Unchecked exception thrown when a relative put operation	reaches the target buffer's limit.
`java.lang.ClassFormatError`	ClassFormatError: Thrown when the Java Virtual Machine attempts to	read a class file and determines that the file is malformed or otherwise cannot be interpreted as a class file.
`java.lang.UnsupportedClassVersionError`	UnsupportedClassVersionError: Thrown when the Java Virtual Machine attempts to	read a class file and determines that the major and minor version numbers in the file are not supported.
`java.net.ContentHandler`	The abstract class ContentHandler is the superclass of all classes that	read an Object from a URLConnection.
`java.nio.channels.ByteChannel`	A channel that can	read and write bytes.
`java.beans.IndexedPropertyDescriptor`	An IndexedPropertyDescriptor describes a property that acts like an array and has an indexed	read and/or indexed write method to access specific elements of the array.
`java.io.StringBufferInputStream`	StringBufferInputStream: This class allows an application to create an input stream in which the bytes	read are supplied by the contents of a string.
`java.nio.channels.ScatteringByteChannel`	ScatteringByteChannel: A channel that can	read bytes into a sequence of buffers.
`java.nio.channels.ReadableByteChannel`	ReadableByteChannel: A channel that can	read bytes.
`java.util.zip.ZipFile`	ZipFile: This class is used to	read entries from a zip file.
`...nio.channels.NonReadableChannelException`	NonReadableChannelException: Unchecked exception thrown when an attempt is made to	read from a channel that was not originally opened for reading.
`java.io.StreamCorruptedException`	StreamCorruptedException: Thrown when control information that was	read from an object stream violates internal consistency checks.
`java.io.ObjectInputStream.GetField`	GetField: Provide access to the persistent fields	read from the input stream.
`java.io.ByteArrayInputStream`	A ByteArrayInputStream contains an internal buffer that contains bytes that may be	read from the stream.
`java.io.UTFDataFormatException`	UTFDataFormatException: Signals that a malformed UTF-8 string has been	read in a data input stream or by any class that implements the data input interface.
`java.io.StreamTokenizer`	The StreamTokenizer class takes an input stream and parses it into "tokens", allowing the tokens to be	read one at a time.
`java.io.OptionalDataException`	Exception indicating the failure of an object	read operation due to unread primitive data, or the end of data belonging to a serialized object in the stream.
`java.net.SocketTimeoutException`	SocketTimeoutException: Signals that a timeout has occurred on a socket	read or accept.
`java.io.DataInputStream`	DataInputStream: A data input stream lets an application	read primitive Java data types from an underlying input stream in a machine-independent way.
`java.io.BufferedReader`		Read text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
`java.util.jar.JarFile`	The JarFile class is used to	read the contents of a JAR file from any file that can be opened with java.io.RandomAccessFile.
`java.util.jar.JarInputStream`	The JarInputStream class is used to	read the contents of a JAR file from any input stream.
`java.beans.XMLDecoder`	The XMLDecoder class is used to	read XML documents created using the XMLEncoder and is used just like the ObjectInputStream.
`java.util.zip.CheckedInputStream`	CheckedInputStream: An input stream that also maintains a checksum of the data being	read.
`java.nio.ReadOnlyBufferException`	ReadOnlyBufferException: Unchecked exception thrown when a content-mutation method such as put or compact is invoked upon a	read-only buffer.
`java.nio.channels.Pipe.SourceChannel`	SourceChannel: A channel representing the	readable end of a {@link Pipe}.
`java.util.logging.SimpleFormatter`	SimpleFormatter: Print a brief summary of the LogRecord in a human	readable format.
`java.lang.CharSequence`	A CharSequence is a	readable sequence of characters.
`java.nio.channels.ReadableByteChannel`		ReadableByteChannel: A channel that can read bytes.
`...imageio.plugins.jpeg.JPEGImageReadParam`	This class adds the ability to set JPEG quantization and Huffman tables when using the built-in JPEG	reader plug-in.
`java.io.PushbackReader`	PushbackReader: A character-stream	reader that allows characters to be pushed back into the stream.
`org.xml.sax.helpers.XMLReaderFactory`	Factory for creating an XML	reader.
`java.io.Reader`		Reader: Abstract class for reading character streams.
`org.xml.sax.XMLReader`	Interface for	reading an XML document using callbacks.
`javax.imageio.IIOException`	IIOException: An exception class used for signaling run-time failure of	reading and writing operations.
`java.io.RandomAccessFile`	RandomAccessFile: Instances of this class support both	reading and writing to a random access file.
`java.io.DataInput`	The DataInput interface provides for	reading bytes from a binary stream and reconstructing from them data in any of the Java primitive types.
`java.io.FileReader`	Convenience class for	reading character files.
`java.io.Reader`	Reader: Abstract class for	reading character streams.
`java.util.zip.GZIPInputStream`	GZIPInputStream: This class implements a stream filter for	reading compressed data in the GZIP format.
`java.util.zip.ZipInputStream`	ZipInputStream: This class implements an input stream filter for	reading files in the ZIP file format.
`java.io.FilterReader`	Abstract class for	reading filtered character streams.
`java.util.jar.JarException`	JarException: Signals that an error of some sort has occurred while	reading from or writing to a JAR file.
`javax.imageio.event.IIOReadUpdateListener`	IIOReadUpdateListener: An interface used by ImageReader implementations to notify callers of their image and thumbnail	reading methods of pixel updates.
`...imageio.event.IIOReadProgressListener`	IIOReadProgressListener: An interface used by ImageReader implementations to notify callers of their image and thumbnail	reading methods of progress.
`...imageio.event.IIOWriteWarningListener`	An interface used by ImageWriter implementations to notify callers of their image and thumbnail	reading methods of warnings non-fatal errors .
`java.io.BufferedReader`	Read text from a character-input stream, buffering characters so as to provide for the efficient	reading of characters, arrays, and lines.
`java.io.ObjectInput`	ObjectInput extends the DataInput interface to include the	reading of objects.
`java.nio.channels.FileChannel`	FileChannel: A channel for	reading, writing, mapping, and manipulating a file.
`...nio.channels.NonReadableChannelException`	NonReadableChannelException: Unchecked exception thrown when an attempt is made to read from a channel that was not originally opened for	reading.
`java.nio.ReadOnlyBufferException`		ReadOnlyBufferException: Unchecked exception thrown when a content-mutation method such as put or compact is invoked upon a read-only buffer.
`java.io.InputStreamReader`	An InputStreamReader is a bridge from byte streams to character streams: It	reads bytes and decodes them into characters using a specified {@link java.nio.charset.Charset charset}.
`java.sql.DataTruncation`	An exception that reports a DataTruncation warning on	reads or throws a DataTruncation exception on writes when JDBC unexpectedly truncates a data value.
`java.security.Identity`	This class represents identities:	real-world objects such as people, companies or organizations whose identities can be authenticated using their public keys.
`java.awt.Graphics`	The Graphics class is the abstract base class for all graphics contexts that allow an application to draw onto components that are	realized on various devices, as well as onto off-screen images.
`java.lang.Exception`	The class Exception and its subclasses are a form of Throwable that indicates conditions that a	reasonable application might want to catch.
`java.lang.Error`	An Error is a subclass of Throwable that indicates serious problems that a	reasonable application should not try to catch.
`...attribute.standard.JobMessageFromOperator`	Class JobMessageFromOperator is a printing attribute class, a text attribute, that provides a message from an operator, system administrator, or "intelligent" process to indicate to the end user the	reasons for modification or other management action taken on a job.
`org.w3c.dom.DOMException`	DOMException: DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impossible to perform either for logical	reasons, because data is lost, or because the implementation has become unstable .
`java.rmi.AccessException`	An AccessException is thrown by certain methods of the java.rmi.Naming class specifically bind,	rebind, and unbind and methods of the java.rmi.activation.ActivationSystem interface to indicate that the caller does not have permission to perform the action requested by the method call.
`org.xml.sax.DTDHandler`		Receive notification of basic DTD-related events.
`org.xml.sax.DocumentHandler`	DocumentHandler:	Receive notification of general document events.
`org.xml.sax.ContentHandler`		Receive notification of the logical content of a document.
`java.rmi.server.Unreferenced`	A remote object implementation should implement the Unreferenced interface to	receive notification when there are no more clients that reference that remote object.
`...nio.channels.AsynchronousCloseException`	AsynchronousCloseException: Checked exception	received by a thread when another thread closes the channel or the part of the channel upon which it is blocked in an I/O operation.
`...nio.channels.ClosedByInterruptException`	ClosedByInterruptException: Checked exception	received by a thread when another thread interrupts it while it is blocked in an I/O operation upon a channel.
`...nio.channels.FileLockInterruptionException`	FileLockInterruptionException: Checked exception	received by a thread when another thread interrupts it while it is waiting to acquire a file lock.
`java.net.PortUnreachableException`	PortUnreachableException: Signals that an ICMP Port Unreachable message has been	received on a connected datagram.

`java.rmi.server.SkeletonMismatchException`	SkeletonMismatchException: This exception is thrown when a call is	received that does not match the available skeleton.
`java.lang.InheritableThreadLocal`	InheritableThreadLocal: This class extends ThreadLocal to provide inheritance of values from parent thread to child thread: when a child thread is created, the child	receives initial values for all inheritable thread-local variables for which the parent has values.
`java.rmi.UnexpectedException`	An UnexpectedException is thrown if the client of a remote method call	receives, as a result of the call, a checked exception that is not among the checked exception types declared in the throws clause of the method in the remote interface.
`java.awt.event.MouseListener`	The listener interface for	receiving "interesting" mouse events press, release, click, enter, and exit on a component.
`java.awt.event.ActionListener`	The listener interface for	receiving action events.
`java.awt.event.AdjustmentListener`	AdjustmentListener: The listener interface for	receiving adjustment events.
`java.awt.event.HierarchyBoundsListener`	The listener interface for	receiving ancestor moved and resized events.
`...beancontext.BeanContextServicesListener`	BeanContextServicesListener: The listener interface for	receiving BeanContextServiceAvailableEvent objects.
`...BeanContextServiceRevokedListener`	BeanContextServiceRevokedListener: The listener interface for	receiving BeanContextServiceRevokedEvent objects.
`java.awt.event.ComponentAdapter`	ComponentAdapter: An abstract adapter class for	receiving component events.
`java.awt.event.ContainerListener`	The listener interface for	receiving container events.
`java.net.DatagramSocket`	This class represents a socket for sending and	receiving datagram packets.
`java.awt.dnd.DragSourceAdapter`	DragSourceAdapter: An abstract adapter class for	receiving drag source events.
`java.awt.dnd.DropTargetAdapter`	DropTargetAdapter: An abstract adapter class for	receiving drop target events.
`java.awt.event.HierarchyListener`	The listener interface for	receiving hierarchy changed events.
`java.awt.event.InputMethodListener`	InputMethodListener: The listener interface for	receiving input method events.
`java.net.MulticastSocket`	The multicast datagram socket class is useful for sending and	receiving IP multicast packets.
`java.awt.event.ItemListener`	The listener interface for	receiving item events.
`java.awt.event.KeyListener`	The listener interface for	receiving keyboard events keystrokes .
`java.awt.event.KeyAdapter`	KeyAdapter: An abstract adapter class for	receiving keyboard events.
`java.awt.event.FocusListener`	The listener interface for	receiving keyboard focus events on a component.
`java.awt.event.FocusAdapter`	FocusAdapter: An abstract adapter class for	receiving keyboard focus events.
`java.awt.event.MouseAdapter`	MouseAdapter: An abstract adapter class for	receiving mouse events.
`java.awt.dnd.DragSourceMotionListener`	DragSourceMotionListener: A listener interface for	receiving mouse motion events during a drag operation.
`java.awt.event.MouseMotionListener`	The listener interface for	receiving mouse motion events on a component.
`java.awt.event.MouseMotionAdapter`	MouseMotionAdapter: An abstract adapter class for	receiving mouse motion events.
`java.awt.event.MouseWheelListener`	The listener interface for	receiving mouse wheel events on a component.
`java.awt.event.AWTEventListener`	The listener interface for	receiving notification of events dispatched to objects that are instances of Component or MenuComponent or their subclasses.
`java.awt.image.ImageObserver`	ImageObserver: An asynchronous update interface for	receiving notifications about Image information as the Image is constructed.
`java.util.prefs.PreferenceChangeListener`	PreferenceChangeListener: A listener for	receiving preference change events.
`java.util.prefs.NodeChangeListener`	NodeChangeListener: A listener for	receiving preference node change events.
`javax.print.event.PrintJobAdapter`	PrintJobAdapter: An abstract adapter class for	receiving print job events.
`java.awt.event.TextListener`	The listener interface for	receiving text events.
`java.awt.event.WindowAdapter`	WindowAdapter: An abstract adapter class for	receiving window events.
`java.awt.event.WindowStateListener`	The listener interface for	receiving window state events.
`java.awt.event.WindowFocusListener`	The listener interface for	receiving WindowEvents, including WINDOW_GAINED_FOCUS and WINDOW_LOST_FOCUS events.
`java.lang.ref.PhantomReference`	PhantomReference: Phantom reference objects, which are enqueued after the collector determines that their referents may otherwise be	reclaimed.
`...auth.callback.UnsupportedCallbackException`	UnsupportedCallbackException: Signals that a CallbackHandler does not	recognize a particular Callback.
`java.io.DataInput`	The DataInput interface provides for reading bytes from a binary stream and	reconstructing from them data in any of the Java primitive types.
`java.util.logging.ConsoleHandler`	This Handler publishes log	records to System.err.
`java.security.UnrecoverableKeyException`	UnrecoverableKeyException: This exception is thrown if a key in the keystore cannot be	recovered.
`java.awt.geom.Rectangle2D`	The Rectangle2D class describes a	rectangle defined by a location x, y and dimension w x h .
`java.awt.geom.Rectangle2D.Double`	The Double class defines a	rectangle specified in double coordinates.
`java.awt.geom.Rectangle2D.Float`	The Float class defines a	rectangle specified in float coordinates.
`java.awt.Rectangle`	A	Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's top-left point x, y in the coordinate space, its width, and its height.
`java.awt.geom.RoundRectangle2D.Double`	The Double class defines a	rectangle with rounded corners all specified in double coordinates.
`java.awt.geom.RoundRectangle2D.Float`	The Float class defines a	rectangle with rounded corners all specified in float coordinates.
`java.awt.geom.RoundRectangle2D`	The RoundRectangle2D class defines a	rectangle with rounded corners defined by a location x, y , a dimension w x h , and the width and height of an arc with which to round the corners.
`java.awt.geom.Arc2D`	Arc2D is the abstract superclass for all objects that store a 2D arc defined by a bounding	rectangle, start angle, angular extent length of the arc , and a closure type OPEN, CHORD, or PIE .
`java.awt.geom.Ellipse2D`	The Ellipse2D class describes an ellipse that is defined by a bounding	rectangle.
`java.awt.geom.Rectangle2D`	The	Rectangle2D class describes a rectangle defined by a location x, y and dimension w x h .
`java.awt.Canvas`	A Canvas component represents a blank	rectangular area of the screen onto which the application can draw or from which the application can trap input events from the user.
`java.awt.image.Raster`	A class representing a	rectangular array of pixels.
`java.awt.geom.RectangularShape`	RectangularShape is the base class for a number of {@link Shape} objects whose geometry is defined by a	rectangular frame.
`java.awt.GridLayout`	The GridLayout class is a layout manager that lays out a container's components in a	rectangular grid.
`java.awt.geom.RectangularShape`		RectangularShape is the base class for a number of {@link Shape} objects whose geometry is defined by a rectangular frame.
`java.lang.StackOverflowError`	StackOverflowError: Thrown when a stack overflow occurs because an application	recurses too deeply.
`java.awt.image.ColorModel`	The ColorModel abstract class encapsulates the methods for translating a pixel value to color components for example,	red, green, and blue and an alpha component.
`java.util.TreeMap`		Red-Black tree based implementation of the SortedMap interface.
`java.sql.Ref`	The mapping in the Java programming language of an SQL	REF value, which is a reference to an SQL structured type value in the database.
`org.w3c.dom.EntityReference`	EntityReference objects may be inserted into the structure model when an entity	reference is in the source document, or when the user wishes to insert an entity reference.
`java.security.acl.AclNotFoundException`	AclNotFoundException: This is an exception that is thrown whenever a	reference is made to a non-existent ACL Access Control List .
`java.lang.ref.SoftReference`	SoftReference: Soft	reference objects, which are cleared at the discretion of the garbage collector in response to memory demand.
`java.lang.ref.PhantomReference`	PhantomReference: Phantom	reference objects, which are enqueued after the collector determines that their referents may otherwise be reclaimed.
`java.lang.ref.WeakReference`	WeakReference: Weak	reference objects, which do not prevent their referents from being made finalizable, finalized, and then reclaimed.
`java.lang.ref.ReferenceQueue`	ReferenceQueue:	Reference queues, to which registered reference objects are appended by the garbage collector after the appropriate reachability changes are detected.
`java.rmi.server.RemoteStub`	The RemoteStub class is the common superclass to client stubs and provides the framework to support a wide range of remote	reference semantics.
`java.rmi.server.Unreferenced`	A remote object implementation should implement the Unreferenced interface to receive notification when there are no more clients that	reference that remote object.
`java.rmi.registry.LocateRegistry`	LocateRegistry is used to obtain a	reference to a bootstrap remote object registry on a particular host including the local host , or to create a remote object registry that accepts calls on a specific port.
`javax.imageio.stream.IIOByteBuffer`	A class representing a mutable	reference to an array of bytes and an offset and length within that array.
`javax.naming.Reference`	This class represents a	reference to an object that is found outside of the naming/directory system.
`java.sql.Ref`	The mapping in the Java programming language of an SQL REF value, which is a	reference to an SQL structured type value in the database.
`javax.naming.Referenceable`	This interface is implemented by an object that can provide a	Reference to itself.
`java.lang.Void`	The Void class is an uninstantiable placeholder class to hold a	reference to the Class object representing the Java keyword void.
`java.rmi.activation.ActivationGroupID`	The identifier for a registered activation group serves several purposes: identifies the group uniquely within the activation system, and contains a	reference to the group's activation system so that the group can contact its activation system when necessary.
`java.beans.beancontext.BeanContextChild`	JavaBeans wishing to be nested within, and obtain a	reference to their execution environment, or context, as defined by the BeanContext sub-interface shall implement this interface.
`javax.naming.LinkRef`	This class represents a	Reference whose contents is a name, called the link name, that is bound to an atomic name in a context.
`java.net.URISyntaxException`	URISyntaxException: Checked exception thrown to indicate that a string could not be parsed as a URI	reference.
`java.lang.ref.Reference`		Reference: Abstract base class for reference objects.
`java.util.IdentityHashMap`	This class implements the Map interface with a hash table, using	reference-equality in place of object-equality when comparing keys and values .
`java.sql.Savepoint`	The representation of a savepoint, which is a point within the current transaction that can be	referenced from the Connection.rollback method.
`java.lang.ref.ReferenceQueue`		ReferenceQueue: Reference queues, to which registered reference objects are appended by the garbage collector after the appropriate reachability changes are detected.
`java.rmi.server.UnicastRemoteObject`	The UnicastRemoteObject class defines a non-replicated remote object whose	references are valid only while the server process is alive.
`java.rmi.registry.Registry`	Registry is a remote interface to a simple remote object registry that provides methods for storing and retrieving remote object	references bound with arbitrary string names.
`java.rmi.Naming`	The Naming class provides methods for storing and obtaining	references to remote objects in the remote object registry.
`...standard.ReferenceUriSchemesSupported`	Class	ReferenceUriSchemesSupported is a printing attribute class an enumeration, that indicates a "URI scheme," such as "http:" or "ftp:", that a printer can use to retrieve print data stored at a URI location.
`java.lang.ref.WeakReference`	WeakReference: Weak reference objects, which do not prevent their	referents from being made finalizable, finalized, and then reclaimed.
`java.lang.ref.PhantomReference`	PhantomReference: Phantom reference objects, which are enqueued after the collector determines that their	referents may otherwise be reclaimed.
`javax.naming.ReferralException`	This abstract class is used to represent a	referral exception, which is generated in response to a referral such as that returned by LDAP v3 servers.
`javax.naming.ldap.LdapReferralException`	This abstract class is used to represent an LDAP	referral exception.
`javax.naming.spi.NamingManager`	This class contains methods for creating context objects and objects	referred to by location information in the naming or directory service.
`java.net.URLClassLoader`	This class loader is used to load classes and resources from a search path of URLs	referring to both JAR files and directories.
`java.lang.reflect.ReflectPermission`	The Permission class for	reflective operations.
`java.lang.IllegalAccessException`	An IllegalAccessException is thrown when an application tries to	reflectively create an instance other than an array , set or get a field, or invoke a method, but the currently executing method does not have access to the definition of the specified class, field, method or constructor.
`java.lang.reflect.Member`	Member is an interface that	reflects identifying information about a single member a field or a method or a constructor.
`javax.security.auth.Refreshable`	Refreshable: Objects such as credentials may optionally implement this interface to provide the capability to	refresh itself.
`javax.security.auth.RefreshFailedException`	RefreshFailedException: Signals that a	refresh operation failed.
`java.awt.DisplayMode`	The DisplayMode class encapsulates the bit depth, height, width, and	refresh rate of a GraphicsDevice.
`javax.security.auth.Refreshable`		Refreshable: Objects such as credentials may optionally implement this interface to provide the capability to refresh itself.
`javax.security.auth.RefreshFailedException`		RefreshFailedException: Signals that a refresh operation failed.

`java.rmi.ConnectException`	A ConnectException is thrown if a connection is	refused to the remote host for a remote method call.
`org.w3c.dom.CDATASection`	CDATA sections are used to escape blocks of text containing characters that would otherwise be	regarded as markup.
`...print.attribute.standard.NumberOfDocuments`	Class NumberOfDocuments is an integer valued printing attribute that indicates the number of individual docs the printer has accepted for this job,	regardless of whether the docs' print data has reached the printer or not.
`...nio.channels.OverlappingFileLockException`	OverlappingFileLockException: Unchecked exception thrown when an attempt is made to acquire a lock on a	region of a file that overlaps a region already locked by the same Java virtual machine, or when another thread is already waiting to lock an overlapping region of the same file.
`java.nio.MappedByteBuffer`	MappedByteBuffer: A direct byte buffer whose content is a memory-mapped	region of a file.
`java.awt.dnd.Autoscroll`	Autoscroll: During DnD operations it is possible that a user may wish to drop the subject of the operation on a	region of a scrollable GUI control that is not currently visible to the user.
`java.awt.TextArea`	A TextArea object is a multi-line	region that displays text.
`java.awt.Polygon`	The Polygon class encapsulates a description of a closed, two-dimensional	region within a coordinate space.
`java.util.Locale`	A Locale object represents a specific geographical, political, or cultural	region.
`java.awt.BorderLayout`	A border layout lays out a container, arranging and resizing its components to fit in five	regions: north, south, east, west, and center.
`java.nio.channels.IllegalSelectorException`	IllegalSelectorException: Unchecked exception thrown when an attempt is made to	register a channel with a selector that was not created by the provider that created the channel.
`javax.xml.transform.ErrorListener`	To provide customized error handling, implement this interface and use the setErrorListener method to	register an instance of the implmentation with the {@link javax.xml.transform.Transformer}.
`javax.rmi.PortableRemoteObject`	Server implementation objects may either inherit from javax.rmi.PortableRemoteObject or they may implement a remote interface and then use the exportObject method to	register themselves as a server object.
`javax.imageio.spi.RegisterableService`		RegisterableService: An optional interface that may be provided by service provider objects that will be registered with a ServiceRegistry.
`java.rmi.activation.ActivationGroupID`	The identifier for a	registered activation group serves several purposes: identifies the group uniquely within the activation system, and contains a reference to the group's activation system so that the group can contact its activation system when necessary.
`java.lang.ref.ReferenceQueue`	ReferenceQueue: Reference queues, to which	registered reference objects are appended by the garbage collector after the appropriate reachability changes are detected.
`java.rmi.server.RMIFailureHandler`	An RMIFailureHandler can be	registered via the RMISocketFactory.setFailureHandler call.
`javax.imageio.spi.RegisterableService`	RegisterableService: An optional interface that may be provided by service provider objects that will be	registered with a ServiceRegistry.
`java.awt.dnd.DragSourceDropEvent`	The DragSourceDropEvent is delivered from the DragSourceContextPeer, via the DragSourceContext, to the dragDropEnd method of DragSourceListeners	registered with that DragSourceContext and with its associated DragSource.
`...AccessibleContainerHandler`	AccessibleContainerHandler: Fire PropertyChange listener, if one is	registered, when children are added or removed.
`...AccessibleAWTFocusHandler`	AccessibleAWTFocusHandler: Fire PropertyChange listener, if one is	registered, when focus events happen
`...AccessibleAWTComponentHandler`	AccessibleAWTComponentHandler: Fire PropertyChange listener, if one is	registered, when shown/hidden..
`...BeanContextServiceAvailableEvent`	BeanContextServiceAvailableEvent: This event type is used by the BeanContextServicesListener in order to identify the service being	registered.
`java.rmi.activation.ActivationSystem`	The ActivationSystem provides a means for	registering groups and "activatable" objects to be activated within those groups.
`javax.naming.event.EventDirContext`	EventDirContext: Contains methods for	registering listeners to be notified of events fired when objects named in a directory context changes.
`javax.naming.event.EventContext`	Contains methods for	registering/deregistering listeners to be notified of events fired when objects named in a context changes.
`javax.sql.ConnectionEventListener`	An object that	registers to be notified of events generated by a PooledConnection object.
`java.nio.channels.SelectionKey`	SelectionKey: A token representing the	registration of a {@link SelectableChannel} with a {@link Selector}.
`java.rmi.NotBoundException`	A NotBoundException is thrown if an attempt is made to lookup or unbind in the	registry a name that has no associated binding.
`javax.imageio.spi.ServiceRegistry`	ServiceRegistry: A	registry for service provider instances.
`java.rmi.registry.Registry`		Registry is a remote interface to a simple remote object registry that provides methods for storing and retrieving remote object references bound with arbitrary string names.
`java.rmi.registry.LocateRegistry`	LocateRegistry is used to obtain a reference to a bootstrap remote object	registry on a particular host including the local host , or to create a remote object registry that accepts calls on a specific port.
`java.rmi.AlreadyBoundException`	An AlreadyBoundException is thrown if an attempt is made to bind an object in the	registry to a name that already has an associated binding.
`java.rmi.Naming`	The Naming class provides methods for storing and obtaining references to remote objects in the remote object	registry.
`java.rmi.registry.RegistryHandler`		RegistryHandler is an interface used internally by the RMI runtime in previous implementation versions.
`java.util.regex.Pattern`	A compiled representation of a	regular expression.
`...imageio.stream.MemoryCacheImageInputStream`	MemoryCacheImageInputStream: An implementation of ImageInputStream that gets its input from a	regular InputStream.
`...stream.MemoryCacheImageOutputStream`	MemoryCacheImageOutputStream: An implementation of ImageOutputStream that writes its output to a	regular OutputStream.
`java.util.regex.PatternSyntaxException`	PatternSyntaxException: Unchecked exception thrown to indicate a syntax error in a	regular-expression pattern.
`java.text.AttributedCharacterIterator`	An AttributedCharacterIterator allows iteration through both text and	related attribute information.
`java.awt.MenuContainer`	MenuContainer: The super class of all menu	related containers.
`...awt.datatransfer.MimeTypeParseException`	MimeTypeParseException: A class to encapsulate MimeType parsing	related exceptions
`javax.security.auth.Subject`	A Subject represents a grouping of	related information for a single entity, such as a person.
`java.lang.Compiler`	The Compiler class is provided to support Java-to-native-code compilers and	related services.
`javax.accessibility.AccessibleRelation`	Class AccessibleRelation describes a	relation between the object that implements the AccessibleRelation and one or more other objects.
`javax.accessibility.AccessibleRelationSet`	Class AccessibleRelationSet determines a component's	relation set.
`...attribute.standard.NumberOfInterveningJobs`	Class NumberOfInterveningJobs is an integer valued printing attribute that indicates the number of jobs that are ahead of this job in the	relative chronological order of expected time to complete i.e., the current scheduled order .
`java.nio.BufferUnderflowException`	BufferUnderflowException: Unchecked exception thrown when a	relative get operation reaches the source buffer's limit.
`java.nio.BufferOverflowException`	BufferOverflowException: Unchecked exception thrown when a	relative put operation reaches the target buffer's limit.
`java.awt.datatransfer.FlavorTable`	A FlavorMap which	relaxes the traditional 1-to-1 restriction of a Map.
`java.awt.event.MouseListener`	The listener interface for receiving "interesting" mouse events press,	release, click, enter, and exit on a component.
`java.awt.image.TileObserver`	TileObserver: An interface for objects that wish to be informed when tiles of a WritableRenderedImage become modifiable by some writer via a call to getWritableTile, and when they become unmodifiable via the last call to	releaseWritableTile.
`java.security.spec.RSAPrivateCrtKeySpec`	RSAPrivateCrtKeySpec: This class specifies an RSA private key, as defined in the PKCS#1 standard, using the Chinese	Remainder Theorem CRT information values for efficiency.
`java.security.interfaces.RSAPrivateCrtKey`	RSAPrivateCrtKey: The interface to an RSA private key, as defined in the PKCS#1 standard, using the Chinese	Remainder Theorem CRT information values.
`java.net.NoRouteToHostException`	NoRouteToHostException: Signals that an error occurred while attempting to connect a socket to a	remote address and port.
`java.rmi.MarshalException`	A MarshalException is thrown if a java.io.IOException occurs while marshalling the	remote call header, arguments or return value for a remote method call.
`...rmi.activation.ActivateFailedException`	ActivateFailedException: This exception is thrown by the RMI runtime when activation fails during a	remote call to an activatable object.
`java.rmi.server.ServerCloneException`	A ServerCloneException is thrown if a	remote exception occurs during the cloning of a UnicastRemoteObject.
`java.rmi.UnknownHostException`	An UnknownHostException is thrown if a java.net.UnknownHostException occurs while creating a connection to the	remote host for a remote method call.
`javax.rmi.PortableRemoteObject`	Server implementation objects may either inherit from javax.rmi.PortableRemoteObject or they may implement a	remote interface and then use the exportObject method to register themselves as a server object.
`java.rmi.Remote`	The	Remote interface serves to identify interfaces whose methods may be invoked from a non-local virtual machine.
`java.rmi.registry.Registry`	Registry is a	remote interface to a simple remote object registry that provides methods for storing and retrieving remote object references bound with arbitrary string names.
`java.rmi.UnmarshalException`	An UnmarshalException can be thrown while unmarshalling the parameters or results of a	remote method call if any of the following conditions occur: if an exception occurs while unmarshalling the call header if the protocol for the return value is invalid if a java.io.IOException occurs unmarshalling parameters on the server side or the return value on the client side .
`java.rmi.UnexpectedException`	An UnexpectedException is thrown if the client of a	remote method call receives, as a result of the call, a checked exception that is not among the checked exception types declared in the throws clause of the method in the remote interface.
`java.rmi.RemoteException`	A RemoteException is the common superclass for a number of communication-related exceptions that may occur during the execution of a	remote method call.
`java.rmi.ServerException`	A ServerException is thrown as a result of a	remote method invocation when a RemoteException is thrown while processing the invocation on the server, either while unmarshalling the arguments, executing the remote method itself, or marshalling the return value.
`java.rmi.ServerRuntimeException`	From a server executing on JDK 1.1, a ServerRuntimeException is thrown as a result of a	remote method invocation when a RuntimeException is thrown while processing the invocation on the server, either while unmarshalling the arguments, executing the remote method itself, or marshalling the return value.
`java.rmi.ServerError`	A ServerError is thrown as a result of a	remote method invocation when an Error is thrown while processing the invocation on the server, either while unmarshalling the arguments, executing the remote method itself, or marshalling the return value.
`java.rmi.activation.Activator`	The Activator facilitates	remote object activation.
`java.rmi.server.SkeletonNotFoundException`	A SkeletonNotFoundException is thrown if the Skeleton corresponding to the	remote object being exported is not found.
`java.rmi.server.SocketSecurityException`	A SocketSecurityException is thrown during	remote object export if the code exporting the remote object either by construction or by explicit call to the exportObject method of UnicastRemoteObject or java.rmi.activation.Activatable does not have permission to create a java.net.ServerSocket on the port number specified during remote object export.
`java.rmi.server.ObjID`	An ObjID is used to identify a	remote object exported to an RMI runtime.
`java.rmi.server.ExportException`	An ExportException is a RemoteException thrown if an attempt to export a	remote object fails.
`java.rmi.server.Unreferenced`	A	remote object implementation should implement the Unreferenced interface to receive notification when there are no more clients that reference that remote object.
`java.rmi.server.ServerRef`	A ServerRef represents the server-side handle for a	remote object implementation.
`java.rmi.registry.LocateRegistry`	LocateRegistry is used to obtain a reference to a bootstrap	remote object registry on a particular host including the local host , or to create a remote object registry that accepts calls on a specific port.
`java.rmi.StubNotFoundException`	A StubNotFoundException is thrown if a valid stub class could not be found for a	remote object when it is exported.
`java.rmi.server.UnicastRemoteObject`	The UnicastRemoteObject class defines a non-replicated	remote object whose references are valid only while the server process is alive.
`java.rmi.server.RemoteRef`	RemoteRef represents the handle for a	remote object.
`java.rmi.Naming`	The Naming class provides methods for storing and obtaining references to	remote objects in the remote object registry.
`java.rmi.activation.ActivationID`	Activation makes use of special identifiers to denote	remote objects that can be activated over time.
`java.rmi.activation.Activatable`	The Activatable class provides support for	remote objects that require persistent access over time and that can be activated by the system.
`java.rmi.server.RemoteCall`	RemoteCall is an abstraction used solely by the RMI runtime in conjunction with stubs and skeletons of	remote objects to carry out a call to a remote object.
`java.rmi.server.RemoteObject`	The RemoteObject class implements the java.lang.Object behavior for	remote objects.
`java.rmi.server.RemoteStub`	The RemoteStub class is the common superclass to client stubs and provides the framework to support a wide range of	remote reference semantics.
`java.rmi.NoSuchObjectException`	A NoSuchObjectException is thrown if an attempt is made to invoke a method on an object that no longer exists in the	remote virtual machine.
`java.rmi.server.RemoteCall`		RemoteCall is an abstraction used solely by the RMI runtime in conjunction with stubs and skeletons of remote objects to carry out a call to a remote object.
`java.rmi.RemoteException`	A	RemoteException is the common superclass for a number of communication-related exceptions that may occur during the execution of a remote method call.
`java.rmi.ServerException`	A ServerException is thrown as a result of a remote method invocation when a	RemoteException is thrown while processing the invocation on the server, either while unmarshalling the arguments, executing the remote method itself, or marshalling the return value.
`java.rmi.server.ExportException`	An ExportException is a	RemoteException thrown if an attempt to export a remote object fails.
`java.rmi.server.RemoteObject`	The	RemoteObject class implements the java.lang.Object behavior for remote objects.
`java.rmi.server.RemoteRef`		RemoteRef represents the handle for a remote object.
`java.rmi.server.RemoteServer`	The	RemoteServer class is the common superclass to server implementations and provides the framework to support a wide range of remote reference semantics.
`java.rmi.server.ServerNotActiveException`	An ServerNotActiveException is an Exception thrown during a call to	RemoteServer.getClientHost if the getClientHost method is called outside of servicing a remote method call.
`java.rmi.server.RemoteStub`	The	RemoteStub class is the common superclass to client stubs and provides the framework to support a wide range of remote reference semantics.
`...beancontext.BeanContextSupport.BCSIterator`	BCSIterator: protected final subclass that encapsulates an iterator but implements a noop	remove method.
`...directory.AttributeModificationException`	This exception is thrown when an attempt is made to add, or	remove, or modify an attribute, its identifier, or its values that conflicts with the attribute's schema definition or the attribute's state.
`...beancontext.BeanContextMembershipEvent`	A BeanContextMembershipEvent encapsulates the list of children added to, or	removed from, the membership of a particular BeanContext.
`java.util.prefs.PreferenceChangeEvent`	An event emitted by a Preferences node to indicate that a preference has been added,	removed or has had its value changed.
`...AccessibleContainerHandler`	AccessibleContainerHandler: Fire PropertyChange listener, if one is registered, when children are added or	removed.

`java.awt.print.PrinterGraphics`	The PrinterGraphics interface is implemented by {@link java.awt.Graphics} objects that are passed to {@link Printable} objects to	render a page.
`java.awt.Font`	The Font class represents fonts, which are used to	render text in a visible way.
`...awt.image.renderable.RenderableImageOp`	RenderableImageOp: This class handles the	renderable aspects of an operation with help from its associated instance of a ContextualRenderedImageFactory.
`java.awt.image.renderable.RenderableImage`	A	RenderableImage is a common interface for rendering-independent images a notion which subsumes resolution independence .
`...image.renderable.RenderableImageProducer`	RenderableImageProducer: An adapter class that implements ImageProducer to allow the asynchronous production of a	RenderableImage.
`java.awt.image.renderable.ParameterBlock`	A ParameterBlock encapsulates all the information about sources and parameters Objects required by a	RenderableImageOp, or other classes that process images.
`...renderable.ContextualRenderedImageFactory`	ContextualRenderedImageFactory provides an interface for the functionality that may differ between instances of	RenderableImageOp.
`...awt.image.renderable.RenderableImageOp`		RenderableImageOp: This class handles the renderable aspects of an operation with help from its associated instance of a ContextualRenderedImageFactory.
`...image.renderable.RenderableImageProducer`		RenderableImageProducer: An adapter class that implements ImageProducer to allow the asynchronous production of a RenderableImage.
`java.awt.image.renderable.RenderContext`	A	RenderContext encapsulates the information needed to produce a specific rendering from a RenderableImage.
`...accessibility.AccessibleExtendedComponent`	The AccessibleExtendedComponent interface should be supported by any object that is	rendered on the screen.
`java.awt.BasicStroke`	The BasicStroke class defines a basic set of rendering attributes for the outlines of graphics primitives, which are	rendered with a {@link Graphics2D} object that has its Stroke attribute set to this BasicStroke.
`java.awt.image.RenderedImage`		RenderedImage is a common interface for objects which contain or can produce image data in the form of Rasters.
`...awt.image.renderable.RenderedImageFactory`	The	RenderedImageFactory interface often abbreviated RIF is intended to be implemented by classes that wish to act as factories to produce different renderings, for example by executing a series of BufferedImageOps on a set of sources, depending on a specific set of parameters, properties, and rendering hints.
`java.awt.RenderingHints.Key`	Key: Defines the base type of all keys used to control various aspects of the	rendering and imaging pipelines.
`java.awt.BasicStroke`	The BasicStroke class defines a basic set of	rendering attributes for the outlines of graphics primitives, which are rendered with a {@link Graphics2D} object that has its Stroke attribute set to this BasicStroke.
`java.awt.image.renderable.RenderContext`	A RenderContext encapsulates the information needed to produce a specific	rendering from a RenderableImage.
`java.awt.RenderingHints`	The RenderingHints class contains	rendering hints that can be used by the {@link java.awt.Graphics2D} class, and classes that implement {@link java.awt.image.BufferedImageOp} and {@link java.awt.image.Raster}.
`...awt.image.renderable.RenderedImageFactory`	The RenderedImageFactory interface often abbreviated RIF is intended to be implemented by classes that wish to act as factories to produce different renderings, for example by executing a series of BufferedImageOps on a set of sources, depending on a specific set of parameters, properties, and	rendering hints.
`java.awt.FontMetrics`	The FontMetrics class defines a font metrics object, which encapsulates information about the	rendering of a particular font on a particular screen.
`java.awt.font.TextAttribute`	The TextAttribute class defines attribute keys and attribute values used for text	rendering.
`java.awt.image.renderable.RenderableImage`	A RenderableImage is a common interface for	rendering-independent images a notion which subsumes resolution independence .
`java.awt.RenderingHints`	The	RenderingHints class contains rendering hints that can be used by the {@link java.awt.Graphics2D} class, and classes that implement {@link java.awt.image.BufferedImageOp} and {@link java.awt.image.Raster}.
`...awt.image.renderable.RenderedImageFactory`	The RenderedImageFactory interface often abbreviated RIF is intended to be implemented by classes that wish to act as factories to produce different	renderings, for example by executing a series of BufferedImageOps on a set of sources, depending on a specific set of parameters, properties, and rendering hints.
`...beancontext.BeanContextServiceProvider`	One of the primary functions of a BeanContext is to act a as	rendezvous between JavaBeans, and BeanContextServiceProviders.
`java.util.TimerTask`	TimerTask: A task that can be scheduled for one-time or	repeated execution by a Timer.
`java.awt.image.ReplicateScaleFilter`		ReplicateScaleFilter: An ImageFilter class for scaling images using the simplest algorithm.
`javax.print.FlavorException`	Interface FlavorException is a mixin interface which a subclass of {@link PrintException PrintException} can implement to	report an error condition involving a doc flavor or flavors class {@link javax.print.DocFlavor DocFlavor} .
`javax.print.URIException`	Interface URIException is a mixin interface which a subclass of {@link PrintException PrintException} can implement to	report an error condition involving a URI address.
`javax.print.AttributeException`	Interface AttributeException is a mixin interface which a subclass of {@link PrintException PrintException} can implement to	report an error condition involving one or more printing attributes that a particular Print Service instance does not support.
`java.rmi.activation.ActivationMonitor`	An ActivationMonitor is specific to an ActivationGroup and is obtained when a group is	reported active via a call to ActivationSystem.activeGroup this is done internally .
`javax.xml.transform.SourceLocator`	SourceLocator: This interface is primarily for the purposes of	reporting where an error occurred in the XML source or transformation instructions.
`javax.xml.transform.dom.DOMLocator`	Indicates the position of a node in a source DOM, intended primarily for error	reporting.
`java.sql.DataTruncation`	An exception that	reports a DataTruncation warning on reads or throws a DataTruncation exception on writes when JDBC unexpectedly truncates a data value.
`javax.print.event.PrintJobEvent`	Class PrintJobEvent encapsulates common events a print job	reports to let a listener know of progress in the processing of the {@link DocPrintJob}.
`...print.event.PrintServiceAttributeEvent`	Class PrintServiceAttributeEvent encapsulates an event a Print Service instance	reports to let the client know of changes in the print service state.
`javax.print.event.PrintJobAttributeEvent`	Class PrintJobAttributeEvent encapsulates an event a PrintService	reports to let the client know that one or more printing attributes for a PrintJob have changed.
`java.security.cert.CertStore`	A class for retrieving Certificates and CRLs from a	repository.
`java.net.URLConnection`	The abstract class URLConnection is the superclass of all classes that	represent a communications link between the application and a URL.
`java.security.acl.Group`	This interface is used to	represent a group of principals.
`java.util.jar.JarEntry`	JarEntry: This class is used to	represent a JAR file entry.
`javax.naming.ReferralException`	This abstract class is used to	represent a referral exception, which is generated in response to a referral such as that returned by LDAP v3 servers.
`java.util.zip.ZipEntry`	ZipEntry: This class is used to	represent a ZIP file entry.
`java.security.Signer`	Signer: This class is used to	represent an Identity that can also digitally sign data.
`javax.naming.ldap.LdapReferralException`	This abstract class is used to	represent an LDAP referral exception.
`java.security.Principal`	Principal: This interface represents the abstract notion of a principal, which can be used to	represent any entity, such as an individual, a corporation, and a login id.
`java.lang.Class`	Instances of the class Class	represent classes and interfaces in a running Java application.
`org.w3c.dom.NamedNodeMap`	Objects implementing the NamedNodeMap interface are used to	represent collections of nodes that can be accessed by name.
`java.awt.image.ComponentColorModel`	A ColorModel class that works with pixel values that	represent color and alpha information as separate samples and that store each sample in a separate data element.
`java.awt.image.PackedColorModel`	The PackedColorModel class is an abstract {@link ColorModel} class that works with pixel values which	represent color and alpha information as separate samples and which pack all samples for a single pixel into a single int, short, or byte quantity.
`java.awt.Image`	The abstract class Image is the superclass of all classes that	represent graphical images.
`javax.imageio.metadata.IIOMetadata`	An abstract class to be extended by objects that	represent metadata non-image data associated with images and streams.
`java.lang.Character.Subset`	Subset: Instances of this class	represent particular subsets of the Unicode character set.
`java.awt.image.DirectColorModel`	The DirectColorModel class is a ColorModel class that works with pixel values that	represent RGB color and alpha information as separate samples and that pack all samples for a single pixel into a single int, short, or byte quantity.
`java.awt.Shape`	The Shape interface provides definitions for objects that	represent some form of geometric shape.
`javax.print.DocFlavor.BYTE_ARRAY`	Class DocFlavor.BYTE_ARRAY provides predefined static constant DocFlavor objects for example doc flavors using a byte array byte as the print data	representation class.
`java.sql.Blob`	The	representation mapping in the JavaTM programming language of an SQL BLOB value.
`java.awt.print.Book`	The Book class provides a	representation of a document in which pages may have different page formats and page painters.
`java.beans.XMLEncoder`	The XMLEncoder class is a complementary alternative to the ObjectOutputStream and can used to generate a textual	representation of a JavaBean in the same way that the ObjectOutputStream can be used to create binary representation of Serializable objects.
`java.util.regex.Pattern`	A compiled	representation of a regular expression.
`java.sql.Savepoint`	The	representation of a savepoint, which is a point within the current transaction that can be referenced from the Connection.rollback method.
`java.rmi.MarshalledObject`	A MarshalledObject contains a byte stream with the serialized	representation of an object given to its constructor.
`java.awt.color.ICC_Profile`	A	representation of color profile data for device independent and device dependent color spaces based on the International Color Consortium Specification ICC.1:1998-09, File Format for Color Profiles, September 1998, and the addendum ICC.1A:1999-04, April 1999, to that specification see http://www.color.org .
`java.security.AlgorithmParameters`	This class is used as an opaque	representation of cryptographic parameters.
`java.io.File`	An abstract	representation of file and directory pathnames.
`javax.xml.transform.Templates`	An object that implements this interface is the runtime	representation of processed transformation instructions.
`java.awt.font.TextLayout`	TextLayout is an immutable graphical	representation of styled character data.
`java.awt.Insets`	An Insets object is a	representation of the borders of a container.
`java.awt.Cursor`	Cursor: A class to encapsulate the bitmap	representation of the mouse cursor.
`java.awt.Stroke`	The Stroke interface allows a {@link Graphics2D} object to obtain a {@link Shape} that is the decorated outline, or stylistic	representation of the outline, of the specified Shape.
`java.awt.Component`	A component is an object having a graphical	representation that can be displayed on the screen and that can interact with the user.
`java.io.PrintWriter`	PrintWriter: Print formatted	representations of objects to a text-output stream.
`java.security.KeyFactory`	Key factories are used to convert keys opaque cryptographic keys of type Key into key specifications transparent	representations of the underlying key material , and vice versa.
`java.io.PrintStream`	A PrintStream adds functionality to another output stream, namely the ability to print	representations of various data values conveniently.
`java.security.cert.PolicyQualifierInfo`	An immutable policy qualifier	represented by the ASN.1 PolicyQualifierInfo structure.
`java.security.PermissionCollection`	Abstract class	representing a collection of Permission objects.
`java.util.zip.Checksum`	Checksum: An interface	representing a data checksum.
`java.sql.ResultSet`	A table of data	representing a database result set, which is usually generated by executing a statement that queries the database.
`java.awt.Point`	Point: A point	representing a location in x, y coordinate space, specified in integer precision.
`java.awt.geom.Point2D`	The Point2D class defines a point	representing a location in x, y coordinate space.
`java.nio.channels.FileLock`	FileLock: A token	representing a lock on a region of a file.
`javax.imageio.stream.IIOByteBuffer`	A class	representing a mutable reference to an array of bytes and an offset and length within that array.
`javax.imageio.metadata.IIOMetadataNode`	IIOMetadataNode: A class	representing a node in a meta-data tree, which implements the org.w3c.dom.Element interface and additionally allows for the storage of non-textual objects via the getUserObject and setUserObject methods.
`java.awt.image.Raster`	A class	representing a rectangular array of pixels.
`java.security.Permission`	Abstract class for	representing access to a system resource.
`java.security.acl.Acl`	Interface	representing an Access Control List ACL .
`java.io.InputStream`	This abstract class is the superclass of all classes	representing an input stream of bytes.
`java.sql.SQLInput`	An input stream that contains a stream of values	representing an instance of an SQL structured type or an SQL distinct type.
`java.io.FileDescriptor`	FileDescriptor: Instances of the file descriptor class serve as an opaque handle to the underlying machine-specific structure	representing an open file, an open socket, or another source or sink of bytes.
`java.io.OutputStream`	This abstract class is the superclass of all classes	representing an output stream of bytes.
`javax.imageio.IIOImage`	A simple container class to aggregate an image, a set of thumbnail preview images, and an object	representing metadata associated with the image.
`java.security.acl.AclEntry`	AclEntry: This is the interface used for	representing one entry in an Access Control List ACL .
`java.lang.Character.UnicodeBlock`	UnicodeBlock: A family of character subsets	representing the character blocks in the Unicode specification.
`java.awt.SystemColor`	A class to encapsulate symbolic colors	representing the color of native GUI objects on a system.
`javax.security.auth.login.Configuration`	This is an abstract class for	representing the configuration of LoginModules under an application.
`java.lang.Void`	The Void class is an uninstantiable placeholder class to hold a reference to the Class object	representing the Java keyword void.
`java.nio.channels.Pipe.SourceChannel`	SourceChannel: A channel	representing the readable end of a {@link Pipe}.
`java.nio.channels.SelectionKey`	SelectionKey: A token	representing the registration of a {@link SelectableChannel} with a {@link Selector}.
`javax.security.auth.Policy`	This is an abstract class for	representing the system policy for Subject-based authorization.
`java.security.Policy`	This is an abstract class for	representing the system security policy for a Java application environment specifying which permissions are available for code from various sources .

`java.awt.dnd.DnDConstants`	DnDConstants: This class contains constant values	representing the type of action s to be performed by a Drag and Drop operation.
`java.nio.channels.Pipe.SinkChannel`	SinkChannel: A channel	representing the writable end of a {@link Pipe}.
`javax.naming.ldap.ExtendedRequest`	This interface represents an LDAPv3 extended operation	request as defined in RFC 2251.
`javax.print.attribute.standard.Fidelity`	Class Fidelity is a printing attribute class, an enumeration, that indicates whether total fidelity to client supplied print	request attributes is required.
`...print.attribute.PrintRequestAttributeSet`	Interface PrintRequestAttributeSet specifies the interface for a set of print	request attributes, i.e.
`javax.naming.ldap.StartTlsRequest`	This class implements the LDAPv3 Extended	Request for StartTLS as defined in Lightweight Directory Access Protocol v3 : Extension for Transport Layer Security The object identifier for StartTLS is 1.3.6.1.4.1.1466.20037 and no extended request value is defined.
`java.awt.im.spi.InputMethodContext`	Provides methods that input methods can use to communicate with their client components or to	request other services.
`...imageio.plugins.jpeg.JPEGImageWriteParam`	This class adds the ability to set JPEG quantization and Huffman tables when using the built-in JPEG writer plug-in, and to	request that optimized Huffman tables be computed for an image.
`java.security.AccessControlException`	AccessControlException: This exception is thrown by the AccessController to indicate that a	requested access to a critical system resource such as the file system or the network is denied.
`java.security.NoSuchProviderException`	NoSuchProviderException: This exception is thrown when a particular security provider is	requested but is not available in the environment.
`java.rmi.AccessException`	An AccessException is thrown by certain methods of the java.rmi.Naming class specifically bind, rebind, and unbind and methods of the java.rmi.activation.ActivationSystem interface to indicate that the caller does not have permission to perform the action	requested by the method call.
`...nio.charset.UnsupportedCharsetException`	UnsupportedCharsetException: Unchecked exception thrown when no support is available for a	requested charset.
`...datatransfer.UnsupportedFlavorException`	UnsupportedFlavorException: Signals that the	requested data is not supported in this flavor.
`...naming.AuthenticationNotSupportedException`	This exception is thrown when the particular flavor of authentication	requested is not supported.
`...print.attribute.UnmodifiableSetException`	UnmodifiableSetException: Thrown to indicate that the	requested operation cannot be performed becasue the set is unmodifiable.
`java.lang.UnsupportedOperationException`	UnsupportedOperationException: Thrown to indicate that the	requested operation is not supported.
`java.awt.IllegalComponentStateException`	IllegalComponentStateException: Signals that an AWT component is not in an appropriate state for the	requested operation.
`...print.attribute.PrintRequestAttribute`	Interface PrintRequestAttribute is a tagging interface which a printing attribute class implements to indicate the attribute denotes a	requested setting for a print job.
`javax.print.attribute.standard.JobKOctets`	Class JobKOctets is an integer valued printing attribute class that specifies the total size of the document s in K octets, i.e., in units of 1024 octets	requested to be processed in the job.
`...attribute.standard.RequestingUserName`	Class	RequestingUserName is a printing attribute class, a text attribute, that specifies the name of the end user that submitted the print job.
`java.util.logging.LogRecord`	LogRecord objects are used to pass logging	requests between the logging framework and individual log Handlers.
`java.util.logging.MemoryHandler`	Handler that buffers	requests in a circular buffer in memory.
`java.awt.im.InputMethodRequests`	InputMethodRequests defines the	requests that a text editing component has to handle in order to work with input methods.
`javax.print.SimpleDoc`	This class is an implementation of interface Doc that can be used in many common printing	requests.
`java.rmi.activation.Activatable`	The Activatable class provides support for remote objects that	require persistent access over time and that can be activated by the system.
`java.awt.image.renderable.ParameterBlock`	A ParameterBlock encapsulates all the information about sources and parameters Objects	required by a RenderableImageOp, or other classes that process images.
`javax.naming.NotContextException`	This exception is thrown when a naming operation proceeds to a point where a context is	required to continue the operation, but the resolved object is not a context.
`java.io.NotSerializableException`	NotSerializableException: Thrown when an instance is	required to have a Serializable interface.
`java.util.AbstractList`	AbstractList: This class provides a skeletal implementation of the List interface to minimize the effort	required to implement this interface backed by a "random access" data store such as an array .
`java.util.AbstractSequentialList`	AbstractSequentialList: This class provides a skeletal implementation of the List interface to minimize the effort	required to implement this interface backed by a "sequential access" data store such as a linked list .
`java.util.AbstractMap`	AbstractMap: This class provides a skeletal implementation of the Map interface, to minimize the effort	required to implement this interface.
`java.awt.datatransfer.StringSelection`	StringSelection: A Transferable which implements the capability	required to transfer a String.
`...LoginModuleControlFlag`	LoginModuleControlFlag: This class represents whether or not a LoginModule is	REQUIRED, REQUISITE, SUFFICIENT or OPTIONAL.
`java.lang.NullPointerException`	NullPointerException: Thrown when an application attempts to use null in a case where an object is	required.
`java.awt.GridBagLayout`	The GridBagLayout class is a flexible layout manager that aligns components vertically and horizontally, without	requiring that the components be of the same size.
`...awt.geom.NoninvertibleTransformException`	The NoninvertibleTransformException class represents an exception that is thrown if an operation is performed	requiring the inverse of an {@link AffineTransform} object but the AffineTransform is in a non-invertible state.
`...LoginModuleControlFlag`	LoginModuleControlFlag: This class represents whether or not a LoginModule is REQUIRED,	REQUISITE, SUFFICIENT or OPTIONAL.
`java.awt.image.RescaleOp`		RescaleOp: This class performs a pixel-by-pixel rescaling of the data in the source image by multiplying the sample values for each pixel by a scale factor and then adding an offset.
`java.awt.image.RescaleOp`	RescaleOp: This class performs a pixel-by-pixel	rescaling of the data in the source image by multiplying the sample values for each pixel by a scale factor and then adding an offset.
`java.nio.InvalidMarkException`	InvalidMarkException: Unchecked exception thrown when an attempt is made to	reset a buffer when its mark is not defined.
`java.io.BufferedInputStream`	A BufferedInputStream adds functionality to another input stream-namely, the ability to buffer the input and to support the mark and	reset methods.
`java.util.ArrayList`		Resizable-array implementation of the List interface.
`java.awt.event.HierarchyBoundsListener`	The listener interface for receiving ancestor moved and	resized events.
`java.awt.BorderLayout`	A border layout lays out a container, arranging and	resizing its components to fit in five regions: north, south, east, west, and center.
`java.awt.image.renderable.RenderableImage`	A RenderableImage is a common interface for rendering-independent images a notion which subsumes	resolution independence .
`javax.naming.spi.ResolveResult`	This class represents the result of	resolution of a name.
`java.awt.KeyEventPostProcessor`	A KeyEventPostProcessor cooperates with the current KeyboardFocusManager in the final	resolution of all unconsumed KeyEvents.
`...print.attribute.standard.PrinterResolution`	Class PrinterResolution is a printing attribute class that specifies an exact	resolution supported by a printer or to be used for a print job.
`javax.naming.spi.Resolver`	This interface represents an "intermediate context" for name	resolution.
`javax.print.attribute.ResolutionSyntax`	Class	ResolutionSyntax is an abstract base class providing the common implementation of all attributes denoting a printer resolution.
`javax.naming.LinkLoopException`	LinkLoopException: This exception is thrown when a loop was detected will attempting to	resolve a link, or an implementation specific limit on link counts has been reached.
`java.net.InetSocketAddress`	InetSocketAddress: This class implements an IP Socket Address IP address + port number It can also be a pair hostname + port number , in which case an attempt will be made to	resolve the hostname.
`javax.naming.NameNotFoundException`	NameNotFoundException: This exception is thrown when a component of the name cannot be	resolved because it is not bound.
`javax.naming.NotContextException`	This exception is thrown when a naming operation proceeds to a point where a context is required to continue the operation, but the	resolved object is not a context.
`org.xml.sax.EntityResolver`	Basic interface for	resolving entities.
`javax.naming.LinkException`	This exception is used to describe problems encounter while	resolving links.
`javax.naming.MalformedLinkException`	MalformedLinkException: This exception is thrown when a malformed link was encountered while	resolving or constructing a link.
`java.security.AccessControlContext`	An AccessControlContext is used to make system	resource access decisions based on the context it encapsulates.
`...accessibility.AccessibleResourceBundle`	AccessibleResourceBundle: A	resource bundle containing the localized strings in the accessibility package.
`java.util.ResourceBundle`		Resource bundles contain locale-specific objects.
`javax.print.attribute.URISyntax`	Class URISyntax is an abstract base class providing the common implementation of all attributes whose value is a Uniform	Resource Identifier URI .
`java.net.URI`	Represents a Uniform	Resource Identifier URI reference.
`java.util.MissingResourceException`	MissingResourceException: Signals that a	resource is missing.
`java.net.URL`	Class URL represents a Uniform	Resource Locator, a pointer to a "resource" on the World Wide Web.
`java.security.AccessControlException`	AccessControlException: This exception is thrown by the AccessController to indicate that a requested access to a critical system	resource such as the file system or the network is denied.
`java.security.Permission`	Abstract class for representing access to a system	resource.
`java.util.ListResourceBundle`	ListResourceBundle is an abstract subclass of	ResourceBundle that manages resources for a locale in a convenient and easy to use list.
`java.util.PropertyResourceBundle`	PropertyResourceBundle is a concrete subclass of	ResourceBundle that manages resources for a locale using a set of static strings from a property file.
`...naming.InsufficientResourcesException`	This exception is thrown when	resources are not available to complete the requested operation.
`java.util.ListResourceBundle`	ListResourceBundle is an abstract subclass of ResourceBundle that manages	resources for a locale in a convenient and easy to use list.
`java.util.PropertyResourceBundle`	PropertyResourceBundle is a concrete subclass of ResourceBundle that manages	resources for a locale using a set of static strings from a property file.
`java.net.URLClassLoader`	This class loader is used to load classes and	resources from a search path of URLs referring to both JAR files and directories.
`java.lang.VirtualMachineError`	VirtualMachineError: Thrown to indicate that the Java Virtual Machine is broken or has run out of	resources necessary for it to continue operating.
`java.rmi.server.UID`	A UID represents an identifier that is unique over time with	respect to the host it is generated on, or one of 216 "well-known" identifiers.
`java.awt.geom.IllegalPathStateException`	The IllegalPathStateException represents an exception that is thrown if an operation is performed on a path that is in an illegal state with	respect to the particular operation being performed, such as appending a path segment to a {@link GeneralPath} without an initial moveto.
`javax.naming.ldap.ExtendedResponse`	This interface represents an LDAP extended operation	response as defined in RFC 2251.
`javax.naming.ldap.StartTlsResponse`	This class implements the LDAPv3 Extended	Response for StartTLS as defined in Lightweight Directory Access Protocol v3 : Extension for Transport Layer Security The object identifier for StartTLS is 1.3.6.1.4.1.1466.20037 and no extended response value is defined.
`javax.naming.ReferralException`	This abstract class is used to represent a referral exception, which is generated in	response to a referral such as that returned by LDAP v3 servers.
`...naming.ldap.UnsolicitedNotificationEvent`	UnsolicitedNotificationEvent: This class represents an event fired in	response to an unsolicited notification sent by the LDAP server.
`java.lang.ref.SoftReference`	SoftReference: Soft reference objects, which are cleared at the discretion of the garbage collector in	response to memory demand.
`java.beans.PersistenceDelegate`	The PersistenceDelegate class takes the	responsibility for expressing the state of an instance of a given class in terms of the methods in the class's public API.
`java.io.Externalizable`	Only the identity of the class of an Externalizable instance is written in the serialization stream and it is the	responsibility of the class to save and restore the contents of its instances.
`java.rmi.activation.ActivationInstantiator`	An ActivationInstantiator is	responsible for creating instances of "activatable" objects.
`java.rmi.activation.ActivationGroup`	An ActivationGroup is	responsible for creating new instances of "activatable" objects in its group, informing its ActivationMonitor when either: its object's become active or inactive, or the group as a whole becomes inactive.
`java.lang.ClassLoader`	A class loader is an object that is	responsible for loading classes.
`java.awt.KeyboardFocusManager`	The KeyboardFocusManager is	responsible for managing the active and focused Windows, and the current focus owner.
`java.awt.dnd.DragSourceContext`	The DragSourceContext class is	responsible for managing the initiator side of the Drag and Drop protocol.
`java.awt.dnd.DragSource`	The DragSource is the entity	responsible for the initiation of the Drag and Drop operation, and may be used in a number of scenarios: 1 default instance per JVM for the lifetime of that JVM.
`java.rmi.activation.ActivationDesc`	ActivationDesc: An activation descriptor contains the information necessary to activate an object: the object's group identifier, the object's fully-qualified class name, the object's code location the location of the class , a codebase URL path, the object's	restart "mode", and, a "marshalled" object that can contain object specific initialization data.
`java.io.Externalizable`	Only the identity of the class of an Externalizable instance is written in the serialization stream and it is the responsibility of the class to save and	restore the contents of its instances.
`...auth.kerberos.DelegationPermission`	This class is used to	restrict the usage of the Kerberos delegation model, ie: forwardable and proxiable tickets.
`java.awt.datatransfer.FlavorTable`	A FlavorMap which relaxes the traditional 1-to-1	restriction of a Map.
`javax.print.attribute.HashDocAttributeSet`	Class HashDocAttributeSet provides an attribute set which inherits its implementation from class {@link HashAttributeSet HashAttributeSet} and enforces the semantic	restrictions of interface {@link DocAttributeSet DocAttributeSet}.
`...print.attribute.HashPrintJobAttributeSet`	Class HashPrintJobAttributeSet provides an attribute set which inherits its implementation from class {@link HashAttributeSet HashAttributeSet} and enforces the semantic	restrictions of interface {@link PrintJobAttributeSet PrintJobAttributeSet}.
`...attribute.HashPrintRequestAttributeSet`	Class HashPrintRequestAttributeSet inherits its implementation from class {@link HashAttributeSet HashAttributeSet} and enforces the semantic	restrictions of interface {@link PrintRequestAttributeSet PrintRequestAttributeSet}.
`...attribute.HashPrintServiceAttributeSet`	Class HashPrintServiceAttributeSet provides an attribute set which inherits its implementation from class {@link HashAttributeSet HashAttributeSet} and enforces the semantic	restrictions of interface {@link PrintServiceAttributeSet PrintServiceAttributeSet}.
`java.beans.Expression`	An Expression object represents a primitive expression in which a single method is applied to a target and a set of arguments to return a	result - as in "a.getFoo ".
`javax.naming.PartialResultException`	PartialResultException: This exception is thrown to indicate that the	result being returned or returned so far is partial, and that the operation cannot be completed.
`java.security.cert.CertPathBuilderResult`	A specification of the	result of a certification path builder algorithm.
`java.security.cert.CertPathValidatorResult`	CertPathValidatorResult: A specification of the	result of a certification path validator algorithm.

`java.rmi.ServerException`	A ServerException is thrown as a	result of a remote method invocation when a RemoteException is thrown while processing the invocation on the server, either while unmarshalling the arguments, executing the remote method itself, or marshalling the return value.
`java.rmi.ServerRuntimeException`	From a server executing on JDK 1.1, a ServerRuntimeException is thrown as a	result of a remote method invocation when a RuntimeException is thrown while processing the invocation on the server, either while unmarshalling the arguments, executing the remote method itself, or marshalling the return value.
`java.rmi.ServerError`	A ServerError is thrown as a	result of a remote method invocation when an Error is thrown while processing the invocation on the server, either while unmarshalling the arguments, executing the remote method itself, or marshalling the return value.
`javax.naming.spi.ResolveResult`	This class represents the	result of resolution of a name.
`java.rmi.UnexpectedException`	An UnexpectedException is thrown if the client of a remote method call receives, as a	result of the call, a checked exception that is not among the checked exception types declared in the throws clause of the method in the remote interface.
`javax.naming.directory.SearchResult`	This class represents an item in the NamingEnumeration returned as a	result of the DirContext.search methods.
`...security.cert.PKIXCertPathBuilderResult`	This class represents the successful	result of the PKIX certification path builder algorithm.
`...security.cert.PKIXCertPathValidatorResult`	This class represents the successful	result of the PKIX certification path validation algorithm.
`javax.naming.directory.SearchControls`	This class encapsulates factors that determine scope of search and what gets returned as a	result of the search.
`java.sql.ResultSet`	A table of data representing a database	result set, which is usually generated by executing a statement that queries the database.
`java.nio.charset.CoderResult`	CoderResult: A description of the	result state of a coder.
`javax.naming.SizeLimitExceededException`	SizeLimitExceededException: This exception is thrown when a method produces a	result that exceeds a size-related limit.
`javax.xml.transform.dom.DOMResult`	DOMResult: Acts as a holder for a transformation	result tree, in the form of a Document Object Model DOM tree.
`javax.xml.transform.Transformer`	An instance of this abstract class can transform a source tree into a	result tree.
`javax.xml.transform.stream.StreamResult`	StreamResult: Acts as an holder for a transformation	result, which may be XML, plain Text, HTML, or some other form of markup.
`javax.xml.transform.sax.TransformerHandler`	A TransformerHandler listens for SAX ContentHandler parse events and transforms them to a	Result.
`javax.xml.transform.Result`		Result: An object that implements this interface contains the information needed to build a transformation result tree.
`javax.naming.spi.DirStateFactory.Result`		Result: An object/attributes pair for returning the result of DirStateFactory.getStateToBind .
`java.sql.Statement`	The object used for executing a static SQL statement and returning the	results it produces.
`java.rmi.UnmarshalException`	An UnmarshalException can be thrown while unmarshalling the parameters or	results of a remote method call if any of the following conditions occur: if an exception occurs while unmarshalling the call header if the protocol for the return value is invalid if a java.io.IOException occurs unmarshalling parameters on the server side or the return value on the client side .
`java.awt.image.AreaAveragingScaleFilter`	AreaAveragingScaleFilter: An ImageFilter class for scaling images using a simple area averaging algorithm that produces smoother	results than the nearest neighbor algorithm.
`java.sql.ResultSetMetaData`	An object that can be used to get information about the types and properties of the columns in a	ResultSet object.
`java.awt.image.PixelGrabber`	The PixelGrabber class implements an ImageConsumer which can be attached to an Image or ImageProducer object to	retrieve a subset of the pixels in that image.
`...security.auth.callback.TextInputCallback`	Underlying security services instantiate and pass a TextInputCallback to the invokeCallback method of a CallbackHandler to	retrieve generic text information.
`javax.security.auth.callback.NameCallback`	Underlying security services instantiate and pass a NameCallback to the invokeCallback method of a CallbackHandler to	retrieve name information.
`javax.xml.transform.OutputKeys`	OutputKeys: Provides string constants that can be used to set output properties for a Transformer, or to	retrieve output properties from a Transformer or Templates object.
`...security.auth.callback.PasswordCallback`	Underlying security services instantiate and pass a PasswordCallback to the invokeCallback method of a CallbackHandler to	retrieve password information.
`...standard.ReferenceUriSchemesSupported`	Class ReferenceUriSchemesSupported is a printing attribute class an enumeration, that indicates a "URI scheme," such as "http:" or "ftp:", that a printer can use to	retrieve print data stored at a URI location.
`javax.security.auth.callback.Callback`	Implementations of this interface are passed to a CallbackHandler, allowing underlying security services the ability to interact with a calling application to	retrieve specific authentication data such as usernames and passwords, or to display certain information, such as error and warning messages.
`...security.auth.callback.CallbackHandler`	An application implements a CallbackHandler and passes it to underlying security services so that they may interact with the application to	retrieve specific authentication data, such as usernames and passwords, or to display certain information, such as error and warning messages.
`...security.auth.callback.LanguageCallback`	Underlying security services instantiate and pass a LanguageCallback to the invokeCallback method of a CallbackHandler to	retrieve the Locale used for localizing text.
`java.awt.geom.PathIterator`	The PathIterator interface provides the mechanism for objects that implement the {@link java.awt.Shape Shape} interface to return the geometry of their boundary by allowing a caller to	retrieve the path of that boundary a segment at a time.
`...security.auth.callback.ChoiceCallback`	Underlying security services instantiate and pass a ChoiceCallback to the invokeCallback method of a CallbackHandler to display a list of choices and to	retrieve the selected choice s .
`java.security.SecureClassLoader`	SecureClassLoader: This class extends ClassLoader with additional support for defining classes with an associated code source and permissions which are	retrieved by the system policy by default.
`java.security.cert.CertStoreException`	An exception indicating one of a variety of problems	retrieving certificates and CRLs from a CertStore.
`java.security.cert.CertStore`	A class for	retrieving Certificates and CRLs from a repository.
`java.rmi.registry.Registry`	Registry is a remote interface to a simple remote object registry that provides methods for storing and	retrieving remote object references bound with arbitrary string names.
`java.beans.Expression`	An Expression object represents a primitive expression in which a single method is applied to a target and a set of arguments to	return a result - as in "a.getFoo ".
`java.lang.Process`	The Runtime.exec methods create a native process and	return an instance of a subclass of Process that can be used to control the process and obtain information about it.
`java.util.Collections`	Collections: This class consists exclusively of static methods that operate on or	return collections.
`java.awt.geom.PathIterator`	The PathIterator interface provides the mechanism for objects that implement the {@link java.awt.Shape Shape} interface to	return the geometry of their boundary by allowing a caller to retrieve the path of that boundary a segment at a time.
`java.rmi.MarshalException`	A MarshalException is thrown if a java.io.IOException occurs while marshalling the remote call header, arguments or	return value for a remote method call.
`java.rmi.UnmarshalException`	An UnmarshalException can be thrown while unmarshalling the parameters or results of a remote method call if any of the following conditions occur: if an exception occurs while unmarshalling the call header if the protocol for the	return value is invalid if a java.io.IOException occurs unmarshalling parameters on the server side or the return value on the client side .
`java.rmi.ServerRuntimeException`	From a server executing on JDK 1.1, a ServerRuntimeException is thrown as a result of a remote method invocation when a RuntimeException is thrown while processing the invocation on the server, either while unmarshalling the arguments, executing the remote method itself, or marshalling the	return value.
`javax.accessibility.AccessibleContext`	AccessibleContext represents the minimum information all accessible objects	return.
`javax.naming.directory.SearchResult`	This class represents an item in the NamingEnumeration	returned as a result of the DirContext.search methods.
`javax.naming.directory.SearchControls`	This class encapsulates factors that determine scope of search and what gets	returned as a result of the search.
`javax.naming.ReferralException`	This abstract class is used to represent a referral exception, which is generated in response to a referral such as that	returned by LDAP v3 servers.
`javax.naming.NamingEnumeration`	This interface is for enumerating lists	returned by methods in the javax.naming and javax.naming.directory packages.
`java.lang.StackTraceElement`	StackTraceElement: An element in a stack trace, as	returned by {@link Throwable#getStackTrace }.
`java.text.DateFormat.Field`	Defines constants that are used as attribute keys in the AttributedCharacterIterator	returned from DateFormat.formatToCharacterIterator and as field identifiers in FieldPosition.
`java.text.Format.Field`	Defines constants that are used as attribute keys in the AttributedCharacterIterator	returned from Format.formatToCharacterIterator and as field identifiers in FieldPosition.
`javax.imageio.metadata.IIOMetadataFormat`	An object describing the structure of metadata documents	returned from IIOMetadata.getAsTree and passed to IIOMetadata.setFromTree and mergeTree.
`java.text.MessageFormat.Field`	Field: Defines constants that are used as attribute keys in the AttributedCharacterIterator	returned from MessageFormat.formatToCharacterIterator.
`java.text.NumberFormat.Field`	Defines constants that are used as attribute keys in the AttributedCharacterIterator	returned from NumberFormat.formatToCharacterIterator and as field identifiers in FieldPosition.
`javax.naming.ldap.HasControls`	This interface is for returning controls with objects	returned in NamingEnumerations.
`javax.naming.PartialResultException`	PartialResultException: This exception is thrown to indicate that the result being	returned or returned so far is partial, and that the operation cannot be completed.
`javax.naming.ldap.HasControls`	This interface is for	returning controls with objects returned in NamingEnumerations.
`javax.naming.spi.DirStateFactory.Result`	Result: An object/attributes pair for	returning the result of DirStateFactory.getStateToBind .
`java.sql.Statement`	The object used for executing a static SQL statement and	returning the results it produces.
`java.awt.geom.FlatteningPathIterator`	The FlatteningPathIterator class	returns a flattened view of another {@link PathIterator} object.
`java.awt.color.CMMException`	CMMException: This exception is thrown if the native CMM	returns an error.
`...imageio.metadata.IIOMetadataFormatImpl`	IIOMetadataFormatImpl: A concrete class providing a	reusable implementation of the IIOMetadataFormat interface.
`java.security.cert.X509CRLEntry`	X509CRLEntry: Abstract class for a revoked certificate in a CRL Certificate	Revocation List .
`java.security.cert.X509CRL`	Abstract class for an X.509 Certificate	Revocation List CRL .
`java.security.cert.CertificateFactory`	This class defines the functionality of a certificate factory, which is used to generate certificate, certification path CertPath and certificate	revocation list CRL objects from their encodings.
`java.security.cert.CRLException`	CRLException: CRL Certificate	Revocation List Exception.
`java.security.cert.CRL`	This class is an abstraction of certificate	revocation lists CRLs that have different formats but important common uses.
`java.security.cert.X509CRLEntry`	X509CRLEntry: Abstract class for a	revoked certificate in a CRL Certificate Revocation List .
`...beancontext.BeanContextServiceRevokedEvent`	BeanContextServiceRevokedEvent: This event type is used by the BeanContextServiceRevokedListener in order to identify the service being	revoked.
`javax.naming.ldap.UnsolicitedNotification`	UnsolicitedNotification: This interface represents an unsolicited notification as defined in	RFC 2251.
`java.awt.image.DirectColorModel`	The DirectColorModel class is a ColorModel class that works with pixel values that represent	RGB color and alpha information as separate samples and that pack all samples for a single pixel into a single int, short, or byte quantity.
`java.awt.image.RGBImageFilter`	This class provides an easy way to create an ImageFilter which modifies the pixels of an image in the default	RGB ColorModel.
`java.awt.color.ICC_ProfileRGB`	The ICC_ProfileRGB class is a subclass of the ICC_Profile class that represents profiles which meet the following criteria: The profile's color space type is	RGB.
`...awt.image.renderable.RenderedImageFactory`	The RenderedImageFactory interface often abbreviated	RIF is intended to be implemented by classes that wish to act as factories to produce different renderings, for example by executing a series of BufferedImageOps on a set of sources, depending on a specific set of parameters, properties, and rendering hints.
`java.rmi.RMISecurityManager`	RMISecurityManager provides an example security manager for use by	RMI applications that use downloaded code.
`java.rmi.server.Skeleton`	The Skeleton interface is used solely by the	RMI implementation.
`java.rmi.server.RemoteCall`	RemoteCall is an abstraction used solely by the	RMI runtime in conjunction with stubs and skeletons of remote objects to carry out a call to a remote object.
`java.rmi.server.RMISocketFactory`	An RMISocketFactory instance is used by the	RMI runtime in order to obtain client and server sockets for RMI calls.
`java.rmi.server.RMIClientSocketFactory`	An RMIClientSocketFactory instance is used by the	RMI runtime in order to obtain client sockets for RMI calls.
`java.rmi.server.RMIServerSocketFactory`	An RMIServerSocketFactory instance is used by the	RMI runtime in order to obtain server sockets for RMI calls.
`java.rmi.registry.RegistryHandler`	RegistryHandler is an interface used internally by the	RMI runtime in previous implementation versions.
`...rmi.activation.ActivateFailedException`	ActivateFailedException: This exception is thrown by the	RMI runtime when activation fails during a remote call to an activatable object.
`java.rmi.server.ObjID`	An ObjID is used to identify a remote object exported to an	RMI runtime.
`java.rmi.server.RMIClassLoader`	RMIClassLoader comprises static methods to support dynamic class loading with	RMI.
`javax.rmi.CORBA.Tie`	Tie: Defines methods which all	RMI-IIOP server side ties must implement.
`javax.rmi.CORBA.Stub`	Stub: Base class from which all	RMI-IIOP stubs must inherit.
`java.rmi.server.RMIClassLoader`		RMIClassLoader comprises static methods to support dynamic class loading with RMI.
`java.rmi.server.RMIClassLoaderSpi`	RMIClassLoaderSpi is the service provider interface for	RMIClassLoader.
`java.rmi.server.RMIClassLoaderSpi`		RMIClassLoaderSpi is the service provider interface for RMIClassLoader.
`java.rmi.server.RMIClientSocketFactory`	An	RMIClientSocketFactory instance is used by the RMI runtime in order to obtain client sockets for RMI calls.
`java.rmi.server.RMIFailureHandler`	An	RMIFailureHandler can be registered via the RMISocketFactory.setFailureHandler call.
`java.rmi.RMISecurityException`	An	RMISecurityException signals that a security exception has occurred during the execution of one of java.rmi.RMISecurityManager's methods.
`java.rmi.RMISecurityManager`		RMISecurityManager provides an example security manager for use by RMI applications that use downloaded code.
`java.rmi.server.RMIServerSocketFactory`	An	RMIServerSocketFactory instance is used by the RMI runtime in order to obtain server sockets for RMI calls.
`java.rmi.server.RMISocketFactory`	An	RMISocketFactory instance is used by the RMI runtime in order to obtain client and server sockets for RMI calls.
`java.rmi.server.RMIFailureHandler`	An RMIFailureHandler can be registered via the	RMISocketFactory.setFailureHandler call.
`javax.accessibility.AccessibleRole`	Class AccessibleRole determines the	role of a component.
`javax.print.ServiceUIFactory`	Services may optionally provide UIs which allow different styles of interaction in different	roles.
`java.awt.FocusTraversalPolicy`	A FocusTraversalPolicy defines the order in which Components with a particular focus cycle	root are traversed.

`java.awt.event.ComponentEvent`	A low-level event which indicates that a component moved, changed size, or changed visibility also, the	root class for the other component-level events .
`java.util.EventObject`	EventObject: The	root class from which all event state objects shall be derived.
`java.awt.AWTEvent`	The	root event class for all AWT events.
`java.awt.event.InputEvent`	InputEvent: The	root event class for all component-level input events.
`java.beans.beancontext.BeanContextEvent`	BeanContextEvent is the abstract	root event class for all events emitted from, and pertaining to the semantics of, a BeanContext.
`java.util.Collection`	The	root interface in the collection hierarchy.
`javax.naming.event.NamingListener`	This interface is the	root of listener interfaces that handle NamingEvents.
`java.lang.Object`	Class Object is the	root of the class hierarchy.
`java.lang.Math`	The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square	root, and trigonometric functions.
`java.awt.event.MouseWheelEvent`	An event which indicates that the mouse wheel was	rotated in a component.
`java.awt.geom.RoundRectangle2D`	The RoundRectangle2D class defines a rectangle with rounded corners defined by a location x, y , a dimension w x h , and the width and height of an arc with which to	round the corners.
`java.awt.geom.RoundRectangle2D.Double`	The Double class defines a rectangle with	rounded corners all specified in double coordinates.
`java.awt.geom.RoundRectangle2D.Float`	The Float class defines a rectangle with	rounded corners all specified in float coordinates.
`java.awt.geom.RoundRectangle2D`	The RoundRectangle2D class defines a rectangle with	rounded corners defined by a location x, y , a dimension w x h , and the width and height of an arc with which to round the corners.
`java.awt.geom.RoundRectangle2D`	The	RoundRectangle2D class defines a rectangle with rounded corners defined by a location x, y , a dimension w x h , and the width and height of an arc with which to round the corners.
`javax.sql.RowSetReader`	The facility that a disconnected RowSet object calls on to populate itself with	rows of data.
`javax.sql.RowSetReader`	The facility that a disconnected	RowSet object calls on to populate itself with rows of data.
`javax.sql.RowSetInternal`	The interface that a	RowSet object implements in order to present itself to a RowSetReader or RowSetWriter object.
`javax.sql.RowSetMetaData`	An object that contains information about the columns in a	RowSet object.
`javax.sql.RowSetInternal`	The interface that a RowSet object implements in order to present itself to a	RowSetReader or RowSetWriter object.
`javax.sql.RowSetWriter`	An object that implements the	RowSetWriter interface, called a writer.
`javax.sql.RowSetInternal`	The interface that a RowSet object implements in order to present itself to a RowSetReader or	RowSetWriter object.
`java.security.spec.RSAKeyGenParameterSpec`	RSAKeyGenParameterSpec: This class specifies the set of parameters used to generate an	RSA key pair.
`...spec.RSAMultiPrimePrivateCrtKeySpec`	RSAMultiPrimePrivateCrtKeySpec: This class specifies an	RSA multi-prime private key, as defined in the PKCS#1 v2.1, using the Chinese Remainder Theorem CRT information values for efficiency.
`...interfaces.RSAMultiPrimePrivateCrtKey`	RSAMultiPrimePrivateCrtKey: The interface to an	RSA multi-prime private key, as defined in the PKCS#1 v2.1, using the Chinese Remainder Theorem CRT information values.
`java.security.spec.RSAPrivateCrtKeySpec`	RSAPrivateCrtKeySpec: This class specifies an	RSA private key, as defined in the PKCS#1 standard, using the Chinese Remainder Theorem CRT information values for efficiency.
`java.security.interfaces.RSAPrivateCrtKey`	RSAPrivateCrtKey: The interface to an	RSA private key, as defined in the PKCS#1 standard, using the Chinese Remainder Theorem CRT information values.
`java.security.interfaces.RSAPrivateKey`	RSAPrivateKey: The interface to an	RSA private key.
`java.security.spec.PSSParameterSpec`	PSSParameterSpec: This class specifies a parameter spec for	RSA PSS encoding scheme, as defined in the PKCS#1 v2.1.
`java.security.interfaces.RSAPublicKey`	RSAPublicKey: The interface to an	RSA public key.
`java.security.interfaces.RSAKey`	RSAKey: The interface to an	RSA public or private key.
`java.security.spec.RSAOtherPrimeInfo`	RSAOtherPrimeInfo: This class represents the triplet prime, exponent, and coefficient inside	RSA's OtherPrimeInfo structure, as defined in the PKCS#1 v2.1.
`java.security.interfaces.RSAKey`		RSAKey: The interface to an RSA public or private key.
`java.security.spec.RSAKeyGenParameterSpec`		RSAKeyGenParameterSpec: This class specifies the set of parameters used to generate an RSA key pair.
`...interfaces.RSAMultiPrimePrivateCrtKey`		RSAMultiPrimePrivateCrtKey: The interface to an RSA multi-prime private key, as defined in the PKCS#1 v2.1, using the Chinese Remainder Theorem CRT information values.
`...spec.RSAMultiPrimePrivateCrtKeySpec`		RSAMultiPrimePrivateCrtKeySpec: This class specifies an RSA multi-prime private key, as defined in the PKCS#1 v2.1, using the Chinese Remainder Theorem CRT information values for efficiency.
`java.security.spec.RSAOtherPrimeInfo`		RSAOtherPrimeInfo: This class represents the triplet prime, exponent, and coefficient inside RSA's OtherPrimeInfo structure, as defined in the PKCS#1 v2.1.
`java.security.interfaces.RSAPrivateCrtKey`		RSAPrivateCrtKey: The interface to an RSA private key, as defined in the PKCS#1 standard, using the Chinese Remainder Theorem CRT information values.
`java.security.spec.RSAPrivateCrtKeySpec`		RSAPrivateCrtKeySpec: This class specifies an RSA private key, as defined in the PKCS#1 standard, using the Chinese Remainder Theorem CRT information values for efficiency.
`java.security.interfaces.RSAPrivateKey`		RSAPrivateKey: The interface to an RSA private key.
`java.security.spec.RSAPrivateKeySpec`		RSAPrivateKeySpec: This class specifies an RSA private key.
`java.security.interfaces.RSAPublicKey`		RSAPublicKey: The interface to an RSA public key.
`java.security.spec.RSAPublicKeySpec`		RSAPublicKeySpec: This class specifies an RSA public key.
`java.text.RuleBasedCollator`	The	RuleBasedCollator class is a concrete subclass of Collator that provides a simple, data-driven, table collator.
`java.awt.AlphaComposite`	This AlphaComposite class implements the basic alpha compositing	rules for combining source and destination pixels to achieve blending and transparency effects with graphics and images.
`java.text.CollationKey`	A CollationKey represents a String under the	rules of a specific Collator object.
`java.awt.event.InvocationEvent`	InvocationEvent: An event which executes the	run method on a Runnable when dispatched by the AWT event dispatcher thread.
`java.applet.Applet`	An applet is a small program that is intended not to be	run on its own, but rather to be embedded inside another application.
`java.beans.Visibility`	Visibility: Under some circumstances a bean may be	run on servers where a GUI is not available.
`java.lang.VirtualMachineError`	VirtualMachineError: Thrown to indicate that the Java Virtual Machine is broken or has	run out of resources necessary for it to continue operating.
`javax.imageio.IIOException`	IIOException: An exception class used for signaling	run-time failure of reading and writing operations.
`java.lang.Runnable`	The	Runnable interface should be implemented by any class whose instances are intended to be executed by a thread.
`java.awt.event.InvocationEvent`	InvocationEvent: An event which executes the run method on a	Runnable when dispatched by the AWT event dispatcher thread.
`javax.print.attribute.standard.MediaSize`	Class MediaSize is a two-dimensional size valued printing attribute class that indicates the dimensions of the medium in a portrait orientation, with the X dimension	running along the bottom edge and the Y dimension running along the left edge.
`java.sql.SQLPermission`	The permission for which the SecurityManager will check when code that is	running in an applet calls the DriverManager.setLogWriter method or the DriverManager.setLogStream deprecated method.
`java.lang.Class`	Instances of the class Class represent classes and interfaces in a	running Java application.
`java.util.logging.LoggingPermission`	The permission which the SecurityManager will check when code that is	running with a SecurityManager calls one of the logging control methods such as Logger.setLevel .
`java.lang.Runtime`	Every Java application has a single instance of class Runtime that allows the application to interface with the environment in which the application is	running.
`java.io.InvalidClassException`	InvalidClassException: Thrown when the Serialization	runtime detects one of the following problems with a Class.
`java.security.ProviderException`	ProviderException: A	runtime exception for Provider exceptions such as misconfiguration errors , which may be subclassed by Providers to throw specialized, provider-specific runtime errors.
`java.rmi.server.RemoteCall`	RemoteCall is an abstraction used solely by the RMI	runtime in conjunction with stubs and skeletons of remote objects to carry out a call to a remote object.
`java.rmi.server.RMISocketFactory`	An RMISocketFactory instance is used by the RMI	runtime in order to obtain client and server sockets for RMI calls.
`java.rmi.server.RMIClientSocketFactory`	An RMIClientSocketFactory instance is used by the RMI	runtime in order to obtain client sockets for RMI calls.
`java.rmi.server.RMIServerSocketFactory`	An RMIServerSocketFactory instance is used by the RMI	runtime in order to obtain server sockets for RMI calls.
`java.rmi.registry.RegistryHandler`	RegistryHandler is an interface used internally by the RMI	runtime in previous implementation versions.
`java.security.SignedObject`	SignedObject is a class for the purpose of creating authentic	runtime objects whose integrity cannot be compromised without being detected.
`java.lang.RuntimePermission`	This class is for	runtime permissions.
`javax.xml.transform.Templates`	An object that implements this interface is the	runtime representation of processed transformation instructions.
`java.lang.Runtime`	Every Java application has a single instance of class	Runtime that allows the application to interface with the environment in which the application is running.
`...rmi.activation.ActivateFailedException`	ActivateFailedException: This exception is thrown by the RMI	runtime when activation fails during a remote call to an activatable object.
`java.rmi.server.ObjID`	An ObjID is used to identify a remote object exported to an RMI	runtime.
`java.lang.Process`	The	Runtime.exec methods create a native process and return an instance of a subclass of Process that can be used to control the process and obtain information about it.
`java.lang.RuntimeException`		RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
`java.rmi.ServerRuntimeException`	From a server executing on JDK 1.1, a ServerRuntimeException is thrown as a result of a remote method invocation when a	RuntimeException is thrown while processing the invocation on the server, either while unmarshalling the arguments, executing the remote method itself, or marshalling the return value.
`...lang.reflect.UndeclaredThrowableException`	Thrown by a method invocation on a proxy instance if its invocation handler's {@link InvocationHandler#invoke invoke} method throws a checked exception a Throwable that is not assignable to	RuntimeException or Error that is not assignable to any of the exception types declared in the throws clause of the method that was invoked on the proxy instance and dispatched to the invocation handler.

Previous Page: Q

Main Page

Next Page: S

This page generated by the Inverted Index Doclet 0.1

To obtain a copy of the doclet, visit Neal Ziring's Java Samples Page.

Java, Java 2D, and JDBC are a trademarks or registered trademarks of Sun Microsystems, Inc. in the US and other countries.