What Are Annotations in Java: Simple Explanation and Example

In Java, annotations are special markers added to code elements like classes, methods, or variables to provide extra information. They do not change the program's behavior directly but help tools and the compiler understand how to handle the code.

How It Works

Think of annotations as sticky notes you put on your code to give hints or instructions without changing the code itself. For example, you might put a note on a method saying "This method should run after the program starts" or "Check this method for errors." The Java compiler and tools can read these notes and act accordingly.

Annotations are written with an @ symbol before a name, like @Override. They can be simple, just marking something, or carry extra details inside parentheses. This system helps keep code clean and organized, letting developers and tools communicate easily.

Example

This example shows how to use the @Override annotation to tell the compiler that a method is meant to replace a method from a parent class.

java

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.sound();
    }
}

Output

Dog barks

When to Use

Use annotations when you want to give extra instructions to the compiler or tools without changing your code's logic. They are helpful for:

• Checking code correctness, like @Override to avoid mistakes.
• Configuring frameworks, such as telling a web framework which methods handle web requests.
• Generating code or documentation automatically.

For example, in testing, @Test marks methods that should be run as tests. In real projects, annotations make code easier to maintain and less error-prone.

Key Points

• Annotations add metadata to code without changing its behavior.
• They start with @ and can include extra information.
• Common annotations include @Override, @Deprecated, and @SuppressWarnings.
• Annotations help tools, compilers, and frameworks understand your code better.

Key Takeaways

Annotations provide extra information to the compiler and tools without altering code behavior.

They are marked with @ and can be simple or carry additional data.

Use annotations to improve code safety, clarity, and integration with frameworks.

Common annotations include @Override for method overriding and @Test for marking test methods.