Multiple Choice Questions on Method Overriding and the @Override Annotation in Java

📖 Quick Study Guide

• ✨ Method Overriding: A powerful OOP feature allowing a subclass to provide a specific implementation for a method already defined in its superclass. It's all about polymorphism!
• 📜 Key Rules for Overriding:
  • 📝 The method signature (name, parameter list) must be the same as in the superclass method. The return type can be the same or a covariant return type (a subtype).
  • 🛡️ The access modifier of the overriding method can be the same or more permissive (e.g., `protected` to `public`), but never more restrictive.
  • 🚫 The overriding method cannot throw new checked exceptions that are broader than those declared in the overridden method.
  • 🧊 `static` methods cannot be overridden (they are hidden).
  • 🔒 `final` methods cannot be overridden.
  • 👻 `private` methods cannot be overridden (as they are not inherited by subclasses for overriding purposes).
  • ⚙️ Constructors cannot be overridden.
• 🏷️ `@Override` Annotation: A marker annotation in Java that explicitly indicates that a method is intended to override a method in a superclass or implement an interface method.
• 🎯 Purpose of `@Override` Annotation:
  • ✔️ Compiler Check: It's a safety net! The compiler verifies that the annotated method truly overrides an existing method. If not, it throws a compile-time error, catching potential typos or signature mismatches early.
  • 👀 Improved Readability: Clearly communicates the programmer's intent to other developers (and your future self!) that this method is providing a specific implementation for an inherited method.
  • 🛠️ Easier Maintenance: If the superclass method's signature changes, the `@Override` annotation in the subclass will immediately flag a compile-time error, helping you maintain consistency.

🧠 Practice Quiz

Test your understanding of method overriding and the @Override annotation!

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

1. A static method can be overridden by a non-static method.
2. The return type of the overriding method must be identical to the overridden method's return type, with no exceptions for covariant types.
3. The access modifier of the overriding method can be more restrictive than the overridden method.
4. Method overriding allows a subclass to provide a specific implementation for a method already defined in its superclass.

2. What is the primary purpose of the @Override annotation in Java?

1. To enforce that a method must be implemented by subclasses.
2. To improve runtime performance of overridden methods.
3. To inform the compiler that the annotated method is intended to override a method in a superclass or implement an interface method.
4. To make a method accessible from any class.

3. Consider the following Java code. Which of the `Child` class implementations correctly demonstrates method overriding of a method from `Parent`?

// Parent class
class Parent {
    void methodA() {}
    static void methodB() {}
    protected void methodC() {}
    final void methodD() {}
}

1. class Child extends Parent {
       static void methodB() {}
   }

2. class Child extends Parent {
       public void methodA(int x) {}
   }

3. class Child extends Parent {
       public void methodC() {}
   }

4. class Child extends Parent {
       void methodD() {}
   }

4. If a method in a superclass is declared private, can it be overridden in a subclass?

1. Yes, but only if the subclass method is also private.
2. Yes, if the subclass method has a more permissive access modifier.
3. No, because private methods are not inherited by subclasses for overriding purposes.
4. Only if the @Override annotation is used.

5. Which of the following is NOT a valid rule for method overriding?

1. The overriding method's argument list must be the same as the overridden method.
2. The overriding method's return type must be a subtype (covariant return type) or the same type as the overridden method's return type.
3. The overriding method can throw new checked exceptions that are not declared in the overridden method.
4. The access modifier of the overriding method cannot be more restrictive than the overridden method.

6. What happens if you use the @Override annotation on a method that does not actually override any method from its superclass or implemented interface?

1. The program will compile but throw a RuntimeException at runtime.
2. The compiler will issue a warning but allow compilation.
3. The compiler will produce a compile-time error.
4. The method will be treated as a new method specific to the subclass.

7. Which of the following is true regarding the @Override annotation?

1. It is mandatory for all overridden methods to compile successfully.
2. It ensures that the method signature is different from the superclass method, thus preventing accidental overriding.
3. It helps the compiler detect if the method is not actually overriding a superclass method, preventing subtle bugs.
4. It automatically converts a method into a static method for better performance.