1. /*

  2.  * @(#)Serializable.java	1.22 03/12/19

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package java.io;

  9. 

  10. /**

  11.  * Serializability of a class is enabled by the class implementing the

  12.  * java.io.Serializable interface. Classes that do not implement this

  13.  * interface will not have any of their state serialized or

  14.  * deserialized.  All subtypes of a serializable class are themselves

  15.  * serializable.  The serialization interface has no methods or fields

  16.  * and serves only to identify the semantics of being serializable. <p>

  17.  *

  18.  * To allow subtypes of non-serializable classes to be serialized, the

  19.  * subtype may assume responsibility for saving and restoring the

  20.  * state of the supertype's public, protected, and (if accessible)

  21.  * package fields.  The subtype may assume this responsibility only if

  22.  * the class it extends has an accessible no-arg constructor to

  23.  * initialize the class's state.  It is an error to declare a class

  24.  * Serializable if this is not the case.  The error will be detected at runtime. <p>

  25.  *

  26.  * During deserialization, the fields of non-serializable classes will

  27.  * be initialized using the public or protected no-arg constructor of

  28.  * the class.  A no-arg constructor must be accessible to the subclass

  29.  * that is serializable.  The fields of serializable subclasses will

  30.  * be restored from the stream. <p>

  31.  *

  32.  * When traversing a graph, an object may be encountered that does not

  33.  * support the Serializable interface. In this case the

  34.  * NotSerializableException will be thrown and will identify the class

  35.  * of the non-serializable object. <p>

  36.  *

  37.  * Classes that require special handling during the serialization and

  38.  * deserialization process must implement special methods with these exact

  39.  * signatures: <p>

  40.  *

  41.  * <PRE>

  42.  * private void writeObject(java.io.ObjectOutputStream out)

  43.  *     throws IOException

  44.  * private void readObject(java.io.ObjectInputStream in)

  45.  *     throws IOException, ClassNotFoundException;

  46.  * </PRE><p>

  47.  *

  48.  * The writeObject method is responsible for writing the state of the

  49.  * object for its particular class so that the corresponding

  50.  * readObject method can restore it.  The default mechanism for saving

  51.  * the Object's fields can be invoked by calling

  52.  * out.defaultWriteObject. The method does not need to concern

  53.  * itself with the state belonging to its superclasses or subclasses.

  54.  * State is saved by writing the individual fields to the

  55.  * ObjectOutputStream using the writeObject method or by using the

  56.  * methods for primitive data types supported by DataOutput. <p>

  57.  *

  58.  * The readObject method is responsible for reading from the stream and

  59.  * restoring the classes fields. It may call in.defaultReadObject to invoke

  60.  * the default mechanism for restoring the object's non-static and non-transient

  61.  * fields.  The defaultReadObject method uses information in the stream to

  62.  * assign the fields of the object saved in the stream with the correspondingly

  63.  * named fields in the current object.  This handles the case when the class

  64.  * has evolved to add new fields. The method does not need to concern

  65.  * itself with the state belonging to its superclasses or subclasses.

  66.  * State is saved by writing the individual fields to the

  67.  * ObjectOutputStream using the writeObject method or by using the

  68.  * methods for primitive data types supported by DataOutput. <p>

  69.  *

  70.  * Serializable classes that need to designate an alternative object to be

  71.  * used when writing an object to the stream should implement this

  72.  * special method with the exact signature: <p>

  73.  *

  74.  * <PRE>

  75.  * ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;

  76.  * </PRE><p>

  77.  *

  78.  * This writeReplace method is invoked by serialization if the method

  79.  * exists and it would be accessible from a method defined within the

  80.  * class of the object being serialized. Thus, the method can have private,

  81.  * protected and package-private access. Subclass access to this method

  82.  * follows java accessibility rules. <p>

  83.  *

  84.  * Classes that need to designate a replacement when an instance of it

  85.  * is read from the stream should implement this special method with the

  86.  * exact signature.<p>

  87.  *

  88.  * <PRE>

  89.  * ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

  90.  * </PRE><p>

  91.  *

  92.  * This readResolve method follows the same invocation rules and

  93.  * accessibility rules as writeReplace.<p>

  94.  *

  95.  * The serialization runtime associates with each serializable class a version

  96.  * number, called a serialVersionUID, which is used during deserialization to

  97.  * verify that the sender and receiver of a serialized object have loaded

  98.  * classes for that object that are compatible with respect to serialization.

  99.  * If the receiver has loaded a class for the object that has a different

  100.  * serialVersionUID than that of the corresponding sender's class, then

  101.  * deserialization will result in an {@link InvalidClassException}.  A

  102.  * serializable class can declare its own serialVersionUID explicitly by

  103.  * declaring a field named <code>"serialVersionUID"</code> that must be static,

  104.  * final, and of type <code>long</code>:<p>

  105.  *

  106.  * <PRE>

  107.  * ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;

  108.  * </PRE>

  109.  *

  110.  * If a serializable class does not explicitly declare a serialVersionUID, then

  111.  * the serialization runtime will calculate a default serialVersionUID value

  112.  * for that class based on various aspects of the class, as described in the

  113.  * Java(TM) Object Serialization Specification.  However, it is <em>strongly

  114.  * recommended</em> that all serializable classes explicitly declare

  115.  * serialVersionUID values, since the default serialVersionUID computation is

  116.  * highly sensitive to class details that may vary depending on compiler

  117.  * implementations, and can thus result in unexpected

  118.  * <code>InvalidClassException</code>s during deserialization.  Therefore, to

  119.  * guarantee a consistent serialVersionUID value across different java compiler

  120.  * implementations, a serializable class must declare an explicit

  121.  * serialVersionUID value.  It is also strongly advised that explicit

  122.  * serialVersionUID declarations use the <code>private</code> modifier where

  123.  * possible, since such declarations apply only to the immediately declaring

  124.  * class--serialVersionUID fields are not useful as inherited members.

  125.  *

  126.  * @author  unascribed

  127.  * @version 1.22, 12/19/03

  128.  * @see java.io.ObjectOutputStream

  129.  * @see java.io.ObjectInputStream

  130.  * @see java.io.ObjectOutput

  131.  * @see java.io.ObjectInput

  132.  * @see java.io.Externalizable

  133.  * @since   JDK1.1

  134.  */

  135. public interface Serializable {

  136. }