Method Overriding

Why We Need Method Overriding

Inheritance gives a subclass the parent's methods, but a general version is often not right for a specific type. A Payment class can define pay(int amount), yet a card payment adds a fee and a UPI payment does not. Overriding lets each subclass supply the correct behaviour while the rest of the program keeps calling the same pay method on a Payment reference.

• Specialised behaviour: each subclass does the job its own way (CardPayment, UpiPayment, WalletPayment).
• Code written once: a loop over Payment objects never needs an if chain checking which kind of payment it holds.
• Easy extension: adding a new payment type means adding a class, not editing every place that takes payments.
• Everyday Java: you override toString(), equals() and hashCode() from Object all the time, and frameworks call your overridden methods (for example run() in a Thread).

Rules an Override Must Follow

For a subclass method to count as a valid override, several strict rules apply, and the compiler enforces every one of them.

• The method name and parameter list (the signature) must be identical to the superclass method.
• The return type must be the same, or a covariant return type — a subtype of the original return type — which Java has allowed since version 5.
• The access modifier in the subclass cannot be more restrictive than in the superclass (you cannot override a public method with a protected one, for example), though it may be less restrictive.
• The overriding method cannot throw new or broader checked exceptions than the overridden method declares.
• A method marked final, static, or private in the superclass cannot be overridden at all.

The @Override Annotation

@Override is an optional but strongly recommended annotation placed above an overriding method. It does not change runtime behavior, but it instructs the compiler to verify that the method actually overrides a superclass method — if you misspell the method name or get the parameter list wrong, the compiler raises an error immediately instead of silently creating an unrelated overloaded method.

Without the annotation, a method named tostring() in your class compiles happily, and System.out.println(obj) still prints the default ClassName@1b6d3586 text, because Object.toString() was never overridden. With @Override on it, javac stops with method does not override or implement a method from a supertype. Put it on every override; it costs nothing.

Covariant Return Types

An override normally returns the same type as the parent method, but Java also accepts a subtype of that return type. If Shape.createCopy() returns Shape, then Circle.createCopy() may return Circle, because every Circle is a Shape and callers using the parent type still get what they expect. The benefit shows up for callers who hold a Circle reference: they get a Circle back with no cast. Covariance works only for reference types. A parent method returning int cannot be overridden with one returning long or Integer.

Exception Rules: Checked vs Unchecked

Code that calls a method through the parent type only prepares for the checked exceptions the parent method declares. An override is therefore not allowed to surprise that code with a new or broader checked exception.

• An override may throw the same checked exception, a narrower one (a subclass, such as FileNotFoundException instead of IOException), or none at all.
• An override may not throw a new or broader checked exception. If the parent declares IOException, the child cannot declare Exception; if the parent declares nothing, the child cannot declare any checked exception.
• Unchecked exceptions (RuntimeException and its subclasses such as IllegalStateException) are not restricted. An override may throw them whatever the parent declares.
• The rule is about checked exceptions only, and javac reports a violation as overridden method does not throw ....

Can static, final and private Methods Be Overridden?

No, and each one fails for a different reason, which is why interviewers like asking about all three together.

• final: the parent has locked the method. Declaring the same method in a subclass is a compile error: overridden method is final.
• private: the method is not inherited, so the subclass cannot see it. A subclass method with the same name is a brand-new, unrelated method, and putting @Override on it fails to compile.
• static: a static method belongs to the class, not to an object. A subclass can declare a static method with the same signature, but that is method hiding: the version that runs is chosen from the reference type at compile time, not from the object at runtime. @Override on a static method is a compile error.
• Related: constructors are not inherited, so they cannot be overridden either, and the main method, being static, can only be hidden.

Calling the Parent Version with super

An override replaces the parent's method body completely, but sometimes you want to add to the parent's work rather than throw it away. Inside the override, super.methodName(...) runs the parent's version, and you can put your own code before or after it. A TimestampLogger can print a time and then call super.log(message) so the original logging logic still runs without being copied. The super keyword lesson covers the other uses of super.

Runtime Polymorphism and Dynamic Method Dispatch

Overriding is what makes runtime polymorphism possible. When you write Payment p = new CardPayment();, the variable's declared type is Payment but the object is a CardPayment. The compiler only checks that Payment has a pay method. At runtime, the JVM looks at the real object and runs CardPayment.pay. This runtime choice is called dynamic method dispatch. It applies only to overridden instance methods; fields, static methods and private methods are all resolved from the reference type at compile time. The next lesson, Runtime Polymorphism and Dynamic Binding, goes deeper.

Overriding vs Overloading

Overriding always involves two classes in an inheritance relationship and an identical signature, resolved at runtime. Overloading always happens within the same class (or via inheritance without changing the return-type-only rule) with a different parameter list, resolved at compile time. Confusing the two is one of the most frequent conceptual errors in Java learning.

• Where: overriding needs a parent and a child class; overloading happens within one class (or a class and its subclass).
• Parameters: overriding keeps them identical; overloading must change them.
• Return type: overriding needs the same type or a covariant subtype; overloading lets it be anything, but a return type alone cannot tell two overloads apart.
• Binding: overriding is resolved at runtime (dynamic dispatch); overloading is resolved at compile time.
• static, final, private: cannot be overridden; can all be overloaded.

Examples

class Shape {
    double area() {
        return 0.0;
    }

    Shape createCopy() {
        return new Shape();
    }
}

class Circle extends Shape {
    double radius = 5.0;

    @Override
    double area() {
        return Math.PI * radius * radius;
    }

    @Override
    Circle createCopy() { // covariant return type: Circle is a subtype of Shape
        return new Circle();
    }

    public static void main(String[] args) {
        Circle c = new Circle();
        System.out.printf("Area: %.2f%n", c.area());
    }
}

Area: 78.54

public class PaymentDemo {
    public static void main(String[] args) {
        Payment[] payments = { new Payment(), new CardPayment(), new UpiPayment() };
        for (Payment p : payments) {
            p.pay(500);   // one call, three different behaviours
        }
    }
}

class Payment {
    void pay(int amount) {
        System.out.println("Paying " + amount + " by a generic method");
    }
}

class CardPayment extends Payment {
    @Override
    void pay(int amount) {
        System.out.println("Paying " + amount + " by card (2% fee: " + amount * 2 / 100 + ")");
    }
}

class UpiPayment extends Payment {
    @Override
    void pay(int amount) {
        System.out.println("Paying " + amount + " by UPI (no fee)");
    }
}

Paying 500 by a generic method
Paying 500 by card (2% fee: 10)
Paying 500 by UPI (no fee)

public class LoggerDemo {
    public static void main(String[] args) {
        Logger log = new TimestampLogger();
        log.log("Order placed");
    }
}

class Logger {
    void log(String message) {
        System.out.println("LOG: " + message);
    }
}

class TimestampLogger extends Logger {
    @Override
    void log(String message) {
        System.out.print("[10:30] ");
        super.log(message); // reuse the parent's work instead of copying it
    }
}

[10:30] LOG: Order placed

public class HidingDemo {
    public static void main(String[] args) {
        Parent ref = new Child();
        ref.show();   // instance method: overridden, runs Child's version
        ref.info();   // static method: hidden, the reference type decides
        Child.info(); // call static methods through the class name instead
    }
}

class Parent {
    void show() {
        System.out.println("Parent.show()");
    }

    static void info() {
        System.out.println("Parent.info()");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child.show()");
    }

    static void info() { // hides Parent.info(); @Override here would not compile
        System.out.println("Child.info()");
    }
}

Child.show()
Parent.info()
Child.info()

import java.io.FileNotFoundException;
import java.io.IOException;

class Reader {
    void read() throws IOException { }
}

class SafeReader extends Reader {
    @Override
    void read() throws FileNotFoundException { } // narrower checked exception: OK
}

class NoThrowReader extends Reader {
    @Override
    void read() { } // throwing nothing: OK
}

class LoudReader extends Reader {
    @Override
    void read() throws IllegalStateException { } // any unchecked exception: OK
}

public class Ok {
    public static void main(String[] args) {
        System.out.println("compiles");
    }
}

compiles

import java.io.FileNotFoundException;
import java.io.IOException;

class Reader {
    public void open() throws FileNotFoundException { }
    public void read() throws IOException { }
    final void close() { }
    static void reset() { }
}

class BadReader extends Reader {
    // 1. Broader checked exception than the parent declares
    @Override
    public void open() throws IOException { }

    // 2. Narrower access than the parent (public -> protected)
    @Override
    protected void read() { }

    // 3. Overriding a final method
    @Override
    void close() { }

    // 4. @Override on a static method
    @Override
    static void reset() { }
}

1. error: open() in BadReader cannot override open() in Reader
       public void open() throws IOException { }
                   ^
     overridden method does not throw IOException

2. error: read() in BadReader cannot override read() in Reader
       protected void read() { }
                      ^
     attempting to assign weaker access privileges; was public

3. error: close() in BadReader cannot override close() in Reader
       void close() { }
            ^
     overridden method is final

4. error: static methods cannot be annotated with @Override
       @Override
       ^

Exercise

This program should print 4 then 2, but it prints 4 twice because the method in Bike is misspelt, so it does not override anything. Add @Override to see the compiler report the problem, then fix the name.

Expected output: 4 then 2

class Vehicle {
    int wheels() {
        return 4;
    }
}

class Bike extends Vehicle {
    int wheel() {
        return 2;
    }
}

public class WheelsDemo {
    public static void main(String[] args) {
        Vehicle car = new Vehicle();
        Vehicle bike = new Bike();
        System.out.println(car.wheels());
        System.out.println(bike.wheels());
    }
}

class Vehicle {
    int wheels() {
        return 4;
    }
}

class Bike extends Vehicle {
    @Override
    int wheels() {
        return 2;
    }
}

public class WheelsDemo {
    public static void main(String[] args) {
        Vehicle car = new Vehicle();
        Vehicle bike = new Bike();
        System.out.println(car.wheels());  // 4
        System.out.println(bike.wheels()); // 2
    }
}

Quick quiz

Interview questions

Go deeper

• super Keyword
• Runtime Polymorphism and Dynamic Binding
• Exception Handling Rules with Method Overriding
• Method Overloading vs Method Overriding: A Comparison