| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| Character
The
Character class wraps a value of the primitive
type char in an object. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| FunctionalInterface
An informative annotation type used to indicate that an interface
type declaration is intended to be a functional interface as
defined by the Java Language Specification.
|
| IllegalStateException
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| 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.
|
| InterruptedException
Thrown when a thread is waiting, sleeping, or otherwise occupied,
and the thread is interrupted, either before or during the activity.
|
| NullPointerException
Thrown when an application attempts to use
null in a
case where an object is required. |
| Number
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte, double, float, int, long, and short. |
| 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.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| Runnable
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| SecurityException
Thrown by the security manager to indicate a security violation.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| UnsupportedOperationException
Thrown to indicate that the requested operation is not supported.
|
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that 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. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalStateException
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Runnable
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Float
The
Float class wraps a value of primitive type
float in an object. |
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Character.Subset
Instances of this class represent particular subsets of the Unicode
character set.
|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| Character.Subset
Instances of this class represent particular subsets of the Unicode
character set.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| InterruptedException
Thrown when a thread is waiting, sleeping, or otherwise occupied,
and the thread is interrupted, either before or during the activity.
|
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Object
Class
Object is the root of the class hierarchy. |
| Runnable
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| 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.
|
| NullPointerException
Thrown when an application attempts to use
null in a
case where an object is required. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| SecurityException
Thrown by the security manager to indicate a security violation.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| Appendable
An object to which char sequences and values can be appended.
|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| FunctionalInterface
An informative annotation type used to indicate that an interface
type declaration is intended to be a functional interface as
defined by the Java Language Specification.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| Readable
A Readable is a source of characters.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| SecurityException
Thrown by the security manager to indicate a security violation.
|
| String
The
String class represents character strings. |
| StringBuffer
A thread-safe, mutable sequence of characters.
|
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Appendable
An object to which char sequences and values can be appended.
|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Byte
The
Byte class wraps a value of primitive type byte
in an object. |
| Character
The
Character class wraps a value of the primitive
type char in an object. |
| Character.Subset
Instances of this class represent particular subsets of the Unicode
character set.
|
| Character.UnicodeBlock
A family of character subsets representing the character blocks in the
Unicode specification.
|
| Character.UnicodeScript
A family of character subsets representing the character scripts
defined in the
Unicode Standard Annex #24: Script Names.
|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassFormatError
Thrown when the Java Virtual Machine attempts to read a class
file and determines that the file is malformed or otherwise cannot
be interpreted as a class file.
|
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in 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. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Double
The
Double class wraps a value of the primitive type
double in an object. |
| Enum
This is the common base class of all Java language enumeration types.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Float
The
Float class wraps a value of primitive type
float in an object. |
| FunctionalInterface
An informative annotation type used to indicate that an interface
type declaration is intended to be a functional interface as
defined by the Java Language Specification.
|
| 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.
|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| IncompatibleClassChangeError
Thrown when an incompatible class change has occurred to some class
definition.
|
| 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.
|
| 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. |
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| InterruptedException
Thrown when a thread is waiting, sleeping, or otherwise occupied,
and the thread is interrupted, either before or during the activity.
|
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| LinkageError
Subclasses of
LinkageError indicate that a class has
some dependency on another class; however, the latter class has
incompatibly changed after the compilation of the former class. |
| Long
The
Long class wraps a value of the primitive type long in an object. |
| NoSuchFieldException
Signals that the class doesn't have a field of a specified name.
|
| NoSuchMethodException
Thrown when a particular method cannot be found.
|
| Number
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte, double, float, int, long, and short. |
| 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.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
Package
Package objects contain version information
about the implementation and specification of a Java package. |
| Process
The
ProcessBuilder.start() and
Runtime.exec
methods create a native process and return an instance of a
subclass of Process that can be used to control the process
and obtain information about it. |
| ProcessBuilder
This class is used to create operating system processes.
|
| ProcessBuilder.Redirect
Represents a source of subprocess input or a destination of
subprocess output.
|
| ProcessBuilder.Redirect.Type
The type of a
ProcessBuilder.Redirect. |
| ReflectiveOperationException
Common superclass of exceptions thrown by reflective operations in
core reflection.
|
| Runnable
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
| Runtime
Every Java application has a single instance of class
Runtime that allows the application to interface with
the environment in which the application is running. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| SecurityException
Thrown by the security manager to indicate a security violation.
|
| SecurityManager
The security manager is a class that allows
applications to implement a security policy.
|
| Short
The
Short class wraps a value of primitive type short in an object. |
| StackTraceElement
An element in a stack trace, as returned by
Throwable.getStackTrace(). |
| String
The
String class represents character strings. |
| StringBuffer
A thread-safe, mutable sequence of characters.
|
| StringBuilder
A mutable sequence of characters.
|
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Thread
A thread is a thread of execution in a program.
|
| Thread.State
A thread state.
|
| Thread.UncaughtExceptionHandler
Interface for handlers invoked when a Thread abruptly
terminates due to an uncaught exception.
|
| ThreadGroup
A thread group represents a set of threads.
|
| ThreadLocal
This class provides thread-local variables.
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| VirtualMachineError
Thrown to indicate that the Java Virtual Machine is broken or has
run out of resources necessary for it to continue operating.
|
| Void
The
Void class is an uninstantiable placeholder class to hold a
reference to the Class object representing the Java keyword
void. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| 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.
|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| NoSuchFieldException
Signals that the class doesn't have a field of a specified name.
|
| NoSuchMethodException
Thrown when a particular method cannot be found.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| 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 and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| StackTraceElement
An element in a stack trace, as returned by
Throwable.getStackTrace(). |
| String
The
String class represents character strings. |
| Thread.State
A thread state.
|
| Class and Description |
|---|
| 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. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| InterruptedException
Thrown when a thread is waiting, sleeping, or otherwise occupied,
and the thread is interrupted, either before or during the activity.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| Class and Description |
|---|
| ArrayIndexOutOfBoundsException
Thrown to indicate that an array has been accessed with an
illegal index.
|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassFormatError
Thrown when the Java Virtual Machine attempts to read a class
file and determines that the file is malformed or otherwise cannot
be interpreted as a class file.
|
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| 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.
|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| 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. |
| LinkageError
Subclasses of
LinkageError indicate that a class has
some dependency on another class; however, the latter class has
incompatibly changed after the compilation of the former class. |
| NegativeArraySizeException
Thrown if an application tries to create an array with negative size.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| ReflectiveOperationException
Common superclass of exceptions thrown by reflective operations in
core reflection.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| SecurityException
Thrown by the security manager to indicate a security violation.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Number
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte, double, float, int, long, and short. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
Package
Package objects contain version information
about the implementation and specification of a Java package. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Appendable
An object to which char sequences and values can be appended.
|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalStateException
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| Readable
A Readable is a source of characters.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| UnsupportedOperationException
Thrown to indicate that the requested operation is not supported.
|
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| IllegalStateException
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| InterruptedException
Thrown when a thread is waiting, sleeping, or otherwise occupied,
and the thread is interrupted, either before or during the activity.
|
| Long
The
Long class wraps a value of the primitive type long in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Void
The
Void class is an uninstantiable placeholder class to hold a
reference to the Class object representing the Java keyword
void. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| FunctionalInterface
An informative annotation type used to indicate that an interface
type declaration is intended to be a functional interface as
defined by the Java Language Specification.
|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| IllegalStateException
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| InterruptedException
Thrown when a thread is waiting, sleeping, or otherwise occupied,
and the thread is interrupted, either before or during the activity.
|
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| UnsupportedOperationException
Thrown to indicate that the requested operation is not supported.
|
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| SecurityException
Thrown by the security manager to indicate a security violation.
|
| SecurityManager
The security manager is a class that allows
applications to implement a security policy.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Appendable
An object to which char sequences and values can be appended.
|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in 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. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| SecurityException
Thrown by the security manager to indicate a security violation.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that 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. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| SecurityException
Thrown by the security manager to indicate a security violation.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Number
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte, double, float, int, long, and short. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| StringBuffer
A thread-safe, mutable sequence of characters.
|
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Long
The
Long class wraps a value of the primitive type long in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| Appendable
An object to which char sequences and values can be appended.
|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Long
The
Long class wraps a value of the primitive type long in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| FunctionalInterface
An informative annotation type used to indicate that an interface
type declaration is intended to be a functional interface as
defined by the Java Language Specification.
|
| Long
The
Long class wraps a value of the primitive type long in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Appendable
An object to which char sequences and values can be appended.
|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Character
The
Character class wraps a value of the primitive
type char in an object. |
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that 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. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Double
The
Double class wraps a value of the primitive type
double in an object. |
| Enum
This is the common base class of all Java language enumeration types.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| FunctionalInterface
An informative annotation type used to indicate that an interface
type declaration is intended to be a functional interface as
defined by the Java Language Specification.
|
| 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.
|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| IllegalStateException
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| 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. |
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Long
The
Long class wraps a value of the primitive type long in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| Readable
A Readable is a source of characters.
|
| Runnable
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| SafeVarargs
A programmer assertion that the body of the annotated method or
constructor does not perform potentially unsafe operations on its
varargs parameter.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| FunctionalInterface
An informative annotation type used to indicate that an interface
type declaration is intended to be a functional interface as
defined by the Java Language Specification.
|
| IllegalStateException
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| InterruptedException
Thrown when a thread is waiting, sleeping, or otherwise occupied,
and the thread is interrupted, either before or during the activity.
|
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| Runnable
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Thread
A thread is a thread of execution in a program.
|
| Thread.UncaughtExceptionHandler
Interface for handlers invoked when a Thread abruptly
terminates due to an uncaught exception.
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Void
The
Void class is an uninstantiable placeholder class to hold a
reference to the Class object representing the Java keyword
void. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Number
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte, double, float, int, long, and short. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| InterruptedException
Thrown when a thread is waiting, sleeping, or otherwise occupied,
and the thread is interrupted, either before or during the activity.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Thread
A thread is a thread of execution in a program.
|
| Class and Description |
|---|
| FunctionalInterface
An informative annotation type used to indicate that an interface
type declaration is intended to be a functional interface as
defined by the Java Language Specification.
|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| FunctionalInterface
An informative annotation type used to indicate that an interface
type declaration is intended to be a functional interface as
defined by the Java Language Specification.
|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| SecurityException
Thrown by the security manager to indicate a security violation.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| FunctionalInterface
An informative annotation type used to indicate that an interface
type declaration is intended to be a functional interface as
defined by the Java Language Specification.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| StringBuffer
A thread-safe, mutable sequence of characters.
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Double
The
Double class wraps a value of the primitive type
double in an object. |
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Long
The
Long class wraps a value of the primitive type long in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| Runnable
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
| SafeVarargs
A programmer assertion that the body of the annotated method or
constructor does not perform potentially unsafe operations on its
varargs parameter.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| InternalError
Thrown to indicate some unexpected internal error has occurred in
the Java Virtual Machine.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| VirtualMachineError
Thrown to indicate that the Java Virtual Machine is broken or has
run out of resources necessary for it to continue operating.
|
| Class and Description |
|---|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Number
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte, double, float, int, long, and short. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that 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. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalStateException
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| UnsupportedOperationException
Thrown to indicate that the requested operation is not supported.
|
| Class and Description |
|---|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| NullPointerException
Thrown when an application attempts to use
null in a
case where an object is required. |
| Number
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte, double, float, int, long, and short. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| UnsupportedOperationException
Thrown to indicate that the requested operation is not supported.
|
| Class and Description |
|---|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Number
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte, double, float, int, long, and short. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Byte
The
Byte class wraps a value of primitive type byte
in an object. |
| Character
The
Character class wraps a value of the primitive
type char in an object. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Double
The
Double class wraps a value of the primitive type
double in an object. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Float
The
Float class wraps a value of primitive type
float in an object. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Long
The
Long class wraps a value of the primitive type long in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| Short
The
Short class wraps a value of primitive type short in an object. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Void
The
Void class is an uninstantiable placeholder class to hold a
reference to the Class object representing the Java keyword
void. |
| Class and Description |
|---|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| 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.
|
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| NoSuchMethodException
Thrown when a particular method cannot be found.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Long
The
Long class wraps a value of the primitive type long in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| Runnable
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassCastException
Thrown to indicate that the code has attempted to cast an object
to a subclass of which it is not an instance.
|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassCastException
Thrown to indicate that the code has attempted to cast an object
to a subclass of which it is not an instance.
|
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| NoSuchMethodException
Thrown when a particular method cannot be found.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| ArrayIndexOutOfBoundsException
Thrown to indicate that an array has been accessed with an
illegal index.
|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Character
The
Character class wraps a value of the primitive
type char in an object. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that 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. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| 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.
|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| IllegalStateException
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| 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. |
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| InterruptedException
Thrown when a thread is waiting, sleeping, or otherwise occupied,
and the thread is interrupted, either before or during the activity.
|
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Number
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte, double, float, int, long, and short. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| Runnable
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
| SafeVarargs
A programmer assertion that the body of the annotated method or
constructor does not perform potentially unsafe operations on its
varargs parameter.
|
| SecurityException
Thrown by the security manager to indicate a security violation.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Integer
The
Integer class wraps a value of the primitive type
int in an object. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class Class. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that 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. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| Runnable
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Thread
A thread is a thread of execution in a program.
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| StringBuffer
A thread-safe, mutable sequence of characters.
|
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that 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. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| AutoCloseable
An object that may hold resources (such as file or socket handles)
until it is closed.
|
| Boolean
The Boolean class wraps a value of the primitive type
boolean in an object. |
| CharSequence
A CharSequence is a readable sequence of
char values. |
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Iterable
Implementing this interface allows an object to be the target of
the "for-each loop" statement.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalStateException
Signals that a method has been invoked at an illegal or
inappropriate time.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| SuppressWarnings
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
|
| Class and Description |
|---|
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Number
The abstract class
Number is the superclass of platform
classes representing numeric values that are convertible to the
primitive types byte, double, float, int, long, and short. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| UnsupportedOperationException
Thrown to indicate that the requested operation is not supported.
|
| Class and Description |
|---|
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| Override
Indicates that a method declaration is intended to override a
method declaration in a supertype.
|
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Error
An
Error is a subclass of Throwable
that indicates serious problems that a reasonable application
should not try to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Comparable
This interface imposes a total ordering on the objects of each class that
implements it.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| 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.
|
| IllegalArgumentException
Thrown to indicate that a method has been passed an illegal or
inappropriate argument.
|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| ClassLoader
A class loader is an object that is responsible for loading classes.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Cloneable
A class implements the
Cloneable interface to
indicate to the Object.clone() method that it
is legal for that method to make a
field-for-field copy of instances of that class. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Deprecated
A program element annotated @Deprecated is one that programmers
are discouraged from using, typically because it is dangerous,
or because a better alternative exists.
|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Class
Instances of the class
Class represent classes and
interfaces in a running Java application. |
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| ClassCastException
Thrown to indicate that the code has attempted to cast an object
to a subclass of which it is not an instance.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class 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.
|
| 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. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
RuntimeException
RuntimeException is the superclass of those
exceptions that can be thrown during the normal operation of the
Java Virtual Machine. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| Exception
The class
Exception and its subclasses are a form of
Throwable that indicates conditions that a reasonable
application might want to catch. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Throwable
The
Throwable class is the superclass of all errors and
exceptions in the Java language. |
| Class and Description |
|---|
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
| Class and Description |
|---|
| ClassCastException
Thrown to indicate that the code has attempted to cast an object
to a subclass of which it is not an instance.
|
| ClassNotFoundException
Thrown when an application tries to load in a class through its
string name using:
The
forName method in class 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.
|
| 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. |
| NullPointerException
Thrown when an application attempts to use
null in a
case where an object is required. |
| Object
Class
Object is the root of the class hierarchy. |
| String
The
String class represents character strings. |
Generated by SciJava from the sources of OpenJDK 8 (Zulu), which are licensed under the GNU General Public License, version 2, with the Classpath Exception. Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
