Should an abstract class have a serialVersionUID

Question

In java, if a class implements Serializable but is abstract, should it have a serialVersionUID long declared, or do the subclasses only require that?

In this case it is indeed the intention that all the sub classes deal with serialization as the purpose of the type is to be used in RMI calls.

Answer 1

The serialVersionUID is provided to determine compatibility between a deseralized object and the current version of the class. As such, it isn't really necessary in the first version of a class, or in this case, in an abstract base class. You'll never have an instance of that abstract class to serialize/deserialize, so it doesn't need a serialVersionUID.

(Of course, it does generate a compiler warning, which you want to get rid of, right?)

It turns out james' comment is correct. The serialVersionUID of an abstract base class does get propagated to subclasses. In light of that, you do need the serialVersionUID in your base class.

The code to test:

import java.io.Serializable;  public abstract class Base implements Serializable {      private int x = 0;     private int y = 0;      private static final long serialVersionUID = 1L;      public String toString()     {         return "Base X: " + x + ", Base Y: " + y;     } }    import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream;  public class Sub extends Base {      private int z = 0;      private static final long serialVersionUID = 1000L;      public String toString()     {         return super.toString() + ", Sub Z: " + z;     }      public static void main(String[] args)     {         Sub s1 = new Sub();         System.out.println( s1.toString() );          // Serialize the object and save it to a file         try {             FileOutputStream fout = new FileOutputStream("object.dat");             ObjectOutputStream oos = new ObjectOutputStream(fout);             oos.writeObject( s1 );             oos.close();         } catch (Exception e) {             e.printStackTrace();         }          Sub s2 = null;         // Load the file and deserialize the object         try {             FileInputStream fin = new FileInputStream("object.dat");             ObjectInputStream ois = new ObjectInputStream(fin);             s2 = (Sub) ois.readObject();             ois.close();         } catch (Exception e) {             e.printStackTrace();         }          System.out.println( s2.toString() );     } } 

Run the main in Sub once to get it to create and save an object. Then change the serialVersionUID in the Base class, comment out the lines in main that save the object (so it doesn't save it again, you just want to load the old one), and run it again. This will result in an exception

java.io.InvalidClassException: Base; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 2 

Answer 2

Yes, in general, for the same reason that any other class needs a serial id - to avoid one being generated for it. Basically any class (not interface) that implements serializable should define serial version id or you risk de-serialization errors when the same .class compile is not in the server and client JVMs.

There are other options if you are trying to do something fancy. I'm not sure what you mean by "it is the intention of the sub classes...". Are you going to write custom serialization methods (eg. writeObject, readObject)? If so there are other options for dealing with a super class.

see: http://java.sun.com/javase/6/docs/api/java/io/Serializable.html

HTH Tom