Dynamic Method Dispatch in Java
- Dynamic Method Dispatch in Java
- Importance of Dynamic Method Dispatch in Java
- Dynamic Method Dispatch with Code Example in Java
This tutorial educates about the dynamic method dispatch in Java. It speaks about its technical definition and importance and explains with code examples.
Dynamic Method Dispatch in Java
Let’s break down the words and think of Dispatch
as deciding which function (method) to call. The word Dynamic
tells that it’s determined at the runtime.
In the simplest words, we can say which function/method should be executed is decided at runtime.
Considering technical definition, the dynamic method dispatch (also known as runtime polymorphism) is a mechanism that is used to resolve a call to an overridden method at runtime instead of compile time.
When we call the overridden method in the child class by using a reference, Java decides which method would be executed depending on the object’s type to which it refers. Let’s understand the definition by using the following two screenshots of code.
Focus on the following screenshot where we have three classes named Shape
, Rectangle
, and the Main
class. The Shape
is the superclass, and Rectangle
is the child class.
The main
method has two objects of the Shape
and Rectangle
type and saves their references in shape
and rectangle
variables.
These variables call the respective class’ display()
method. For instance, if we call shape.display()
, it would be decided at compile-time that the display()
of the Shape
class is being called because the shape
contains the reference of the Shape
class.
Now, change the code as given in the following screenshot. Here, the main
method contains the two objects, one for the Shape
class and the other for the Rectangle
class but both (the variable shape
and rectangle
) contain the reference of the Shape
class.
So, how the program decides which overridden method should be called? This is where dynamic method dispatch plays its role.
Here, Java determines which method should be executed depending on the type of object it refers to.
If the object is Rectangle
type, then the display()
from the Rectangle
class would be called, and if the object is of Shape
type, then the display()
method of the Shape
class would be called. And all these decisions are made at runtime.
This is what we call the runtime polymorphism or dynamic method dispatch.
Importance of Dynamic Method Dispatch in Java
The following points increase the importance of using the dynamic method dispatch.
- The dynamic method dispatch lets the Java support method overriding necessary for the runtime polymorphism.
- It lets the child class incorporate their functions and update the implementation as per project requirements.
- It lets the superclass define a function/method that would be shared with its child classes and allow these child classes to update the function’s implementation.
Dynamic Method Dispatch with Code Example in Java
Example Code:
class Shape {
Shape() {}
void display() {
System.out.println("I am in the Shape class");
}
}
class Rectangle extends Shape {
Rectangle() {}
void display() {
System.out.println("I am in the Rectangle class");
}
}
class Triangle extends Shape {
Triangle() {}
void display() {
System.out.println("I am in the Triangle class");
}
}
public class Main {
public static void main(String args[]) {
Shape rectangle = new Rectangle();
Shape triangle = new Triangle();
rectangle.display();
triangle.display();
}
}
Output:
I am in the Rectangle class
I am in the Triangle class
Here, the Rectangle
and Triangle
classes extend the Shape
class. These classes have a display()
method that we are supposed to call the main
method.
The main
method has two objects, one for the Rectangle
type and the other for the Triangle
type, but the reference variables rectangle
and triangle
refer to the same parent class named Shape
.
How to find out which function would be called? Here, the dynamic dispatch method comes into the picture.
Remember, we are also using dynamic binding and upcasting in the following two codes of code.
Shape rectangle = new Rectangle();
Shape triangle = new Triangle();
The dynamic binding uses the object (instance of the class, which is new Rectangle()
and new Triangle()
here) to resolve the method call at runtime.
Here the upcasting is also used because the parent class reference variables (rectangle
and triangle
) are referencing the child classes Rectangle
and Triangle
.