Method overriding rules in Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of overridden method with super call

What is the output of this Java program?

Java

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

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

public class Test {
    public static void main(String[] args) {
        Parent obj = new Child();
        obj.show();
    }
}

A Parent show\nChild show

B Child show\nParent show

C Child show

D Parent show

💡 Hint

Remember that the overridden method in the child class calls super.show() after printing.

The object is of type Child, so Child's show() runs. It prints "Child show" then calls super.show(), which prints "Parent show".

❓ Predict Output

intermediate

Return type covariance in method overriding

What will be the output when this Java code runs?

Java

class Animal {}
class Dog extends Animal {}

class Parent {
    Animal getAnimal() {
        System.out.println("Parent getAnimal");
        return new Animal();
    }
}

class Child extends Parent {
    @Override
    Dog getAnimal() {
        System.out.println("Child getAnimal");
        return new Dog();
    }
}

public class Test {
    public static void main(String[] args) {
        Parent p = new Child();
        Animal a = p.getAnimal();
    }
}

A Child getAnimal\n

B Parent getAnimal\n

C Compilation error due to return type mismatch

D Runtime error

💡 Hint

Check if the return type in Child is allowed to be a subclass of Parent's return type.

Java allows covariant return types in overriding. Child's getAnimal returns Dog, a subclass of Animal, so it compiles and runs. The overridden method in Child is called, printing "Child getAnimal".

❓ Predict Output

advanced

Access modifier rules in method overriding

What error or output occurs when compiling and running this code?

Java

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

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

public class Test {
    public static void main(String[] args) {
        Parent p = new Child();
        p.display();
    }
}

A Runtime error

B Child display

C Parent display

D Compilation error: attempting to assign weaker access privileges

💡 Hint

Check if the access modifier in Child's display is compatible with Parent's.

Parent's display is protected. Child's display has default (package-private) access, which is weaker. Java does not allow reducing visibility in overriding, so this causes a compilation error.

❓ Predict Output

advanced

Exception rules in overridden methods

What happens when compiling this code?

Java

class Parent {
    void process() throws Exception {
        System.out.println("Parent process");
    }
}

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

public class Test {
    public static void main(String[] args) {
        Parent p = new Child();
        try {
            p.process();
        } catch (Exception e) {
            System.out.println("Caught Exception");
        }
    }
}

A RuntimeException thrown at runtime

B Compilation error: overridden method throws broader exception

C Child process

D Caught Exception

💡 Hint

Check if RuntimeException is allowed as an overridden method exception.

Child's process throws RuntimeException, which is unchecked and allowed. The method runs and prints "Child process". No exception is thrown, so catch block is not executed.

🧠 Conceptual

expert

Which statement about method overriding is true?

Select the only true statement about method overriding in Java.

A An overriding method must have the same return type or a subtype of the overridden method's return type.

B An overriding method can have a more restrictive access modifier than the overridden method.

C Static methods can be overridden like instance methods.

D An overriding method can throw any checked exception regardless of the overridden method's exceptions.

💡 Hint

Think about access modifiers, exceptions, return types, and static methods rules.

In Java, overriding methods must have the same or covariant return type. Access modifiers cannot be more restrictive. Checked exceptions must be the same or narrower. Static methods are hidden, not overridden.

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