Introduction
Dynamic Method Dispatch is the foundation of the polymorphic capabilities of Java. It is the technique by which the call to an overridden method is resolved at runtime rather than at compile time. In other words, when the reference of the parent class refers to an object of the child class, the decision of which version of the method is called is based on the actual object type, not on the reference type. This facility allows programmers to create systems that can behave in different ways depending on the implementation of the object. Are you ready to learn these fundamental concepts? Here is our Java course syllabus.
Dynamic Method Dispatch in Java
Dynamic Method Dispatch is one of the fundamental concepts in Java programming. It helps in achieving Runtime Polymorphism. Dynamic Method Dispatch is the process in which the call to the overridden method happens at Runtime instead of Compile Time.
When we use the reference variable of the superclass and point it to the object of the subclass, the execution of the method depends on the actual object rather than the reference variable.
How It Works: The “Animal” Example
In this example, the reference variable “myAnimal” of the superclass “Animal” has been used to call the method “makeSound()”. The execution of the method depends on the actual object assigned to the reference variable.
Code Snippet: Java
class Animal {
void makeSound() {
System.out.println(“The animal makes a sound”);
}
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println(“The dog barks”);
}
}
class Cat extends Animal {
@Override
void makeSound() {
System.out.println(“The cat meows”);
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal;
myAnimal = new Dog();
myAnimal.makeSound(); // Output: The dog barks
myAnimal = new Cat();
myAnimal.makeSound(); // Output: The cat meows
}
}
Output:
The dog barks
The cat meows
Why does this happen?
Although both new Dog() and new Cat() are assigned to the variable of the type Animal, Java performs Run-Time Polymorphism.
- First Call: The JVM examines the reference variable myAnimal and sees that it refers to a Dog object. The JVM then ignores the implementation of the makeSound() method in the Animal class and uses the implementation in the Dog class.
- Second Call: The reference variable has been reassigned to refer to a Cat object. The JVM recognizes this at run-time and uses the implementation in the Cat class.
Key Rules to Remember
- Method Overriding: Dynamic dispatch is only possible for overridden methods.
- Reference vs. Object: The reference type checks for the method availability (compile-time safety), whereas the object type determines the method execution (run-time execution).
- Not for Everything: Static methods, private methods, and variables are not suitable for dynamic dispatch because they are resolved at compile time. Learn more with our Java training in Chennai.
Conclusion
Understanding dynamic method dispatch in Java is what differentiates a beginner programmer from an experienced Java programmer. Are you looking for a course that offers a particular Java certification, or are you more interested in a course that offers placement? Explore our software training institute in Chennai.
