Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

The @Override annotation is a built-in Java marker annotation applied to a method declaration to indicate that the method is intended to override or implement a method declared in a superclass or interface. It functions as a strict compiler directive, triggering compile-time signature verification against the parent type hierarchy.

​
Technical Specifications

  • Package: java.lang.Override
  • Target: @Target(ElementType.METHOD) – It can only be applied to methods. Applying it to classes, fields, or variables results in a compilation error.
  • Retention: @Retention(RetentionPolicy.SOURCE) – It is retained only in the source code and is discarded by the compiler. It is not written to the .class file and is unavailable at runtime via reflection.

​
Syntax

@Override
[access_modifier] [return_type] [method_name]([parameters]) {
    // method body
}

​
Compiler Mechanics and Verification Rules

When the Java compiler encounters the @Override annotation, it performs a strict lookup within the type hierarchy. The compilation succeeds only if all the following conditions are met:
  1. Signature Matching: The compiler searches the direct superclass and all implemented interfaces for a method with an identical name and matching parameter types. The parameter types must match exactly after type erasure.
  2. Return Type Compatibility: The return type of the annotated method must be identical to, or a subtype of (covariant return type), the return type declared in the overridden method.
  3. Access Modifiers: The annotated method cannot assign a more restrictive access modifier than the method it overrides (e.g., a protected method in the superclass cannot be overridden as private).
  4. Exception Handling: The annotated method cannot declare any new or broader checked exceptions that are not declared by the overridden method.
If the compiler fails to find a matching method in the supertype hierarchy, or if any of the overriding rules are violated, it throws a fatal compile-time error: method does not override or implement a method from a supertype.

​
Interface Implementation

Prior to Java 1.6, the @Override annotation was restricted exclusively to overriding methods from a superclass. As of Java 1.6 and later, the compiler specification was updated to allow and verify the @Override annotation on methods that implement a declared method from an interface. 
public interface Executable {
    void execute();
}

public class Task implements Executable {
    @Override
    public void execute() {
        // Compiler verifies 'execute()' exists in the Executable interface
    }
}
Master Java with Deep Grasping Methodology!Learn More