This week's book giveaway is in the Servlets forum.
We're giving away four copies of Murach's Java Servlets and JSP and have Joel Murach on-line!
See this thread for details.
The moose likes Programmer Certification (SCJP/OCPJP) and the fly likes damn overriding again Big Moose Saloon
  Search | Java FAQ | Recent Topics | Flagged Topics | Hot Topics | Zero Replies
Register / Login

Win a copy of Murach's Java Servlets and JSP this week in the Servlets forum!
JavaRanch » Java Forums » Certification » Programmer Certification (SCJP/OCPJP)
Bookmark "damn overriding again " Watch "damn overriding again " New topic

damn overriding again

Anshul Manisha
Ranch Hand

Joined: Apr 17, 2001
Posts: 74
Hello folks,
Now this situation has me completely foxed. I have following code:

When I try to compile this program under JVM 1.3 I am getting compiler error as follows

"": Error #: 304 : reference to method1 is ambiguous; both method method1(int) in class anshul.Java06131 and method method1(double) in class anshul.Java0613 match at line 28, column 10

When I move the method with signature as double to superclass then it doesn't complain about the method ambiguity and the program executes nicely.
Comments invited .


AM<BR> <A HREF="" rel="nofollow"></A>
Ranjan Chaudhuri
Ranch Hand

Joined: May 22, 2001
Posts: 33
You aren't overriding the method, you are OVERLOADING it. But there's still something fishy about it. It is OK for the compiler to report an ambiguity, I suppose, because the value passed (3) matches the signatures of both the int and double methods, one in the subclass and one in the superclass.
(See JLS 5.3 and 5.1.2 for the relevant parts on widening conversions.)
However, moving both methods to the superclass shouldn't then RESOLVE the ambiguity in favor of the (int) method! (Unless somehow having them both in the same method helps the compiler disambiguate by figuring that the (int) version is more specific now, but why should the overloaded method being inherited make a difference?)In fact, Sections 15.12.1, 15.12.2, and of the JLS suggest that the ambiguity should still exist. If the (int) method in the superclass is applicable and accessible, so should the (double) method be!
I get the same error as you with 1.3.1--but with the fastjavac compiler, the error I get is *different*, namely "No method found matching method1(int)". I think this is a strange situation, possibly a compiler bug. Perhaps someone else can verify this. I simplified your code to isolate the problem, and used the following:

The error I got at line 24 was "No method found matching amethod(int)."
Again, the way I interpret the relevant sections of the JLS (see 15.12.1 and 15.12.2), there should be no problem, as it is stated in that "method definitions inherited from superclasses and superinterfaces are included in this search [for an appropriate method signature]."
In my case, what seems to be happening is that the superclass method is somehow getting "shadowed" by the method of the same name as the subclass, which shouldn't happen. (Removing the method from the subclass altogether or moving it to the superclass "solves" the problem here too--the (int) version of the method gets called.)
Does anyone else come across this? What happens when you compile it on JDK 1.2.1 or on non-Sun compilers? [I got the same behavior with jikes, i.e. ambiguous when the double and int versions are in different classes, and no problem when both are in the superclass, with the int version being selected when passed an int.] Am I misreading the JLS? Compiler bug in both cases?
[This message has been edited by Ranjan Chaudhuri (edited June 20, 2001).]
[This message has been edited by Ranjan Chaudhuri (edited June 20, 2001).]
[This message has been edited by Ranjan Chaudhuri (edited June 20, 2001).]
Anshul Manisha
Ranch Hand

Joined: Apr 17, 2001
Posts: 74
thanks ranjan,
it is overloading and not overriding.
sona gold
Ranch Hand

Joined: Feb 14, 2001
Posts: 234
in case of overloading what happens is, the most specific method is chosen
that is if u have a mehtod taking an int as a parameter and another taking a double
and if u pass int as a parameter, the method that takes the int as parameter will be called. (when the methods are in the same class)
in the case shown in the above code
we are overloading the method in subclass
and calling the method with reference to the object with an int parameter
now we have a method taking double as a parameter in the subclass and an int parameter will fit into it. but it also has an int method inherited from superclass thus the ambiguity.
it is something like when the subclass has a satisfying method in its own class it does not understand why it should use it from the super class

sona<br />SCJP
Ranjan Chaudhuri
Ranch Hand

Joined: May 22, 2001
Posts: 33
Intuitively, I agree and that's what I always assumed. But I would be much happier if someone could show me (preferably using the JLS), why the (int) version is more specific than the (double) version in the above case, or even in the simpler one below. It's probably something as simple as the fact that requiring a widening conversion makes the (double) version less specific. BUT IN THAT CASE, this should be so even if the (int) version is in the superclass and the (double) version is in the subclass, no? I keep thinking there's some sort of inconsistency here.
I think looking at the JLS too closely has confused me.

[This message has been edited by Ranjan Chaudhuri (edited June 20, 2001).]
Don't get me started about those stupid light bulbs.
subject: damn overriding again
Similar Threads
Decison between overriding methods & arithmetic prmotable overloaded methods
Abstract Class
decimal precision
Inner classes & Static blocks
String conversion in to double