method overloading and class overriding

[Karthik Guru]

I had a basic doubt...

class Test{
 void foo(Object o){
  sys.o.p("object");
 }
 void foo(String o){
  sys.o.p("String");
 }
 void call(){
  sys.o.p("test's call");
 }
 
 public static void main(String[] args){
   Test t = new Test();
   String s = "hello";
   Object obj = s;
   /** The static type of the parameter    determines the method called */
   t.foo(s); --> prints "string"
   t.foo(obj); --> prints "object"
   Test t1 = new Test1();
   Test t2 = new Test2();
   /** Runtime type of the the caller determines the called method**/
   t1.call();
   t2.call();
 }
}
class Test1 extends Test{
 void call(){
  sys.o.p("test1's call");
 }
}
class Test1 extends Test{
 void call(){
  sys.o.p("test2's call");
 }
}

Why does the runtime behaviour differ in the above 2 cases?
Overriding a method thro' inheritance seems pretty natural to me.
But the behaviour in the other case (method overloading) puzzles me.
Why runtime type does'nt matter there?

[Ilja Preuss]

Short answer: Because the language designer decided to resolve parameter types at compile time.
Longer answer: It would have been possible to resolve parameter types at runtime, but it's a little bit tricky. For example, you can easily get ambigious situations:
having methods with signatures
foo(Object, String)
foo(String, Object)
which one should be called by
foo("string", "string"); ?
The language designer probably thought that it would be better to not let such problems happen at runtime.
BTW, if you need this form of runtime polymorphism, you should take a look at the Visitor Design Pattern aka Double Dispatch.

[Karthik Guru]

thanks, i found an article on multiple dispatch on the web.
BTW, i was wondering if there are languages that support this kind of runtime behaviour?
thanks.

Originally posted by Ilja Preuss:
BTW, if you need this form of runtime polymorphism, you should take a look at the Visitor Design Pattern aka Double Dispatch.