So we all know that all classes implicitly extend Object. How about interfaces? Is there an implicit super-interface? I say there is. The following code compiles:
java.io.Serializable s1 = null;
java.io.Serializable s2 = null;
s1.equals(s2);
The equals
method is not declared in Serializable, but in Object. Since interfaces can only extend other interfaces, and Object is a class, not an interface, there must be some implicit interface that is being extended. And the Object
class must then implicitly implement this implicit interface (wow, that was weird to write).
So, the question is, how correct is this?
-
s1 and s2 here are object references, referring to instances of objects that implement Serializable. There is no such thing as an interface reference in Java.
So Java knows that whatever these objects are, they descend from java.lang.Object. Hence the above code is valid.
-
When you declare something like:
java.io.Serializable s1 = null;
don't forget that everything in Java is derived from
Object
. So here, you are only saying thats1
is something (eitherObject
or some class extendingObject
) thatimplements Serializable
. There is no magic. Everything in Java is derived fromObject
whether it is explicit or not. Thus, theequals
method is always available.McWafflestix : maybe I'm missing something, but how is declaring a variable "declaring a type"?Eddie : OK, I worded it poorly. Let me edit and try again. -
I don't think there's any super interface.
When you declare a variable like this:
java.io.Serializable s1 = null;
you haven't created any
Object
.The compiler knows that
s1
ands2
will implementSerializable
and will descend fromObject
so it allows theequals
. -
Since interfaces can only extend other interfaces, and Object is a class, not an interface, there must be some implicit interface that is being extended.
No. Citing the Java Language Specification:
If an interface has no direct superinterfaces, then the interface implicitly declares a public abstract member method m with signature s, return type r, and throws clause t corresponding to each public instance method m with signature s, return type r, and throws clause t declared in Object, unless a method with the same signature, same return type, and a compatible throws clause is explicitly declared by the interface. It is a compile-time error if the interface explicitly declares such a method m in the case where m is declared to be final in Object.
The difference between this and your "implicit super interface" is that
Object
has a number of final and protected methods, and you couldn't have those modifiers in an interface.Michael Myers : +1 for actually citing the spec.
0 comments:
Post a Comment