Is method overriding always run time polymorphism?

Question

Does runtime polymorphism always happen with method overriding, or does it happen only if method is called after assigning sub class object to super class variable, during method overriding?

class A {
    public void myFunc() {
        System.out.println("Something");
    }
}

class B extends A {
    public void myFunc() {
        System.out.println("Something else");
    }

    public static void main (String args[]) {
        A obj = new B();
        obj.myFunc(); //Is only this call resolved at run time?
     
        A obj2 = new A();
        obj2.myFunc(); //Or is this call too resolved at run time?
   
        B obj3 = new B();
        obj3.myFunc(); //Is this call resolved at compile time?
    }
}

In all cases, the compiler and runtime *both* need to do some work to find out what method is to be called. I answered a [similar question](https://stackoverflow.com/questions/52776368/how-does-polymorphism-in-java-work-for-this-general-case-method-with-parameter) a few days back that can give you a basic idea. — TiiJ7, Oct 16 '18 at 11:48
TiiJ7, what I get from your answer is that, ultimately, all method calls are resolved at run time after some compile time work. — Lemmy, Oct 16 '18 at 12:24
When you call an overridden method through a reference of parent class, then the method to be executed is determined by the type of the object. And it is determined at runtime. Therefore only the first call will be runtime polymorphism — Onur Baştürk, Sep 13 '20 at 11:54
@Lemmy, all your methods given above are resolved at run time. — Vishwa Ratna, Sep 14 '20 at 04:56
If the override is `final` and called from the current class scope, it can be resolved at compile time. Whether Java actually does that is another question. — user207421, Sep 14 '20 at 05:10
@MarquisofLorne How do we check that `final` override from the current scope is resolved at the compile time? I disassemble and compared the byte code. it looks identical. — Govinda Sakhare, Sep 14 '20 at 13:44

score 6 · Answer 1 · edited Sep 14 '20 at 04:47

In method overriding, method resolution always takes care by JVM based on the RUN TIME OBJECT. Yes, all these calls will get resolved at run-time.

A obj = new B();
obj.myFunc();

here reference variable is of class A but object is of class B. Hence, class B myFunc method will get called

A obj2 = new A();

obj2.myFunc();

here reference variable is of class A and object is also of class A. Hence, class A myFunc method will get called

B obj3 = new B();

obj3.myFunc();

here reference variable is of class B and object is also of class B, Hence, class B myFunc method will get called

score 4 · Answer 2 · answered Sep 18 '20 at 15:44

Whether the compiler is actually able to optimize any or all of the three method invocations and resolve the calls at compile time now or in some future implementation is irrelevant: All three method invocations are examples of runtime polymorphism, also known as dynamic dispatch This is contrasted with what is referred to as static polymorphism, also known as method overloading, which is a class having multiple methods with the same name but with different argument types.

Here is a small Java program:

public class Test {


    public void foo(String inputString)
    {
        System.out.println(inputString);
    }


    public static void main(String[] args) {
        Test test = new Test();
        test.foo("a"); # very obvious method invocation
    }

}

It is very clear to a human what method would be invoked at runtime. Here is the disassembled bytecode:

Compiled from "Test.java"
public class Test {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public void foo(java.lang.String);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_1
       4: invokevirtual #3                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       7: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #4                  // class Test
       3: dup
       4: invokespecial #5                  // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: ldc           #6                  // String a
      11: invokevirtual #7                  // Method foo:(Ljava/lang/String;)V
      14: return
}

Instruction 11 is a runtime dispatch of a virtual method.

But as I said, even if in some future compiler implementation this was optimized to a different call, that would just be an implementation detail.

I think this is the most valid answer to the question because it shows how it is in bytecode after compile. — Chayne P. S., Sep 18 '20 at 16:07

score 0 · Answer 3 · answered Sep 18 '20 at 08:16

Private, final and static members (methods and variables) use static binding.
While for virtual methods (In Java methods are virtual by default) binding is done at run time based upon the object held by the variable.

So to answer your question, Method Resolution always done at runtime for all of the below cases. (Whether the subclass' object assigned to superclass' variable or same type of object held by the variable)

    A obj = new B();
    obj.myFunc();
 
    A obj2 = new A();
    obj2.myFunc();

    B obj3 = new B();
    obj3.myFunc();

score 0 · Answer 4 · answered Sep 18 '20 at 15:00

Polymorphism is a principle in object oriented programming: write the logic of your software without caring of implementations The right implementation of code to be executed is ( at least in principle ), is always determined at runtime

Your doubt is about this example: A a = new A(); but it's equivalent to this A a = MyFactory.get();

Maybe JVM performs some optimization final A a = new B(); to avoid searching the right implementation ?

score 0 · Answer 5 · edited Sep 20 '20 at 16:11

0

Generally the concept of polymorphism is related to using different forms of one type (class/interface), thats why the sub classes needs to have the similar contract as per the super type.

Considering your question all the three statements will be resolved at runtime but only the first one comes under the hood of polymorphism.

edited Sep 20 '20 at 16:11

Pierre.Vriens

2,117
75
29
42

answered Sep 20 '20 at 13:09

Shaheryar

1
3

Is method overriding always run time polymorphism?

5 Answers5

Linked

Related