Polymorphism & Overriding

Polymorphism, meaning 'many forms', is a pillar of OOP that allows a single interface to represent different underlying forms (data types). In Java, runtime polymorphism is achieved through method overriding. Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. For the override to be valid, the method in the subclass must have the same name, same parameters, and same return type (or a subtype) as the method in the superclass. The power of polymorphism comes from the ability to use a superclass reference variable to refer to a subclass object. For example, if `Dog` and `Cat` are subclasses of `Animal`, you can write `Animal myPet = new Dog();`. When you call a method on `myPet`, like `myPet.makeSound()`, the Java Virtual Machine (JVM) determines at runtime which version of the method to execute based on the actual object type. If `myPet` refers to a `Dog` object, the `makeSound()` method from the `Dog` class is called. If it refers to a `Cat` object, the `Cat`'s version is called. This is also known as dynamic method dispatch or late binding. This allows for writing flexible and extensible code. You can write code that operates on objects of the superclass type, and it will work correctly with any new subclasses that are created later, without needing any modification.