1. Classes IMPLEMENT interfaces
2. Interfaces EXTEND interfaces

This comment seems to be lost, although I could see it in the website right after adding it… am I missing something here ?

Maybe the line between what’s contract and what’s implementation is not always clear, but given marking an interface Serializable doesn’t give you any guarantees about the classes implementing it I would prefer not to use it at all.

So how can an application enforce 3rd party implementations of APIs are serializable ? They just can’t do it at compile time. All they can do is try to handle NotSerializableExceptions if the class doesn’t implement Serializable or just fail if class does implement Serializable but hasn’t coded properly for serialization. In any case it won’t be the application’s problem if an implementation is broken.

If you’ve got control over both the client and the server, then it’s not really much of an issue — if you get a serialisation error, then you update the classpath on both and bounce. If you’re dealing with a more separated system where you maybe don’t have control, you probably shouldn’t be using serialization anyway, and using something independent like XML to transfer data.

If your interface is something that needs to be used in a Serializable context, then marking that interface extend Serializable is a good way of enforcing the contract to implementors of that interface. Let’s face it, if you have a method called bar() in the interface, you’re expecting that classes that implement the interface called bar() do it properly, right? And if it was a super interface that defined foo() (which the class also had to implement) that it would do it correctly too, that it would also be done properly? Or implementing toString() or equals() that come from a superclass?

So why is it any different from Serializable, just because there’s no method? You’re stating a requirement by implementing the interface, and subclasses should respect that. If they don’t, they are broken.

What is in fact serializable is not a class or an interface but an instance. Classes have instances, so it makes sense to say that the instances of SomeClass extend Serializable. Interfaces as such don’t have instances (instances conform to interfaces), so it does not make sense.

For SomeInterface to extend Serializable is essentially to demand that any class extending SomeInterface have serializable instances. Unfortunately, since Serializable is a marker interface, there is no way for the compiler to check whether the instances are truly serializable or not. Therefore, having SomeInterface extend Serializable makes promises that may or may not be kept.

Exactly the same arguments apply to Cloneable, to the nonstandard interface Immutable, and indeed to any other marker interface. In any case, the only operation you can perform on a marker interface is to ask whether an object is an instance of it, a function which can now be performed better with annotations. IMHO, annotations should supersede marker interfaces in future designs.