Understanding Runtime Polymorphism with Example

Did you know that runtime polymorphism is one of Java's hidden strengths? It’s like Java having the flexibility to decide which method to call at the right moment, depending on the actual object type, not just the reference type. 

In simple terms, runtime polymorphism helps manage different object types as if they are part of the same family, improving code flexibility and scalability. As Java is one of the world’s fourth most in-demand languages, mastering runtime polymorphism can significantly enhance your Java programming skills.

Think of it as Java having the smarts to adjust on the go, based on the context. It’s what gives your code versatility and future-proofing abilities. 

In this article, you’ll dive deeper into how runtime polymorphism works, example of polymorphism in Java and how it can improve your skills.

Let’s explore!

How Does Runtime Polymorphism Implemented?

Runtime polymorphism is a powerful concept that provides flexibility in Java. It allows you to invoke methods dynamically at runtime based on the actual object type, not just the reference type and is also one of the most used polymorphisms in Java.

Let’s break it down step by step.

• The core of runtime polymorphism is Dynamic Method Dispatch. It ensures that the method call is resolved at runtime based on the actual object type rather than the reference type. 
• It enables Java to decide which method to invoke when you call an overridden method on a parent class reference pointing to a child class object.
• When the program runs, the JVM dynamically chooses the method to execute, making the system more flexible and adaptable. 
• This is what makes Java a powerful, object-oriented language that utilizes runtime polymorphism.

Steps to Implement Runtime Polymorphism

Now, let’s look at the key steps you need to follow to implement runtime polymorphism.

• Step 1: Create a Parent Class 

Start by creating a parent class using a method (like display() or makeSound()).

• Step 2: Create a Subclass 

Next, create a subclass that overrides the parent class method. This allows the subclass to provide its own version of the method.

• Step 3: Use Upcasting 

Assign the subclass object to a reference of the parent class type. This is known as upcasting, where a subclass object is treated as an object of the parent class.

• Step 4: Call the Overridden Method 

Finally, call the overridden method using the parent class reference. At runtime, Java will invoke the appropriate method based on the actual object type, not just the reference type.

Moving ahead, let’s see these steps in action with an example. 

In this scenario, we have a parent class Animal and a subclass Dog. The Dog class overrides the makeSound() method from the Animal class.

Example Code:

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

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

// Main Class
public class TestPolymorphism {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();  // Parent class reference
        Animal myDog = new Dog();         // Child class reference, upcasted to Parent class

        myAnimal.makeSound();  // Outputs: Animal makes sound
        myDog.makeSound();     // Outputs: Dog barks
    }
}

Output of the Code:

Animal makes sound
Dog barks

Explanation of the Code:

• Parent Class (Animal): The Animal class defines a method makeSound(), which outputs "Animal makes sound".
• Child Class (Dog): The Dog class inherits from Animal and overrides the makeSound() method. The overridden method prints "Dog barks" instead of the generic animal sound.
• Upcasting: In the TestPolymorphism class, we use upcasting:
  • myAnimal is a reference of type Animal pointing to an instance of Animal.
  • myDog is a reference of type Animal but points to a Dog object. This allows us to treat the subclass object as if it’s of the parent class type.
• Method Calls:
  • When myAnimal.makeSound() is called, the method from the Animal class is executed.
  • When myDog.makeSound() is called, despite the reference being of type Animal, the method in the Dog class is executed due to runtime polymorphism.

Here’s a quick summary of the steps to implement runtime polymorphism in Java.

Also Read: Types of Polymorphism in Java [Static & Dynamic Polymorphism with Examples]

Examples of Runtime Polymorphism in Java

Runtime polymorphism lets your Java pick the right method to run based on the actual object it’s working with—no matter what type of reference you use. This makes your code more flexible and easier to tweak as it adapts to different objects seamlessly.

To clarify, a method for calculating speed might work differently for a car than for a bicycle, even though both use the same method name. This flexibility, through method overriding and interfaces, enables scalable and adaptable code.

Here are two examples of how runtime polymorphism can be implemented in Java.

Example 1: Method Overriding with Parent and Child Classes

In this example of polymorphism in Java, method overriding occurs when a child class provides a specific implementation for a method defined in its parent class. 

The real power of runtime polymorphism comes when you use a parent class reference to invoke a method on a child class object. 

This allows you to use the same method name but have different implementations depending on the object’s actual class type.

Example Code:

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

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

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal myAnimal = new Animal(); // Parent class reference
        Animal myDog = new Dog();       // Child class object

        myAnimal.sound(); // Outputs: Animal makes a sound
        myDog.sound();    // Outputs: Dog barks
    }
}

Output:

Animal makes a sound
Dog barks

Explanation:

Here, Animal is the parent class with a sound() method. The Dog class overrides this method and provides its own implementation. 

Even though myDog is declared as an Animal reference, at runtime, Java dynamically binds the method call to the Dog class's sound() method. 

This is the essence of runtime polymorphism: The method called depends on the actual object (Dog), not the reference type (Animal).

Also Read: Difference Between Overloading and Overriding | Overloading vs Overriding

By now, you've seen how runtime polymorphism operates within class hierarchies. Next, let's dive into how it can be applied to interfaces and abstract classes for even greater flexibility in your code.

Example 2: Using Interfaces and Abstract Classes for Runtime Polymorphism

In this example of polymorphism in Java, Runtime polymorphism is not limited to class inheritance. 

You can also achieve polymorphism through interfaces and abstract classes, allowing different classes to implement their own versions of a method defined by an interface or abstract class. 

This further extends Java's flexibility, as different types of objects, all implementing the same method, can be handled uniformly.

Example Code:

interface Animal {
    void sound();
}

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

class Bird implements Animal {
    @Override
    public void sound() {
        System.out.println("Bird chirps");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal myCat = new Cat();  // Using Interface reference
        Animal myBird = new Bird(); // Using Interface reference

        myCat.sound();  // Outputs: Cat meows
        myBird.sound(); // Outputs: Bird chirps
    }
}

Output:

Cat meows
Bird chirps

Explanation:

In this example of polymorphism in Java, the Animal interface defines a method sound(), which the Cat and Bird classes implement differently. 

The real benefit of polymorphism is evident when we use an Animal reference to hold different objects (E.g., a Cat or a Bird). 

At runtime, Java determines which class's sound() method to invoke based on the actual object type, allowing you to use the same method name for different behaviors.

Also Read: Virtual Function in Java

What is Method Overriding?

Method overriding in Java is a fun yet powerful feature that lets a subclass redefine a method from its parent class to suit its needs. It is similar to an employee tailoring a standard procedure while still following the core principles.

In the world of Java, using this you can modify the behavior of inherited methods, enabling dynamic decision-making at runtime.

Now that you understand method overriding, let's discuss the key conditions you need to follow.

• Same Method Name: The method name in the subclass must match the name in the parent class. 
  • For example, if your parent class has a drive() method, the subclass must also define a drive() method.
• Same Parameter List: The parameter list in the subclass method must exactly match the one in the parent class. 

So, if the parent’s drive() method takes two integers, your subclass method must do the same.

• Same Return Type: The return type must also match. If the parent method returns an int, your subclass method should return the same type or a subclass of it.
• Types of Inheritance: The method being overridden must be part of the parent class i.e., you can't override a method from a class you don't inherit from.
• Use of @Override Annotation (Optional but Recommended): Although it's not mandatory, it’s best practice to use @Override to ensure you're truly overriding a method and not accidentally overloading it.

With the conditions set, let's discuss how method overriding powers runtime polymorphism in Java code.

Relationship Between Method Overriding and Runtime Polymorphism

So, why does method overriding matter? It’s the magic behind runtime polymorphism in Java! Polymorphism lets the method that gets called depend on the actual object type, not just the reference type. 

Imagine you have a Car class and a Truck class, both overriding a method like StartEngine (). 

Even if you're using a reference of type Vehicle, Java will call the right method at runtime—startEngine() for a Car or a Truck.

Let’s break this down further to see how it works in different scenarios.

• Upcasting in Overriding: 

Upcasting allows you to assign a subclass object to a parent class reference. Despite the reference being of the parent class type, Java will still call the overridden method in the subclass. 

Think of it like following a proven business strategy, where each team (class) adds their own unique approach to make it their own.

• Dynamic Method Dispatch: 

Here’s where the JVM does its magic. It decides at runtime which version of the method to call based on the actual object. 

It’s like a project manager selecting team members based on their strengths and availability, rather than strictly sticking to the original plan.

It’s time to see these concepts in action, so let’s walk through an example of method overriding and runtime polymorphism.

Example:

A Practical Demonstration of Method Overriding Enabling Runtime Polymorphism.

// Parent class
class Vehicle {
    public void startEngine() {
        System.out.println("Vehicle engine starts");
    }
}

// Child class
class Car extends Vehicle {
    @Override
    public void startEngine() {
        System.out.println("Car engine starts with a roar!");
    }
}

// Main class
public class TestPolymorphism {
    public static void main(String[] args) {
        Vehicle myVehicle = new Vehicle();  // Parent class reference
        Vehicle myCar = new Car();           // Child class reference, upcasted to Parent class

        myVehicle.startEngine();  // Outputs: Vehicle engine starts
        myCar.startEngine();      // Outputs: Car engine starts with a roar!
    }
}

Output:

Vehicle engine starts
Car engine starts with a roar!

Explanation of the Code:

• Parent Class - Vehicle: 

The Vehicle class has a method startEngine(), which prints "Vehicle engine starts". This is a simple method in the parent class.

• Child Class - Car: 
  • The Car class inherits from Vehicle and overrides the startEngine() method. 
  • The @Override annotation ensures that Java knows this method is being overridden from the parent class. 
  • The child class version of startEngine() prints "Car engine starts with a roar!", giving a more specific implementation.
• Upcasting in Main:

 In the TestPolymorphism class, two objects are created:

• myVehicle is a reference method of Vehicle pointing to an instance of the Vehicle class.
• myCar is a reference of type Vehicle pointing to an instance of the Car class.
• This is called upcasting—even though the reference is of type Vehicle, it refers to a Car object.
• Method Calls:
  • When myVehicle.startEngine() is called, the method in the Vehicle class is executed, outputting "Vehicle engine starts".
  • When myCar.startEngine() is called, despite the reference being of type Vehicle, the JVM dynamically determines that the actual object is of type Car. 
  • So, it calls the Car class's overridden startEngine() method, printing "Car engine starts with a roar!".

After seeing the example, let’s go over the important rules you need to keep in mind to implement runtime polymorphism correctly.

• Same Method Signature: Ensure the method name, parameters, and return type match exactly between the parent and subclass.
• Inheritance Required: The parent class method must be available to the subclass for overriding.
• Instance Methods Only: Static methods, private methods, and constructors cannot be overridden.
• Dynamic Dispatch at Runtime: The JVM uses dynamic dispatch to determine which method to call based on the actual object, ensuring flexibility and scalability.

Also Read: Memory Allocation in Java: Everything You Need To Know 

What are the Advantages and Disadvantages of Runtime Polymorphism in Java?

Runtime polymorphism is a key feature driving innovation in modern software development. 

While runtime polymorphism offers great benefits, understanding its challenges is also essential. This knowledge helps you maximize its potential while effectively managing any complexities it may bring.

Ready to make the most of it in your projects? Let’s dive into its advantages and disadvantages.

Advantages of Runtime Polymorphism

Think of runtime polymorphism as a versatile tool in your coding toolkit. It lets your program adapt and perform different tasks without rewriting the whole system, giving you cleaner, more efficient code.

Here’s how their strengths stack up.

• Code Reusability: For example, in a payment system, overriding processPayment() for different payment types avoids repetitive code, increasing efficiency.
• Flexibility: Polymorphism allows classes like CreditCardPayment and PaypalPayment to use the same method but behave differently, offering adaptable solutions.
• Scalability: Like adding new delivery methods in a logistics system, polymorphism allows new features without altering existing code.
• Easier Maintenance: Changes in parent classes automatically apply to subclasses, reducing the maintenance effort, as seen in updating payment gateways.

Disadvantages of Runtime Polymorphism

While runtime polymorphism can enhance your code, it’s essential to be aware of its drawbacks. 

Improper usage or overuse can introduce performance and complexity issues that may hinder your application's efficiency and maintainability.

Here’s a closer look at all such limitations.

• Performance Overhead: Dynamic method resolution adds extra steps, slowing down applications, similar to checking ingredient supplies in a restaurant.
• Increased Complexity: Too many overridden methods can complicate debugging, like trying to trace multiple payment methods in a banking system.
• Risk of Misuse: Overusing polymorphism can lead to unnecessary complexity, making code harder to understand, much like overcomplicating a game with excessive object types.
• Memory Consumption: Frequent dynamic method calls use more memory, impacting large applications with many classes, such as apps with numerous user interactions.

Curious to know more about example of Polymorphism in Java? Start your journey with upGrad’s Core Java course today  and gain essential skills!

What are the Real-World Use Cases of Runtime Polymorphism?

Runtime polymorphism in Java is like a code ninja—it effortlessly adjusts its behavior in real-time!

By using method overriding and dynamic resolution at runtime, your code stays flexible and scalable, allowing it to adapt without major changes. This makes it perfect for building versatile applications that grow as easily as they evolve.

Here are some real-world use cases where runtime polymorphism plays a vital role.

Graphical User Interface (GUI) Applications

Runtime polymorphism is magic in GUI frameworks like Swing or JavaFX. It lets components like buttons and text fields perform different actions depending on what is clicked. 

For instance, clicking a "Submit" button triggers one action, while a "Reset" button triggers another, making your app interactive and responsive to user actions.

Frameworks like Spring

The Spring framework uses runtime polymorphism for Dependency Injection (DI), letting different beans (objects) be injected based on runtime conditions. 

This keeps your application flexible and scalable, with bean behavior changing depending on the runtime implementation—just like swapping parts to customize performance without rewriting the whole system!

Method Overriding in Collections

Polymorphism in collections is like a multi-tasking pro—different objects, same methods! 

In Java, collections like List, Set, and Queue store various objects. Each can override methods like add() and remove() to handle specific types. 

It’s runtime polymorphism in action. Each collection handles tasks independently, keeping your code adaptable and efficient.

Design Patterns (Factory and Strategy Patterns)

In design patterns like Factory and Strategy, runtime polymorphism acts like a real-time decision-maker for you, picking the right class or method based on runtime inputs.

 It’s especially useful in dynamic systems, like a payment gateway, where the system can switch between different providers depending on the situation—making everything run smoothly without a glitch!

Web Services and APIs

Polymorphism is useful when a web service needs to return different responses based on the request type or parameters. 

For example, One API endpoint can handle multiple data requests—whether XML or JSON—and return different objects based on the request type. It’s like a multi-tool that adapts to your needs!

Unit Testing and Mocking

During unit testing, runtime polymorphism allows you to mock specific behaviors of a class. 

Test frameworks like JUnit use this feature to replace real object behaviors with mock objects, helping you simulate and test specific conditions efficiently. 

This makes testing more flexible, letting you focus on testing only what’s necessary while keeping your tests clean and maintainable.

Database Operations

In database applications, runtime polymorphism is like a smart switch for you—automatically choosing the right data access object (DAO) depending on the database management system in use. 

This allows the system to work with multiple databases without needing to change the code structure, keeping things flexible and efficient.

Can Java drive your data career forward? Definitely! upGrad’s Master’s Degree in Artificial Intelligence and Data Science course prepares you for the challenges of the future. Start your journey now!

How Can upGrad Help You Build a Career in Programming?

With over 1 million+ learners globally enhancing their skills, upGrad has established itself as a leader in programming education. 

Our programming courses combine industry-relevant curricula, hands-on projects, and mentorship to help you stay ahead in a competitive tech environment. 

Here’s how upGrad supports your programming journey.

• Full Stack Development Course: Master the art of building dynamic applications using Java for the back end and React for the front end.
• Job-Ready Full Stack Developer: Become proficient in both front-end and back-end development with a detailed curriculum that includes key technologies like Java, React, and JavaScript.
• Java Object-oriented Programming:  Establish a strong foundation in Java with a focus on object-oriented principles, which are crucial for back-end development.
• JavaScript Basics from Scratch: Strengthen your programming skills with JavaScript and explore essential web development concepts to create interactive applications.

Not sure where to begin? upGrad offers personalized career counseling to help you choose the right course. From exploring an example of polymorphism in Java to mastering full-stack development or diving into data science, there’s a course for you.

Start your journey today and open doors to exciting tech career opportunities with upGrad!

Master Java with step-by-step tutorials, practical examples, and expert tips to enhance your programming skills.

References:
https://economictimes.indiatimes.com/magazines/panache/these-are-the-highest-paying-programming-languages-you-should-learn-ranked-by-salary/articleshow/45258811.cms?from=mdr