How to override a method in Java?

Understanding Method Overriding in Java

In Java, method overriding is a fundamental concept that allows a subclass to provide a specific implementation of a method that is already defined in its superclass. This is a key feature of object-oriented programming (OOP) and enables polymorphism, which is the ability of objects of different classes to respond to the same method call.

Overriding vs. Overloading

It's important to differentiate between method overriding and method overloading. Overloading occurs when a class has multiple methods with the same name but different parameters, whereas overriding involves a subclass providing its own implementation of a method that is already defined in its superclass.

Rules for Method Overriding

When overriding a method in Java, there are several rules that must be followed:

1. Method Signature: The method signature (name and parameter list) in the subclass must be exactly the same as the method signature in the superclass.
2. Return Type: The return type of the overriding method in the subclass must be the same as or a subtype of the return type of the overridden method in the superclass.
3. Access Modifier: The access modifier of the overriding method must be the same as or more accessible than the access modifier of the overridden method. For example, if the overridden method is protected, the overriding method can be protected or public, but not private.
4. Exceptions: The overriding method can declare a subset of the exceptions declared by the overridden method, or no exceptions at all. It cannot declare exceptions that are higher in the exception hierarchy.

Example of Method Overriding

Let's consider a simple example to illustrate method overriding in Java:

// Superclass
class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
}

// Subclass
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // Output: The animal makes a sound

        Dog dog = new Dog();
        dog.makeSound(); // Output: The dog barks

        Animal animalRef = new Dog();
        animalRef.makeSound(); // Output: The dog barks
    }
}

In this example, the Dog class overrides the makeSound() method of the Animal class. When we create an instance of the Dog class and call the makeSound() method, the implementation in the Dog class is executed. This is the essence of method overriding: the specific implementation of a method is determined by the actual type of the object, not the reference type.

The last part of the example demonstrates the concept of polymorphism. When we create an Animal reference that points to a Dog object, the makeSound() method of the Dog class is still called, even though the reference type is Animal. This is because the JVM determines the actual type of the object and calls the appropriate method implementation.

Real-World Analogy

Imagine you have a pet dog and a pet cat. Both are animals, but they have different ways of making sounds. When you call the makeSound() method on your pet, you expect it to make the appropriate sound, whether it's a dog barking or a cat meowing. This is exactly what method overriding allows you to do in Java: the specific implementation of the makeSound() method is determined by the actual type of the animal object, not the variable type you use to reference it.

In summary, method overriding in Java allows subclasses to provide their own implementation of a method that is already defined in the superclass. This is a crucial feature that enables polymorphism and allows objects of different classes to respond to the same method call in their own unique way.