Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| J2ME CDC
PREV NEXT | FRAMES NO FRAMES

## Uses of Interface
java.io.Serializable

Packages that use Serializable
java.io |
java.lang |
java.lang.reflect |
java.math |
java.net |
java.security |
java.security.cert |
java.security.spec |
java.text |
java.util |
java.util.jar |
java.util.zip |
javax.microedition.io |

Uses of Serializable in java.io

Subinterfaces of Serializable in java.io
`interface` | `Externalizable` Only the identity of the class of an Externalizable instance is written in the serialization stream and it is the responsibility of the class to save and restore the contents of its instances.

Classes in java.io that implement Serializable
`class` | `CharConversionException` Base class for character conversion exceptions.
`class` | `EOFException` Signals that an end of file or end of stream has been reached unexpectedly during input.
`class` | `File` An abstract representation of file and directory pathnames.
`class` | `FileNotFoundException` Signals that an attempt to open the file denoted by a specified pathname has failed.
`class` | `FilePermission` This class represents access to a file or directory.
`class` | `InterruptedIOException` Signals that an I/O operation has been interrupted.
`class` | `InvalidClassException` Thrown when the Serialization runtime detects one of the following problems with a Class.
`class` | `InvalidObjectException` Indicates that one or more deserialized objects failed validation tests.
`class` | `IOException` Signals that an I/O exception of some sort has occurred.
`class` | `NotActiveException` Thrown when serialization or deserialization is not active.
`class` | `NotSerializableException` Thrown when an instance is required to have a Serializable interface.
`class` | `ObjectStreamClass` Serialization's descriptor for classes.
`class` | `ObjectStreamException` Superclass of all exceptions specific to Object Stream classes.
`class` | `OptionalDataException` Unexpected data appeared in an ObjectInputStream trying to read an Object.
`class` | `SerializablePermission` This class is for Serializable permissions.
`class` | `StreamCorruptedException` Thrown when control information that was read from an object stream violates internal consistency checks.
`class` | `SyncFailedException` Signals that a sync operation has failed.
`class` | `UnsupportedEncodingException` The Character Encoding is not supported.
`class` | `UTFDataFormatException` Signals that a malformed UTF-8 string has been read in a data input stream or by any class that implements the data input interface.
`class` | `WriteAbortedException` Signals that one of the ObjectStreamExceptions was thrown during a write operation.

Uses of Serializable in java.lang

Classes in java.lang that implement Serializable
`class` | `AbstractMethodError` Thrown when an application tries to call an abstract method.
`class` | `ArithmeticException` Thrown when an exceptional arithmetic condition has occurred.
`class` | `ArrayIndexOutOfBoundsException` Thrown to indicate that an array has been accessed with an illegal index.
`class` | `ArrayStoreException` Thrown to indicate that an attempt has been made to store the wrong type of object into an array of objects.
`class` | `Boolean` The Boolean class wraps a value of the primitive type `boolean` in an object.
`class` | `Byte` The Byte class is the standard wrapper for byte values.
`class` | `Character` The Character class wraps a value of the primitive type `char` in an object.
`class` | `Class` Instances of the class `Class` represent classes and interfaces in a running Java application.
`class` | `ClassCastException` Thrown to indicate that the code has attempted to cast an object to a subclass of which it is not an instance.
`class` | `ClassCircularityError` Thrown when a circularity has been detected while initializing a class.
`class` | `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.
`class` | `ClassNotFoundException` Thrown when an application tries to load in a class through its string name using: The `forName` method in class `Class`.
`class` | `CloneNotSupportedException` Thrown to indicate that the `clone` method in class `Object` has been called to clone an object, but that the object's class does not implement the `Cloneable` interface.
`class` | `Double` The Double class wraps a value of the primitive type `double` in an object.
`class` | `Error` An `Error` is a subclass of `Throwable` that indicates serious problems that a reasonable application should not try to catch.
`class` | `Exception` The class `Exception` and its subclasses are a form of `Throwable` that indicates conditions that a reasonable application might want to catch.
`class` | `ExceptionInInitializerError` Signals that an unexpected exception has occurred in a static initializer.
`class` | `Float` The Float class wraps a value of primitive type `float` in an object.
`class` | `IllegalAccessError` Thrown if an application attempts to access or modify a field, or to call a method that it does not have access to.
`class` | `IllegalAccessException` Thrown when an application tries to load in a class, but the currently executing method does not have access to the definition of the specified class, because the class is not public and in another package.
`class` | `IllegalArgumentException` Thrown to indicate that a method has been passed an illegal or inappropriate argument.
`class` | `IllegalMonitorStateException` Thrown to indicate that a thread has attempted to wait on an object's monitor or to notify other threads waiting on an object's monitor without owning the specified monitor.
`class` | `IllegalStateException` Signals that a method has been invoked at an illegal or inappropriate time.
`class` | `IllegalThreadStateException` Thrown to indicate that a thread is not in an appropriate state for the requested operation.
`class` | `IncompatibleClassChangeError` Thrown when an incompatible class change has occurred to some class definition.
`class` | `IndexOutOfBoundsException` Thrown to indicate that an index of some sort (such as to an array, to a string, or to a vector) is out of range.
`class` | `InstantiationError` Thrown when an application tries to use the Java `new` construct to instantiate an abstract class or an interface.
`class` | `InstantiationException` Thrown when an application tries to create an instance of a class using the `newInstance` method in class `Class`, but the specified class object cannot be instantiated because it is an interface or is an abstract class.
`class` | `Integer` The Integer class wraps a value of the primitive type `int` in an object.
`class` | `InternalError` Thrown to indicate some unexpected internal error has occurred in the Java Virtual Machine.
`class` | `InterruptedException` Thrown when a thread is waiting, sleeping, or otherwise paused for a long time and another thread interrupts it using the `interrupt` method in class `Thread`.
`class` | `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.
`class` | `Long` The Long class wraps a value of the primitive type `long` in an object.
`class` | `NegativeArraySizeException` Thrown if an application tries to create an array with negative size.
`class` | `NoClassDefFoundError` Thrown if the Java Virtual Machine or a classloader tries to load in the definition of a class (as part of a normal method call or as part of creating a new instance using the `new` expression) and no definition of the class could be found.
`class` | `NoSuchFieldError` Thrown if an application tries to access or modify a specified field of an object, and that object no longer has that field.
`class` | `NoSuchFieldException` Signals that the class doesn't have a field of a specified name.
`class` | `NoSuchMethodError` Thrown if an application tries to call a specified method of a class (either static or instance), and that class no longer has a definition of that method.
`class` | `NoSuchMethodException` Thrown when a particular method cannot be found.
`class` | `NullPointerException` Thrown when an application attempts to use `null` in a case where an object is required.
`class` | `Number` The abstract class `Number` is the superclass of classes `Byte`, `Double`, `Float`, `Integer`, `Long`, and `Short`.
`class` | `NumberFormatException` Thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.
`class` | `OutOfMemoryError` Thrown when the Java Virtual Machine cannot allocate an object because it is out of memory, and no more memory could be made available by the garbage collector.
`class` | `RuntimeException` `RuntimeException` is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
`class` | `RuntimePermission` This class is for runtime permissions.
`class` | `SecurityException` Thrown by the security manager to indicate a security violation.
`class` | `Short` The Short class is the standard wrapper for short values.
`class` | `StackOverflowError` Thrown when a stack overflow occurs because an application recurses too deeply.
`class` | `String` The `String` class represents character strings.
`class` | `StringBuffer` A string buffer implements a mutable sequence of characters.
`class` | `StringIndexOutOfBoundsException` Thrown by the `charAt` method in class `String` and by other `String` methods to indicate that an index is either negative or greater than or equal to the size of the string.
`class` | `ThreadDeath` An instance of `ThreadDeath` is thrown in the victim thread when the `stop` method with zero arguments in class `Thread` is called.
`class` | `Throwable` The `Throwable` class is the superclass of all errors and exceptions in the Java language.
`class` | `UnsatisfiedLinkError` Thrown if the Java Virtual Machine cannot find an appropriate native-language definition of a method declared `native`.
`class` | `UnsupportedClassVersionError` Thrown when the Java Virtual Machine attempts to read a class file and determines that the major and minor version numbers in the file are not supported.
`class` | `UnsupportedOperationException` Thrown to indicate that the requested operation is not supported.
`class` | `VerifyError` Thrown when the "verifier" detects that a class file, though well formed, contains some sort of internal inconsistency or security problem.
`class` | `VirtualMachineError` Thrown to indicate that the Java Virtual Machine is broken or has run out of resources necessary for it to continue operating.

Uses of Serializable in java.lang.reflect

Classes in java.lang.reflect that implement Serializable
`class` | `InvocationTargetException` InvocationTargetException is a checked exception that wraps an exception thrown by an invoked method or constructor.
`class` | `Proxy` `Proxy` provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.
`class` | `ReflectPermission` The Permission class for reflective operations.
`class` | `UndeclaredThrowableException` Thrown by a method invocation on a proxy instance if its invocation handler's `invoke` method throws a checked exception (a `Throwable` that is not assignable to `RuntimeException` or `Error`) that is not assignable to any of the exception types declared in the `throws` clause of the method that was invoked on the proxy instance and dispatched to the invocation handler.

Uses of Serializable in java.math

Classes in java.math that implement Serializable
`class` | `BigInteger` Immutable arbitrary-precision integers.

Uses of Serializable in java.net

Classes in java.net that implement Serializable
`class` | `ConnectException` Signals that an error occurred while attempting to connect a socket to a remote address and port.
`class` | `InetAddress` This class represents an Internet Protocol (IP) address.
`class` | `MalformedURLException` Thrown to indicate that a malformed URL has occurred.
`class` | `NetPermission` This class is for various network permissions.
`class` | `ProtocolException` Thrown to indicate that there is an error in the underlying protocol, such as a TCP error.
`class` | `SocketException` Thrown to indicate that there is an error in the underlying protocol, such as a TCP error.
`class` | `SocketPermission` This class represents access to a network via sockets.
`class` | `UnknownHostException` Thrown to indicate that the IP address of a host could not be determined.
`class` | `UnknownServiceException` Thrown to indicate that an unknown service exception has occurred.
`class` | `URL` Class `URL` represents a Uniform Resource Locator, a pointer to a "resource" on the World Wide Web.

Uses of Serializable in java.security

Subinterfaces of Serializable in java.security
`interface` | `Key` The Key interface is the top-level interface for all keys.
`interface` | `PrivateKey` A private key.
`interface` | `PublicKey` A public key.

Classes in java.security that implement Serializable
`class` | `AccessControlException` This exception is thrown by the AccessController to indicate that a requested access (to a critical system resource such as the file system or the network) is denied.
`class` | `AllPermission` The AllPermission is a permission that implies all other permissions.
`class` | `BasicPermission` The BasicPermission class extends the Permission class, and can be used as the base class for permissions that want to follow the same naming convention as BasicPermission.
`class` | `CodeSource` This class extends the concept of a codebase to encapsulate not only the location (URL) but also the certificate(s) that were used to verify signed code originating from that location.
`class` | `DigestException` This is the generic Message Digest exception.
`class` | `GeneralSecurityException` This is the general security exception class, which serves to group all the exception classes of the `java.security` package that extend from it.
`class` | `GuardedObject` A GuardedObject is an object that is used to protect access to another object.
`class` | `Identity` Deprecated. This class is no longer used. Its functionality has been replaced by `java.security.KeyStore`, the `java.security.cert` package, and `java.security.Principal`.
`class` | `IdentityScope` Deprecated. This class is no longer used. Its functionality has been replaced by `java.security.KeyStore`, the `java.security.cert` package, and `java.security.Principal`.
`class` | `InvalidAlgorithmParameterException` This is the exception for invalid or inappropriate algorithm parameters.
`class` | `InvalidKeyException` This is the exception for invalid Keys (invalid encoding, wrong length, uninitialized, etc).
`class` | `InvalidParameterException` This exception is thrown when an invalid parameter is passed to a method.
`class` | `KeyException` This is the basic key exception.
`class` | `KeyManagementException` This is the general key management exception, for all operations dealing with key management.
`class` | `KeyPair` This class is a simple holder for a key pair (a public key and a private key).
`class` | `KeyStoreException` This is the generic KeyStore exception.
`class` | `NoSuchAlgorithmException` This exception is thrown when a particular cryptographic algorithm is requested but is not available in the environment.
`class` | `NoSuchProviderException` This exception is thrown when a particular security provider is requested but is not available in the environment.
`class` | `Permission` Abstract class for representing access to a system resource.
`class` | `PermissionCollection` Abstract class representing a collection of Permission objects.
`class` | `Permissions` This class represents a heterogeneous collection of Permissions.
`class` | `PrivilegedActionException` This exception is thrown by `doPrivileged(PrivilegedExceptionAction)` and `doPrivileged(PrivilegedExceptionAction, AccessControlContext context)` to indicate that the action being performed threw a checked exception.
`class` | `Provider` This class represents a "provider" for the Java Security API, where a provider implements some or all parts of Java Security, including: Algorithms (such as DSA, RSA, MD5 or SHA-1).
`class` | `SecureRandom` This class provides a cryptographically strong pseudo-random number generator (PRNG).
`class` | `SecureRandomSpi` This class defines the Service Provider Interface (SPI) for the `SecureRandom` class.
`class` | `SecurityPermission` This class is for security permissions.
`class` | `SignatureException` This is the generic Signature exception.
`class` | `Signer` Deprecated. This class is no longer used. Its functionality has been replaced by `java.security.KeyStore`, the `java.security.cert` package, and `java.security.Principal`.
`class` | `UnrecoverableKeyException` This exception is thrown if a key in the keystore cannot be recovered.
`class` | `UnresolvedPermission` The UnresolvedPermission class is used to hold Permissions that were "unresolved" when the Policy was initialized.

Uses of Serializable in java.security.cert

Classes in java.security.cert that implement Serializable
`class` | `Certificate` Abstract class for managing a variety of identity certificates.
`protected static class` | `Certificate.CertificateRep` Alternate Certificate class for serialization.
`class` | `CertificateEncodingException` Certificate Encoding Exception.
`class` | `CertificateException` This exception indicates one of a variety of certificate problems.
`class` | `CertificateExpiredException` Certificate Expired Exception.
`class` | `CertificateNotYetValidException` Certificate is not yet valid exception.
`class` | `CertificateParsingException` Certificate Parsing Exception.
`class` | `CRLException` CRL (Certificate Revocation List) Exception
`class` | `X509Certificate` Abstract class for X.509 certificates.

Uses of Serializable in java.security.spec

Classes in java.security.spec that implement Serializable
`class` | `InvalidKeySpecException` This is the exception for invalid key specifications.
`class` | `InvalidParameterSpecException` This is the exception for invalid parameter specifications.

Uses of Serializable in java.text

Classes in java.text that implement Serializable
`class` | `ChoiceFormat` A `ChoiceFormat` allows you to attach a format to a range of numbers.
`class` | `DateFormat` DateFormat is an abstract class for date/time formatting subclasses which formats and parses dates or time in a language-independent manner.
`class` | `DateFormatSymbols` `DateFormatSymbols` is a public class for encapsulating localizable date-time formatting data, such as the names of the months, the names of the days of the week, and the time zone data.
`class` | `DecimalFormat` `DecimalFormat` is a concrete subclass of `NumberFormat` that formats decimal numbers.
`class` | `DecimalFormatSymbols` This class represents the set of symbols (such as the decimal separator, the grouping separator, and so on) needed by `DecimalFormat` to format numbers.
`class` | `Format` `Format` is an abstract base class for formatting locale-sensitive information such as dates, messages, and numbers.
`class` | `MessageFormat` `MessageFormat` provides a means to produce concatenated messages in language-neutral way.
`class` | `NumberFormat` `NumberFormat` is the abstract base class for all number formats.
`class` | `ParseException` Signals that an error has been reached unexpectedly while parsing.
`class` | `SimpleDateFormat` `SimpleDateFormat` is a concrete class for formatting and parsing dates in a locale-sensitive manner.

Uses of Serializable in java.util

Classes in java.util that implement Serializable
`class` | `ArrayList` Resizable-array implementation of the `List` interface.
`class` | `Calendar` `Calendar` is an abstract base class for converting between a `Date` object and a set of integer fields such as `YEAR`, `MONTH`, `DAY`, `HOUR`, and so on.
`class` | `ConcurrentModificationException` This exception may be thrown by methods that have detected concurrent modification of a backing object when such modification is not permissible.
`class` | `Date` The class `Date` represents a specific instant in time, with millisecond precision.
`class` | `EmptyStackException` Thrown by methods in the `Stack` class to indicate that the stack is empty.
`class` | `EventObject` The root class from which all event state objects shall be derived.
`class` | `GregorianCalendar` `GregorianCalendar` is a concrete subclass of `Calendar` and provides the standard calendar used by most of the world.
`class` | `HashMap` Hash table based implementation of the `Map` interface.
`class` | `HashSet` This class implements the `Set` interface, backed by a hash table (actually a `HashMap` instance).
`class` | `Hashtable` This class implements a hashtable, which maps keys to values.
`class` | `LinkedList` Linked list implementation of the `List` interface.
`class` | `Locale` A `Locale` object represents a specific geographical, political, or cultural region.
`class` | `MissingResourceException` Signals that a resource is missing.
`class` | `NoSuchElementException` Thrown by the `nextElement` method of an `Enumeration` to indicate that there are no more elements in the enumeration.
`class` | `Properties` The `Properties` class represents a persistent set of properties.
`class` | `PropertyPermission` This class is for property permissions.
`class` | `Random` An instance of this class is used to generate a stream of pseudorandom numbers.
`class` | `SimpleTimeZone` `SimpleTimeZone` is a concrete subclass of `TimeZone` that represents a time zone for use with a Gregorian calendar.
`class` | `Stack` The `Stack` class represents a last-in-first-out (LIFO) stack of objects.
`class` | `TimeZone` `TimeZone` represents a time zone offset, and also figures out daylight savings.
`class` | `TooManyListenersException` The `TooManyListenersException` Exception is used as part of the Java Event model to annotate and implement a unicast special case of a multicast Event Source.
`class` | `TreeMap` Red-Black tree based implementation of the `SortedMap` interface.
`class` | `TreeSet` This class implements the `Set` interface, backed by a `TreeMap` instance.
`class` | `Vector` The `Vector` class implements a growable array of objects.

Uses of Serializable in java.util.jar

Classes in java.util.jar that implement Serializable
`class` | `JarException` Signals that an error of some sort has occurred while reading from or writing to a JAR file.

Uses of Serializable in java.util.zip

Classes in java.util.zip that implement Serializable
`class` | `DataFormatException` Signals that a data format error has occurred.
`class` | `ZipException` Signals that a Zip exception of some sort has occurred.

Uses of Serializable in javax.microedition.io

Classes in javax.microedition.io that implement Serializable
`class` | `ConnectionNotFoundException` This class is used to signal that a connection target cannot be found

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| J2ME CDC
PREV NEXT | FRAMES NO FRAMES

Java is a trademark or registred trademark of Sun Microsystems, Inc. in the US and other countries.
Copyright 1993-2000 Sun Microsystems, Inc. 901 San Antonio Road,
Palo, Alto, California, 94303, U.S.A All Rights Reserved.