ObjectInputStream question

[Jia Tan]

In java SE6 API, there is a paragraph in ObjectInputStream:

Serializable classes that require special handling during the serialization and deserialization process should implement the following methods:

private void writeObject(java.io.ObjectOutputStream stream)
throws IOException;
private void readObject(java.io.ObjectInputStream stream)
throws IOException, ClassNotFoundException;
private void readObjectNoData()
throws ObjectStreamException;

Now that the method are all marked "private", how can they be "implement"ed? Can anyone give an example or shed some light on it? TIA

[Ankit Garg]

what's the problem with implementing a private method. They are just giving you the liberty of using any access modifier you want. This is to ensure that no one calls the method on your class. These methods are usually meant for the JVM to use while serializing and deserializing...

[Punit Singh]

these private methods are not declared in Serializable interface, Serializable is just an marker inteface, it is just a design that will tell you to write two private methods with given signature for custom serialization.
I am providing an example, see DogT class is performing custom serialization process and adding Collar information in serialization process.

 import java.io.*;
public class TransientSerializeDog {
	public static void main(String[] args) {
		CollarT c = new CollarT(3);
		DogT d = new DogT(c, 5);
		System.out.println("before: collar size is "
				+ d.getCollar().getCollarSize());
		try {
			FileOutputStream fs = new FileOutputStream("testSer.ser");
			ObjectOutputStream os = new ObjectOutputStream(fs);
			System.out.println("Going to call writeObject(d)");
			os.writeObject(d);
			System.out.println("call to writeObject(d) completes");
			os.close();
		} catch (Exception e) { e.printStackTrace(); }
		try {
			FileInputStream fis = new FileInputStream("testSer.ser");
			ObjectInputStream ois = new ObjectInputStream(fis);
			d = (DogT) ois.readObject();
			ois.close();
		} catch (Exception e) { e.printStackTrace(); }
		System.out.println("after: collar size is "
				+ d.getCollar().getCollarSize());
	}
}
class DogT implements Serializable {
	private transient CollarT theCollar;
	private int dogSize;
	public DogT(CollarT collar, int size) {
		theCollar = collar;
		dogSize = size;
	}
	public CollarT getCollar() { return theCollar; }
	private void writeObject(ObjectOutputStream os) {
		try {
			System.out.println("writeObject(d) is calling dog's overriden writeObject()");
			os.writeInt(theCollar.getCollarSize()); // 3
			os.defaultWriteObject(); // 2
			System.out.println("calling dog's overriden writeObject() completes");
		} catch (Exception e) { e.printStackTrace(); }
	}
	private void readObject(ObjectInputStream is) {
			try {
			
			theCollar = new CollarT(is.readInt()); // 6
			is.defaultReadObject(); // 5
		} catch (Exception e) { e.printStackTrace(); }
	}
}
class CollarT{
	private int collarSize;
	public CollarT(int size) { collarSize = size; }
	public int getCollarSize() { return collarSize; }
}   

[Jia Tan]

Thank you Punit, your example helps a lot! I was wondering why I cann't find these methods in the ObjectInputStream API, and didn't realize that the programmer had to write their own implementation. Maybe I didn't read it carefully. This is some sort of stipulation the JVM made to help serialize/deserialize some objects that do not implement Serializable interface right?

[Punit Singh]

Jia Tan wrote:Thank you Punit, your example helps a lot! I was wondering why I cann't find these methods in the ObjectInputStream API, and didn't realize that the programmer had to write their own implementation. Maybe I didn't read it carefully. This is some sort of stipulation the JVM made to help serialize/deserialize some objects that do not implement Serializable interface right?

Right.