Java Method Overriding

Java Method Overriding is a fundamental concept in object-oriented programming that enables a subclass to provide a specific implementation of a method already defined in its superclass.

Key Concepts

• Inheritance: Overriding is only possible through inheritance, allowing a subclass to inherit methods from its superclass.
• Same Method Signature: The method in the subclass must have the same name, return type, and parameter list as the method in the superclass.
• Dynamic Method Dispatch: Java uses dynamic method dispatch to determine which method to call at runtime based on the object's type.
• @Override Annotation: It is a good practice to use the @Override annotation when overriding a method, as it helps avoid errors by ensuring the method is actually overriding a superclass method.

Why Use Method Overriding?

• Runtime Polymorphism: Overriding allows for runtime polymorphism, enabling a program to decide at runtime which method to invoke.
• Specific Behavior: Subclasses can implement specific behaviors while still retaining the general behavior defined in the superclass.

Example

Here’s a simple example to illustrate method overriding:

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 Main {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // Upcasting
        myDog.sound(); // Calls Dog's sound method
    }
}

Explanation of the Example

• Animal Class: This is the superclass that has a method sound().
• Dog Class: This subclass overrides the sound() method to provide a specific behavior (barking).
• Upcasting: The myDog variable is of type Animal but references a Dog object, demonstrating polymorphism. When myDog.sound() is called, the Dog class's implementation is executed.

Summary

• Method overriding is a powerful feature in Java that enhances flexibility and reusability.
• It allows subclasses to define specific behavior for methods inherited from superclasses.
• Using the @Override annotation is recommended to ensure methods are properly overridden.

By understanding and utilizing method overriding, Java developers can create more dynamic and adaptable applications.