11.2.3. Polymorphism

Polymorphism allows objects to be treated as instances of their parent class rather than their actual class.

Polymorphism is a core concept in object-oriented programming that allows methods or objects to take on more than one form. Essentially, it means that we can call the same method on different objects, and each of those objects can respond in a way that is specific to their class. This is useful because it lets you write more general code that can work with objects of different types, leading to more flexible and reusable components.

Imagine a general phone as a parent class. You might have different types of phones, like smartphone and flip phone, as child classes. Both types of phones can make calls, but a smartphone can also browse the internet. When you use the 'makeCall' method, both phones can respond, but based on their type, they might perform additional actions or respond differently to the same command.

• Compile-time Polymorphism (Method Overloading)

Compile-time polymorphism occurs when multiple methods have the same name but different parameters (method overloading). The method to be called is determined at compile time based on the method signature (name + parameter types). This allows programmers to use the same method for different types of inputs, making the code easier to read and maintain.

Think of a restaurant where you can order a drink. You might have options like 'orderDrink(Coffee)' or 'orderDrink(Tea, withSugar)'. The restaurant knows how to prepare each drink based on the order you placed, allowing them to serve a variety of drinks using the same ordering method.

• Runtime Polymorphism (Method Overriding)

Runtime polymorphism is achieved through method overriding, where a subclass provides a specific implementation of a method that is already defined in its superclass. The JVM determines which method to invoke at runtime based on the object type that calls the method, rather than the reference type of the object. This means that at runtime, the program can decide which version of the method to execute depending on the actual object that is being referred to.

Consider a situation where you have a base class 'Animal' with a method 'makeSound'. Subclasses like 'Dog' and 'Cat' override the 'makeSound' method to provide their own sound. When you call 'makeSound' on an 'Animal' reference pointing to a 'Dog' object, the program will output 'Bark'; if it points to a 'Cat', it outputs 'Meow'. This allows different animals to behave differently while still being treated as 'Animals' in general.

Example (Method Overriding in Java): class Animal { void sound() { System.out.println("Animal makes a sound"); } } class Cat extends Animal { void sound() { System.out.println("Meow"); } }

In this Java example, there's a parent class 'Animal' that has a method 'sound' which outputs a general phrase. The 'Cat' class extends 'Animal', and it overrides the 'sound' method, providing its own specific output: 'Meow'. When you create a 'Cat' object and call the 'sound' method, it will execute the 'Cat' class version instead of the 'Animal' class version. This demonstrates how runtime polymorphism works in practice.

Think of a 'Vehicle' class with a method called 'start'. You might have a 'Car' class and a 'Bike' class that extend 'Vehicle'. When you start a bike, it may have a different mechanism than starting a car, so you override the 'start' method in both classes to implement their specific startup processes.

--