Polymorphism in Java

Introduction to Polymorphism in Java

One of the core pillars of object-oriented programming is polymorphism. The word "polymorphism" means "many forms," and in the context of Java, it allows the same method or object to behave differently based on context.

Polymorphism in Java helps in building flexible and extensible code that can evolve over time with minimal changes.

Types of Polymorphism in Java

Polymorphism in Java is broadly classified into two types:

• Compile-time Polymorphism (Method Overloading)
• Runtime Polymorphism (Method Overriding)

1. Compile-Time Polymorphism (Method Overloading)

Method overloading means defining multiple methods with the same name but different parameter lists within the same class.

The compiler determines which version to call based on the arguments provided.

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 3));           // Calls first method
        System.out.println(calc.add(5.5, 2.5));       // Calls second method
        System.out.println(calc.add(1, 2, 3));        // Calls third method
    }
}

    

2. Runtime Polymorphism (Method Overriding)

Method overriding occurs when a subclass provides its own implementation of a method that is already defined in its parent class.

The method to be called is determined at runtime using dynamic method dispatch.

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    void sound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a;
        a = new Dog();  // Dog is-an Animal
        a.sound();      // Calls Dog's version

        a = new Cat();  // Cat is-an Animal
        a.sound();      // Calls Cat's version
    }
}

    

Why Use Polymorphism?

Polymorphism promotes code reusability and improves maintainability. With polymorphism, you can write more general and extensible code.

For example, you can use the same interface to interact with different types of objects without knowing their exact classes.

Real-World Analogy

Think of a remote control. You can use it to control a TV, a sound system, or even an air conditioner. The remote is the interface, but the implementation varies depending on the device.

Similarly, polymorphism allows one interface to control different underlying implementations.

Important Notes on Polymorphism

• Method overloading is resolved at compile time, while method overriding is resolved at runtime.
• Polymorphism is often used in conjunction with inheritance and interfaces.
• Overriding methods must have the same name, return type, and parameters.
• The @Override annotation helps ensure that you're actually overriding a method.

Conclusion

Polymorphism in Java allows developers to design systems that are modular, scalable, and easier to manage. Whether it's method overloading at compile-time or method overriding at runtime, polymorphism gives your code the power to handle complexity with grace.

Mastering this concept is essential for any Java developer aiming to write clean and flexible applications.