1. /*

  2.  * @(#)Serializable.java	1.16 00/02/02

  3.  *

  4.  * Copyright 1996-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. package java.io;

  12. 

  13. /**

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

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

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

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

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

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

  20.  *

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

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

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

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

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

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

  27.  * Serializable in this case.  The error will be detected at runtime. <p>

  28.  *

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

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

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

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

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

  34.  *

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

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

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

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

  39.  *

  40.  * Classes that require special handling during the serialization and deserialization

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

  42.  *

  43.  * <PRE>

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

  45.  *     throws IOException

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

  47.  *     throws IOException, ClassNotFoundException;

  48.  * </PRE><p>

  49.  *

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

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

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

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

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

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

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

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

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

  59.  *

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

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

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

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

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

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

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

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

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

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

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

  71.  *

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

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

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

  75.  *

  76.  * <PRE>

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

  78.  * </PRE><p>

  79.  *

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

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

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

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

  84.  * follows java accessibility rules. <p>

  85.  *

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

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

  88.  * exact signatute.<p>

  89.  *

  90.  * <PRE>

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

  92.  * </PRE><p>

  93.  *

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

  95.  * accessibility rules as writeReplace.

  96.  *

  97.  * @author  unascribed

  98.  * @version 1.16, 02/02/00

  99.  * @see java.io.ObjectOutputStream

  100.  * @see java.io.ObjectInputStream

  101.  * @see java.io.ObjectOutput

  102.  * @see java.io.ObjectInput

  103.  * @see java.io.Externalizable

  104.  * @since   JDK1.1

  105.  */

  106. public interface Serializable {

  107. }