| Package | Description | 
|---|---|
| java.awt | 
 Contains all of the classes for creating user
interfaces and for painting graphics and images. 
 | 
| java.awt.color | 
 Provides classes for color spaces. 
 | 
| java.awt.datatransfer | 
 Provides interfaces and classes for transferring data
between and within applications. 
 | 
| java.awt.dnd | 
 Drag and Drop is a direct manipulation gesture found in many Graphical
User Interface systems that provides a mechanism to transfer
information between two entities logically associated with presentation
elements in the GUI. 
 | 
| java.awt.event | 
 Provides interfaces and classes for dealing with different
types of events fired by AWT components. 
 | 
| java.awt.geom | 
 Provides the Java 2D classes for defining and performing operations
on objects related to two-dimensional geometry. 
 | 
| java.awt.im.spi | 
 Provides interfaces that enable the development of input methods
that can be used with any Java runtime environment. 
 | 
| java.awt.image | 
 Provides classes for creating and modifying images. 
 | 
| java.awt.print | 
 Provides classes and interfaces for a general printing API. 
 | 
| java.beans | 
 Contains classes related to developing
beans -- components
based on the JavaBeans™ architecture. 
 | 
| java.io | 
 Provides for system input and output through data streams,
serialization and the file system. 
 | 
| java.lang | 
 Provides classes that are fundamental to the design of the Java
 programming language. 
 | 
| java.lang.annotation | 
 Provides library support for the Java programming language
 annotation facility. 
 | 
| java.lang.instrument | 
 Provides services that allow Java programming language agents to instrument programs running on the JVM. 
 | 
| java.lang.invoke | 
 The  
java.lang.invoke package contains dynamic language support provided directly by
 the Java core class libraries and virtual machine. | 
| java.lang.reflect | 
 Provides classes and interfaces for obtaining reflective
 information about classes and objects. 
 | 
| java.net | 
 Provides the classes for implementing networking applications. 
 | 
| java.nio | 
 Defines buffers, which are containers for data, and provides an overview of the
other NIO packages. 
 | 
| java.nio.channels | 
 Defines channels, which represent connections to entities that are capable of
 performing I/O operations, such as files and sockets; defines selectors, for
 multiplexed, non-blocking I/O operations. 
 | 
| java.nio.charset | 
 Defines charsets, decoders, and encoders, for translating between bytes and
Unicode characters. 
 | 
| java.nio.file | 
 Defines interfaces and classes for the Java virtual machine to access files,
 file attributes, and file systems. 
 | 
| java.nio.file.attribute | 
 Interfaces and classes providing access to file and file system attributes. 
 | 
| java.rmi | 
 Provides the RMI package. 
 | 
| java.rmi.activation | 
 Provides support for RMI Object Activation. 
 | 
| java.rmi.server | 
 Provides classes and interfaces for supporting the server
side of RMI. 
 | 
| java.security | 
 Provides the classes and interfaces for the security framework. 
 | 
| java.security.acl | 
 The classes and interfaces in this package have been
 superseded by classes in the java.security package. 
 | 
| java.security.cert | 
 Provides classes and interfaces for parsing and managing
 certificates, certificate revocation lists (CRLs), and
 certification paths. 
 | 
| java.security.spec | 
 Provides classes and interfaces for key specifications and algorithm
 parameter specifications. 
 | 
| java.sql | 
 Provides the API for accessing and processing data stored in a 
data source (usually a relational database) using the 
JavaTM programming language. 
 | 
| java.text | 
 Provides classes and interfaces for handling text, dates, numbers, and messages
in a manner independent of natural languages. 
 | 
| java.time | 
 
 The main API for dates, times, instants, and durations. 
 | 
| java.time.format | 
 
 Provides classes to print and parse dates and times. 
 | 
| java.time.temporal | 
 
 Access to date and time using fields and units, and date time adjusters. 
 | 
| java.time.zone | 
 
 Support for time-zones and their rules. 
 | 
| java.util | 
 Contains the collections framework, legacy collection classes, event model,
date and time facilities, internationalization, and miscellaneous utility
classes (a string tokenizer, a random-number generator, and a bit array). 
 | 
| java.util.concurrent | 
 Utility classes commonly useful in concurrent programming. 
 | 
| java.util.jar | 
 Provides classes for reading and writing the JAR (Java ARchive) file
format, which is based on the standard ZIP file format with an
optional manifest file. 
 | 
| java.util.logging | 
 
Provides the classes and interfaces of 
the JavaTM 2
 platform's core logging facilities. 
 | 
| java.util.prefs | 
 This package allows applications to store and retrieve user and system
preference and configuration data. 
 | 
| java.util.regex | 
 Classes for matching character sequences against patterns specified by regular
expressions. 
 | 
| java.util.zip | 
 Provides classes for reading and writing the standard ZIP and GZIP
file formats. 
 | 
| javax.activation | |
| javax.activity | 
 Contains Activity service related exceptions thrown by the ORB machinery during
unmarshalling. 
 | 
| javax.annotation.processing | 
 Facilities for declaring annotation processors and for
 allowing annotation processors to communicate with an annotation processing
 tool environment. 
 | 
| javax.crypto | 
 Provides the classes and interfaces for cryptographic operations. 
 | 
| javax.imageio | 
 The main package of the Java Image I/O API. 
 | 
| javax.imageio.metadata | 
 A package of the Java Image I/O API dealing with reading and writing
metadata. 
 | 
| javax.lang.model | 
 Classes and hierarchies of packages used to model the Java
 programming language. 
 | 
| javax.lang.model.element | 
 Interfaces used to model elements of the Java programming language. 
 | 
| javax.lang.model.type | 
 Interfaces used to model Java programming language types. 
 | 
| javax.management | 
 Provides the core classes for the Java Management Extensions. 
 | 
| javax.management.loading | 
 Provides the classes which implement advanced dynamic
        loading. 
 | 
| javax.management.modelmbean | 
 Provides the definition of the ModelMBean classes. 
 | 
| javax.management.monitor | 
 Provides the definition of the monitor classes. 
 | 
| javax.management.openmbean | 
 Provides the open data types and Open MBean descriptor classes. 
 | 
| javax.management.relation | 
 Provides the definition of the Relation Service. 
 | 
| javax.management.remote | 
 Interfaces for remote access to
        JMX MBean servers. 
 | 
| javax.management.timer | 
 Provides the definition of the Timer MBean. 
 | 
| javax.naming | 
 Provides the classes and interfaces for accessing naming services. 
 | 
| javax.naming.directory | 
 Extends the javax.naming package to provide functionality
for accessing directory services. 
 | 
| javax.naming.ldap | 
 Provides support for LDAPv3 extended operations and controls. 
 | 
| javax.naming.spi | |
| javax.net.ssl | 
 Provides classes for the secure socket package. 
 | 
| javax.print | 
 Provides the principal classes and interfaces for the 
JavaTM Print Service API. 
 | 
| javax.print.attribute | 
 Provides classes and interfaces
that describe the types of JavaTM Print
Service attributes and how they can be collected into attribute sets. 
 | 
| javax.script | 
 The scripting API consists of interfaces and classes that define
Java TM Scripting Engines and provides
a framework for their use in Java applications. 
 | 
| javax.security.auth | 
 This package provides a framework for authentication and
 authorization. 
 | 
| javax.security.auth.callback | 
 This package provides the classes necessary for services
 to interact with applications in order to retrieve
 information (authentication data including usernames
 or passwords, for example) or to display information
 (error and warning messages, for example). 
 | 
| javax.security.auth.login | 
 This package provides a pluggable authentication framework. 
 | 
| javax.security.cert | 
 Provides classes for public key certificates. 
 | 
| javax.security.sasl | 
 Contains class and interfaces for supporting SASL. 
 | 
| javax.sound.midi | 
 Provides interfaces and classes for I/O, sequencing, and synthesis of MIDI 
(Musical Instrument Digital Interface) data. 
 | 
| javax.sound.sampled | 
 Provides interfaces and classes for capture, processing, and playback of sampled audio data. 
 | 
| javax.sql.rowset | 
 Standard interfaces and base classes for JDBC  
RowSet
implementations. | 
| javax.sql.rowset.serial | 
 Provides utility classes to allow serializable mappings between SQL types
and data types in the Java programming language. 
 | 
| javax.sql.rowset.spi | 
 The standard classes and interfaces that a third party vendor has to
use in its implementation of a synchronization provider. 
 | 
| javax.swing | 
 Provides a set of "lightweight"
(all-Java language) components that,
to the maximum degree possible, work the same on all platforms. 
 | 
| javax.swing.text | 
 Provides classes and interfaces that deal with editable
and noneditable text components. 
 | 
| javax.swing.tree | 
 Provides classes and interfaces for dealing with
 
javax.swing.JTree. | 
| javax.swing.undo | 
 Allows developers to provide support for undo/redo
in applications such as text editors. 
 | 
| javax.transaction | 
 Contains three exceptions thrown by the ORB machinery during unmarshalling. 
 | 
| javax.transaction.xa | 
 Provides the API that defines the contract between the transaction 
manager and the resource manager, which allows the transaction 
manager to enlist and delist resource objects (supplied by the 
resource manager driver) in JTA transactions. 
 | 
| javax.xml.bind | 
 
        Provides a runtime binding framework for client applications including
        unmarshalling, marshalling, and validation capabilities. 
 | 
| javax.xml.bind.annotation.adapters | 
XmlAdapter and its spec-defined
        sub-classes to allow arbitrary Java classes to be used with JAXB. | 
| javax.xml.crypto | 
 Common classes for XML cryptography. 
 | 
| javax.xml.crypto.dsig | 
 Classes for generating and validating XML digital
signatures. 
 | 
| javax.xml.datatype | 
 XML/Java Type Mappings. 
 | 
| javax.xml.parsers | 
 
                Provides classes allowing the processing of XML documents. 
 | 
| javax.xml.soap | 
 Provides the API for creating and building SOAP messages. 
 | 
| javax.xml.stream | |
| javax.xml.transform | 
 This package defines the generic APIs for processing transformation
instructions, and performing a transformation from source to result. 
 | 
| javax.xml.ws | 
 This package contains the core JAX-WS APIs. 
 | 
| javax.xml.ws.http | 
 This package defines APIs specific to the HTTP binding. 
 | 
| javax.xml.ws.soap | 
 This package defines APIs specific to the SOAP binding. 
 | 
| javax.xml.xpath | 
 This package provides an object-model neutral API for the
evaluation of XPath expressions and access to the evaluation
environment. 
 | 
| org.ietf.jgss | 
 This package presents a framework that allows application developers to
    make use of security services like authentication, data integrity and
    data confidentiality from a variety of underlying security mechanisms
    like Kerberos, using a unified API. 
 | 
| org.omg.CORBA | 
 Provides the mapping of the OMG CORBA APIs to the JavaTM
programming language, including the class ORB, which is implemented
so that a programmer can use it as a fully-functional Object Request Broker
(ORB). 
 | 
| org.omg.CORBA.DynAnyPackage | 
 Provides the exceptions used with the  
DynAny interface 
(InvalidValue,  
Invalid, InvalidSeq, and 
TypeMismatch). | 
| org.omg.CORBA.ORBPackage | 
 Provides the exception  
InvalidName, which is thrown
by the method ORB.resolve_initial_references
and the exception InconsistentTypeCode, which is thrown
by the Dynamic Any creation methods in the ORB class. | 
| org.omg.CORBA.portable | 
 Provides a portability layer, that is, a set of ORB APIs
that makes it possible for code generated
by one vendor to run on another vendor's ORB. 
 | 
| org.omg.CORBA.TypeCodePackage | 
 Provides the user-defined exceptions  
BadKind
and Bounds, which are thrown by methods in
in the class TypeCode. | 
| org.omg.CosNaming.NamingContextExtPackage | 
 This package contains the following classes, which are used in 
org.omg.CosNaming.NamingContextExt: 
 | 
| org.omg.CosNaming.NamingContextPackage | 
 This package contains Exception classes for the org.omg.CosNaming
 package. 
 | 
| org.omg.IOP.CodecFactoryPackage | 
 This package contains the exceptions
specified in the IOP::CodeFactory interface (as part of the Portable
 Interceptors spec). 
 | 
| org.omg.IOP.CodecPackage | 
 This package is generated from the IOP::Codec IDL interface
definition. 
 | 
| org.omg.PortableInterceptor | 
 Provides a mechanism to register ORB hooks through which ORB services
can intercept the normal flow of execution of the ORB. 
 | 
| org.omg.PortableInterceptor.ORBInitInfoPackage | 
 This package contains the exceptions and typedefs from the ORBInitInfo
local interface of the PortableInterceptor module specified in the OMG
Portable Interceptor specification,
http://cgi.omg.org/cgi-bin/doc?ptc/2000-08-06, section 21.7.2. 
 | 
| org.omg.PortableServer | 
 Provides classes and interfaces for making the server side of your applications 
portable across multivendor ORBs. 
 | 
| org.omg.PortableServer.CurrentPackage | 
  Provides method implementations with 
 access to the identity of the object on which the 
 method was invoked. 
 | 
| org.omg.PortableServer.POAManagerPackage | 
 
Encapsulates the processing 
 state of the POAs it is associated with. 
 | 
| org.omg.PortableServer.POAPackage | 
 Allows programmers to construct object implementations that are portable
between different ORB products. 
 | 
| org.w3c.dom | 
 Provides the interfaces for the Document Object Model (DOM). 
 | 
| org.w3c.dom.events | |
| org.w3c.dom.ls | |
| org.xml.sax | 
  This package provides the core SAX APIs. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AWTException
Signals that an Abstract Window Toolkit exception has occurred. 
 | 
class  | 
FontFormatException
Thrown by method createFont in the  
Font class to indicate
 that the specified font is bad. | 
class  | 
HeadlessException
Thrown when code that is dependent on a keyboard, display, or mouse
 is called in an environment that does not support a keyboard, display,
 or mouse. 
 | 
class  | 
IllegalComponentStateException
Signals that an AWT component is not in an appropriate state for
 the requested operation. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
CMMException
This exception is thrown if the native CMM returns an error. 
 | 
class  | 
ProfileDataException
This exception is thrown when an error occurs in accessing or
 processing an ICC_Profile object. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
MimeTypeParseException
A class to encapsulate MimeType parsing related exceptions 
 | 
class  | 
UnsupportedFlavorException
Signals that the requested data is not supported in this flavor. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InvalidDnDOperationException
This exception is thrown by various methods in the java.awt.dnd package. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Exception | 
InvocationEvent.getException()
Returns any Exception caught while executing the Runnable's  
run()
  method. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
IllegalPathStateException
The  
IllegalPathStateException represents an
 exception that is thrown if an operation is performed on a path
 that is in an illegal state with respect to the particular
 operation being performed, such as appending a path segment
 to a GeneralPath without an initial moveto. | 
class  | 
NoninvertibleTransformException
The  
NoninvertibleTransformException class represents
 an exception that is thrown if an operation is performed requiring
 the inverse of an AffineTransform object but the
 AffineTransform is in a non-invertible state. | 
| Modifier and Type | Method and Description | 
|---|---|
InputMethod | 
InputMethodDescriptor.createInputMethod()
Creates a new instance of the corresponding input method. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ImagingOpException
The  
ImagingOpException is thrown if one of the
 BufferedImageOp or RasterOp filter methods cannot
 process the image. | 
class  | 
RasterFormatException
The  
RasterFormatException is thrown if there is
 invalid layout information in the Raster. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
PrinterAbortException
The  
PrinterAbortException class is a subclass of
 PrinterException and is used to indicate that a user
 or application has terminated the print job while it was in
 the process of printing. | 
class  | 
PrinterException
The  
PrinterException class and its subclasses are used
 to indicate that an exceptional condition has occurred in the print
 system. | 
class  | 
PrinterIOException
The  
PrinterIOException class is a subclass of
 PrinterException and is used to indicate that an IO error
 of some sort has occurred while printing. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
IntrospectionException
Thrown when an exception happens during Introspection. 
 | 
class  | 
PropertyVetoException
A PropertyVetoException is thrown when a proposed change to a
 property represents an unacceptable value. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
ExceptionListener.exceptionThrown(Exception e)
This method is called when a recoverable exception has
 been caught. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
Expression.execute()
The  
execute method finds a method whose name is the same
 as the methodName property, and invokes the method on
 the target. | 
void | 
Statement.execute()
The  
execute method finds a method whose name is the same
 as the methodName property, and invokes the method on
 the target. | 
Object | 
Expression.getValue()
If the value property of this instance is not already set,
 this method dynamically finds the method with the specified
 methodName on this target with these arguments and calls it. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
CharConversionException
Base class for character conversion exceptions. 
 | 
class  | 
EOFException
Signals that an end of file or end of stream has been reached
 unexpectedly during input. 
 | 
class  | 
FileNotFoundException
Signals that an attempt to open the file denoted by a specified pathname
 has failed. 
 | 
class  | 
InterruptedIOException
Signals that an I/O operation has been interrupted. 
 | 
class  | 
InvalidClassException
Thrown when the Serialization runtime detects one of the following
 problems with a Class. 
 | 
class  | 
InvalidObjectException
Indicates that one or more deserialized objects failed validation
 tests. 
 | 
class  | 
IOException
Signals that an I/O exception of some sort has occurred. 
 | 
class  | 
NotActiveException
Thrown when serialization or deserialization is not active. 
 | 
class  | 
NotSerializableException
Thrown when an instance is required to have a Serializable interface. 
 | 
class  | 
ObjectStreamException
Superclass of all exceptions specific to Object Stream classes. 
 | 
class  | 
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. 
 | 
class  | 
StreamCorruptedException
Thrown when control information that was read from an object stream
 violates internal consistency checks. 
 | 
class  | 
SyncFailedException
Signals that a sync operation has failed. 
 | 
class  | 
UncheckedIOException
Wraps an  
IOException with an unchecked exception. | 
class  | 
UnsupportedEncodingException
The Character Encoding is not supported. 
 | 
class  | 
UTFDataFormatException
Signals that a malformed string in
 modified UTF-8
 format has been read in a data
 input stream or by any class that implements the data input
 interface. 
 | 
class  | 
WriteAbortedException
Signals that one of the ObjectStreamExceptions was thrown during a
 write operation. 
 | 
| Modifier and Type | Field and Description | 
|---|---|
Exception | 
WriteAbortedException.detail
Exception that was caught while writing the ObjectStream. 
 | 
| Constructor and Description | 
|---|
WriteAbortedException(String s,
                     Exception ex)
Constructs a WriteAbortedException with a string describing
 the exception and the exception causing the abort. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ArithmeticException
Thrown when an exceptional arithmetic condition has occurred. 
 | 
class  | 
ArrayIndexOutOfBoundsException
Thrown to indicate that an array has been accessed with an
 illegal index. 
 | 
class  | 
ArrayStoreException
Thrown to indicate that an attempt has been made to store the
 wrong type of object into an array of objects. 
 | 
class  | 
ClassCastException
Thrown to indicate that the code has attempted to cast an object
 to a subclass of which it is not an instance. 
 | 
class  | 
ClassNotFoundException
Thrown when an application tries to load in a class through its
 string name using:
 
 The  
forName method in class Class. | 
class  | 
CloneNotSupportedException
Thrown to indicate that the  
clone method in class
 Object has been called to clone an object, but that
 the object's class does not implement the Cloneable
 interface. | 
class  | 
EnumConstantNotPresentException
Thrown when an application tries to access an enum constant by name
 and the enum type contains no constant with the specified name. 
 | 
class  | 
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. 
 | 
class  | 
IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
 inappropriate argument. 
 | 
class  | 
IllegalMonitorStateException
Thrown to indicate that a thread has attempted to wait on an
 object's monitor or to notify other threads waiting on an object's
 monitor without owning the specified monitor. 
 | 
class  | 
IllegalStateException
Signals that a method has been invoked at an illegal or
 inappropriate time. 
 | 
class  | 
IllegalThreadStateException
Thrown to indicate that a thread is not in an appropriate state
 for the requested operation. 
 | 
class  | 
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. 
 | 
class  | 
InstantiationException
Thrown when an application tries to create an instance of a class
 using the  
newInstance method in class
 Class, but the specified class object cannot be
 instantiated. | 
class  | 
InterruptedException
Thrown when a thread is waiting, sleeping, or otherwise occupied,
 and the thread is interrupted, either before or during the activity. 
 | 
class  | 
NegativeArraySizeException
Thrown if an application tries to create an array with negative size. 
 | 
class  | 
NoSuchFieldException
Signals that the class doesn't have a field of a specified name. 
 | 
class  | 
NoSuchMethodException
Thrown when a particular method cannot be found. 
 | 
class  | 
NullPointerException
Thrown when an application attempts to use  
null in a
 case where an object is required. | 
class  | 
NumberFormatException
Thrown to indicate that the application has attempted to convert
 a string to one of the numeric types, but that the string does not
 have the appropriate format. 
 | 
class  | 
ReflectiveOperationException
Common superclass of exceptions thrown by reflective operations in
 core reflection. 
 | 
class  | 
RuntimeException
RuntimeException is the superclass of those
 exceptions that can be thrown during the normal operation of the
 Java Virtual Machine. | 
class  | 
SecurityException
Thrown by the security manager to indicate a security violation. 
 | 
class  | 
StringIndexOutOfBoundsException
Thrown by  
String methods to indicate that an index
 is either negative or greater than the size of the string. | 
class  | 
TypeNotPresentException
Thrown when an application tries to access a type using a string
 representing the type's name, but no definition for the type with
 the specified name can be found. 
 | 
class  | 
UnsupportedOperationException
Thrown to indicate that the requested operation is not supported. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
AutoCloseable.close()
Closes this resource, relinquishing any underlying resources. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AnnotationTypeMismatchException
Thrown to indicate that a program has attempted to access an element of
 an annotation whose type has changed after the annotation was compiled
 (or serialized). 
 | 
class  | 
IncompleteAnnotationException
Thrown to indicate that a program has attempted to access an element of
 an annotation type that was added to the annotation type definition after
 the annotation was compiled (or serialized). 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
IllegalClassFormatException
Thrown by an implementation of
  
ClassFileTransformer.transform
 when its input parameters are invalid. | 
class  | 
UnmodifiableClassException
Thrown by an implementation of
  
Instrumentation.redefineClasses
 when one of the specified classes cannot be modified. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
LambdaConversionException
LambdaConversionException 
 | 
class  | 
WrongMethodTypeException
Thrown to indicate that code has attempted to call a method handle
 via the wrong method type. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InvocationTargetException
InvocationTargetException is a checked exception that wraps
 an exception thrown by an invoked method or constructor. 
 | 
class  | 
MalformedParameterizedTypeException
Thrown when a semantically malformed parameterized type is
 encountered by a reflective method that needs to instantiate it. 
 | 
class  | 
MalformedParametersException
Thrown when  
the
 java.lang.reflect package attempts to read method parameters from
 a class file and determines that one or more parameters are
 malformed. | 
class  | 
UndeclaredThrowableException
Thrown by a method invocation on a proxy instance if its invocation
 handler's  
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. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
BindException
Signals that an error occurred while attempting to bind a
 socket to a local address and port. 
 | 
class  | 
HttpRetryException
Thrown to indicate that a HTTP request needs to be retried
 but cannot be retried automatically, due to streaming mode
 being enabled. 
 | 
class  | 
MalformedURLException
Thrown to indicate that a malformed URL has occurred. 
 | 
class  | 
NoRouteToHostException
Signals that an error occurred while attempting to connect a
 socket to a remote address and port. 
 | 
class  | 
PortUnreachableException
Signals that an ICMP Port Unreachable message has been
 received on a connected datagram. 
 | 
class  | 
ProtocolException
Thrown to indicate that there is an error in the underlying
 protocol, such as a TCP error. 
 | 
class  | 
SocketException
Thrown to indicate that there is an error creating or accessing a Socket. 
 | 
class  | 
SocketTimeoutException
Signals that a timeout has occurred on a socket read or accept. 
 | 
class  | 
UnknownHostException
Thrown to indicate that the IP address of a host could not be determined. 
 | 
class  | 
UnknownServiceException
Thrown to indicate that an unknown service exception has
 occurred. 
 | 
class  | 
URISyntaxException
Checked exception thrown to indicate that a string could not be parsed as a
 URI reference. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
BufferOverflowException
Unchecked exception thrown when a relative put operation reaches
 the target buffer's limit. 
 | 
class  | 
BufferUnderflowException
Unchecked exception thrown when a relative get operation reaches
 the source buffer's limit. 
 | 
class  | 
InvalidMarkException
Unchecked exception thrown when an attempt is made to reset a buffer
 when its mark is not defined. 
 | 
class  | 
ReadOnlyBufferException
Unchecked exception thrown when a content-mutation method such as
 put or compact is invoked upon a read-only buffer. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AcceptPendingException
Unchecked exception thrown when an attempt is made to initiate an accept
 operation on a channel and a previous accept operation has not completed. 
 | 
class  | 
AlreadyConnectedException
Unchecked exception thrown when an attempt is made to connect a  
SocketChannel that is already connected. | 
class  | 
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. 
 | 
class  | 
CancelledKeyException
Unchecked exception thrown when an attempt is made to use
 a selection key that is no longer valid. 
 | 
class  | 
ClosedByInterruptException
Checked exception received by a thread when another thread interrupts it
 while it is blocked in an I/O operation upon a channel. 
 | 
class  | 
ClosedChannelException
Checked exception thrown when an attempt is made to invoke or complete an
 I/O operation upon channel that is closed, or at least closed to that
 operation. 
 | 
class  | 
ClosedSelectorException
Unchecked exception thrown when an attempt is made to invoke an I/O
 operation upon a closed selector. 
 | 
class  | 
ConnectionPendingException
Unchecked exception thrown when an attempt is made to connect a  
SocketChannel for which a non-blocking connection operation is already in
 progress. | 
class  | 
FileLockInterruptionException
Checked exception received by a thread when another thread interrupts it
 while it is waiting to acquire a file lock. 
 | 
class  | 
IllegalBlockingModeException
Unchecked exception thrown when a blocking-mode-specific operation
 is invoked upon a channel in the incorrect blocking mode. 
 | 
class  | 
IllegalChannelGroupException
Unchecked exception thrown when an attempt is made to open a channel
 in a group that was not created by the same provider. 
 | 
class  | 
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. 
 | 
class  | 
InterruptedByTimeoutException
Checked exception received by a thread when a timeout elapses before an
 asynchronous operation completes. 
 | 
class  | 
NoConnectionPendingException
Unchecked exception thrown when the  
finishConnect method of a SocketChannel is invoked without first
 successfully invoking its connect method. | 
class  | 
NonReadableChannelException
Unchecked exception thrown when an attempt is made to read
 from a channel that was not originally opened for reading. 
 | 
class  | 
NonWritableChannelException
Unchecked exception thrown when an attempt is made to write
 to a channel that was not originally opened for writing. 
 | 
class  | 
NotYetBoundException
Unchecked exception thrown when an attempt is made to invoke an I/O
 operation upon a server socket channel that is not yet bound. 
 | 
class  | 
NotYetConnectedException
Unchecked exception thrown when an attempt is made to invoke an I/O
 operation upon a socket channel that is not yet connected. 
 | 
class  | 
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. 
 | 
class  | 
ReadPendingException
Unchecked exception thrown when an attempt is made to read from an
 asynchronous socket channel and a previous read has not completed. 
 | 
class  | 
ShutdownChannelGroupException
Unchecked exception thrown when an attempt is made to construct a channel in 
 a group that is shutdown or the completion handler for an I/O operation 
 cannot be invoked because the channel group has terminated. 
 | 
class  | 
UnresolvedAddressException
Unchecked exception thrown when an attempt is made to invoke a network
 operation upon an unresolved socket address. 
 | 
class  | 
UnsupportedAddressTypeException
Unchecked exception thrown when an attempt is made to bind or connect
 to a socket address of a type that is not supported. 
 | 
class  | 
WritePendingException
Unchecked exception thrown when an attempt is made to write to an
 asynchronous socket channel and a previous write has not completed. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
CharacterCodingException
Checked exception thrown when a character encoding
 or decoding error occurs. 
 | 
class  | 
IllegalCharsetNameException
Unchecked exception thrown when a string that is not a
 legal charset name is used as such. 
 | 
class  | 
MalformedInputException
Checked exception thrown when an input byte sequence is not legal for given
 charset, or an input character sequence is not a legal sixteen-bit Unicode
 sequence. 
 | 
class  | 
UnmappableCharacterException
Checked exception thrown when an input character (or byte) sequence
 is valid but cannot be mapped to an output byte (or character)
 sequence. 
 | 
class  | 
UnsupportedCharsetException
Unchecked exception thrown when no support is available
 for a requested charset. 
 | 
| Constructor and Description | 
|---|
CoderMalfunctionError(Exception cause)
Initializes an instance of this class. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AccessDeniedException
Checked exception thrown when a file system operation is denied, typically
 due to a file permission or other access check. 
 | 
class  | 
AtomicMoveNotSupportedException
Checked exception thrown when a file cannot be moved as an atomic file system
 operation. 
 | 
class  | 
ClosedDirectoryStreamException
Unchecked exception thrown when an attempt is made to invoke an operation on
 a directory stream that is closed. 
 | 
class  | 
ClosedFileSystemException
Unchecked exception thrown when an attempt is made to invoke an operation on
 a file and the file system is closed. 
 | 
class  | 
ClosedWatchServiceException
Unchecked exception thrown when an attempt is made to invoke an operation on
 a watch service that is closed. 
 | 
class  | 
DirectoryIteratorException
Runtime exception thrown if an I/O error is encountered when iterating over
 the entries in a directory. 
 | 
class  | 
DirectoryNotEmptyException
Checked exception thrown when a file system operation fails because a
 directory is not empty. 
 | 
class  | 
FileAlreadyExistsException
Checked exception thrown when an attempt is made to create a file or
 directory and a file of that name already exists. 
 | 
class  | 
FileSystemAlreadyExistsException
Runtime exception thrown when an attempt is made to create a file system that
 already exists. 
 | 
class  | 
FileSystemException
Thrown when a file system operation fails on one or two files. 
 | 
class  | 
FileSystemLoopException
Checked exception thrown when a file system loop, or cycle, is encountered. 
 | 
class  | 
FileSystemNotFoundException
Runtime exception thrown when a file system cannot be found. 
 | 
class  | 
InvalidPathException
Unchecked exception thrown when path string cannot be converted into a
  
Path because the path string contains invalid characters, or
 the path string is invalid for other file system specific reasons. | 
class  | 
NoSuchFileException
Checked exception thrown when an attempt is made to access a file that does
 not exist. 
 | 
class  | 
NotDirectoryException
Checked exception thrown when a file system operation, intended for a
 directory, fails because the file is not a directory. 
 | 
class  | 
NotLinkException
Checked exception thrown when a file system operation fails because a file
 is not a symbolic link. 
 | 
class  | 
ProviderMismatchException
Unchecked exception thrown when an attempt is made to invoke a method on an
 object created by one file system provider with a parameter created by a
 different file system provider. 
 | 
class  | 
ProviderNotFoundException
Runtime exception thrown when a provider of the required type cannot be found. 
 | 
class  | 
ReadOnlyFileSystemException
Unchecked exception thrown when an attempt is made to update an object
 associated with a  
read-only FileSystem. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
UserPrincipalNotFoundException
Checked exception thrown when a lookup of  
UserPrincipal fails because
 the principal does not exist. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
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. | 
class  | 
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. | 
class  | 
ConnectException
A  
ConnectException is thrown if a connection is refused
 to the remote host for a remote method call. | 
class  | 
ConnectIOException
A  
ConnectIOException is thrown if an
 IOException occurs while making a connection
 to the remote host for a remote method call. | 
class  | 
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. | 
class  | 
NotBoundException
A  
NotBoundException is thrown if an attempt
 is made to lookup or unbind in the registry a name that has
 no associated binding. | 
class  | 
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. | 
class  | 
RMISecurityException
Deprecated. 
 
Use  
SecurityException instead.
 Application code should never directly reference this class, and
 RMISecurityManager no longer throws this subclass of
 java.lang.SecurityException. | 
class  | 
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. | 
class  | 
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 or
 executing the remote method itself. | 
class  | 
ServerRuntimeException
Deprecated. 
 
no replacement 
 | 
class  | 
StubNotFoundException
A  
StubNotFoundException is thrown if a valid stub class
 could not be found for a remote object when it is exported. | 
class  | 
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. | 
class  | 
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). | 
| Constructor and Description | 
|---|
AccessException(String s,
               Exception ex)
Constructs an  
AccessException with the specified
 detail message and nested exception. | 
ConnectException(String s,
                Exception ex)
Constructs a  
ConnectException with the specified
 detail message and nested exception. | 
ConnectIOException(String s,
                  Exception ex)
Constructs a  
ConnectIOException with the specified
 detail message and nested exception. | 
MarshalException(String s,
                Exception ex)
Constructs a  
MarshalException with the specified
 detail message and nested exception. | 
ServerException(String s,
               Exception ex)
Constructs a  
ServerException with the specified
 detail message and nested exception. | 
ServerRuntimeException(String s,
                      Exception ex)
Deprecated. 
 
no replacement 
 | 
StubNotFoundException(String s,
                     Exception ex)
Constructs a  
StubNotFoundException with the specified
 detail message and nested exception. | 
UnexpectedException(String s,
                   Exception ex)
Constructs a  
UnexpectedException with the specified
 detail message and nested exception. | 
UnknownHostException(String s,
                    Exception ex)
Constructs an  
UnknownHostException with the specified
 detail message and nested exception. | 
UnmarshalException(String s,
                  Exception ex)
Constructs an  
UnmarshalException with the specified
 detail message and nested exception. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ActivateFailedException
This exception is thrown by the RMI runtime when activation
 fails during a remote call to an activatable object. 
 | 
class  | 
ActivationException
General exception used by the activation interfaces. 
 | 
class  | 
UnknownGroupException
An  
UnknownGroupException is thrown by methods of classes and
 interfaces in the java.rmi.activation package when the
 ActivationGroupID parameter to the method is determined to be
 invalid, i.e., not known by the ActivationSystem. | 
class  | 
UnknownObjectException
An  
UnknownObjectException is thrown by methods of classes and
 interfaces in the java.rmi.activation package when the
 ActivationID parameter to the method is determined to be
 invalid. | 
| Constructor and Description | 
|---|
ActivateFailedException(String s,
                       Exception ex)
Constructs an  
ActivateFailedException with the specified
 detail message and nested exception. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ExportException
An  
ExportException is a RemoteException
 thrown if an attempt to export a remote object fails. | 
class  | 
ServerCloneException
A  
ServerCloneException is thrown if a remote exception occurs
 during the cloning of a UnicastRemoteObject. | 
class  | 
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. | 
class  | 
SkeletonMismatchException
Deprecated. 
 
no replacement.  Skeletons are no longer required for remote
 method calls in the Java 2 platform v1.2 and greater. 
 | 
class  | 
SkeletonNotFoundException
Deprecated. 
 
no replacement.  Skeletons are no longer required for remote
 method calls in the Java 2 platform v1.2 and greater. 
 | 
class  | 
SocketSecurityException
Deprecated. 
 
This class is obsolete. Use  
ExportException instead. | 
| Modifier and Type | Field and Description | 
|---|---|
Exception | 
ServerCloneException.detail
The cause of the exception. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
boolean | 
RMIFailureHandler.failure(Exception ex)
The  
failure callback is invoked when the RMI
 runtime is unable to create a ServerSocket via the
 RMISocketFactory. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
Skeleton.dispatch(Remote obj,
        RemoteCall theCall,
        int opnum,
        long hash)
Deprecated. 
 
no replacement 
 | 
void | 
RemoteCall.executeCall()
Deprecated. 
 
no replacement 
 | 
void | 
RemoteRef.invoke(RemoteCall call)
Deprecated. 
 
1.2 style stubs no longer use this method. Instead of
 using a sequence of method calls to the remote reference
 ( 
newCall, invoke, and done), a
 stub uses a single method, invoke(Remote, Method, Object[],
 int), on the remote reference to carry out parameter
 marshalling, remote method executing and unmarshalling of the return
 value. | 
Object | 
RemoteRef.invoke(Remote obj,
      Method method,
      Object[] params,
      long opnum)
Invoke a method. 
 | 
| Constructor and Description | 
|---|
ExportException(String s,
               Exception ex)
Constructs an  
ExportException with the specified
 detail message and nested exception. | 
ServerCloneException(String s,
                    Exception cause)
Constructs a  
ServerCloneException with the specified
 detail message and cause. | 
SkeletonNotFoundException(String s,
                         Exception ex)
Deprecated.  
Constructs a  
SkeletonNotFoundException with the specified
 detail message and nested exception. | 
SocketSecurityException(String s,
                       Exception ex)
Deprecated.  
Constructs an  
SocketSecurityException with the specified
 detail message and nested exception. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AccessControlException
 This exception is thrown by the AccessController to indicate
 that a requested access (to a critical system resource such as the
 file system or the network) is denied. 
 | 
class  | 
DigestException
This is the generic Message Digest exception. 
 | 
class  | 
GeneralSecurityException
The  
GeneralSecurityException class is a generic
 security exception class that provides type safety for all the
 security-related exception classes that extend from it. | 
class  | 
InvalidAlgorithmParameterException
This is the exception for invalid or inappropriate algorithm parameters. 
 | 
class  | 
InvalidKeyException
This is the exception for invalid Keys (invalid encoding, wrong
 length, uninitialized, etc). 
 | 
class  | 
InvalidParameterException
This exception, designed for use by the JCA/JCE engine classes,
 is thrown when an invalid parameter is passed
 to a method. 
 | 
class  | 
KeyException
This is the basic key exception. 
 | 
class  | 
KeyManagementException
This is the general key management exception for all operations
 dealing with key management. 
 | 
class  | 
KeyStoreException
This is the generic KeyStore exception. 
 | 
class  | 
NoSuchAlgorithmException
This exception is thrown when a particular cryptographic algorithm is
 requested but is not available in the environment. 
 | 
class  | 
NoSuchProviderException
This exception is thrown when a particular security provider is
 requested but is not available in the environment. 
 | 
class  | 
PrivilegedActionException
This exception is thrown by
  
doPrivileged(PrivilegedExceptionAction) and
 doPrivileged(PrivilegedExceptionAction,
 AccessControlContext context) to indicate
 that the action being performed threw a checked exception. | 
class  | 
ProviderException
A runtime exception for Provider exceptions (such as
 misconfiguration errors or unrecoverable internal errors),
 which may be subclassed by Providers to
 throw specialized, provider-specific runtime errors. 
 | 
class  | 
SignatureException
This is the generic Signature exception. 
 | 
class  | 
UnrecoverableEntryException
This exception is thrown if an entry in the keystore cannot be recovered. 
 | 
class  | 
UnrecoverableKeyException
This exception is thrown if a key in the keystore cannot be recovered. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Exception | 
PrivilegedActionException.getException()
Returns the exception thrown by the privileged computation that
 resulted in this  
PrivilegedActionException. | 
| Modifier and Type | Method and Description | 
|---|---|
T | 
PrivilegedExceptionAction.run()
Performs the computation. 
 | 
| Constructor and Description | 
|---|
PrivilegedActionException(Exception exception)
Constructs a new PrivilegedActionException "wrapping"
 the specific Exception. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AclNotFoundException
This is an exception that is thrown whenever a reference is made to a
 non-existent ACL (Access Control List). 
 | 
class  | 
LastOwnerException
This is an exception that is thrown whenever an attempt is made to delete
 the last owner of an Access Control List. 
 | 
class  | 
NotOwnerException
This is an exception that is thrown whenever the modification of an object
 (such as an Access Control List) is only allowed to be done by an owner of
 the object, but the Principal attempting the modification is not an owner. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
CertificateRevokedException
An exception that indicates an X.509 certificate is revoked. 
 | 
class  | 
CertPathBuilderException
An exception indicating one of a variety of problems encountered when
 building a certification path with a  
CertPathBuilder. | 
class  | 
CertPathValidatorException
An exception indicating one of a variety of problems encountered when
 validating a certification path. 
 | 
class  | 
CertStoreException
An exception indicating one of a variety of problems retrieving
 certificates and CRLs from a  
CertStore. | 
class  | 
CRLException
CRL (Certificate Revocation List) Exception. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InvalidKeySpecException
This is the exception for invalid key specifications. 
 | 
class  | 
InvalidParameterSpecException
This is the exception for invalid parameter specifications. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
BatchUpdateException
The subclass of  
SQLException thrown when an error
 occurs during a batch update operation. | 
class  | 
DataTruncation
An exception  thrown as a  
DataTruncation exception
 (on writes) or reported as a
 DataTruncation warning (on reads)
  when a data values is unexpectedly truncated for reasons other than its having
  exceeded MaxFieldSize. | 
class  | 
SQLClientInfoException
The subclass of  
SQLException is thrown when one or more client info properties
 could not be set on a Connection. | 
class  | 
SQLDataException
The subclass of  
SQLException thrown when the SQLState class value
 is '22', or under vendor-specified conditions. | 
class  | 
SQLException
An exception that provides information on a database access
 error or other errors. 
 | 
class  | 
SQLFeatureNotSupportedException
The subclass of  
SQLException thrown when the SQLState class value is '0A'
 ( the value is 'zero' A). | 
class  | 
SQLIntegrityConstraintViolationException
The subclass of  
SQLException thrown when the SQLState class value
 is '23', or under vendor-specified conditions. | 
class  | 
SQLInvalidAuthorizationSpecException
The subclass of  
SQLException thrown when the SQLState class value
 is '28', or under vendor-specified conditions. | 
class  | 
SQLNonTransientConnectionException
The subclass of  
SQLException thrown for the SQLState
 class value '08', or under vendor-specified conditions. | 
class  | 
SQLNonTransientException
The subclass of  
SQLException thrown when an instance where a retry
 of the same operation would fail unless the cause of the SQLException
 is corrected. | 
class  | 
SQLRecoverableException
The subclass of  
SQLException thrown in situations where a
 previously failed operation might be able to succeed if the application performs
  some recovery steps and retries the entire transaction or in the case of a
 distributed transaction, the transaction branch. | 
class  | 
SQLSyntaxErrorException
The subclass of  
SQLException thrown when the SQLState class value
 is '42', or under vendor-specified conditions. | 
class  | 
SQLTimeoutException
The subclass of  
SQLException thrown when the timeout specified by
 Statement.setQueryTimeout, DriverManager.setLoginTimeout,
 DataSource.setLoginTimeout,XADataSource.setLoginTimeout
 has expired. | 
class  | 
SQLTransactionRollbackException
The subclass of  
SQLException thrown when the SQLState class value
 is '40', or under vendor-specified conditions. | 
class  | 
SQLTransientConnectionException
The subclass of  
SQLException for the SQLState class
 value '08', or under vendor-specified conditions. | 
class  | 
SQLTransientException
The subclass of  
SQLException is thrown in situations where a
 previously failed operation might be able to succeed when the operation is
 retried without any intervention by application-level functionality. | 
class  | 
SQLWarning
An exception that provides information on  database access
 warnings. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ParseException
Signals that an error has been reached unexpectedly
 while parsing. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DateTimeException
Exception used to indicate a problem while calculating a date-time. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DateTimeParseException
An exception thrown when an error occurs during parsing. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
UnsupportedTemporalTypeException
UnsupportedTemporalTypeException indicates that a ChronoField or ChronoUnit is
 not supported for a Temporal class. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ZoneRulesException
Thrown to indicate a problem with time-zone configuration. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ConcurrentModificationException
This exception may be thrown by methods that have detected concurrent
 modification of an object when such modification is not permissible. 
 | 
class  | 
DuplicateFormatFlagsException
Unchecked exception thrown when duplicate flags are provided in the format
 specifier. 
 | 
class  | 
EmptyStackException
Thrown by methods in the  
Stack class to indicate
 that the stack is empty. | 
class  | 
FormatFlagsConversionMismatchException
Unchecked exception thrown when a conversion and flag are incompatible. 
 | 
class  | 
FormatterClosedException
Unchecked exception thrown when the formatter has been closed. 
 | 
class  | 
IllegalFormatCodePointException
Unchecked exception thrown when a character with an invalid Unicode code
 point as defined by  
Character.isValidCodePoint(int) is passed to the
 Formatter. | 
class  | 
IllegalFormatConversionException
Unchecked exception thrown when the argument corresponding to the format
 specifier is of an incompatible type. 
 | 
class  | 
IllegalFormatException
Unchecked exception thrown when a format string contains an illegal syntax
 or a format specifier that is incompatible with the given arguments. 
 | 
class  | 
IllegalFormatFlagsException
Unchecked exception thrown when an illegal combination flags is given. 
 | 
class  | 
IllegalFormatPrecisionException
Unchecked exception thrown when the precision is a negative value other than
 -1, the conversion does not support a precision, or the value is
 otherwise unsupported. 
 | 
class  | 
IllegalFormatWidthException
Unchecked exception thrown when the format width is a negative value other
 than -1 or is otherwise unsupported. 
 | 
class  | 
IllformedLocaleException
Thrown by methods in  
Locale and Locale.Builder to
 indicate that an argument is not a well-formed BCP 47 tag. | 
class  | 
InputMismatchException
Thrown by a  
Scanner to indicate that the token
 retrieved does not match the pattern for the expected type, or
 that the token is out of range for the expected type. | 
class  | 
InvalidPropertiesFormatException
Thrown to indicate that an operation could not complete because
 the input did not conform to the appropriate XML document type
 for a collection of properties, as per the  
Properties
 specification. | 
class  | 
MissingFormatArgumentException
Unchecked exception thrown when there is a format specifier which does not
 have a corresponding argument or if an argument index refers to an argument
 that does not exist. 
 | 
class  | 
MissingFormatWidthException
Unchecked exception thrown when the format width is required. 
 | 
class  | 
MissingResourceException
Signals that a resource is missing. 
 | 
class  | 
NoSuchElementException
Thrown by various accessor methods to indicate that the element being requested
 does not exist. 
 | 
class  | 
TooManyListenersException
 The  
 TooManyListenersException  Exception is used as part of
 the Java Event model to annotate and implement a unicast special case of
 a multicast Event Source. | 
class  | 
UnknownFormatConversionException
Unchecked exception thrown when an unknown conversion is given. 
 | 
class  | 
UnknownFormatFlagsException
Unchecked exception thrown when an unknown flag is given. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
BrokenBarrierException
Exception thrown when a thread tries to wait upon a barrier that is
 in a broken state, or which enters the broken state while the thread
 is waiting. 
 | 
class  | 
CancellationException
Exception indicating that the result of a value-producing task,
 such as a  
FutureTask, cannot be retrieved because the task
 was cancelled. | 
class  | 
CompletionException
Exception thrown when an error or other exception is encountered
 in the course of completing a result or task. 
 | 
class  | 
ExecutionException
Exception thrown when attempting to retrieve the result of a task
 that aborted by throwing an exception. 
 | 
class  | 
RejectedExecutionException
Exception thrown by an  
Executor when a task cannot be
 accepted for execution. | 
class  | 
TimeoutException
Exception thrown when a blocking operation times out. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
V | 
Callable.call()
Computes a result, or throws an exception if unable to do so. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
JarException
Signals that an error of some sort has occurred while reading from
 or writing to a JAR file. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
ErrorManager.error(String msg,
     Exception ex,
     int code)
The error method is called when a Handler failure occurs. 
 | 
protected void | 
Handler.reportError(String msg,
           Exception ex,
           int code)
Protected convenience method to report an error to this Handler's
 ErrorManager. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
BackingStoreException
Thrown to indicate that a preferences operation could not complete because
 of a failure in the backing store, or a failure to contact the backing
 store. 
 | 
class  | 
InvalidPreferencesFormatException
Thrown to indicate that an operation could not complete because
 the input did not conform to the appropriate XML document type
 for a collection of preferences, as per the  
Preferences
 specification. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
PatternSyntaxException
Unchecked exception thrown to indicate a syntax error in a
 regular-expression pattern. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DataFormatException
Signals that a data format error has occurred. 
 | 
class  | 
ZipException
Signals that a Zip exception of some sort has occurred. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
UnsupportedDataTypeException
Signals that the requested operation does not support the
 requested data type. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ActivityCompletedException
This exception may be thrown on any method for which Activity context is
 accessed and indicates that ongoing work within the Activity is not
 possible. 
 | 
class  | 
ActivityRequiredException
This exception is thrown by a container if Activity context is not received
 on a method for which Activity context is mandatory. 
 | 
class  | 
InvalidActivityException
This exception may be thrown on any method for which Activity context
 is accessed and indicates that the attempted invocation or the Activity
 context associated with the attempted invocation is incompatible with
 the Activity's current state. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
FilerException
Indicates a  
Filer detected an attempt to open a file that
 would violate the guarantees provided by the Filer. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AEADBadTagException
This exception is thrown when a  
Cipher operating in
 an AEAD mode (such as GCM/CCM) is unable to verify the supplied
 authentication tag. | 
class  | 
BadPaddingException
This exception is thrown when a particular padding mechanism is
 expected for the input data but the data is not padded properly. 
 | 
class  | 
ExemptionMechanismException
This is the generic ExemptionMechanism exception. 
 | 
class  | 
IllegalBlockSizeException
This exception is thrown when the length of data provided to a block
 cipher is incorrect, i.e., does not match the block size of the cipher. 
 | 
class  | 
NoSuchPaddingException
This exception is thrown when a particular padding mechanism is
 requested but is not available in the environment. 
 | 
class  | 
ShortBufferException
This exception is thrown when an output buffer provided by the user
 is too short to hold the operation result. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
IIOException
An exception class used for signaling run-time failure of reading
 and writing operations. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
IIOInvalidTreeException
An  
IIOInvalidTreeException is thrown when an attempt
 by an IIOMetadata object to parse a tree of
 IIOMetadataNodes fails. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
UnknownEntityException
Superclass of exceptions which indicate that an unknown kind of
 entity was encountered. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
UnknownAnnotationValueException
Indicates that an unknown kind of annotation value was encountered. 
 | 
class  | 
UnknownElementException
Indicates that an unknown kind of element was encountered. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
MirroredTypeException
Thrown when an application attempts to access the  
Class object
 corresponding to a TypeMirror. | 
class  | 
MirroredTypesException
Thrown when an application attempts to access a sequence of  
Class objects each corresponding to a TypeMirror. | 
class  | 
UnknownTypeException
Indicates that an unknown kind of type was encountered. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AttributeNotFoundException
The specified attribute does not exist or cannot be retrieved. 
 | 
class  | 
BadAttributeValueExpException
Thrown when an invalid MBean attribute is passed to a query
 constructing method. 
 | 
class  | 
BadBinaryOpValueExpException
Thrown when an invalid expression is passed to a method for
 constructing a query. 
 | 
class  | 
BadStringOperationException
Thrown when an invalid string operation is passed
 to a method for constructing a query. 
 | 
class  | 
InstanceAlreadyExistsException
The MBean is already registered in the repository. 
 | 
class  | 
InstanceNotFoundException
The specified MBean does not exist in the repository. 
 | 
class  | 
InvalidApplicationException
Thrown when an attempt is made to apply either of the following: A
 subquery expression to an MBean or a qualified attribute expression
 to an MBean of the wrong class. 
 | 
class  | 
InvalidAttributeValueException
The value specified is not valid for the attribute. 
 | 
class  | 
JMException
Exceptions thrown by JMX implementations. 
 | 
class  | 
JMRuntimeException
Runtime exceptions emitted by JMX implementations. 
 | 
class  | 
ListenerNotFoundException
The specified MBean listener does not exist in the repository. 
 | 
class  | 
MalformedObjectNameException
The format of the string does not correspond to a valid ObjectName. 
 | 
class  | 
MBeanException
Represents "user defined" exceptions thrown by MBean methods
 in the agent. 
 | 
class  | 
MBeanRegistrationException
Wraps exceptions thrown by the preRegister(), preDeregister() methods
 of the  
MBeanRegistration interface. | 
class  | 
NotCompliantMBeanException
Exception which occurs when trying to register an  object in the MBean server that is not a JMX compliant MBean. 
 | 
class  | 
OperationsException
Represents exceptions thrown in the MBean server when performing operations
 on MBeans. 
 | 
class  | 
ReflectionException
Represents exceptions thrown in the MBean server when using the
 java.lang.reflect classes to invoke methods on MBeans. 
 | 
class  | 
RuntimeErrorException
When a  
java.lang.Error occurs in the agent it should be caught and
 re-thrown as a RuntimeErrorException. | 
class  | 
RuntimeMBeanException
Represents runtime exceptions thrown by MBean methods in
 the agent. 
 | 
class  | 
RuntimeOperationsException
Represents runtime exceptions thrown in the agent when performing operations on MBeans. 
 | 
class  | 
ServiceNotFoundException
Represents exceptions raised when a requested service is not supported. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Exception | 
ReflectionException.getTargetException()
Returns the actual  
Exception thrown. | 
Exception | 
MBeanException.getTargetException()
Return the actual  
Exception thrown. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
StandardMBean.preDeregister()
Allows the MBean to perform any operations it needs before
 being unregistered by the MBean server. 
 | 
void | 
MBeanRegistration.preDeregister()
Allows the MBean to perform any operations it needs before
 being unregistered by the MBean server. 
 | 
ObjectName | 
StandardMBean.preRegister(MBeanServer server,
           ObjectName name)
Allows the MBean to perform any operations it needs before
 being registered in the MBean server. 
 | 
ObjectName | 
MBeanRegistration.preRegister(MBeanServer server,
           ObjectName name)
Allows the MBean to perform any operations it needs before
 being registered in the MBean Server. 
 | 
| Constructor and Description | 
|---|
MBeanException(Exception e)
Creates an  
MBeanException that wraps the actual java.lang.Exception. | 
MBeanException(Exception e,
              String message)
Creates an  
MBeanException that wraps the actual java.lang.Exception with
 a detail message. | 
MBeanRegistrationException(Exception e)
Creates an  
MBeanRegistrationException that wraps
 the actual java.lang.Exception. | 
MBeanRegistrationException(Exception e,
                          String message)
Creates an  
MBeanRegistrationException that wraps
 the actual java.lang.Exception with a detailed
 message. | 
ReflectionException(Exception e)
Creates a  
ReflectionException that wraps the actual java.lang.Exception. | 
ReflectionException(Exception e,
                   String message)
Creates a  
ReflectionException that wraps the actual java.lang.Exception with
 a detail message. | 
| Modifier and Type | Method and Description | 
|---|---|
protected URL | 
MLet.check(String version,
     URL codebase,
     String jarfile,
     MLetContent mlet)
This method is to be overridden when extending this service to
 support caching and versioning. 
 | 
void | 
MLet.preDeregister()
Allows the m-let to perform any operations it needs before being unregistered
 by the MBean server. 
 | 
ObjectName | 
MLet.preRegister(MBeanServer server,
           ObjectName name)
Allows the m-let to perform any operations it needs before
 being registered in the MBean server. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InvalidTargetObjectTypeException
Exception thrown when an invalid target object type is specified. 
 | 
class  | 
XMLParseException
This exception is thrown when an XML formatted string is being parsed into ModelMBean objects
 or when XML formatted strings are being created from ModelMBean objects. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
RequiredModelMBean.preDeregister()
Allows the MBean to perform any operations it needs before
 being unregistered by the MBean server. 
 | 
ObjectName | 
RequiredModelMBean.preRegister(MBeanServer server,
           ObjectName name)
Allows the MBean to perform any operations it needs before
 being registered in the MBean server. 
 | 
| Constructor and Description | 
|---|
InvalidTargetObjectTypeException(Exception e,
                                String s)
Constructor taking an exception and a string. 
 | 
XMLParseException(Exception e,
                 String s)
Constructor taking a string and an exception. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
MonitorSettingException
Exception thrown by the monitor when a monitor setting becomes invalid while the monitor is running. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
Monitor.preDeregister()
Allows the monitor MBean to perform any operations it needs
 before being unregistered by the MBean server. 
 | 
ObjectName | 
Monitor.preRegister(MBeanServer server,
           ObjectName name)
Allows the monitor MBean to perform any operations it needs
 before being registered in the MBean server. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InvalidOpenTypeException
This runtime exception is thrown to indicate that the open type of an open data value
 is not the one expected. 
 | 
class  | 
KeyAlreadyExistsException
This runtime exception is thrown to indicate that the index of a row to be added to a tabular data instance
 is already used to refer to another row in this tabular data instance. 
 | 
class  | 
OpenDataException
This checked exception is thrown when an open type, an open data  or an open MBean metadata info instance
 could not be constructed because one or more validity constraints were not met. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InvalidRelationIdException
This exception is raised when relation id provided for a relation is already
 used. 
 | 
class  | 
InvalidRelationServiceException
This exception is raised when an invalid Relation Service is provided. 
 | 
class  | 
InvalidRelationTypeException
Invalid relation type. 
 | 
class  | 
InvalidRoleInfoException
This exception is raised when, in a role info, its minimum degree is greater
 than its maximum degree. 
 | 
class  | 
InvalidRoleValueException
Role value is invalid. 
 | 
class  | 
RelationException
This class is the superclass of any exception which can be raised during
 relation management. 
 | 
class  | 
RelationNotFoundException
This exception is raised when there is no relation for a given relation id
 in a Relation Service. 
 | 
class  | 
RelationServiceNotRegisteredException
This exception is raised when an access is done to the Relation Service and
 that one is not registered. 
 | 
class  | 
RelationTypeNotFoundException
This exception is raised when there is no relation type with given name in
 Relation Service. 
 | 
class  | 
RoleInfoNotFoundException
This exception is raised when there is no role info with given name in a
 given relation type. 
 | 
class  | 
RoleNotFoundException
This exception is raised when a role in a relation does not exist, or is not
 readable, or is not settable. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
RelationService.preDeregister()  | 
void | 
RelationSupport.preDeregister()  | 
ObjectName | 
RelationService.preRegister(MBeanServer server,
           ObjectName name)  | 
ObjectName | 
RelationSupport.preRegister(MBeanServer server,
           ObjectName name)  | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
JMXProviderException
Exception thrown by  
JMXConnectorFactory and
 JMXConnectorServerFactory when a provider exists for
 the required protocol but cannot be used for some reason. | 
class  | 
JMXServerErrorException
Exception thrown as the result of a remote  
MBeanServer
 method invocation when an Error is thrown while
 processing the invocation in the remote MBean server. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
JMXConnectorServer.preDeregister()
Called by an MBean server when this connector server is
 unregistered from that MBean server. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
Timer.preDeregister()
Allows the timer MBean to perform any operations it needs before being unregistered
 by the MBean server. 
 | 
ObjectName | 
Timer.preRegister(MBeanServer server,
           ObjectName name)
Allows the timer MBean to perform any operations it needs before being registered
 in the MBean server. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AuthenticationNotSupportedException
This exception is thrown when
 the particular flavor of authentication requested is not supported. 
 | 
class  | 
CannotProceedException
This exception is thrown to indicate that the operation reached
 a point in the name where the operation cannot proceed any further. 
 | 
class  | 
CommunicationException
This exception is thrown when the client is
 unable to communicate with the directory or naming service. 
 | 
class  | 
ConfigurationException
This exception is thrown when there is a configuration problem. 
 | 
class  | 
ContextNotEmptyException
This exception is thrown when attempting to destroy a context that
 is not empty. 
 | 
class  | 
InsufficientResourcesException
This exception is thrown when resources are not available to complete
 the requested operation. 
 | 
class  | 
InterruptedNamingException
This exception is thrown when the naming operation
 being invoked has been interrupted. 
 | 
class  | 
InvalidNameException
This exception indicates that the name being specified does
 not conform to the naming syntax of a naming system. 
 | 
class  | 
LimitExceededException
This exception is thrown when a method
 terminates abnormally due to a user or system specified limit. 
 | 
class  | 
LinkException
This exception is used to describe problems encounter while resolving links. 
 | 
class  | 
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. 
 | 
class  | 
MalformedLinkException
This exception is thrown when a malformed link was encountered while
 resolving or constructing a link. 
 | 
class  | 
NameAlreadyBoundException
This exception is thrown by methods to indicate that
 a binding cannot be added because the name is already bound to
 another object. 
 | 
class  | 
NameNotFoundException
This exception is thrown when a component of the name cannot be resolved
 because it is not bound. 
 | 
class  | 
NamingException
This is the superclass of all exceptions thrown by
 operations in the Context and DirContext interfaces. 
 | 
class  | 
NamingSecurityException
This is the superclass of security-related exceptions
 thrown by operations in the Context and DirContext interfaces. 
 | 
class  | 
NoInitialContextException
This exception is thrown when no initial context implementation
 can be created. 
 | 
class  | 
NoPermissionException
This exception is thrown when attempting to perform an operation
 for which the client has no permission. 
 | 
class  | 
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. 
 | 
class  | 
OperationNotSupportedException
This exception is thrown when a context implementation does not support
 the operation being invoked. 
 | 
class  | 
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. 
 | 
class  | 
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. 
 | 
class  | 
ServiceUnavailableException
This exception is thrown when attempting to communicate with a
 directory or naming service and that service is not available. 
 | 
class  | 
SizeLimitExceededException
This exception is thrown when a method
 produces a result that exceeds a size-related limit. 
 | 
class  | 
TimeLimitExceededException
This exception is thrown when a method
 does not terminate within the specified time limit. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AttributeInUseException
This exception is thrown when an operation attempts
 to add an attribute that already exists. 
 | 
class  | 
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. 
 | 
class  | 
InvalidAttributeIdentifierException
This exception is thrown when an attempt is
 made to add to create an attribute with an invalid attribute identifier. 
 | 
class  | 
InvalidAttributesException
This exception is thrown when an attempt is
 made to add or modify an attribute set that has been specified
 incompletely or incorrectly. 
 | 
class  | 
InvalidSearchControlsException
This exception is thrown when the specification of
 the SearchControls for a search operation is invalid. 
 | 
class  | 
InvalidSearchFilterException
This exception is thrown when the specification of
 a search filter is invalid. 
 | 
class  | 
NoSuchAttributeException
This exception is thrown when attempting to access
 an attribute that does not exist. 
 | 
class  | 
SchemaViolationException
This exception is thrown when a method
 in some ways violates the schema. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
LdapReferralException
This abstract class is used to represent an LDAP referral exception. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static Object | 
NamingManager.getObjectInstance(Object refInfo,
                 Name name,
                 Context nameCtx,
                 Hashtable<?,?> environment)
Creates an instance of an object for the specified object
 and environment. 
 | 
Object | 
ObjectFactory.getObjectInstance(Object obj,
                 Name name,
                 Context nameCtx,
                 Hashtable<?,?> environment)
Creates an object using the location or reference information
 specified. 
 | 
static Object | 
DirectoryManager.getObjectInstance(Object refInfo,
                 Name name,
                 Context nameCtx,
                 Hashtable<?,?> environment,
                 Attributes attrs)
Creates an instance of an object for the specified object,
 attributes, and environment. 
 | 
Object | 
DirObjectFactory.getObjectInstance(Object obj,
                 Name name,
                 Context nameCtx,
                 Hashtable<?,?> environment,
                 Attributes attrs)
Creates an object using the location or reference information, and attributes
 specified. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
SSLException
Indicates some kind of error detected by an SSL subsystem. 
 | 
class  | 
SSLHandshakeException
Indicates that the client and server could not negotiate the
 desired level of security. 
 | 
class  | 
SSLKeyException
Reports a bad SSL key. 
 | 
class  | 
SSLPeerUnverifiedException
Indicates that the peer's identity has not been verified. 
 | 
class  | 
SSLProtocolException
Reports an error in the operation of the SSL protocol. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
PrintException
Class PrintException encapsulates a printing-related error condition that
 occurred while using a Print Service instance. 
 | 
| Constructor and Description | 
|---|
PrintException(Exception e)
Construct a print exception chaining the supplied exception. 
 | 
PrintException(String s,
              Exception e)
Construct a print exception with the given detail message
 and chained exception. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
UnmodifiableSetException
Thrown to indicate that the requested operation cannot be performed
 because the set is unmodifiable. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ScriptException
The generic  
Exception class for the Scripting APIs. | 
| Constructor and Description | 
|---|
ScriptException(Exception e)
Creates a  
ScriptException wrapping an Exception thrown by an underlying
 interpreter. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DestroyFailedException
Signals that a  
destroy operation failed. | 
class  | 
RefreshFailedException
Signals that a  
refresh operation failed. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
UnsupportedCallbackException
Signals that a  
CallbackHandler does not
 recognize a particular Callback. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AccountException
A generic account exception. 
 | 
class  | 
AccountExpiredException
Signals that a user account has expired. 
 | 
class  | 
AccountLockedException
Signals that an account was locked. 
 | 
class  | 
AccountNotFoundException
Signals that an account was not found. 
 | 
class  | 
CredentialException
A generic credential exception. 
 | 
class  | 
CredentialExpiredException
Signals that a  
Credential has expired. | 
class  | 
CredentialNotFoundException
Signals that a credential was not found. 
 | 
class  | 
FailedLoginException
Signals that user authentication failed. 
 | 
class  | 
LoginException
This is the basic login exception. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
CertificateEncodingException
Certificate Encoding Exception. 
 | 
class  | 
CertificateException
This exception indicates one of a variety of certificate problems. 
 | 
class  | 
CertificateExpiredException
Certificate Expired Exception. 
 | 
class  | 
CertificateNotYetValidException
Certificate is not yet valid exception. 
 | 
class  | 
CertificateParsingException
Certificate Parsing Exception. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AuthenticationException
This exception is thrown by a SASL mechanism implementation
 to indicate that the SASL
 exchange has failed due to reasons related to authentication, such as
 an invalid identity, passphrase, or key. 
 | 
class  | 
SaslException
This class represents an error that has occurred when using SASL. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InvalidMidiDataException
An  
InvalidMidiDataException indicates that inappropriate MIDI
 data was encountered. | 
class  | 
MidiUnavailableException
A  
MidiUnavailableException is thrown when a requested MIDI
 component cannot be opened or created because it is unavailable. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
LineUnavailableException
A  
LineUnavailableException is an exception indicating that a
 line cannot be opened because it is unavailable. | 
class  | 
UnsupportedAudioFileException
An  
UnsupportedAudioFileException is an exception indicating that an
 operation failed because a file did not contain valid data of a recognized file
 type and format. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
RowSetWarning
An extension of  
SQLException that provides information
 about database warnings set on RowSet objects. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
SerialException
Indicates and an error with the serialization or de-serialization of
 SQL types such as  
BLOB, CLOB, STRUCT or ARRAY in
 addition to SQL types such as DATALINK and JAVAOBJECT | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
SyncFactoryException
Indicates an error with  
SyncFactory mechanism. | 
class  | 
SyncProviderException
Indicates an error with the  
SyncProvider mechanism. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
UnsupportedLookAndFeelException
An exception that indicates the requested look & feel
 management classes are not present on the user's system. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected abstract T | 
SwingWorker.doInBackground()
Computes a result, or throws an exception if unable to do so. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
BadLocationException
This exception is to report bad locations within a document model
 (that is, attempts to reference a location that doesn't exist). 
 | 
class  | 
ChangedCharSetException
ChangedCharSetException as the name indicates is an exception
 thrown when the charset is changed. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ExpandVetoException
Exception used to stop and expand/collapse from happening. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
CannotRedoException
Thrown when an UndoableEdit is told to  
redo() and can't. | 
class  | 
CannotUndoException
Thrown when an UndoableEdit is told to  
undo() and can't. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InvalidTransactionException
This exception indicates that the request carried an invalid transaction
 context. 
 | 
class  | 
TransactionRequiredException
This exception indicates that a request carried a null transaction context,
 but the target object requires an activate transaction. 
 | 
class  | 
TransactionRolledbackException
This exception indicates that the transaction associated with processing
 of the request has been rolled back, or marked to roll back. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
XAException
The XAException is thrown by the Resource Manager (RM) to inform the
 Transaction Manager of an error encountered by the involved transaction. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DataBindingException
Exception that represents a failure in a JAXB operation. 
 | 
class  | 
JAXBException
This is the root exception class for all JAXB exceptions. 
 | 
class  | 
PropertyException
This exception indicates that an error was encountered while getting or
 setting a property. 
 | 
class  | 
TypeConstraintException
This exception indicates that a violation of a dynamically checked type
 constraint was detected. 
 | 
class  | 
ValidationException
This exception indicates that an error has occurred while performing
 a validate operation. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
abstract ValueType | 
XmlAdapter.marshal(BoundType v)
Convert a bound type to a value type. 
 | 
abstract BoundType | 
XmlAdapter.unmarshal(ValueType v)
Convert a value type to a bound type. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
KeySelectorException
Indicates an exceptional condition thrown by a  
KeySelector. | 
class  | 
MarshalException
Indicates an exceptional condition that occurred during the XML
 marshalling or unmarshalling process. 
 | 
class  | 
NoSuchMechanismException
This exception is thrown when a particular XML mechanism is requested but
 is not available in the environment. 
 | 
class  | 
URIReferenceException
Indicates an exceptional condition thrown while dereferencing a
  
URIReference. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
TransformException
Indicates an exceptional condition that occurred while executing a
 transform algorithm. 
 | 
class  | 
XMLSignatureException
Indicates an exceptional condition that occurred during the XML
 signature generation or validation process. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DatatypeConfigurationException
Indicates a serious configuration error. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ParserConfigurationException
Indicates a serious configuration error. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Exception | 
FactoryConfigurationError.getException()
Return the actual exception (if any) that caused this exception to
 be raised. 
 | 
| Constructor and Description | 
|---|
FactoryConfigurationError(Exception e)
Create a new  
FactoryConfigurationError with a
 given Exception base cause of the error. | 
FactoryConfigurationError(Exception e,
                         String msg)
Create a new  
FactoryConfigurationError with the
 given Exception base cause and detail message. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
SOAPException
An exception that signals that a SOAP exception has occurred. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
XMLStreamException
The base exception for unexpected processing errors. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Exception | 
FactoryConfigurationError.getException()
Return the nested exception (if any) 
 | 
| Constructor and Description | 
|---|
FactoryConfigurationError(Exception e)
Construct an exception with a nested inner exception 
 | 
FactoryConfigurationError(Exception e,
                         String msg)
Construct an exception with a nested inner exception
 and a message 
 | 
FactoryConfigurationError(String msg,
                         Exception e)
Construct an exception with a nested inner exception
 and a message 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
TransformerConfigurationException
Indicates a serious configuration error. 
 | 
class  | 
TransformerException
This class specifies an exceptional condition that occurred
 during the transformation process. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Exception | 
TransformerFactoryConfigurationError.getException()
Return the actual exception (if any) that caused this exception to
 be raised. 
 | 
| Constructor and Description | 
|---|
TransformerFactoryConfigurationError(Exception e)
Create a new  
TransformerFactoryConfigurationError with a
 given Exception base cause of the error. | 
TransformerFactoryConfigurationError(Exception e,
                                    String msg)
Create a new  
TransformerFactoryConfigurationError with the
 given Exception base cause and detail message. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
WebServiceException
The  
WebServiceException class is the base
  exception class for all JAX-WS API runtime exceptions. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
HTTPException
The  
HTTPException exception represents a
  XML/HTTP fault. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
SOAPFaultException
The  
SOAPFaultException exception represents a
  SOAP 1.1 or 1.2 fault. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
XPathException
XPathException represents a generic XPath exception. | 
class  | 
XPathExpressionException
XPathExpressionException represents an error in an XPath expression. | 
class  | 
XPathFactoryConfigurationException
XPathFactoryConfigurationException represents a configuration error in a XPathFactory environment. | 
class  | 
XPathFunctionException
XPathFunctionException represents an error with an XPath function. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
GSSException
This exception is thrown whenever a GSS-API error occurs, including
 any mechanism specific error. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ACTIVITY_COMPLETED
The  
ACTIVITY_COMPLETED system exception may be raised on any
 method for which Activity context is accessed. | 
class  | 
ACTIVITY_REQUIRED
The  
ACTIVITY_REQUIRED system exception may be raised on any
 method for which an Activity context is required. | 
class  | 
BAD_CONTEXT
Exception thrown when an operation is invoked by a client but the passed
 context does not contain the context values required by the operation. 
 | 
class  | 
BAD_INV_ORDER
This exception indicates that the caller has invoked operations in
 the wrong order. 
 | 
class  | 
BAD_OPERATION
Exception thrown when an object reference denotes an existing object,
 but that the object does not support the operation that was invoked. 
 | 
class  | 
BAD_PARAM
Exception  thrown
 when a parameter passed to a call is out of range or
 otherwise considered illegal. 
 | 
class  | 
BAD_QOS
The  
BAD_QOS exception is raised whenever an object cannot
 support the quality of service required by an invocation parameter that
 has a quality of service semantics associated with it. | 
class  | 
BAD_TYPECODE
Exception thrown when the ORB has encountered a malformed type code
 (for example, a type code with an invalid TCKind value). 
 | 
class  | 
Bounds
A user exception thrown when a parameter is not within
 the legal bounds for the object that a method is trying
 to access. 
 | 
class  | 
CODESET_INCOMPATIBLE
This exception is raised whenever meaningful communication is not possible
 between client and server native code sets. 
 | 
class  | 
COMM_FAILURE
This exception is raised if communication is lost while an operation
 is in progress, after the request was sent by the client, but before
 the reply from the server has been returned to the client. 
 | 
class  | 
DATA_CONVERSION
This exception is raised if an ORB cannot convert the representation
 of data as marshaled into its native representation or vice-versa. 
 | 
class  | 
FREE_MEM
Exception thrown
 when the ORB failed in an attempt to free dynamic memory, for example
 because of heap corruption or memory segments being locked. 
 | 
class  | 
IMP_LIMIT
This exception indicates that an implementation limit was
 exceeded in the ORB run time. 
 | 
class  | 
INITIALIZE
Exception thrown
 when an ORB has encountered a failure during its initialization,
 such as failure to acquire networking resources or detecting a
 configuration error. 
 | 
class  | 
INTERNAL
This exception indicates an internal failure in an ORB, for
 example, if an ORB has detected corruption of its internal
 data structures. 
 | 
class  | 
INTF_REPOS
Exception raised
 when an ORB cannot reach the interface
 repository, or some other failure relating to the interface repository
 is detected. 
 | 
class  | 
INV_FLAG
Exception thrown
 when an invalid flag was passed to an operation (for example, when
 creating a DII request). 
 | 
class  | 
INV_IDENT
This exception indicates that an IDL identifier is syntactically
 invalid. 
 | 
class  | 
INV_OBJREF
This exception indicates that an object reference is internally
 malformed. 
 | 
class  | 
INV_POLICY
Standard exception  thrown
 when an invocation cannot be made because of an incompatibility between
 Policy overrides that apply to the particular invocation. 
 | 
class  | 
INVALID_ACTIVITY
The  
INVALID_ACTIVITY system exception may be raised on the
 Activity or Transaction services' resume methods if a transaction or
 Activity is resumed in a context different to that from which it was
 suspended. | 
class  | 
INVALID_TRANSACTION
Exception  thrown
 when the request carried an invalid transaction context. 
 | 
class  | 
MARSHAL
A request or reply from the network is structurally invalid. 
 | 
class  | 
NO_IMPLEMENT
This exception indicates that even though the operation that
 was invoked exists (it has an IDL definition), no implementation
 for that operation exists. 
 | 
class  | 
NO_MEMORY
Exception  thrown when the ORB run time has run out of memory. 
 | 
class  | 
NO_PERMISSION
Exception  thrown when an invocation failed because the caller
 has insufficient privileges. 
 | 
class  | 
NO_RESOURCES
Exception thrown when the ORB has encountered some general resource
 limitation. 
 | 
class  | 
NO_RESPONSE
This exception is raised if a client attempts to retrieve the result
 of a deferred synchronous call, but the response for the request is
 not yet available. 
 | 
class  | 
OBJ_ADAPTER
This exception typically indicates an administrative mismatch, for
 example, a server may have made an attempt to register itself with
 an implementation repository under a name that is already in use,
 or is unknown to the repository. 
 | 
class  | 
OBJECT_NOT_EXIST
Exception raised whenever an invocation on a deleted object was
 performed. 
 | 
class  | 
PERSIST_STORE
This exception indicates a persistent storage failure, for example,
 failure to establish a database connection or corruption of a
 database. 
 | 
class  | 
PolicyError
A user exception thrown when a policy error occurs. 
 | 
class  | 
REBIND
REBIND is raised when the current effective RebindPolicy,
 has a value of NO_REBIND or NO_RECONNECT and an invocation on a bound
 object reference results in a LocateReply message with status
 OBJECT_FORWARD or a Reply message with status LOCATION_FORWARD. | 
class  | 
SystemException
The root class for all CORBA standard exceptions. 
 | 
class  | 
TIMEOUT
TIMEOUT is raised when no delivery has been made and the
 specified time-to-live period has been exceeded. | 
class  | 
TRANSACTION_MODE
The CORBA  
TRANSACTION_MODE exception is thrown
 by the client ORB if it detects a mismatch between the
 InvocationPolicy in the IOR and the chosen invocation path
 (i.e, direct or routed invocation). | 
class  | 
TRANSACTION_REQUIRED
Exception  indicates that the request carried a null transaction context,
 but an active transaction is required. 
 | 
class  | 
TRANSACTION_ROLLEDBACK
Exception  thrown when the transaction associated with the request has
 already been rolled back or marked to roll back. 
 | 
class  | 
TRANSACTION_UNAVAILABLE
The CORBA  
TRANSACTION_UNAVAILABLE exception is thrown
 by the ORB when it cannot process a transaction service context because
 its connection to the Transaction Service has been abnormally terminated. | 
class  | 
TRANSIENT
Exception  thrown when the ORB attempted to reach an object and failed. 
 | 
class  | 
UNKNOWN
This exception is raised if an operation implementation
 throws a non-CORBA exception (such as an exception
 specific to the implementation's programming language),
 or if an operation raises a user exception that does not
 appear in the operation's raises expression. 
 | 
class  | 
UnknownUserException
A class that contains user exceptions returned by the server. 
 | 
class  | 
UserException
The root class for CORBA IDL-defined user exceptions. 
 | 
class  | 
WrongTransaction
The CORBA  
WrongTransaction user-defined exception. | 
| Modifier and Type | Method and Description | 
|---|---|
abstract Exception | 
Environment.exception()
Retrieves the exception in this  
Environment object. | 
| Modifier and Type | Method and Description | 
|---|---|
abstract void | 
Environment.exception(Exception except)
Inserts the given exception into this  
Environment object. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
Invalid
Invalid is thrown by dynamic any operations when a bad
  
DynAny or Any is passed as a parameter. | 
class  | 
InvalidSeq
The InvalidSeq exception is thrown by all operations on dynamic
 anys that take a sequence (Java array) as an argument, when that
 sequence is invalid. 
 | 
class  | 
InvalidValue  | 
class  | 
TypeMismatch
TypeMismatch is thrown by dynamic any accessor methods when
 type of the actual contents do not match what is trying to be
 accessed. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InconsistentTypeCode
InconsistentTypeCode is thrown when an attempt is made to create a
 dynamic any with a type code that does not match the particular
 subclass of  
DynAny. | 
class  | 
InvalidName
The  
InvalidName exception is raised when
 ORB.resolve_initial_references is passed a name
 for which there is no initial reference. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ApplicationException
This class is used for reporting application level exceptions between ORBs and stubs. 
 | 
class  | 
IndirectionException
The Indirection exception is a Java specific system exception. 
 | 
class  | 
RemarshalException
This class is used for reporting locate forward exceptions and object forward
GIOP messages back to the ORB. 
 | 
class  | 
UnknownException
The org.omg.CORBA.portable.UnknownException is used for reporting
 unknown exceptions between ties and ORBs and between ORBs and stubs. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
BadKind
The exception  
BadKind is thrown when
 an inappropriate operation is invoked on a TypeCode object. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InvalidAddress
org/omg/CosNaming/NamingContextExtPackage/InvalidAddress.java . 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AlreadyBound
org/omg/CosNaming/NamingContextPackage/AlreadyBound.java . 
 | 
class  | 
CannotProceed
org/omg/CosNaming/NamingContextPackage/CannotProceed.java . 
 | 
class  | 
NotEmpty
org/omg/CosNaming/NamingContextPackage/NotEmpty.java . 
 | 
class  | 
NotFound
org/omg/CosNaming/NamingContextPackage/NotFound.java . 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
UnknownEncoding
org/omg/IOP/CodecFactoryPackage/UnknownEncoding.java . 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
FormatMismatch
org/omg/IOP/CodecPackage/FormatMismatch.java . 
 | 
class  | 
InvalidTypeForEncoding
org/omg/IOP/CodecPackage/InvalidTypeForEncoding.java . 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
InvalidSlot
org/omg/PortableInterceptor/InvalidSlot.java . 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DuplicateName
org/omg/PortableInterceptor/ORBInitInfoPackage/DuplicateName.java . 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ForwardRequest
org/omg/PortableServer/ForwardRequest.java . 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
NoContext
org/omg/PortableServer/CurrentPackage/NoContext.java . 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AdapterInactive
org/omg/PortableServer/POAManagerPackage/AdapterInactive.java . 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AdapterAlreadyExists
org/omg/PortableServer/POAPackage/AdapterAlreadyExists.java . 
 | 
class  | 
AdapterNonExistent
org/omg/PortableServer/POAPackage/AdapterNonExistent.java . 
 | 
class  | 
InvalidPolicy
org/omg/PortableServer/POAPackage/InvalidPolicy.java . 
 | 
class  | 
NoServant
org/omg/PortableServer/POAPackage/NoServant.java . 
 | 
class  | 
ObjectAlreadyActive
org/omg/PortableServer/POAPackage/ObjectAlreadyActive.java . 
 | 
class  | 
ObjectNotActive
org/omg/PortableServer/POAPackage/ObjectNotActive.java . 
 | 
class  | 
ServantAlreadyActive
org/omg/PortableServer/POAPackage/ServantAlreadyActive.java . 
 | 
class  | 
ServantNotActive
org/omg/PortableServer/POAPackage/ServantNotActive.java . 
 | 
class  | 
WrongAdapter
org/omg/PortableServer/POAPackage/WrongAdapter.java . 
 | 
class  | 
WrongPolicy
org/omg/PortableServer/POAPackage/WrongPolicy.java . 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
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). 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
EventException
Event operations may throw an  
EventException as specified in
 their method descriptions. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
LSException
Parser or write operations may throw an  
LSException if the
 processing is stopped. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
SAXException
Encapsulate a general SAX error or warning. 
 | 
class  | 
SAXNotRecognizedException
Exception class for an unrecognized identifier. 
 | 
class  | 
SAXNotSupportedException
Exception class for an unsupported operation. 
 | 
class  | 
SAXParseException
Encapsulate an XML parse error or warning. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Exception | 
SAXException.getException()
Return the embedded exception, if any. 
 | 
| Constructor and Description | 
|---|
SAXException(Exception e)
Create a new SAXException wrapping an existing exception. 
 | 
SAXException(String message,
            Exception e)
Create a new SAXException from an existing exception. 
 | 
SAXParseException(String message,
                 Locator locator,
                 Exception e)
Wrap an existing exception in a SAXParseException. 
 | 
SAXParseException(String message,
                 String publicId,
                 String systemId,
                 int lineNumber,
                 int columnNumber,
                 Exception e)
Create a new SAXParseException with an embedded exception. 
 | 
 Submit a bug or feature 
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
 Copyright © 1993, 2017, Oracle and/or its affiliates.  All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.