1. /*

  2.  * @(#)Serializable.java	1.20 03/01/23

  3.  *

  4.  * Copyright 2003 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.

  94.  *

  95.  * @author  unascribed

  96.  * @version 1.20, 01/23/03

  97.  * @see java.io.ObjectOutputStream

  98.  * @see java.io.ObjectInputStream

  99.  * @see java.io.ObjectOutput

  100.  * @see java.io.ObjectInput

  101.  * @see java.io.Externalizable

  102.  * @since   JDK1.1

  103.  */

  104. public interface Serializable {

  105. }