Overriding in Java

Overriding in Java is a fundamental concept of object-oriented programming that allows a subclass to provide a specific implementation of a method that is already defined in its parent class. This is crucial for achieving runtime polymorphism and designing flexible, reusable, and maintainable code.

This guide explains overriding in Java in detail, from basic syntax and rules to practical use cases and advanced examples, suitable for beginners to intermediate learners.

What is Method Overriding in Java?

Method overriding occurs when a subclass provides its own implementation of a method that is already defined in the parent class. The overridden method must have the same name, return type, and parameter list as the parent class method.

Key Points about Overriding

• Occurs in inheritance hierarchies
• Enables runtime polymorphism
• Requires same method signature

Syntax of Method Overriding in Java

📄

class Parent {
    void display() {
        System.out.println("This is the parent class method.");
    }
}

class Child extends Parent {
    @Override
    void display() {
        System.out.println("This is the child class method.");
    }
}

Rules for Method Overriding in Java

• The method must have the same name, return type, and parameters.
• The access level of the overriding method cannot be more restrictive than the parent method.
• The overriding method cannot throw new or broader checked exceptions.
• Static methods cannot be overridden (they can be hidden).
• Constructors cannot be overridden.

Example of Overriding with Return Types

In Java, method overriding allows a subclass to provide a specific implementation of a method defined in its parent class. Starting from Java 5, covariant return types were introduced, allowing the overriding method to return a subtype of the parent method's return type.

Covariant Return Types Explained

Covariant return types mean that if a parent class method returns a type parent, the overriding method in a subclass can return child (a subclass of Parent). This provides more flexibility and type safety.

Rules for Overriding with Return Types

• The method name and parameters must match exactly with the parent class method.
• The return type can either be the same or a subclass (covariant type).
• Access modifiers should not be more restrictive than the parent method.

Practical Example

📄

class Parent {
    Parent getObject() {
        System.out.println("Returning Parent object");
        return new Parent();
    }
}

class Child extends Parent {
    @Override
    Child getObject() {
        System.out.println("Returning Child object");
        return new Child();
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parentRef1 = new Parent();
        Parent parentRef2 = new Child();

        parentRef1.getObject(); // Calls Parent's method
        parentRef2.getObject(); // Calls Child's overridden method
    }
}

Benefits of Overriding with Covariant Return Types

• Improves type safety by returning the most specific type possible.
• Makes the code more readable and maintainable.
• Supports polymorphic behavior without explicit casting.
• Enables flexible API design when using inheritance.

Since Java 5, methods can have covariant return types, meaning the overriding method can return a subtype of the parent method's return type.

📄

class Parent {
    Parent getObject() {
        return new Parent();
    }
}

class Child extends Parent {
    @Override
    Child getObject() {
        return new Child();
    }
}

Overriding vs Overloading in Java

Practical Use Case of Method Overriding

Method overriding is widely used in Java frameworks and applications, including:

• Polymorphic behavior in collections and data structures
• Customizing methods in GUI frameworks like Swing or JavaFX
• Defining specific behavior in subclasses of abstract classes

Example: Vehicle Class

📄

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

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

class Bike extends Vehicle {
    @Override
    void start() {
        System.out.println("Bike is starting with kick start");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle v1 = new Car();
        Vehicle v2 = new Bike();
        
        v1.start(); // Car's start() is called
        v2.start(); // Bike's start() is called
    }
}

This demonstrates runtime polymorphism where the method call resolves to the subclass method at runtime.

Best Practices for Overriding in Java

• Always use @override  annotation for clarity and compile-time checking
• Follow consistent access levels to prevent unexpected behavior
• Avoid overriding final methods
• Use method overriding to implement polymorphic behavior and improve code maintainability

Conclusion

Method overriding in Java is a key feature of object-oriented programming that allows subclasses to provide specific implementations of methods defined in parent classes. By understanding overriding rules, syntax, and best practices, developers can write flexible, reusable, and polymorphic code that adapts at runtime.

Frequently Asked Questions (FAQs)

1. What is method overriding in Java?

Method overriding occurs when a subclass provides a specific implementation for a method already defined in its parent class with the same name, return type, and parameters.

2. What is the difference between overriding and overloading?

Overriding is runtime polymorphism where a subclass changes the behavior of a parent class method. Overloading is compile-time polymorphism where methods have the same name but different parameter lists within the same class.

3. Can private methods be overridden?

No, private methods are not visible to subclasses and therefore cannot be overridden. They can only be redefined in the subclass.

4. Why use the @Override annotation?

The @override annotation ensures that the method is correctly overriding a method from the parent class. It helps catch errors at compile-time if the method signature doesn't match.

5. Can a static method be overridden?

No, static methods belong to the class rather than an instance and cannot be overridden. They can be hidden by defining a method with the same name in the subclass.