Polymorphism: Decoding Method Overriding in Java

Method Overriding is one of the core concepts of polymorphism in Java, allowing a subclass to provide a specific implementation of a method already defined in its superclass. This powerful feature helps achieve runtime polymorphism and enables dynamic method dispatch. In this post, we’ll dive into the essential concepts, rules, and real-world examples to understand method overriding thoroughly.

What is Method Overriding?

Method overriding occurs when a subclass redefines a method from its superclass with the same method signature (same name, parameters, and return type or a covariant return type). Unlike method overloading, which is resolved at compile-time, method overriding achieves runtime polymorphism, where the actual method called depends on the object's runtime type.

1. Rules of Method Overriding

1. Method Signature Consistency:

• The method name and parameter list in the subclass must exactly match the method in the superclass.

2. Return Type and Covariant Return Types:

• The return type must either be the same or a covariant type (a subtype of the original return type in the superclass).

3. Access Modifiers:

• A method in a subclass cannot have a more restrictive access level than the method in the superclass (e.g., if the superclass method is protected, the subclass cannot make it private).

Public > Protected > Default (Package-Private) > Private

4. Method Visibility:

• Private methods cannot be overridden. Instead, if redefined in the subclass, they are treated as entirely new methods.

Example: Basic Method Overriding

package oops.polymorphism;

// Base class
public class MethodOverridingParent {

    // Private Methods CANNOT be overridden
    private String getName() {
        return "Hello";
    }

    // Display method to be overridden (Access Modifier: default)
    void display() {
        System.out.println("Parent Method Called");
    }

    // Return type is Number (parent class of Integer, Double, etc.)
    public Number getCount() {
        return 20;
    }
}

In MethodOverridingParent, only display() and getCount() can be overridden by subclasses, as they are accessible beyond the parent class. However, getName() is private, so it cannot be overridden since it isn’t inherited by subclasses.

2. Method Overriding in Child Class

package oops.polymorphism;

public class MethodOverridingChild extends MethodOverridingParent {

    // Access Level Increased; Default -> Protected
    @Override
    protected void display() {
        System.out.println("Child Method Called");
    }

    public static void main(String[] args) {

        // Calling Parent Class Method
        MethodOverridingParent parent = new MethodOverridingParent();
        parent.display(); // Output: Parent Method Called

        // Calling Child Class Overridden Method - Runtime Polymorphism
        MethodOverridingParent child = new MethodOverridingChild();
        child.display(); // Output: Child Method Called
    }
}

Explanation: Since display() is overridden in the subclass MethodOverridingChild, invoking display() on a MethodOverridingChild instance calls the child’s version. This is runtime polymorphism in action.

3. Covariant Return Types: A Practical Example

Java’s support for covariant return types allows the subclass to return a type that’s more specific than the superclass’s return type. This approach follows the Liskov Substitution Principle in the SOLID principles, enhancing code flexibility.

package oops.polymorphism;

// Demonstrating covariant return type
public class CovariantReturnType extends MethodOverridingParent {

    // Parent method's Return type is Number
    // Since Integer is a subclass of Number, covariance is achieved
    // Since Base class' method is public, subclass has to use public
    @Override
    public Integer getCount() {
        return 40;
    }

    public static void main(String[] args) {
        CovariantReturnType type = new CovariantReturnType();
        System.out.println(type.getCount()); // Output: 40
    }
}

Explanation: In CovariantReturnType, getCount() overrides the parent’s method by returning an Integer, a subtype of Number, demonstrating covariant return types. The method remains public because Java requires that the access level of an overridden method can’t be reduced.

Method Overriding vs. Method Overloading

• Method Overriding enables dynamic polymorphism and operates in inheritance hierarchies.
• Method Overloading is a form of static polymorphism achieved within the same class by having different parameter types or numbers.

When to Use Method Overriding

1. Dynamic Method Resolution: Overriding methods are resolved at runtime based on the object type, providing greater flexibility.
2. Extending Behavior: Subclasses can modify or extend the functionality of superclass methods.

Conclusion

By understanding and applying method overriding, we can build more flexible, reusable, and polymorphic Java applications that adhere to object-oriented programming principles.

Related Posts

• Java Fundamentals

• Array Interview Essentials

• Java Memory Essentials

• Java Keywords Essentials

• Collections Framework Essentials

Happy Coding!