Introduction to Java Annotations
Annotations were introduced or became available in the 1.5 version of the Java Development Kit (JDK). Annotations in Java provide more information about the data present in the code structure, i.e., it is data about data, also known as metadata.
What are Annotations in Java?
Annotations help in defining metadata in code in a standardized manner. Also, annotations help in providing instructions to your java compiler to follow while compiling that java code.
When using the annotations, we use the ‘@’ sign and then followed by the name of your annotation so that the compiler treats it as an annotation.
It is important to note that the annotations can be added before:
- A class declaration
- A member variable declaration
- A constructor declaration
- A method declaration
- A parameter declaration
- A local variable declaration.
Important points to remember are that all annotations extend java.lang.annotation.Annotation interface. Also, annotations cannot include any extended clause.
Built-in Java Annotations
In Java, there are in-built annotations such as @Override, @Deprecated, @SuppressWarnings that are designed for a specific purpose and used in one of the above situations(s), for example, only for the class or only for method, etc.
Example #1 – Override
Code:
class Dad {
public void say() {
System.out.println("Do your homework");
}
}
public class Child extends Dad {
@Override
public void say(){
System.out.println("I wanna play");
}
public static void main(String args[]){
Dad daddy = new Child();
daddy.say();
}
}Output:
Example #2 – Deprecated
Code:
public class Outdated
{
@Deprecated
public void oldShow()
{
System.out.println("This Method is deprecated"); }
public static void main(String args[])
{
Outdated od = new Outdated ();
od.oldShow();
}
}Output:
Meta Annotations
There are five types of meta-annotations:
- Documented – It informs that the member, variable, or class that uses this annotation needs to be documented by Javadoc or any other similar tools available.
- Target – It is used to specify at which type the annotation is used. It is mostly used along with your custom annotations.
- Inherited – It marks the annotation to be inherited to the subclass.
- Retention – It indicates how long annotations with the annotated type are to be retained. It takes the Retention Policy argument whose Possible values are: SOURCE, CLASS, and RUNTIME.
- Repeatable – This informs that the annotation types whose declaration it annotates are repeatable.
Example – Documentation and Retention
Code:
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@interface RSample {
String rentent();
}
@Documented
@interface DSample {
String doc();
}
public class MetaAnnotate {
public static void main(String arg[])
{
new MetaAnnotate().rentent();
new MetaAnnotate().doc();
}
@RSample (rentent="Meta Info R")
public void rentent() {
System.out.println("Retention Policy Applied");
}
@DSample(doc="Meta Info D")
public void doc() {
System.out.println("Code Documented with the value");
}
}Output:
Explanation:
- RetentionPolicy.RUNTIME – This value specifies that the annotation value should be available at runtime for inspection via java reflection.
- Run the Javadoc command to view the documentation of your code.
Types of Annotations
There are three categories of annotations, and there are as follows:
1. Marker Annotations – These types of annotations are used as a declaration to notify the developer what the below function or class is all about, i.e., it shares extra information about the function or class like whether the function is overriding another function or is the function deprecated, etc. @Override, @Deprecated are considered as marker annotations.
Example: DemoAnnotation()
2. Single Value Annotations – This kind of annotation takes in value to specify that value for that member for which the annotation is placed in front of and hence, don’t need to specify the name of that member.
Example: DemoAnnotation(“custId123”)
3. Full Annotations – This kind of annotation takes in multiple values, pairs, members.
Example: DemoAnnotation(category=”Toys”, value=1500)
Custom
Custom annotations are created by the user interface, followed by an annotation name, as we will see in the below example.
File 1: Custom Annotation Defined
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Magicians
{
String Wizard() default "Reynolds";
String House() default "Green";
}
@Magicians
public class Magician
{
@Magicians(Wizard = "Harry Potter", House = "Red")
public String getString() { return null; }
}File 2: Main Class that calls the Custom Annotation Class
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;
public class MyCustomAnnotation
{
public static void main(String[] args) throws NoSuchMethodException, SecurityException
{
new Magician();
Class<Magician> magic = Magician.class;
readAnnotationOn(magic);
Method method = magic.getMethod("getString", new Class[]{});
readAnnotationOn(method);
}
static void readAnnotationOn(AnnotatedElement element)
{
try
{
System.out.println("\n Find annotations on " + element.getClass().getName());
Annotation[] annotations = element.getAnnotations();
for (Annotation annotation : annotations)
{
if (annotation instanceof Magicians)
{
Magicians mData = (Magicians) annotation;
System.out.println("Wizard Name :" + mData.Wizard());
System.out.println("Wizard House Color :" + mData.House());
}
}
} catch (Exception e)
{
e.printStackTrace();
}
}
}Output:
Conclusion
In this article, we saw about what are java annotations and their types with examples, we saw examples of built-in annotations provided by java and coded our custom annotations. We saw annotations that are useful in standardizing the code and also help in better understanding the code and its structure.
Recommended Articles
This is a guide to Java Annotations. Here we discuss the basic concept, how to Built-in java annotations with the given examples and outputs. You may also have a look at the following articles to learn more –
