Method overriding rules in Java - Step-by-Step Execution

Concept Flow - Method overriding rules

Parent class defines method

↓

Child class defines method with same signature

↓

Check method signature match?

No→Compile error

Yes↓

Check access modifier (child >= parent)?

No→Compile error

Yes↓

Check return type compatibility?

No→Compile error

Yes↓

Method overridden successfully

↓

At runtime, child method is called if object is child type

This flow shows how Java checks method overriding rules step-by-step to ensure the child class method properly overrides the parent method.

Execution Sample

Java

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

This code shows a parent and child class where the child overrides the show() method, and the child method is called at runtime.

Execution Table

Step	Action	Check/Evaluation	Result
1	Parent class defines show()	Method signature: void show()	Method created in Parent
2	Child class defines show()	Method signature matches Parent's show()	Signature matches, proceed
3	Check access modifier	Child's show() is default, Parent's show() is default	Access modifier compatible
4	Check return type	Both return void	Return type compatible
5	Compile-time	No errors found	Method overriding allowed
6	Runtime: call show() on Child object	Child's show() overrides Parent's	Output: Child
7	End	Execution complete	Program ends

💡 Method overriding rules passed, child method called at runtime

Variable Tracker

Variable	Start	After Step 2	After Step 6	Final
objectType	Parent	Child	Child	Child
methodCalled	Parent.show()	Child.show()	Child.show()	Child.show()

Key Moments - 3 Insights

Why must the child method have the same signature as the parent method?

Because overriding requires the method name and parameters to match exactly, as shown in execution_table step 2 where signature match is checked.

What happens if the child method has a more restrictive access modifier?

It causes a compile error because the child method must have the same or less restrictive access, as checked in step 3.

Why does the child method get called at runtime instead of the parent method?

Because Java uses dynamic method dispatch, so the actual object's method is called, shown in step 6 where Child.show() runs.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is checked?

A If the child method has the same name as the parent method

B If the child method's access modifier is compatible with the parent's

C If the child method's return type matches the parent's

D If the child method throws the same exceptions as the parent

💡 Hint

See execution_table row 3 under 'Check access modifier'

At which step does the program decide which method to call at runtime?

A Step 2

B Step 4

C Step 6

D Step 7

💡 Hint

Look at execution_table step 6 where runtime call happens

If the child method had a different return type, what would happen according to the flow?

A The method would override successfully

B There would be a compile error

C The parent method would be called instead

D The program would run but print a warning

💡 Hint

See concept_flow step checking return type compatibility

Concept Snapshot

Method overriding rules in Java:
- Child method must have same name and parameters as parent
- Access modifier in child must be same or less restrictive
- Return type must be compatible (same or covariant)
- @Override annotation helps catch errors
- At runtime, child's method is called if object is child type

Full Transcript

This visual execution trace shows how Java enforces method overriding rules. First, the parent class defines a method. Then the child class defines a method with the same signature. Java checks if the method signatures match exactly. Next, it verifies that the child's access modifier is not more restrictive than the parent's. Then it checks if the return types are compatible. If all checks pass, the method overriding is allowed. At runtime, when calling the method on a child object, the child's method runs, demonstrating dynamic dispatch. Common confusions include why signatures must match, why access modifiers matter, and why the child's method is called at runtime. The quiz questions reinforce these points by referencing specific steps in the execution table.

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