Method overriding rules in Java - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to override the method display in the subclass.

Java

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

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

Drag options to blanks, or click blank then click option'

Ashow

Bprint

Cdisplay

DdisplayMessage

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different method name in the subclass.

Forgetting the @Override annotation (not mandatory but recommended).

The method name in the subclass must exactly match the method name in the parent class to override it. Here, display is the correct method name.

2fill in blank

medium

Complete the code to override the method with the correct return type.

Java

class Parent {
    int getNumber() {
        return 10;
    }
}

class Child extends Parent {
    @Override
    public [1] getNumber() {
        return 20;
    }
}

Drag options to blanks, or click blank then click option'

Aint

Bvoid

CString

Ddouble

Attempts:

3 left

💡 Hint

Common Mistakes

Changing the return type to a different incompatible type.

Using void when the parent method returns a value.

The return type in the overriding method must be the same or a subtype (covariant) of the parent method's return type. Here, int matches exactly.

3fill in blank

hard

Fix the error in the method overriding by choosing the correct access modifier.

Java

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

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

Drag options to blanks, or click blank then click option'

Afinal

Bdefault

Cprivate

Dprotected

Attempts:

3 left

💡 Hint

Common Mistakes

Using private in the child method which is more restrictive.

Using final which prevents overriding.

The overriding method cannot have a more restrictive access modifier. Since the parent method is protected, the child method must be protected or more accessible.

4fill in blank

hard

Fill both blanks to correctly override the method and handle exceptions.

Java

class Parent {
    void process() throws [1] {
        System.out.println("Parent process");
    }
}

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

Drag options to blanks, or click blank then click option'

AIOException

BException

CFileNotFoundException

DRuntimeException

Attempts:

3 left

💡 Hint

Common Mistakes

Throwing a broader exception in the child method.

Throwing an unrelated exception.

The child method can only throw the same or narrower exceptions. FileNotFoundException is a subclass of IOException, so this is allowed.

5fill in blank

hard

Fill all three blanks to correctly override the method with covariant return type and access modifier.

Java

class Parent {
    Number getValue() {
        return 10;
    }
}

class Child extends Parent {
    @Override
    public [1] getValue() {
        return new [2]();
    }
}

class [3] extends Number {
    public int intValue() { return 0; }
    public long longValue() { return 0L; }
    public float floatValue() { return 0.0f; }
    public double doubleValue() { return 0.0; }
}

Drag options to blanks, or click blank then click option'

ANumber

BInteger

CMyNumber

Dprotected

Attempts:

3 left

💡 Hint

Common Mistakes

Using a return type not related to Number.

Using a more restrictive access modifier than the parent method.

The overriding method must have the same or more accessible modifier (here public is already set), the return type can be a subclass of the parent's return type (covariant). MyNumber extends Number and is returned.

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