How Custom Annotaion In Java Works

Introduction

In this article we discuss custom annotation in Java.

What is Custom Annotation

Custom Annotation creation is similar to writing an interface, but it differs in the implementation since it uses a prefix, the "@" symbol. We can declare methods in annotations. We can create the user-defined annotation also. The @interface elements is used to declare an annotation.

Example

@interface OurAnnotation{}

Some points to remember

Programmers must remember some points about annotations; they are:

1. Methods don't contain parameters.
2. Methods don't contain any throws clauses.
3. Methods must return one of the following: primitive data types, a Class, String, enum or array.
4. We should prefix @ just before the interface keyword to define an annotation.
5. It may assign a default value to the method.

Types of Annotations

There are basically three types of annotations, they are:

1. Single-Value
2. Multi-Value
3. Marker Annotation

1. Marker Annotation

When no methods are used in an annotation, it is called a marker annotation. For example:

@interface OurAnnotation{}

2. Single-Value Annotation

As the name indicates, it contains only one method. For example:

@interface OurAnnotation
{
int val() default();
}

We can provide the default value also. For example:

@interface OurAnnotation
{
int val() default 0;
}

How to apply a Single-Value Annotation

Let's see the following code to apply the single value annotation.

@OurAnnotation (val=20)

The value can be anything.

3. Multi-Value Annotation

According its name, the annotation that has more than one method, is called Multi-Value annotation. For example:

@interface OurAnnotation
{
int val1();
String val2();
String val3();
}
}

We can provide the default value also. For example:

@interface OurAnnotation
{
int val1() default 1;
String val2() default "";
String val3() default "abc";
}

How to apply Multi-Value Annotation

Let's see the following code to apply a multi-value annotation.

@OurAnnotation (val1=20, val2="Jaun Pol", val3="Noida")

Built-In-Annotation

Built-In-Annotations applied to other annotations (Custom annotations) are:

• @Inherited
• @Documented
• @Target
• @retention

@Target

This tag specifies which type is to be used.

The "java.lang.annotation.ElementType" enum declares many constants to specify the type of element for annotation, such as TYPE, METHOD, FIELD, etcetera. Let's see the constants of the ElementType enum.

Element Types	Where the annotation can be applied
TYPE	class, interface or enumeration
FIELD	fields
METHOD	methods
CONSTRUCTOR	constructors
LOCAL_VARIABLE	local variables
ANNOTATION_TYPE	annotation type
PARAMETER	parameter

Example

In this example, we specify annotation for a class:

@Target (ElementType. TYPE)
@interface OurAnnotation
{
int val1();
String val2();
}

Example

In this example, we specify an annotation for methods, fields or classes.

@Target ({ElementType.METHOD, ElementType.TYPE, ElementType.FIELD})
@interface OurAnnotation
{
int val1();
String val2();
}

@Ratention

This annotation is used to specify what level of annotation will be available.

RetentionPolicy	Availabilty
RetentionPolicy.SOURCE	refres to the source code, discarded during compilation. It will not be available in the compiled class.
RetentionPolicy.CLASS	refers to the .classfile, available to the Java compiler but not to JVM. It is included in the class file
RetentionPolicy.RUNTIME	refers to the runtime, available to the Java compiler and JVM.

Example

This example shows how to specify RetentionPolicy:

@Retention (RetentionPolicy.RUNTIME)
@Target (ElementType.TYPE)
@interface OurAnnotation
{
int val1();
String val2()
}

Example

In this example, we use a custom annotation; creating, applying and accessing an annotation:

//Creating annotation

import java.lang.reflect.*;

import java.lang.annotation.*;

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

@interface OurAnnotation

  {

    int val();

  }

//Creating annotation

class Parent

  {

    @OurAnnotation(val=20)

    public void sayParent()

      {

        System.out.println("Parent annotation");

      }

  }

//Accessing annotation

class CustomAnnEx

  {

    public static void main(String args[])throws Exception

      {

        Parent p=new Parent();

        Method m=p.getClass().getMethod("sayParent");

        OurAnnotation oanno=m.getAnnotation(OurAnnotation.class);

        System.out.println("value passed is: "+oanno.val());

      }
  }

Output