In case a subclass wants to say:
   if (...)
       return super.readResolve();
perhaps ?  Or so that you can write tests for your objects' implementations of
the serialisation protocol independently of the complexities of the real
serialisation code ?

   -- chris

That seems to be the answer from the JMM list.

http://www.cs.umd.edu/~pugh/java/memoryModel/archive/1636.html

pre-1.5 type-safe enums. If you subclass for certain constants, then you
probably don't want to repeat the readResolve method. Much the same goes
for anywhere where the base class is peers with a fixed set of
subclasses. I suppose where creation is done through a static creation
method.

If you are coding for both J2ME and J2SE, then you can't put
serialisation code in J2ME classes. Subclassing every class is not on.
What you can do is insert serialisation base classes on different
sourcepaths for J2ME and J2SE.

Tom Hawtin

Yeah.  Actually playing with writeReplace and readResolve for a while, I
slapped myself and did the following:

   private final File nameFile;

   private void writeObject(ObjectOutputStream out) throws IOException
   {
       out.defaultWriteObject();
       out.writeObject(nameFile.getPath());
   }

   private void readObject(ObjectInputStream in)
           throws IOException, ClassNotFoundException
   {
       in.defaultReadObject();
       String savedPath = (String)in.readObject();

       if (!savedPath.equals(nameFile.getPath()) ||
               nameFile.getParent() != null)
       {
           throw new InvalidObjectException(savedPath +
                   ": not compatible with this platform");
       }
   }

nameFile contains a single element of a pathname, either a "prefix" or a
name.  It is properly final, since a single element is immutable.  I use
a File, rather than a String, so that I can compare element names and
let the File class worry about the rules of the platform on which I'm
running.

By saving it's original name, I can check that the File serialization/
deserialization doesn't change it's name (\ --> / for example).  I also
check that the name doesn't contain anything that's interpreted as a
directory separator on the current platform.  Linux allows backslashes
in file names, for example.