Java Polymorphism Basics

Polymorphism is a fundamental concept in object-oriented programming, and it plays a significant role in Java. It allows objects of different classes to be treated as objects of a common superclass or interface, providing a way to create code that is more flexible, extensible, and reusable.

In Java, polymorphism is primarily achieved through method overriding and method overloading.

1. Method Overriding:

Method overriding occurs when a subclass provides its implementation of a method that is already defined in its superclass. The method in the subclass must have the same name, return type, and parameters as the method in the superclass. By invoking the overridden method through a superclass reference, you can execute the subclass's implementation instead.

Here's an example: class Animal { public void makeSound() { System.out.println("The animal makes a sound"); } } class Dog extends Animal { @Override public void makeSound() { System.out.println("The dog barks"); } } public class Main { public static void main(String[] args) { Animal animal = new Dog(); // Polymorphic assignment animal.makeSound(); // Output: The dog barks } }

In the above example, the `makeSound` method is overridden in the `Dog` class. When `animal.makeSound()` is called, it invokes the overridden method in the `Dog` class.

2. Method Overloading:

Method overloading occurs when multiple methods in the same class have the same name but different parameters. The methods can have different parameter types, different numbers of parameters, or both. Java determines which method to invoke based on the arguments provided at the time of the method call.

Here's an example: class Calculator { public int add(int a, int b) { return a + b; } public double add(double a, double b) { return a + b; } } public class Main { public static void main(String[] args) { Calculator calculator = new Calculator(); System.out.println(calculator.add(2, 3)); // Output: 5 System.out.println(calculator.add(2.5, 3.5)); // Output: 6.0 } }

In the above example, the `Calculator` class has two `add` methods with different parameter types (integers and doubles). The appropriate method is selected based on the arguments passed during the method call.

Polymorphism allows you to write code that is more flexible, as you can work with objects at a higher level of abstraction, without being concerned with their specific types. It facilitates code reuse, simplifies maintenance, and promotes modular and extensible designs.