Polymorphism in Java

Polymorphism in Java is the ability of an object to take on multiple forms or behaviors based on the context in which it is used. It allows objects of different classes to be treated as objects of a common superclass or interface, providing flexibility and code reusability. Polymorphism is a key concept in object-oriented programming and is closely related to inheritance and method overriding.

Types of Polymorphism in Java

  1. Compile-time Polymorphism (Static Polymorphism):

    • Method Overloading: It allows the same method name to be used with different parameter lists within the same class. The compiler determines the appropriate method to call based on the method name and the arguments provided.
    • Constructor Overloading: Similar to method overloading, it allows multiple constructors with different parameter lists within the same class. The compiler selects the appropriate constructor based on the arguments used during object creation.

  2. Runtime Polymorphism (Dynamic Polymorphism):

    • Method Overriding: It occurs when a subclass provides its own implementation of a method that is already defined in its superclass. The appropriate method is determined dynamically at runtime based on the actual type of the object. The @Override annotation is commonly used to indicate that a method is intended to override a superclass method.
    • Inheritance Polymorphism: It allows objects of a derived class to be treated as objects of their superclass. This enables the usage of derived class objects wherever the superclass objects are expected, promoting code flexibility and extensibility.

Polymorphism allows for code to be written in a more general and abstract manner, making it adaptable to different scenarios and requirements. It enables the concept of "programming to an interface," where objects are defined in terms of their common behavior rather than their specific implementation. This promotes code modularity, flexibility, and code reuse, as objects can be replaced or extended without affecting the overall structure of the code.

Here's a simple example to illustrate polymorphism in Java:

class Animal {
    public void makeSound() {
        System.out.println("Animal is making a sound");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Cat();
        Animal animal2 = new Dog();

        animal1.makeSound();  // Output: Meow!
        animal2.makeSound();  // Output: Woof!
    }
}

In this example, the Animal class is the superclass, and the Cat and Dog classes are subclasses that override the makeSound() method. The Main class demonstrates polymorphism by creating objects of type Animal but assigning them instances of Cat and Dog respectively. When the makeSound() method is called on these objects, the appropriate implementation is executed based on the actual object type, resulting in different output.

Polymorphism provides flexibility and extensibility in Java, allowing code to be written in a more general and reusable manner, adapting to varying object types and behaviors at runtime.

Next Article ❯