How to write override methods in Java

Mastering Method Overriding in Java

Learn the principles, rules, and best practices for implementing method overriding in Java, a core concept of polymorphism.

Method overriding is a fundamental concept in object-oriented programming, particularly in Java, that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its superclasses or parent classes. When a method in a subclass has the same name, same parameters, and same return type (or a covariant return type) as a method in its superclass, then the method in the subclass is said to override the method in the superclass. This mechanism is crucial for achieving runtime polymorphism.

Understanding the Basics of Overriding

For a method to be considered overridden, several rules must be followed. The most important ones include matching method signatures (name, parameter list), compatible return types, and access modifiers. Overriding allows you to customize the behavior of inherited methods without altering the superclass, promoting code reusability and extensibility. It's a powerful tool for creating flexible and maintainable class hierarchies.

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

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

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();

        myAnimal.makeSound(); // Outputs: The animal makes a sound
        myDog.makeSound();    // Outputs: The dog barks (runtime polymorphism)
    }
}

Basic example of method overriding in Java

Rules and Constraints for Overriding

While overriding is flexible, there are strict rules to ensure type safety and proper inheritance. These include restrictions on final and static methods, access modifier visibility, and exception handling. Understanding these constraints is vital to avoid common pitfalls and write robust Java code. For instance, you cannot override final methods, as they are designed to prevent modification in subclasses. Similarly, static methods cannot be overridden; instead, they are 'hidden' by a subclass method with the same signature.

1. Step 1

Ensure the method in the subclass has the exact same name, parameter list, and a compatible return type (or covariant return type) as the method in the superclass.

2. Step 2

Verify that the access modifier of the overriding method is not more restrictive than the overridden method (e.g., public can override protected, but protected cannot override public).

3. Step 3

Confirm that the method is not declared final or static in the superclass, as these cannot be overridden.

4. Step 4

If the overridden method declares exceptions, the overriding method can declare the same exceptions, a subclass of those exceptions, or no exceptions, but cannot declare broader checked exceptions.

class Parent {
    protected Object getValue() {
        return new Object();
    }
    // final void cannotBeOverridden() { /* ... */ }
    static void staticMethod() {
        System.out.println("Parent's static method");
    }
}

class Child extends Parent {
    @Override
    public String getValue() { // Covariant return type (String is a subclass of Object)
        return "Hello";
    }

    // This is not overriding, but hiding the static method
    static void staticMethod() {
        System.out.println("Child's static method");
    }
}

public class OverridingDemo {
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.getValue()); // Outputs: Hello
        Parent.staticMethod(); // Outputs: Parent's static method
        Child.staticMethod();  // Outputs: Child's static method
    }
}

Demonstration of overriding rules including covariant return types and static method hiding

Class diagram illustrating method overriding with Shape, Circle, and Rectangle classes.