@Annotations in Java:

Annotations are special labels (metadata) that can be added to code elements (classes, methods, fields, etc.) to provide additional information.
They don't directly affect the code's functionality, but they can be used by the compiler, JVM, or other tools to process the code in specific ways.

Key Characteristics:

Syntax: Start with the @ symbol, followed by the annotation name.
No Impact on Code Execution: They don't change the runtime behavior of the code.
Association with Code Elements: Can be applied to various elements like classes, methods, fields, etc.
Information for Compiler and Tools: Used by the compiler, JVM, or other tools for specific purposes.

Types of Annotations:

Built-in Annotations:
- Provided by the Java language itself.
- Common examples:
  - @Override: Indicates a method overrides a superclass method.
  - @Deprecated: Marks a method or class as deprecated.
  - @SuppressWarnings: Suppresses compiler warnings.
  - @FunctionalInterface: Indicates an interface is a functional interface.
Custom Annotations:
- Created by developers for specific purposes.
- Define their own structure and behavior.

Purposes of Annotations:

Compiler Instructions:
- Provide information for the compiler to detect errors or enforce certain rules (e.g., @Override, @Deprecated).
Code Analysis and Generation:
- Used by tools for code analysis, code generation, or other tasks (e.g., generating documentation, creating test cases).
Runtime Processing:
- Processed by the JVM or libraries at runtime to provide specific behaviors (e.g., dependency injection frameworks).

Example:

@Author(name = "John Doe", date = "2023-11-21")
public class MyClass {
    @Deprecated
    public void oldMethod() { ... }

    @Override
    public void doSomething() { ... }
}

@Override Annotations in Java

The @Override annotation in Java is used to indicate that a method in a subclass is intended to override a method defined in its superclass. This annotation helps the compiler catch errors where the method signature in the subclass does not match any method in the superclass.

What it is:

It's a built-in annotation that signals to the compiler that a method in a subclass is intended to override a method in its superclass.
It doesn't change the method's behavior, but it serves as a safety check and improves code readability.

Purpose:

Preventing Accidental Overloading:
- If you try to override a method but accidentally introduce a different signature (name, parameters, return type), the compiler will raise an error if you've used @Override. This prevents unintended method overloading instead of overriding.
Maintaining Code Clarity:
- It makes it explicit which methods are overriding inherited ones, enhancing code understanding and maintainability, especially in large codebases with complex inheritance structures.
Catching Changes in Superclasses:
- If a method signature in the superclass is modified, any subclasses using @Override will throw compilation errors, indicating necessary adjustments to maintain proper overriding. This helps prevent unexpected behavior due to mismatched signatures.

Here's a simple example:

class Animal {
    public void makeSound() {
        System.out.println("Some generic sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
}

In this example, the Dog class extends the Animal class and overrides the makeSound method. The @Override annotation is used to indicate that the makeSound method in the Dog class is intended to override the makeSound method in the Animal class.

If, for some reason, the method in the Dog class does not correctly override a method in the superclass (e.g., misspelled method name, incorrect parameters), the compiler generates an error, making it easier to catch such mistakes during development.

It's worth noting that the @Override annotation is optional. However, using it is considered good practice because it helps improve code readability and maintainability by explicitly indicating the developer's intent to override a method. Additionally, it allows the compiler to provide better error checking.

Key Points:

It's optional, but highly recommended as a best practice.
It can only be used with methods, not fields or constructors.
It's inherited, so methods in subclasses of a class using @Override also implicitly use it.
It's not limited to overriding superclass methods; it can also be used for methods implementing interface methods.

Best Practices:

Use @Override consistently for all inherited method overrides.
Consider using IDE features or code analysis tools to automatically add @Override where appropriate.

Bharat Kumar's Blog