How do we identify if a method is an overridden method?

To identify if a method is an overridden method, you must examine its relationship with a method in its superclass, specifically checking if it adheres to a precise set of rules for method signature, return type, and other modifiers.

How to Identify an Overridden Method

An overridden method is a method in a subclass that has the same signature (name and parameter list) as a method in its superclass. This mechanism allows a subclass to provide a specific implementation of a method that is already defined in its parent class, enabling polymorphism.

Core Principles of Method Overriding

The fundamental characteristic of an overridden method is that it provides a new implementation for an inherited method. When an object of the subclass is used, the overridden method's implementation is executed instead of the superclass's version.

Key Rules for Overriding

For a method to correctly override a method in a superclass, it must adhere to several strict rules:

1. Method Signature

The overriding method must have the exact same name as the method it overrides. Additionally, it must have the same number and type of parameters in the same order. Any deviation in the parameter list makes it an overloaded method, not an overridden one.

2. Return Type (Covariant Return Types)

The overriding method must have the same return type as the overridden method. However, an important exception exists: an overriding method can also return a subtype of the type returned by the overridden method. This feature is known as a covariant return type.

Example: If a superclass method returns Object, an overriding method can return String (because String is a subtype of Object).

3. Access Modifiers

The access modifier of the overriding method cannot be more restrictive than the overridden method's access modifier. It can be less restrictive or the same.

public can be overridden by public.
protected can be overridden by protected or public.
default (package-private) can be overridden by default, protected, or public.
private methods are not inherited by subclasses and thus cannot be overridden. If a subclass has a method with the same signature as a private method in its superclass, it's considered a new method, not an override.

4. Exception Handling

The overriding method can declare fewer or no checked exceptions, the same checked exceptions, or a subtype of the checked exceptions declared by the overridden method. It cannot declare new, broader checked exceptions than those declared in the superclass method. Unchecked exceptions (runtime exceptions) do not follow this rule.

5. `final`, `static`, and `private` Methods

final Methods: A method declared as final in the superclass cannot be overridden in a subclass.
static Methods: static methods cannot be overridden. If a subclass declares a static method with the same signature as a static method in its superclass, it is known as "method hiding," not overriding. The behavior depends on whether the method is called on the class type or an instance.
private Methods: As mentioned, private methods are not inherited, so they cannot be overridden.

Practical Examples

Consider a base class Vehicle and a subclass Car:

class Vehicle {
    public void start() {
        System.out.println("Vehicle started.");
    }

    public Object getInfo() {
        return "Generic Vehicle";
    }

    protected void accelerate() {
        System.out.println("Vehicle accelerating.");
    }
}

class Car extends Vehicle {
    @Override // This annotation helps verify overriding rules
    public void start() {
        System.out.println("Car started with a key."); // Overridden method
    }

    @Override
    public String getInfo() { // Covariant return type: String is a subtype of Object
        return "Specific Car Model";
    }

    @Override
    protected void accelerate() { // Access modifier can be same or less restrictive (here, same)
        System.out.println("Car accelerating faster.");
    }

    // This would NOT be an override (different parameter)
    // public void start(String type) { ... }

    // This would NOT be an override (more restrictive access)
    // private void accelerate() { ... }
}

In the Car class:

start() overrides Vehicle.start() because it has the same name, no parameters, and public access.
getInfo() overrides Vehicle.getInfo() due to the same name and parameters, and utilizes a covariant return type (String is a subtype of Object).
accelerate() overrides Vehicle.accelerate() because it maintains the signature and protected access, which is allowed.

The @Override annotation is a highly recommended practice in Java. It informs the compiler that the method is intended to override a method in the superclass. If the method does not correctly override a superclass method (e.g., due to a mismatch in signature or return type), the compiler will generate an error, helping to catch mistakes early.

Why Method Overriding Matters

Method overriding is crucial for achieving polymorphism in object-oriented programming. It allows you to write generic code that interacts with objects of different classes through a common superclass interface, while the actual behavior is determined by the specific subclass object at runtime. This leads to more flexible, extensible, and maintainable code.