Imagine being able to add metadata to your code that informs the compiler or frameworks how to behave—without affecting business logic. That's the power of annotations in Java. They provide a clean and declarative way to inject behaviors or configurations.
Whether you're suppressing warnings, marking methods for override, or configuring frameworks like Spring, annotations act as powerful tools for modern development.
Annotations in Java are metadata that provide information to the compiler, runtime, or development tools. They do not directly influence program logic but can be used by frameworks or compilers to generate code, enforce rules, or apply configurations.
@ symbol.Annotations are heavily used in frameworks like Spring, JUnit, and Hibernate to reduce boilerplate and configure behaviors declaratively.
class Parent {
void display() {
System.out.println("Parent display");
}
}
class Child extends Parent {
@Override
void display() {
System.out.println("Child display");
}
}
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MyAnnotation {
String value();
}
public class Demo {
@MyAnnotation(value = "Custom Message")
public void show() {
System.out.println("Annotated method");
}
}
Used in frameworks like Spring for dependency injection, transaction management, and more.
JUnit uses annotations like @Test and @BeforeEach to define test cases and setup methods.
Security configurations in frameworks often use annotations to declare access control and roles.
Annotations are metadata in Java used to provide additional information to the compiler or runtime about the code. They do not alter the program logic directly.
@Override indicates that a method is overriding a superclass method. @Deprecated marks the method as outdated and discourages its usage.
You define it using @interface, and specify @Target and @Retention policies to control where and how it can be used.