3.3. Runtime Polymorphism (Method Overriding)

Method overriding happens when a subclass provides a specific implementation for a method already defined in its superclass. The method in the subclass should have the same name, return type, and parameters.

Method overriding allows a subclass (a more specialized version of a superclass) to define a method that is already defined in its superclass but with a specific implementation. To override a method, all the following conditions must be met: the method name must be the same in both classes, it must have the same return type, and it must have the same parameters as the superclass method.

Think of it like a parent teaching a child how to perform a task, like cooking. The parent might have a general recipe (superclass method) for a dish. However, the child can create their own version of that dish by changing a few ingredients (subclass method) while keeping the overall method of preparation the same. This allows the child to express their creativity while building on the foundational knowledge given by the parent.

At runtime, Java determines which method to call based on the actual object type (dynamic method dispatch).

Dynamic method dispatch is the process through which Java determines which overridden method to execute at runtime rather than compile time. This means that even though an object may refer to a superclass type, the actual method that gets called is determined by the actual object type that it references. This allows for more flexible and dynamic code.

Imagine you have a remote control that can operate different devices like a TV, a DVD player, or a sound system. When you press the 'play' button, the remote doesn’t know ahead of time which device will respond; it decides at the moment based on which device is actively connected. In the same way, Java decides which method to invoke based on the real type of the object during the execution of the program.

Example:

class Animal {
 void sound() {
 System.out.println("Animal makes a sound");
 }
}
class Cat extends Animal {
 void sound() {
 System.out.println("Cat meows");
 }
}
public class TestOverriding {
 public static void main(String[] args) {
 Animal a = new Cat();
 a.sound(); // Output: Cat meows
 }
}

In this example, we have a superclass called Animal with a method sound(). The subclass Cat overrides this method to provide its own specific implementation of sound(). In the TestOverriding class, we create an object of type Animal but assign it an instance of Cat. When we call a.sound(), it invokes the overridden sound() method of the Cat class, demonstrating runtime polymorphism.

Think of a performer at a concert. The performer has a typical script (the general behavior provided by the superclass). However, during one performance, they decide to improvise and include personal touches (the overridden behavior) that make it unique for each show. When the audience sees their performance, they experience that individual flair, despite the performer usually following a general routine.

--