Method overriding in Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is method overriding in Java?

Method overriding occurs when a subclass provides its own version of a method that is already defined in its superclass. It allows the subclass to change or extend the behavior of that method.

intermediate

What are the rules for method overriding in Java?

The method in the subclass must have the same name, return type, and parameters as the method in the superclass. The overriding method cannot have more restrictive access than the overridden method.

beginner

Can a private method be overridden in Java?

No, private methods cannot be overridden because they are not visible to subclasses. They are only accessible within the class they are declared in.

beginner

What is the use of the @Override annotation?

The @Override annotation tells the compiler that the method is intended to override a method in the superclass. It helps catch errors if the method does not correctly override any method.

intermediate

What happens if you call an overridden method on a superclass reference pointing to a subclass object?

The subclass's version of the method is called. This is called dynamic method dispatch and supports runtime polymorphism.

Which of the following is true about method overriding?

A The subclass method must have the same signature as the superclass method.

B The subclass method can have a different return type than the superclass method.

C Private methods can be overridden.

D The subclass method must have more restrictive access than the superclass method.

Method overriding requires the subclass method to have the same name, parameters, and return type as the superclass method.

What does the @Override annotation do?

A It forces the method to be private.

B It changes the method's return type.

C It prevents the method from being overridden.

D It tells the compiler the method is intended to override a superclass method.

The @Override annotation helps the compiler check that the method correctly overrides a method from the superclass.

If a superclass reference points to a subclass object, which method is called when invoking an overridden method?

A The subclass method.

B Both methods are called.

C The superclass method.

D An error occurs.

Java uses dynamic method dispatch to call the subclass's overridden method at runtime.

Can a subclass override a static method from its superclass?

A Yes, static methods can be overridden.

B Only if the superclass method is public.

C No, static methods cannot be overridden but can be hidden.

D Only if the subclass method is also static.

Static methods belong to the class, not instances, so they cannot be overridden but can be hidden by a subclass static method.

Which access modifier is NOT allowed for an overriding method compared to the overridden method?

A Same restrictive

B More restrictive

C Less restrictive

D Public

The overriding method cannot have more restrictive access than the overridden method to maintain accessibility.

Explain method overriding and why it is useful in Java.

Think about how subclasses can change what a method does.

Describe the rules and restrictions when overriding a method in Java.

Focus on what must stay the same and what cannot be changed.

Practice

1.

What is method overriding in Java?

easy

A. When a child class provides a new version of a method from its parent class

B. When a method calls itself repeatedly

C. When two methods have the same name but different parameters

D. When a method is hidden from other classes

Solution

1. Step 1: Understand method overriding concept

   Method overriding means a child class changes the behavior of a method inherited from its parent class.

2. Step 2: Compare options with definition

   When a child class provides a new version of a method from its parent class correctly describes this. When a method calls itself repeatedly is recursion, C is method overloading, D is incorrect.

3. Final Answer:

   When a child class provides a new version of a method from its parent class -> Option A

4. Quick Check:

   Method overriding = child changes parent method [OK]

Hint: Overriding means child changes parent's method behavior [OK]

Common Mistakes:

• Confusing overriding with overloading
• Thinking overriding changes method signature
• Mixing overriding with recursion

2.

Which of the following is the correct syntax to override a method in Java?

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

easy

A. private void show() { System.out.println("Child"); }

B. @Override void show() { System.out.println("Child"); }

C. void Show() { System.out.println("Child"); }

D. void show(int x) { System.out.println("Child"); }

Solution

1. Step 1: Check method signature and annotation

   To override, method name and parameters must match exactly. Using @Override annotation helps catch mistakes.

2. Step 2: Analyze options

   private void show() { System.out.println("Child"); } uses private access modifier, narrowing from package-private (not allowed for overriding; causes hiding). void show(int x) { System.out.println("Child"); } changes parameters (overloading). void Show() { System.out.println("Child"); } has method name mismatch ('Show' vs 'show' due to case sensitivity). @Override void show() { System.out.println("Child"); } matches method signature exactly and uses @Override correctly.

3. Final Answer:

   @Override void show() { System.out.println("Child"); } -> Option B

4. Quick Check:

   @Override + same signature = correct override [OK]

Hint: Use @Override and same method signature to override [OK]

Common Mistakes:

• Narrowing access modifier (e.g., to private)
• Changing method parameters (overloading instead)
• Method name case mismatch

3.

What will be the output of the following code?

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 Test {
    public static void main(String[] args) {
        Parent obj = new Child();
        obj.greet();
    }
}

medium

A. Hello from Parent

B. Compilation error

C. Runtime error

D. Hello from Child

Solution

1. Step 1: Understand dynamic method dispatch

   When a parent reference points to a child object, overridden methods in child are called at runtime.

2. Step 2: Trace the method call

   obj is Parent type but refers to Child instance. Calling greet() runs Child's version.

3. Final Answer:

   Hello from Child -> Option D

4. Quick Check:

   Parent ref + Child object calls Child method [OK]

Hint: Parent reference calls child's overridden method at runtime [OK]

Common Mistakes:

• Expecting parent method output
• Confusing compile-time and runtime method binding
• Thinking method overloading applies here

4.

Identify the error in the following code snippet:

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

medium

A. Method name case mismatch causes no overriding

B. Missing return type in Child class method

C. Cannot override a method without parameters

D. No error, code is correct

Solution

1. Step 1: Check method names carefully

   Parent method is 'display' (lowercase d), Child method is 'Display' (uppercase D). Java is case-sensitive, so these are different methods.

2. Step 2: Understand @Override annotation effect

   @Override expects exact match. Here, it causes a compile-time error because method names differ in case.

3. Final Answer:

   Method name case mismatch causes no overriding -> Option A

4. Quick Check:

   Method names must match exactly, including case [OK]

Hint: Method names must match case exactly to override [OK]

Common Mistakes:

• Ignoring case sensitivity in method names
• Assuming @Override is optional and ignoring errors
• Confusing overriding with overloading

5.

Consider the following classes:

class Animal {
    String sound() { return "Some sound"; }
}
class Dog extends Animal {
    @Override
    String sound() { return "Bark"; }
}
class Cat extends Animal {
    @Override
    String sound() { return "Meow"; }
}
public class Test {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat(), new Animal()};
        for (Animal a : animals) {
            System.out.println(a.sound());
        }
    }
}

What is the output of this program?

hard

A. Bark
Some sound
Meow

B. Some sound
Some sound
Some sound

C. Bark
Meow
Some sound

D. Compilation error due to array of different types

Solution

1. Step 1: Understand polymorphism with overridden methods

   Each object calls its own overridden sound() method at runtime, even if referenced as Animal.

2. Step 2: Trace the loop output

   Dog's sound() returns "Bark", Cat's returns "Meow", Animal's returns "Some sound".

3. Final Answer:

   Bark Meow Some sound -> Option C

4. Quick Check:

   Array of Animals calls each overridden sound() correctly [OK]

Hint: Array of parent type calls each child's overridden method [OK]

Common Mistakes:

• Expecting all calls to use parent method
• Thinking array cannot hold different subclass objects
• Confusing overriding with overloading