class A {
public void doSomething(float f) {
//print "in A"
}
}
class B extends A {
public void doSomething(int i) {
// print "in B"
}
public static void main(String[] args) {
A a = new B();
a.doSomething(10);
}
}
The compiler first checks if doSomething() is present in class A. Once confirmed, during runtime, the object type is checked and the corresponding method is executed that is doSomething() of class B should be executed but doSomething() of class A is executed instead.
If both the methods would be the same then only class B doSomething() would be executed.
How does the compiler decide that a certain method is overridden and thus it will be taken care by the JVM?
To put it simply:
In step 1, the compiler looks at the declared type of the object on which the method is invoked, and also at the parameter types, which means:
a is A ("declared type", aka static type); it therefore can only search methods in A or methods inherited by A. This means that the compiler doesn't even search for doSomething in class B in your example.doSomething method (the one with a float parameter)Based on the above, the compiler can only conclude that it's doSomething(float) that will run. You can look at it as if the compiler's selected method signature is written in stone, the runtime can't change that.
In step 2, the runtime knows which signature will run (doSomething(float)), the only thing it needs to do is pick which implementation of that signature will be invoked. For that, it looks at the actual object type (the object that was created), new B(), in your example. It will then run the implementation in B, if overridden, or search up the tree any overridden implementation of that exact signature until it gets to the inherited implementation in A. Because B does not override doSomething(float), the inherited implementation A.doSomething(float) from A runs.