Runtime polymorphism decision

Question

I have read somewhere that runtime polymorphism is a result of dynamic typing in langugages. By inspecting the code below we can see a clear example of runtime polymorphism.

class A{
    do(){}
}
class B extends A{
    do(){}
}
...
A ex = new B();
ex.do();

Since there is superclass type reference , compiler can't decide which type will reference refer actually and binds method in the runtime.but what about the usage below with same class definitions?

My 1st question is for the example below;

class A{
    do(){}
}
class B extends A{
  //no overriding
}
...
A ex = new B();
ex.do();

There is only one version of method do() in the hierarchy. Does the system still wait runtime to bind the method?Or does it bind in compile time?

My second question is for the example below;

class A{
    do(){}
}
class B extends A{
  do(){}
}
...
B ex = new B();
ex.do();

There is subclass(lowest in inheritance chain) type reference now. Will it be bound in runtime?

Answer 1

When compiling a invocation of a non-static method javac will always use a invokevirtual instruction, so there is no optimization done at compile time.

But since devirtualization of method calls is an important optimization (save the vtable lookup, possibly inline the method) the runtime (hotspot, etc.) will try to apply it if possible due to code analysis.

So in your second example (third code block) the runtime might recognize that it can replace the virtual call to A.do with a call to B.do since ex is actually a B (should be trivial to figure out by the runtime in this case).

For your first example (second code block) there is another optimization technique. The runtime first sees class A. Any invocations of A.do are now compiled as static invocations as if no derived class exists which overrides A.do. If such a class is later loaded the runtime will rollback this optimistic assumption and introduce virtual method calls instead.