Overriding and overloading together

Question

Hi all,i've a qn on overloading and over-riding combined.
Consider the following program.
class base {
int i;
base(int val) { i = val; }
void f(int i) { System.out.println("base int"); } // <1> case1
void f(double d) { System.out.println("base double"); } //case2
class sub extends base {
int j;
sub(int val1, int val2) { super(val1); j = val2; }
void f(int i) { System.out.println("sub int"); } // <2> //case3
void f(double d) { System.out.println("sub double"); } //case4
class Test {
public static void main(String argv[]) {
base a = new base(1);
sub s = new sub(1,2);
base b = s;
a.f(1);
a.f(1.2);
s.f(1);
s.f(1.2);
b.f(1);
b.f(1.2);
when i comment case1 follwoing is printed
base double
base double
sub int
sub double
sub double
sub double
apparently the reason being, when i override the overloaded function, the over-riding will hide all the variants of the member function and not just the one which i overrode.
Line 5 - Here the subtle issue is that we are overriding already overloaded
function. Case2 and case3 are overloaded (in base/sub classes) and case4
overrides case2. Due to this , the overriding hides all the overloaded
variants of that member function and hence case2/case3 are hidden. So due
to dynamic binding and hiding of the overloaded (case3) , sub's double is
called. Also since sub's int is not availble, co-ercion takes place too. IS THIS REASONING CORRECT??
Also,what happens if i uncomment case1 and comment case3??
Where can i find more information on this??
Any help is highly appreciated
Regards

Answer 1

Then what will happen if i uncomment case1 and comment case3?Did you try it?
base int
base double
base int
sub double
base int
sub doubleIt is the difference between early and late binding.
Overloaded methods are bound early.
Overridden methods are bound late.
To reiterate,
Determining which of the overloaded methods to call is done when the class is compiled[], based on the compile time type information.
Determining which overridden version of that method to call is done at [b]runtime.
Even if a subclass DOES have a more appropriate overloaded method to call at runtime, that method can not get used. This was demonstrated when you commented out case1. The most appropriate method it found in the base class took a float. It knew nothing (at that time) about the overloaded version in the subclass.
So we know the signature of the method we are going to call before we run the program.
At runtime it looks at the actual type of the object that it has, and calls the version most lately declared in the object's hierarchy - ie this resolves the overriding.
So explaining the results above:
It detemines at compile time which version of the overloaded methods it will call.
Because both are available in the base class, it will call
f(int)
f(double)
f(int)
f(double)
f(int)
f(double)
At RUNTIME, when you call it
- the first object is of type base, and thus calls the int and double methods of base
- the second object is of type sub. But it doesn't override the int version of the method, so base's implementation is used. It DOES override the float version, so you get its implementation there.
- same result for the third object.
Hope this clears things up,
cheers,
evnafets