Annotations

A school program needs reliable data and clear rules. An annotation attaches structured information to a declaration. Tools or runtime code may use it, depending on its retention and the code that reads it.

Java Annotations are one of those features that quietly power many of Java’s most powerful frameworks—like Spring, Hibernate, and JUnit—yet they often get misunderstood or overlooked by beginners. In this tutorial, we’ll explore what annotations are, why they exist, and how to use them effectively in your programs.

Annotations in Java are a special kind of metadata that provide information about the code but do not directly affect its execution. They act like notes to the compiler or runtime, guiding them on how to treat the annotated elements (classes, methods, variables, etc.).

Before annotations, developers relied heavily on XML configuration files or marker interfaces. Annotations offer:

• Better readability and less clutter
• Compile-time error checking
• Cleaner and more maintainable code
• Support for tools and frameworks that process metadata

Java provides several built-in annotations, especially useful for compile-time checks.

@Override

Indicates that a method is intended to override a method in a superclass.

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

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

Dog barks

@Deprecated

Marks a method or class as outdated, warning developers to avoid using it.

class LegacyCode {
    @Deprecated
    void oldMethod() {
        System.out.println("Old method, avoid using.");
    }
}

@SuppressWarnings

Instructs the compiler to suppress specific warnings.

@SuppressWarnings("unchecked")
List list = new ArrayList();

Java also provides meta-annotations that annotate other annotations:

• @Target – Specifies the kinds of elements an annotation can be applied to.
• @Retention – Indicates how long annotations are retained (SOURCE, CLASS, or RUNTIME).
• @Documented – Marks an annotation for inclusion in the generated JavaDoc.
• @Inherited – Allows subclasses to inherit the annotation from a superclass.

Let’s see how you can define your own annotation:

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface LogExecutionTime {
}

Now, apply this annotation to a method:

class Demo {
    @LogExecutionTime
    void run() {
        System.out.println("Running method...");
    }
}

Using Java Reflection API, we can process annotations at runtime.

import java.lang.reflect.Method;

class AnnotationProcessor {
    public static void main(String[] args) throws Exception {
        Demo d = new Demo();
        Method m = d.getClass().getMethod("run");

        if (m.isAnnotationPresent(LogExecutionTime.class)) {
            long start = System.currentTimeMillis();
            m.invoke(d);
            long end = System.currentTimeMillis();
            System.out.println("Execution time: " + (end - start) + "ms");
        }
    }
}

Running method...
Execution time: Xms

Annotations are not just academic—they are used widely in:

• Spring Framework – @Autowired, @Component, @Service
• Hibernate – @Entity, @Table, @Id
• JUnit – @Test, @Before, @After

• Annotations are a way to add metadata to Java code.
• They improve readability and tool support.
• You can create your own annotations and use reflection to act on them.

An annotation does not execute an action by itself. Override asks the compiler to check an overriding relationship.

Before running this Java program, write down each line you expect to see. Identify the value, branch, object or exception responsible for each line. Then explain whether the following assumption is valid: An annotation does not execute an action by itself.

Java 17 · Main.java · complete practice program

public class Main  {
  static abstract class Person  {
    abstract String role();
  }
  static class Teacher extends Person  {
    @Override String role()  {
      return "Teacher";
    }
  }
  public static void main(String[] args)  {
    System.out.println(new Teacher().role());
  }
}

Java 17 · Main.java · source repeated for this answer

public class Main  {
  static abstract class Person  {
    abstract String role();
  }
  static class Teacher extends Person  {
    @Override String role()  {
      return "Teacher";
    }
  }
  public static void main(String[] args)  {
    System.out.println(new Teacher().role());
  }
}

Expected output

Teacher

An annotation attaches structured information to a declaration. Tools or runtime code may use it, depending on its retention and the code that reads it.

An annotation does not execute an action by itself. Override asks the compiler to check an overriding relationship.

Run with javac Main.java, then java Main. The declaration inside Main keeps the helper type available to this standalone example.

An annotation attaches structured information to a declaration. Tools or runtime code may use it, depending on its retention and the code that reads it. An annotation does not execute an action by itself. Override asks the compiler to check an overriding relationship.

Related explanations: Java Variables, Java If Statement - Syntax and Examples, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide and Java 17 language specification.