Dynamic vs. Static Binding: How Does Java Resolve Method Calls at Runtime?

Understanding Polymorphism: Distinguishing Dynamic from Static Bindings in Java

In Java, polymorphism, the ability of a variable to refer to objects of different classes, comes in two forms: dynamic and static.

Static Binding (Compile-Time Binding)

In static binding, method calls are bound to the specific object at compile time. This occurs when methods with different signatures are defined in the same class, known as method overloading. For example:

<code class="java">class Calculation {
    void sum(int a, int b) { System.out.println(a + b); }
    void sum(int a, int b, int c) { System.out.println(a + b + c); }

    public static void main(String[] args) {
        Calculation obj = new Calculation();
        obj.sum(10, 10); // 20
        obj.sum(10, 10, 10); // 30
    }
}</code>

Dynamic Binding (Run-Time Binding)

In dynamic binding, method calls are bound to the specific object at run time. This occurs when subclasses override methods defined in their superclasses. For instance:

<code class="java">class Animal {
    public void move() { System.out.println("Animals can move"); }
}

class Dog extends Animal {
    public void move() { System.out.println("Dogs can walk and run"); }
}

public class TestDog {
    public static void main(String[] args) {
        Animal a = new Animal(); // Animal reference and object
        Animal b = new Dog(); // Animal reference but Dog object

        a.move(); // output: Animals can move
        b.move(); // output: Dogs can walk and run
    }
}</code>

The above is the detailed content of Dynamic vs. Static Binding: How Does Java Resolve Method Calls at Runtime?. For more information, please follow other related articles on the PHP Chinese website!