4.6. Polymorphism in Java

Polymorphism allows objects to be treated as instances of their parent class, enabling method overriding and overloading.

Polymorphism is a fundamental concept in object-oriented programming. It means 'many forms' and enables methods to behave differently based on the object that is calling them. This is particularly useful because it allows a single interface to represent different underlying forms (data types). This flexibility is achieved through two key mechanisms: method overriding and method overloading.

Imagine you have a remote control for your TV. No matter what brand the TV is, the volume and channel buttons are the same. You can think of each TV brand as a different class, and the remote control is like the polymorphism interface that allows you to interact with all TVs in a similar way.

Method Overloading: Multiple methods with the same name but different parameters in the same class.

Method overloading occurs when there are multiple methods in the same class that have the same name but different parameter lists (different types or numbers of parameters). This allows the programmer to use the same method name for similar actions while tailoring the input requirements, making the code cleaner and more understandable.

Think of a 'draw' method in a graphics program. You could have draw methods for different shapes: drawCircle(radius), drawRectangle(width, height), and drawTriangle(side1, side2, side3). All these methods perform a similar action but require different types of input.

Method Overriding: A subclass provides a specific implementation of a method that is already defined in its superclass.

Method overriding allows a subclass to provide a specific implementation of a method that is already defined in its superclass. This is a way to achieve polymorphism, as the method that gets executed is determined at runtime based on the object's actual class rather than the reference type. This means the method in the subclass 'overrides' the method in the parent class, allowing for specialized behavior.

Consider a parent class Animal with a method sound(). If you have a subclass Dog that overrides the sound() method to bark, while other subclasses like Cat override it to meow, invoking sound() on an object gives different outputs based on the actual object type (dog or cat), but the call remains the same.

Example of Polymorphism (Method Overriding):

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}
class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal(); // Animal object
        Animal myDog = new Dog(); // Dog object
        myAnimal.sound(); // Output: Animal makes a sound
        myDog.sound(); // Output: Dog barks
    }
}

In this Java example, we define a parent class Animal with a method sound(). We then create a subclass Dog that overrides the sound() method to provide its own implementation. When we create an object of the Dog class using an Animal reference, calling sound() on that reference invokes the method in Dog, demonstrating how polymorphism allows an object to behave according to its actual class rather than the reference type.

This scenario is much like how you might use a mobile phone. If you give the same voice command to different smart assistants (like Siri, Google Assistant), their responses and actions might be different based on each assistant’s capabilities, yet your command remains the same.

--