Java IO.pdf - Nguyen Dang Binh

11.8.1 The readObject( ) and writeObject( ) Methods
Java I/O
The code that serializes objects is built into the virtual machine and is not part of the
ObjectInputStream and ObjectOutputStream classes. This allows the private data of an
object to be read and written. If serialization was written in pure Java without any special
access to the internals of all the different classes, it wouldn't be able to get at the private,
internal state of most objects. However, as long as serialization is allowed to access private
members of an object, that might as well be taken advantage of to customize the serialization
process without affecting the picture of a class shown to the rest of the world.
By default, serialization takes place as previously described. When an object is passed to an
ObjectOutput's writeObject() method, the ObjectOutput reads the data in the object and
writes it onto the underlying output stream in a specified format. Data is written starting with
the highest serializable superclass of the object and continuing down through the hierarchy.
However, before the data of each class is written, the virtual machine checks to see if the class
in question has methods with these two signatures:
private void writeObject(ObjectOutputStream out) throws IOException
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException
(Actually, an ObjectOutput only checks to see if the object has a writeObject() method,
and an ObjectInput only checks for a readObject() method, but it's rare to implement one
of these methods without implementing the other.) If the appropriate method is present, it is
used to serialize the fields of this class rather than writing them directly. The object stream
still handles serialization for any superclass or subclass fields.
For example, let's return to the issue of making a SerializableZipFile. Previously it wasn't
possible, because the superclass, ZipFile, didn't have a no-argument constructor. In fact,
because of this problem, no subclass of this class can be serializable. However, it is possible
to use composition rather than inheritance to make our zip file serializable. [2] Example 11.3
shows a SerializableZipFile class that does not extend java.util.zip.ZipFile.
Instead, it stores a ZipFile object in a transient field in the class called zf. The zf field is
initialized either in the constructor or in the readObject() method. Invocations of the normal
ZipFile methods, like entries() or getInputStream(), are merely passed along to the
ZipFile field zf.
Example 11.3. SerializableZipFile
import java.io.*;
import java.util.*;
import java.util.zip.*;
public class SerializableZipFile implements Serializable {
ZipFile zf;
public SerializableZipFile(String filename) throws IOException {
this.zf = new ZipFile(filename);
}
2 Design pattern aficionados may recognize what's about to happen as an application of the Decorator pattern so common in the java.io
package. For more details, see Design Patterns, Erich Gamma, et al., pp. 179-184, Addison-Wesley, 1995.
252