Java IO.pdf - Nguyen Dang Binh

}
Java I/O
The main() method attempts to create an instance of this class, serialize it to a byte array
output stream, then read it back in from a byte array input stream. However, here's what
happens when you run it:
D:\JAVA>java SerializableZipFileNot test.zip
Wrote object!
java.io.InvalidClassException: java.util.zip.ZipFile;
at java.io.ObjectInputStream.inputObject(Compiled Code)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:363)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:226)
at SerializableZipFileNot.main(SerializableZipFileNot.java:28)
Since the superclass, ZipFile, is not itself serializable and cannot be instantiated with a noargument
constructor, the subclass cannot be deserialized. It can be serialized, but that isn't
much use unless you can get the object back again. Later, you'll see how to make a
SerializableZipFile class that can be both written and read. However, to do this, you'll
have to give up something else, notably the ZipFile type.
11.5.1.3 Problem 3: Deliberate throwing of NotSerializableException
A few classes appear to be not serializable out of pure spite (though normally there's more
reason to it than that). Sometimes it's necessary, for security or other reasons, to make a class
not serializable, even though one of its superclasses does implement Serializable. Since a
subclass can't unimplement an interface implemented in its superclass, the subclass may
choose to deliberately throw a NotSerializableException when you attempt to serialize it.
You'll see exactly how this is done shortly.
11.5.1.4 Locating the offending object
When you encounter a class that you think should be serializable but isn't (and this happens
all too frequently, often after you've spent two hours adjusting and customizing several dozen
beans in a builder tool that now can't save your work), you'll need to locate the offending
class. The detailMessage field of the NotSerializableException contains the name of the
unserializable class. This can be retrieved with the getMessage() method of
java.lang.Throwable or as part of the string returned by toString():
try {
out.writeObject(unserializableObject);
}
catch (NotSerializableException e) {
System.err.println(e);
System.err.println(e.getMessage() + " could not be serialized");
}
It is not always obvious where the offending class sneaked in. For example, if you're trying to
serialize a hash table that contains seven vectors, each of which contains many different
objects of different classes, a single nonserializable object in one of the vectors will cause a
NotSerializableException. You'll need to explore the source code to determine which
object caused the problem.
246