Method overriding rules in Java

Introduction

Method overriding lets a child class change how a method from its parent works. This helps make programs flexible and easy to update.

When you want a child class to do something different from the parent class for the same action.

When you need to customize behavior in a subclass without changing the parent class code.

When using polymorphism to call child class methods through parent class references.

When you want to extend or improve a method's behavior in a subclass.

When implementing abstract methods from a parent or interface.

Syntax

Java

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

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

The method in the child class must have the same name, return type, and parameters as the parent method.

Use the @Override annotation to help the compiler check you are correctly overriding.

Examples

Child class Dog changes the sound method to print a dog-specific message.

Java

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

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

The Car class overrides speed to return a different number.

Java

class Vehicle {
    int speed() {
        return 50;
    }
}

class Car extends Vehicle {
    @Override
    int speed() {
        return 100;
    }
}

Sample Program

This program shows method overriding. The greet method is called on parent, child, and parent reference to child object. The child method runs when the object is child.

Java

class Parent {
    void greet() {
        System.out.println("Hello from Parent");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Parent p = new Parent();
        p.greet();

        Child c = new Child();
        c.greet();

        Parent pc = new Child();
        pc.greet();
    }
}

Important Notes

The overriding method cannot have more restrictive access than the parent method. For example, if parent method is public, child method must be public too.

Static methods cannot be overridden, only instance methods can.

Constructors cannot be overridden.

Summary

Method overriding lets a child class provide its own version of a parent method.

The method signature must match exactly.

Use @Override to avoid mistakes.

Practice

1. Which of the following is true about method overriding in Java?

easy

A. The method in the child class can have fewer parameters than the parent method.

B. The method in the child class must have the same name and parameters as in the parent class.

C. The method in the child class must be static to override the parent method.

D. The method in the child class must have a different return type than the parent method.

Solution

1. Step 1: Understand method overriding signature rules

   Method overriding requires the child method to have the exact same name and parameter list as the parent method.

2. Step 2: Check return type and modifiers

   The return type must be the same or a subtype, and the method cannot be static to override.

3. Final Answer:

   The method in the child class must have the same name and parameters as in the parent class. -> Option B

4. Quick Check:

   Method signature match = D [OK]

Hint: Method name and parameters must match exactly to override [OK]

Common Mistakes:

• Thinking return type can be different
• Assuming static methods can be overridden
• Changing parameter count in child method

2. Which of the following method declarations correctly overrides a parent method public int calculate(int x)?

easy

A. public int calculate(int x) { return x * 2; }

B. public void calculate(int x) { System.out.println(x); }

C. public int calculate(double x) { return (int)x; }

D. static public int calculate(int x) { return x + 1; }

Solution

1. Step 1: Match method signature exactly

   The overriding method must have the same name and parameter types: calculate(int x).

2. Step 2: Check return type and modifiers

   Return type must be int and method must not be static.

3. Final Answer:

   public int calculate(int x) { return x * 2; } -> Option A

4. Quick Check:

   Exact signature and return type = A [OK]

Hint: Match method name, parameters, and return type exactly [OK]

Common Mistakes:

• Changing return type to void
• Changing parameter type
• Making method static

3. What is the output of the following code?

class Parent {
    void show() { System.out.println("Parent"); }
}
class Child extends Parent {
    @Override
    void show() { System.out.println("Child"); }
}
public class Test {
    public static void main(String[] args) {
        Parent obj = new Child();
        obj.show();
    }
}

medium

A. Parent

B. Runtime error

C. Compilation error

D. Child

Solution

1. Step 1: Understand dynamic method dispatch

   When a parent reference points to a child object, the overridden child method is called at runtime.

2. Step 2: Check method overriding and call

   The show() method is overridden in Child, so obj.show() calls Child's version.

3. Final Answer:

   Child -> Option D

4. Quick Check:

   Overridden method called at runtime = B [OK]

Hint: Overridden method runs, not parent, when using child object [OK]

Common Mistakes:

• Expecting parent method output
• Confusing compile-time and runtime method calls
• Ignoring @Override annotation effect

4. Identify the error in the following code snippet:

class Parent {
    void display() {}
}
class Child extends Parent {
    @Override
    void display(int x) {}
}

medium

A. Cannot use @Override annotation on any method.

B. Missing return type in Child's display method.

C. Method display(int x) does not override display() due to different parameters.

D. Child class cannot have methods with parameters.

Solution

1. Step 1: Compare method signatures in Parent and Child

   Parent has display() with no parameters; Child has display(int x) with one parameter.

2. Step 2: Understand @Override annotation rules

   @Override requires exact signature match; here, parameters differ, so it's not overriding.

3. Final Answer:

   Method display(int x) does not override display() due to different parameters. -> Option C

4. Quick Check:

   @Override requires exact signature match = C [OK]

Hint: @Override needs exact method signature match to avoid errors [OK]

Common Mistakes:

• Ignoring parameter difference
• Thinking @Override can be used on any method
• Assuming method overloading is overriding

5. Consider this code:

class Animal {
    Number getValue() { return 10; }
}
class Dog extends Animal {
    @Override
    Integer getValue() { return 20; }
}

Which statement about this overriding is correct?

hard

A. This is valid because Integer is a subclass of Number (covariant return type).

B. This causes a compile-time error due to different return types.

C. This is invalid because return types must be exactly the same.

D. This is invalid because @Override cannot be used with different return types.

Solution

1. Step 1: Check return types in parent and child methods

   Parent returns Number, child returns Integer, which is a subclass of Number.

2. Step 2: Understand covariant return types in Java overriding

   Java allows child methods to return a subtype of the parent's return type when overriding.

3. Final Answer:

   This is valid because Integer is a subclass of Number (covariant return type). -> Option A

4. Quick Check:

   Covariant return types allowed = A [OK]

Hint: Child can return subtype of parent's return type when overriding [OK]

Common Mistakes:

• Thinking return types must be exactly the same
• Assuming @Override forbids different return types
• Confusing overloading with overriding