Static binding Vs Dynamic Binding

[seshu kumar]

Here is a code snippet

  
public class Test 
{ 
  public void method(Parent p) 
  { 
   System.out.println("Parent Version"); 
  } 
  public  void method(Child c) 
  { 
    System.out.println("Child Version"); 
  }
  public static void main(String args[]) 
  { 
     Test test = new Test(); 
     Parent p = new Child();
     Child  c = new Child();
     test.method(p); 
     test.method(c);
  }
}
class Parent
{
};
class Child extends Parent
{
};

And output is

Parent Version
Child Version
Normal Termination

Shouldnt both method calls give Child Parent Version using Dynamic binding

[Deepali Pate]

I think in this particular ? there is no need of binding coz the method is invoked using the same reference.
You are passing reference var to the methods and it chosses the method that is most specific to the argument type passed.
So that explains the nature of o/p.
Am i right??

[seshu kumar]

Ya,
It looks like a dynamic binding but isnt.
It is a case of pure method invocation and i think it is resolved at compile time itself.
Similar example

public class Test2
{ 
 
public void method(Object o) 
{ 
 System.out.println("Object Version"); 
} 
public  void method(String s) 
{ 
System.out.println("String Version"); 
}
public static void main(String args[]) 
{ 
 Test2 test2 = new Test2(); 
 test2.method(null);
}
}

Whats will the result be?

[Deepali Pate]

String version will be printed as that is more specific down the inheritence.
But if u replaced the Object bit by an object of StringBuffer it will give error. Coz though even StringBuffer can have null value but it does not belong to the hierarchy so becomes ambigious.

[Amir Ghahrai]

seshu,
in your first code snippet, I don't see the definition of method in neither the Parent class nor the Child class. therefore, the method from the Test class is invoked depending on the argument type.
The general rule for dynamic method lookup is that the method invoked, depends on the class of the reference, and not its compile-time type. Had you had a definition of method in both your Parent and Child classes, then dynamic binding will go to work and will call the methods from appropriate classes.

[Anthony Villanueva]

According to the JLS:
When a method is invoked (�15.12), the number of actual arguments and the compile-time types of the arguments are used, at compile time, to determine the signature of the method that will be invoked (�15.12.2).
So for overloaded methods, you use the object reference type, not the type of the object at runtime, in this particular case.