Java IO.pdf - Nguyen Dang Binh

public class NetworkWindow extends Frame implements Serializable {
}
private Socket theSocket;
// several dozen other fields and methods
You could make this class fully serializable by merely declaring theSocket transient:
private transient Socket theSocket;
Java I/O
Let's assume you actually do want to restore the state of the socket when the object is
deserialized. In this case, you can use private readObject() and writeObject() methods as
in the last section. You can use defaultReadObject() and defaultWriteObject() methods
to handle all the normal, nontransient fields; then handle the socket specifically. For example:
private void writeObject(ObjectOutputStream out) throws IOException {
}
out.defaultWriteObject();
out.writeObject(theSocket.getInetAddress());
out.writeInt(theSocket.getPort());
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
}
in.defaultReadObject();
InetAddress ia = (InetAddress) in.readObject();
int thePort = in.readInt();
this.theSocket = new Socket(ia, thePort);
It isn't even necessary to know what the other fields are to make this work. The only extra
work that has to be done is for the transient fields. This technique applies far beyond this one
example. It can be used anytime when you're happy with the default behavior and merely
want to do additional things on serialization or deserialization. For instance, it can be used to
set the values of static fields or to execute additional code when deserialization is complete.
However, if the latter is your intent, you might be better served by validation, discussed later
in the chapter. For example, let's suppose you have a Die class that must have a value
between 1 and 6, as shown in Example 11.4.
Example 11.4. A Six-Sided Die
import java.util.*;
import java.io.*;
public class Die implements Serializable {
private int face = 1;
Random shooter = new Random();
public Die(int face) {
this.face = (int) (Math.abs(face % 6) + 1);
}
255