Path: csiph.com!usenet.pasdenom.info!weretis.net!feeder1.news.weretis.net!news.swapon.de!eternal-september.org!feeder.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail From: Eric Sosman Newsgroups: comp.lang.java.programmer Subject: Re: Use of @Override when implementing interfaces Date: Sun, 08 Dec 2013 16:45:34 -0500 Organization: A noiseless patient Spider Lines: 54 Message-ID: References: <52a1867c$0$2911$e4fe514c@news2.news.xs4all.nl> <796271a4-11a0-402c-85ff-0f91556c8e7a@googlegroups.com> Mime-Version: 1.0 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Injection-Date: Sun, 8 Dec 2013 21:45:33 +0000 (UTC) Injection-Info: mx05.eternal-september.org; posting-host="858a9d65d95f4ea4d355bd116aa2cdbf"; logging-data="10038"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18vzFvX2HLArzLWBnx2eMZM" User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:24.0) Gecko/20100101 Thunderbird/24.1.1 In-Reply-To: Cancel-Lock: sha1:VIPAg+xvFg7OP0pTBcTdGLnfUx0= Xref: csiph.com comp.lang.java.programmer:26785 On 12/8/2013 3:02 PM, Y HA wrote: > > > using @java.lang.Override seems to have worked... > > why there was the need to specify java.lang.Override ? 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