Re: Use of @Override when implementing interfaces

On 12/8/2013 3:02 PM, Y HA wrote:


     Because (as two or three people have explained) `Override' is
just a name, not something built in to the compiler like `throw'
or `float'. When your source contains `@Override', the compiler
realizes `Override' must be the name of something and sees that it
is an unqualified name: The package that defines the name has not
been specified. So the compiler searches in various places,
looking for a package that defines `Override'.

     Usually, the compiler finds `Override' in the `java.lang'
package and concludes that the full name is `java.lang.Override'.
This particular definition of `Override' is of the right kind to
be used as an annotation, so all is well. But in your case there
was another `Override' definition, a class (probably in a file
named "Override.java") with `Override' as its name. The compiler
found this other `Override' first, and said "Aha! `Override' is
shorthand for `whatever.package.Override'." Unfortunately, your
`Override' was entirely the wrong sort of thing: A class, not a
sub-interface of `java.lang.annotation.Annotation'.

     When you wrote `@java.lang.Override' in your source, the
compiler knew immediately what package contained the `Override'
definition that was needed. So the compiler didn't need to
search for anything, didn't find your non-Annotation `Override',
and went right ahead with the `java.lang.Override' version.

     Names in Java are not globally unique; different packages
can define classes and interfaces and enums with the same name.
Java SE 7 includes two different things named `Parser', three
named `AttributeList', four named `Attribute', five named `Element',
and so it goes. How can all these colliding names coexist? They
are in different packages.

     Usually, you import the package that defines the particular
kind of `FooBar' your source refers to (the compiler makes the
java and java.lang packages visible without the need to import).
Then you write `FooBar' in the source, and the compiler finds the
right definition among your imports. But occasionally you need
to deal with more than one kind of `FooBar' in the same source:
For example, you may use the `java.util.List' interface and the
`java.awt.List' class at the same time. When this happens, you
need to write out the full name; `List' by itself is ambiguous
when there's more than one kind of `List' in play. Similarly,
`Override' by itself is ambiguous when there's more than one.

--
Eric Sosman
esosman@comcast-dot-net.invalid