Question

Complete the following tasks, assuming that each applies to the same program: a) Write a statement that opens file "oldmast.ser" for input-use 0bjectInputstream variable in01 dMaster to wrap an InputStream object. b) Write a statement that opens file "trans.ser" for input-use ObjectInputStream variable inTransaction to wrap an InputStream object. c) Write a statement that opens file "newmast.ser" for output (and creation) -use Object0utputStream variable outNewMaster to wrap an OutputStream. d) Write a statement that reads a record from the file "oldmast.ser". The record is an object of class Account-use ObjectInputStream variable in01dMaster. Assume class Account is the same as the Account class in Fig. 15.9 e) Write a statement that reads a record from the file "trans.ser". The record is an object of class TransactionRecord-use ObjectInputStream variable inTransaction. f) Write a statement that outputs a record of type Account to the file "newmast. ser"-use Object0utputStream variable outNewMaster.

Short answer

Use FileInputStream to open input files, wrapped by ObjectInputStream. Use FileOutputStream for the output file, wrapped by ObjectOutputStream. Use readObject method to read objects, cast as necessary, and writeObject to write objects.

Step-by-step solution

Opening

First, import the necessary Java I/O classes. After that, create an instance of FileInputStream to open the file 'oldmast.ser' for reading. Then wrap it with an ObjectInputStream to read objects from the file.

Opening

Similarly, open the file 'trans.ser' by creating a new instance of FileInputStream and then wrap this with a new ObjectInputStream. Use the variable name inTransaction for the ObjectInputStream.

Opening

For writing to 'newmast.ser', create an instance of FileOutputStream to create the file for output. Then wrap it with an ObjectOutputStream so that you can write objects to this stream. Use the variable name outNewMaster for the ObjectOutputStream.

Reading from

To read an Account object from 'oldmast.ser', use the readObject method of the ObjectInputStream associated with inOldMaster. The returned object should be cast to the Account type.

Reading from

To read a TransactionRecord object from 'trans.ser', again use the readObject method of the corresponding ObjectInputStream, inTransaction. Cast the returned object to the TransactionRecord type.

Writing to

To write an Account object to 'newmast.ser', use the writeObject method of the ObjectOutputStream associated with outNewMaster. Pass the Account object to be written to the file as an argument to this method.

Key concepts

ObjectInputStream

When working with Java, you may encounter a need to read objects from a file or another source. This is where the ObjectInputStream comes into play. It is a high-level stream that works in conjunction with lower-level streams, like FileInputStream, to deserialize objects – which is just a technical way of saying 'to convert the binary data from the file back into an object in memory'.

Using ObjectInputStream is particularly useful when dealing with Java Serialization, where you store objects in a byte-stream format. When using inOldMaster and inTransaction from the exercise, you effectively create an ObjectInputStream that reads from the files 'oldmast.ser' and 'trans.ser', respectively. Here's a typical usage pattern:

• First, you create a FileInputStream pointing to the file.
• Next, you wrap this in an ObjectInputStream.
• Finally, you call the readObject() method to read an object from the stream and cast it back into its appropriate class.

Keep in mind that when casting the objects back to their original class, the class must be present in the Java Virtual Machine and be compatible with the version of the class at the time of Serialization.

Java Serialization

Java Serialization is a mechanism where you can convert an object's state into a byte stream, effectively 'freezing' the object's data to be transferred or stored. This process allows you to save objects to files, send them through streams like sockets, or store them on in-memory caches to reconstruct them later.

To serialize an object, the class must implement the java.io.Serializable interface. This interface acts as a marker, indicating to the JVM that this class is okay to serialize. But, there's no method to implement — it's just a signal to the JVM. And when you serialize an object, you also serialize all the objects referenced from this object, as long as they are also serializable.

The companion process to serialization is deserialization; the exercise’s use of ObjectInputStream for reading a serialized object back is an example of deserialization. This process poses some risks like the infamous 'Java Deserialization Attacks', so it's important to ensure that the data source is secure and the classes used are compatible.

File Handling in Java

File Handling in Java is an essential topic as it deals with creating, reading, updating, and deleting files. Java provides strong support for file operations through its java.io package, offering a rich variety of streams and writer/reader classes.

The exercise highlights two important classes for file handling: FileInputStream and FileOutputStream. When you need to read raw data, like bytes, from files, you use FileInputStream; when you want to write raw data to a file, FileOutputStream takes the lead. You can conveniently write objects to files or read them using ObjectOutputStream and ObjectInputStream by wrapping these lower-level streams in the higher-level object streams.

• FileInputStream helps in reading data from a file and serves as a basis for more complex input streams like ObjectInputStream.
• FileOutputStream writes data to a file, creating the file if it doesn’t exist or replacing its contents if it does.

These streams help in managing resources properly, as they must be closed after use to free up system resources.