Java IO.pdf - Nguyen Dang Binh

Chapter 11. Object Serialization
Java I/O
The last several chapters have shown you how to read and write Java's fundamental data types
(byte, int, String, etc.). However, there's been one glaring omission. Java is a fully objectoriented
language; and yet aside from the special case of strings, you haven't seen any
general-purpose methods for reading or writing objects.
Object serialization, first used in the context of Remote Method Invocation (RMI) and later
for JavaBeans, addresses this need. The java.io.ObjectOutputStream class provides a
writeObject() method you can use to write a Java object onto a stream. The
java.io.ObjectInputStream class has a readObject() method you can use to read an
object from a stream. In this chapter you'll learn how to use these two classes to read and
write objects as well as how to customize the format used for serialization.
11.1 Reading and Writing Objects
Object serialization saves an object's state in a sequence of bytes so that the object can be
reconstituted from those bytes at a later time. Serialization in Java was first developed for use
in RMI. RMI allows an object in one virtual machine to invoke methods in an object in
another virtual machine, possibly in a different computer on the other side of the planet, by
sending arguments and return values across the Internet. This requires a way to convert those
arguments and return values to and from byte streams. It's a trivial task for primitive data
types, but you need to be able to convert objects as well. That's what object serialization
provides.
Object serialization is also used in the JavaBeans component software architecture. Bean
classes are loaded into visual builder tools like the BeanBox (shown in Figure 11.1) or
Borland's JBuilder. The designer then customizes the beans by assigning fonts, sizes, text, and
other properties to each bean and connects them together with events. For instance, a button
bean generally has a label property that is encoded as a string of text ("Start" in the button in
Figure 11.1). The designer can change this text.
Figure 11.1. The BeanBox showing a Juggler bean and an ExplicitButton bean
Once the designer has assembled and customized the beans, the form containing all the beans
must be saved. It's not enough to save the bean classes themselves; the customizations that
have been applied to the beans must also be saved. That's where serialization comes in: it
237