1. /*

  2.  * @(#)Serializable.java	1.15 01/11/29

  3.  *

  4.  * Copyright 2002 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 in this 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 deserialization

  38.  * process must implement special methods with these exact signatures: <p>

  39.  *

  40.  * <PRE>

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

  42.  *     throws IOException

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

  44.  *     throws IOException, ClassNotFoundException;

  45.  * </PRE><p>

  46.  *

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

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

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

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

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

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

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

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

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

  56.  *

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

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

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

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

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

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

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

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

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

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

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

  68.  *

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

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

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

  72.  *

  73.  * <PRE>

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

  75.  * </PRE><p>

  76.  *

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

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

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

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

  81.  * follows java accessibility rules. <p>

  82.  *

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

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

  85.  * exact signatute.<p>

  86.  *

  87.  * <PRE>

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

  89.  * </PRE><p>

  90.  *

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

  92.  * accessibility rules as writeReplace.

  93.  *

  94.  * @author  unascribed

  95.  * @version 1.15, 11/29/01

  96.  * @see java.io.ObjectOutputStream

  97.  * @see java.io.ObjectInputStream

  98.  * @see java.io.ObjectOutput

  99.  * @see java.io.ObjectInput

  100.  * @see java.io.Externalizable

  101.  * @since   JDK1.1

  102.  */

  103. public interface Serializable {

  104. }