Java Polymorphism with code Examples

Java polymorphism is a powerful feature that allows objects of different classes to be treated as objects of a common superclass. It enables developers to write more flexible and reusable code by providing a way to perform a single action in different ways.

In this blog post, we will explore the concept of polymorphism in Java and provide examples to help you understand how it works.

What is Polymorphism?

Polymorphism, derived from the Greek words “poly” meaning many and “morph” meaning form, refers to the ability of an object to take on many forms. In the context of Java programming, polymorphism allows objects of different classes to be treated as objects of a common superclass.

At its core, polymorphism is based on inheritance. When a class extends another class, it inherits all the methods and fields of the superclass. Polymorphism takes advantage of this inheritance relationship to allow objects of different types to be used interchangeably.

Types of Polymorphism in Java

There are two types of polymorphism in Java: compile-time polymorphism and runtime polymorphism.

1. Compile-time Polymorphism:

Compile-time polymorphism, also known as method overloading, occurs when multiple methods in a class have the same name but different parameters. The compiler determines which method to invoke based on the number and types of arguments passed to it.

Here’s an example:

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

In the above code, the Calculator class has two add methods – one that takes two integers and another that takes two doubles. Depending on the arguments passed, the compiler will invoke the appropriate method.

2. Runtime Polymorphism:

Runtime polymorphism, also known as method overriding, occurs when a subclass provides its own implementation of a method defined in its superclass. The decision of which method to invoke is made at runtime based on the actual type of the object.

Here’s an example:

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

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

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

In the above code, the Animal class has a makeSound method, and its subclasses Dog and Cat override this method with their own implementations. When we create objects of these subclasses and invoke the makeSound method, the appropriate implementation is executed based on the actual type of the object.

Benefits of Polymorphism

Polymorphism offers several benefits in Java programming:

1. Code Reusability:

By using polymorphism, you can write code that is more reusable. You can create methods that accept objects of a superclass and perform operations on them, knowing that they can also work with objects of any subclass.

2. Flexibility:

Polymorphism allows you to write code that can handle multiple types of objects without the need to write separate code for each type. This makes your code more flexible and adaptable to changes.

3. Easy Maintenance:

When you use polymorphism, you can easily add new subclasses without modifying existing code. This makes your code more maintainable and reduces the risk of introducing bugs.

Conclusion

Polymorphism is a powerful feature in Java that allows objects of different classes to be treated as objects of a common superclass. It enables code reusability, flexibility, and easy maintenance. By understanding and leveraging the concept of polymorphism, you can write more efficient and maintainable code.

Remember, polymorphism is just one of the many features that make Java a versatile and popular programming language. Keep exploring and experimenting with different concepts to enhance your Java programming skills.