Java - Runtime Polymorphism (Method Overriding)

 Runtime Polymorphism (Method Overriding) in Java

Java Runtime Polymorphism, also known as Method Overriding, is one of the most powerful and essential concepts in Object-Oriented Programming (OOP). It enables Java programs to decide which method to execute during runtime rather than compile time. This dynamic behavior makes Java flexible, scalable, and ideal for developing modular and maintainable applications. In this detailed guide, we will explore every aspect of Runtime Polymorphism, including how method overriding works, rules for overriding, advantages, use cases, real-world examples, difference between static and dynamic polymorphism, and best coding practices in Java. Every section is explained with clarity, extended descriptions, and SEO-friendly content to improve reach and usefulness for Java learners.

What is Runtime Polymorphism in Java?

Runtime Polymorphism in Java allows a subclass to offer a specific implementation of a method that is already defined in its superclass. This concept enables Java to resolve method calls at runtime depending on the actual object type rather than reference type. In simple terms, even when a parent class reference refers to a child class object, the overridden method of the child class executes. This feature supports dynamic method dispatch and improves flexibility in programming. Method overriding is the foundation of runtime polymorphism. It allows classes in Java to modify the behavior of inherited methods according to the needs of the subclass. This capability is particularly useful when you want the same method name to behave differently across different types of objects. Understanding runtime polymorphism is essential for mastering inheritance, object interaction, abstraction, and real-world application design in Java.

Basic Example of Runtime Polymorphism

The following example demonstrates how Java determines the method implementation at runtime. We use a parent class Animal and a child class Dog. Even though the reference type is Animal, the overridden method in Dog executes because the actual object created is Dog. This dynamic decision is what makes runtime polymorphism extremely powerful. This example is commonly used by beginners and is an excellent demonstration of method overriding. Carefully observe how the method run behaves differently depending on the actual object type passed at runtime. This example is simple but clearly reflects the key concept behind dynamic method dispatch in Java.

class Animal {
    void run() {
        System.out.println("Animal is running");
    }
}

class Dog extends Animal {
    void run() {
        System.out.println("Dog is running fast");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.run();
    }
}

Dog is running fast

What is Method Overriding?

Method Overriding occurs when a subclass provides its own version of a method already defined in the superclass. The method in the child class must have the same name, the same return type, and the same method parameters. The overriding method essentially replaces the parent class method for objects of the subclass. This substitution gives Java its dynamic behavior at runtime. Method overriding allows classes to modify or enhance behaviors inherited from parent classes without changing the original code. It enables a more specialized implementation tailored to the subclass needs. This feature ensures that Java programs achieve high levels of flexibility and extensibility. With method overriding, developers can write code that is generic at the parent level while allowing specific implementations at the child class level, enabling better scalability and code reusability.

Example of Method Overriding

Below is a clear demonstration of method overriding where the parent class Vehicle has a method start, and the subclass Car overrides that method with a more specific implementation. This example illustrates how subclasses can modify or extend the functionality of methods defined in the parent class. It is helpful in scenarios where different objects must behave differently even when they share the same method signature. The output confirms that the overridden method from Car is executed because the object created is of Car type. This is the essence of runtime polymorphism.

class Vehicle {
    void start() {
        System.out.println("Vehicle is starting");
    }
}

class Car extends Vehicle {
    void start() {
        System.out.println("Car is starting with key");
    }
}

public class OverrideDemo {
    public static void main(String[] args) {
        Vehicle v = new Car();
        v.start();
    }
}

Car is starting with key

Rules for Method Overriding

Method overriding follows several important rules that must be obeyed to ensure valid overriding in Java. These rules ensure consistency, predictability, and correctness in polymorphic behavior. The overriding method must have the same name, the same parameter list, and the same return type. Access modifiers must be the same or more visible in the child class. You cannot override static methods because they belong to the class and not the object. The overridden method cannot be final, as final methods cannot be modified. Exception rules also apply — the overriding method should not throw broader exceptions than the parent method. Understanding and applying these rules ensures your code behaves correctly during runtime. These rules are important not only for avoiding compile-time errors but also for writing clean, maintainable, and predictable Java applications.

Example Demonstrating Overriding Rules

The following example shows a few essential rules of overriding. Notice how the child class changes the visibility of the method by expanding it from default to public, which is allowed. However, Java will not allow reducing visibility or overriding static/final methods. This example clarifies how overriding rules must be followed strictly to avoid compilation errors. Study this code carefully to understand how method overriding interacts with visibility and inheritance.

class Parent {
    void show() {
        System.out.println("Parent show method");
    }
}

class Child extends Parent {
    public void show() {
        System.out.println("Child show method");
    }
}

public class RulesDemo {
    public static void main(String[] args) {
        Parent p = new Child();
        p.show();
    }
}

Child show method

Why Use Runtime Polymorphism?

There are many reasons why runtime polymorphism is used in Java. It improves code flexibility by allowing different behaviors for a common method name, making code easier to scale and maintain. It enables dynamic decision-making during execution, which is important for real-world scenarios such as UI rendering, payment processing, or message handling. Polymorphism supports loose coupling by programming to an interface rather than an implementation. Code reusability is enhanced because parent class methods can be reused while still allowing subclasses to provide specialized behavior. Runtime polymorphism also plays a vital role in designing frameworks, libraries, and enterprise-level applications. Java Collections, JDBC drivers, and Servlet API heavily rely on it. Understanding its purpose will help you write better and more flexible Java applications.

Real-World Polymorphism Example

The following example illustrates a real-world scenario where multiple types of bank accounts have different interest calculation mechanisms. Even though the reference variable is of type Bank, the overridden method in each subclass executes according to the actual object created. This design is common in financial, billing, and business applications. It demonstrates how runtime polymorphism simplifies complex decision-making and improves code maintainability. Observe how different implementation outputs are produced depending on the actual class object.

class Bank {
    float getRate() {
        return 0;
    }
}

class SBI extends Bank {
    float getRate() {
        return 5.4f;
    }
}

class HDFC extends Bank {
    float getRate() {
        return 6.1f;
    }
}

public class RealWorldExample {
    public static void main(String[] args) {
        Bank b;

        b = new SBI();
        System.out.println("SBI Interest Rate: " + b.getRate());

        b = new HDFC();
        System.out.println("HDFC Interest Rate: " + b.getRate());
    }
}

SBI Interest Rate: 5.4
HDFC Interest Rate: 6.1

Dynamic Method Dispatch

Dynamic Method Dispatch is the mechanism by which Java decides which overridden method to call at runtime. It is essential to achieving runtime polymorphism. When a superclass reference variable refers to a subclass object, Java invokes the method of the actual object type rather than the reference type. This allows Java to dynamically resolve the method call. This mechanism allows Java to support object substitution, enabling parent class references to hold objects of multiple child classes. Dynamic method dispatch provides flexibility and simplifies the design of scalable applications. It is heavily used in frameworks and APIs where behavior depends on the object passed at runtime.

Example of Dynamic Method Dispatch

Here is an example demonstrating dynamic method dispatch. Notice how different outputs are generated depending on whether the object is of Laptop or Mobile. This example makes it clear that Java determines the appropriate method only at runtime, not compile time. This is one of the most important mechanisms behind runtime polymorphism.

class Device {
    void info() {
        System.out.println("General device");
    }
}

class Laptop extends Device {
    void info() {
        System.out.println("Laptop device");
    }
}

class Mobile extends Device {
    void info() {
        System.out.println("Mobile device");
    }
}

public class DispatchDemo {
    public static void main(String[] args) {
        Device d;

        d = new Laptop();
        d.info();

        d = new Mobile();
        d.info();
    }
}

Laptop device
Mobile device

Difference Between Compile-Time and Runtime Polymorphism

Java supports two types of polymorphism: Compile-Time Polymorphism and Runtime Polymorphism. Compile-Time Polymorphism occurs through method overloading, where the method to be executed is determined during compilation. Runtime Polymorphism occurs through method overriding, where the method execution is decided at runtime. Compile-time polymorphism is faster but less flexible compared to runtime polymorphism. Runtime polymorphism supports inheritance and dynamic method dispatch, enabling specialized behavior in subclasses. Understanding these differences helps developers choose the right polymorphism technique for a specific use case.

Comparison Example

The following example contrasts compile-time behavior (method overloading) with runtime behavior (method overriding). The example clearly shows how Java resolves method calls differently in each case. Overloading is determined by argument types, while overriding is determined by actual object type.

// Compile-time Polymorphism Example
class MathUtil {
    int add(int a, int b) { return a + b; }
    int add(int a, int b, int c) { return a + b + c; }
}

// Runtime Polymorphism Example
class Shape {
    void draw() {
        System.out.println("Drawing shape");
    }
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing circle");
    }
}

Compile-time decision based on parameter count.

Drawing circle

Runtime Polymorphism (Method Overriding) is one of the most essential building blocks of Java OOP concepts. It enables dynamic behavior, promotes flexibility, supports abstraction, and helps developers write scalable applications. Every real-world Java application—from Spring Framework to Android and JavaFX—heavily uses method overriding. With a strong understanding of rules, examples, dynamic method dispatch, and real-world scenarios, you can confidently implement runtime polymorphism in your Java projects. This detailed guide ensures clarity, depth, and complete understanding with examples, outputs, and SEO-optimized explanations for maximum learning impact.