Method Overriding in Java

Method overriding lets a subclass provide a specific implementation of a method that is already defined in its parent class. It is the foundation of runtime polymorphism in Java and a key principle of object-oriented design.

• The parent class declares the method.
• The subclass redeclares it with the same name and parameters.
• Mark the subclass method with @Override.
• Use super.method() to call the parent version.

Let's start with a hands-on example. The program below shows the core idea behind Method Overriding in just a few lines of Java. Read it line by line and observe how Java executes each statement in order.

class Animal
{
    void sound() { System.out.println("Some sound"); }
}

class Dog extends Animal
{
    @Override
    void sound() { System.out.println("Bark"); }
}

class Main
{
    public static void main(String args[])
    {
        Animal a = new Dog();
        a.sound();
    }
}

The following examples progress from simple to more practical patterns. Try each in your IDE, change the inputs and observe the output. This is the fastest way to internalize the concept.

class Vehicle
{
    void run() { System.out.println("Vehicle is running"); }
}

class Bike extends Vehicle
{
    @Override
    void run() { System.out.println("Bike is running fast"); }
}

class Main
{
    public static void main(String args[])
    {
        new Bike().run();
    }
}

class A
{
    void hello() { System.out.println("Hello from A"); }
}

class B extends A
{
    @Override
    void hello()
    {
        super.hello();
        System.out.println("Hello from B");
    }
}

class Main
{
    public static void main(String args[])
    {
        new B().hello();
    }
}

class Shape { void draw() { System.out.println("Shape"); } }

class Circle extends Shape { @Override void draw() { System.out.println("Circle"); } }
class Square extends Shape { @Override void draw() { System.out.println("Square"); } }

class Main
{
    public static void main(String args[])
    {
        Shape arr[] = { new Circle(), new Square(), new Shape() };

        for (Shape s : arr) s.draw();
    }
}

class A
{
    Number get() { return 10; }
}

class B extends A
{
    @Override
    Integer get() { return 20; }   // covariant return
}

class Main
{
    public static void main(String args[])
    {
        System.out.println(new B().get());
    }
}

• Always use @Override — the compiler catches subtle mistakes.
• Final, private and static methods can't be overridden.
• Constructors can't be overridden — they aren't inherited.
• Override's access modifier must be at least as permissive as the parent.
• Runtime polymorphism enables dependency-inversion designs.

Reading is not enough — practice solidifies knowledge. Try every question below in your own editor before peeking at any solution.

• Q1. Create a Shape class with subclasses Circle and Triangle that override area().
• Q2. Override toString() in a Book class.
• Q3. Demonstrate calling the parent's overridden method via super.
• Q4. Create an Animal class and override sound() in three subclasses.
• Q5. Show why final methods cannot be overridden.

These are the most common questions asked in Java interviews on this topic. Memorize the concept, not just the answer — interviewers often follow up with edge cases.

Even experienced developers slip on the same pitfalls. Watch out for these classic mistakes while working with Method Overriding in Java:

• Forgetting the semicolon ; at the end of statements while using Method Overriding.
• Mixing up similar method names — read Java docs before using new APIs related to Method Overriding.
• Ignoring compiler warnings — they often hint at bugs that will appear later in production.
• Hard-coding values that should come from configuration files or environment variables.
• Not handling edge cases: empty inputs, very large inputs, negative numbers and null references.
• Skipping unit tests — small tests prevent big regressions, especially around control flow.