Polymorphism in Java: Master 2 Essential Types – Compile-Time and Runtime Explained

Polymorphism in Java

• Polymorphism in Java is one of the fundamental concepts in Object-Oriented Programming (OOP), which allows objects to be treated as instances of their parent class rather than their actual class.
• The word polymorphism comes from Greek, meaning “many forms.”
• In Java, polymorphism allows a single action to behave differently based on the object that it is acting upon.

There are two main types of Polymorphism in Java:

1. Compile-time Polymorphism (also known as Method Overloading)
2. Runtime Polymorphism (also known as Method Overriding)

1. Compile-Time Polymorphism (Method Overloading)

• Compile-time polymorphism, or method overloading, occurs when multiple methods with the same name exist in a class, but with different parameters (different number or types of parameters).
• The correct method is determined at compile time based on the method signature.

Key Points:

• The method name is the same, but the parameters differ.
• It is resolved at compile time by the compiler.
• Overloaded methods can have different return types, but the parameters must differ in type or number.

Example:

class Calculator {

// Method to add two integers
public int add(int a, int b) {
return a + b;
}

// Overloaded method to add three integers
public int add(int a, int b, int c) {
return a + b + c;
}

// Overloaded method to add two double values
public double add(double a, double b) {
return a + b;
}
}

public class Main {
public static void main(String[] args) {
Calculator calculator = new Calculator();

// Calling overloaded methods
System.out.println(“Sum of two integers: ” + calculator.add(10, 20)); // 30
System.out.println(“Sum of three integers: ” + calculator.add(10, 20, 30)); // 60
System.out.println(“Sum of two doubles: ” + calculator.add(10.5, 20.5)); // 31.0
}
}

• In the above example, the add method is overloaded three times with different parameter types and numbers. The correct version is chosen based on the arguments passed.

2. Runtime Polymorphism (Method Overriding)

• Runtime polymorphism, or method overriding, occurs when a subclass provides a specific implementation of a method that is already defined in its superclass.
• At runtime, the Java Virtual Machine (JVM) determines which method to call based on the actual object type (not the reference type).

Key Points:

• Method in the subclass overrides a method in the parent class.
• The method signature in both parent and subclass must be the same.
• Overridden methods are resolved at runtime based on the object type (dynamic method dispatch).

Example:

// Parent class
class Animal {
// Method in parent class
public void sound() {
System.out.println(“Animal makes a sound”);
}
}

// Child class (inherits from Animal)
class Dog extends Animal {
// Overriding the sound method
@Override
public void sound() {
System.out.println(“Dog barks”);
}
}

// Another child class (inherits from Animal)
class Cat extends Animal {
// Overriding the sound method
@Override
public void sound() {
System.out.println(“Cat meows”);
}
}

public class Main {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // Reference type is Animal
Animal myDog = new Dog(); // Reference type is Animal, but object type is Dog
Animal myCat = new Cat(); // Reference type is Animal, but object type is Cat

// Demonstrating runtime polymorphism
myAnimal.sound(); // Output: Animal makes a sound
myDog.sound(); // Output: Dog barks
myCat.sound(); // Output: Cat meows
}
}

In this example:

• sound() is overridden in both the Dog and Cat classes.
• When the sound() method is called on the Animal reference, the actual method that is invoked is determined by the object type (i.e., the actual instance of the class at runtime), not by the reference type.

Benefits of Polymorphism in Java

1. Code Reusability: The same interface can be used for different implementations, thus promoting code reuse.
2. Flexibility: You can change the behavior of a method depending on the type of object without changing the code that calls the method.
3. Maintainability: It’s easier to maintain the code when different classes implement a common interface or extend the same base class.

Difference between Compile-Time Polymorphism and Runtime Polymorphism: