Annotations in Java: Types, Uses and Examples

Explore our Popular Software Engineering Courses

3. Marker Annotations

Marker annotations are only meant for declaration purposes. Neither does this annotation contain any members nor does any data exist within it. Its only purpose is to maintain a presence as an annotation. For example: @Override.

4. Type annotations

These annotations can be used everywhere that a type is used. For example, we can annotate a method’s return type. Type annotations are tagged with the @Target annotation. 

Code which can illustrate type annotations are:

// Importing required classes

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

// Using target annotation to annotate a type

@Target(ElementType.TYPE_USE)

// Declaring a simple type annotation

@interface TypeAnnoDemo{}

// Main class

public class GFG {

    // Main driver method

    public static void main(String[] args) {

        // Annotating the type of a string

        @TypeAnnoDemo String string = "This code is annotated with a type annotation";
        System.out.println(string);
        abc();
    }

    // Annotating return type of a function

    static @TypeAnnoDemo int abc() {
        System.out.println("This function's  return type is annotated");
        return 0;
    }

Examples of Predefined Annotations

There are many varieties of predefined annotations which we have mentioned earlier. Let us take a look:

1. @Override

This marker annotation can only be used on methods. Any method with the @override annotation must supersede another method from a superclass. Failing this, a compile-time error gets triggered. This happens since it must ensure that the superclass is actually overridden and not just overloaded.

Code which can illustrate the Override Annotation is: 

// Class 1
class Base
{
     public void Display()
     {
         System.out.println("Base display()");
     }
     public static void main(String args[])
     {
         Base t1 = new Derived();
         t1.Display();
     }    
}
// Class 2
// Extending above class
class Derived extends Base
{
     @Override
     public void Display()
     {
         System.out.println("Derived display()");
     }
}

2. @Target

It is only meant to be used as an annotation to another annotation. @Target accepts one parameter, which must be an ElementType constant. The parameter decides which declarations it can be applied to. The @Target annotation can have multiple values instead of just a singular value. However, if multiple values must be declared, then it must be in the form of braces such as: @Target({ElementType.FIELD, ElementType.LOCAL_VARIABLE}).

The @Retention annotation can be used here to determine the retention status of the annotation. Three factors affect a @Retention annotation:

• Source: The compiler disregards the annotations as they are usually kept at the source level.
• Runtime: It is retained at runtime.
• Class: The annotations remain compile-time and are disregarded by the Java program.

3. @Inherited

This annotation can only be used for declaration purposes, and hence, only affects certain class declarations. One annotation can supersede the other and inherit its properties. Thus,  the superclass can be checked if specific annotations are absent from the subclass. However, if the annotation is present, it gets the @Inherited annotation.

For example:

// Class 1
class DeprecatedTest
{
    @Deprecated
    public void Display()
    {
        System.out.println("Deprecatedtest display()");
    }
}
// Class 2
public class SuppressWarningTest
{
    // If we comment below annotation, program generates
    // warning
    @SuppressWarnings({"checked", "deprecation"})
    public static void main(String args[])
    {
        DeprecatedTest d1 = new DeprecatedTest()
        d1.Display();
    }
}

Spring Annotations in Java

Spring Annotations in Java act as metadata and offer program data. These annotations are extremely useful for delivering supplemental program information. These annotations don’t belong to the application being developed. Therefore, it does not directly influence the operation of the code and can’t modify the action of the compiled program. 

The different annotations in Spring Boot are as follows:

• @EnableAutoConfiguration: It helps in auto-configuring the bean available in the classpath. The purpose of configuring the classpath is to run different methods. The use of this annotation became limited with Spring Boot 1.2.0.
• @SpringBootApplication: It can be defined as an alternative to the @EnableAutoConfiguration. Apart from that, this annotation also combines the properties of @Configuration and @ComponentScan. 

A few core Spring Annotations in Java are as follows:

@Required: It can help with the application of the bean setter method. It symbolizes that the annotated bean needs to be populated with the required property at the time of configuration. Otherwise, an exception called the BeanInitializationException will surface. 

Examples of the @Required Annotation:

public class Machine   

{  
private Integer cost;  
@Required  
public void setCost(Integer cost)   
{  
this.cost = cost;  
}  
public Integer getCost()   
{  
return cost;  
}     
}

@Autowired: This is useful for supporting auto-wiring based on annotations in Java. It can help autowire spring beans on a constructor, instance variable, and setter methods. This annotation can lead to auto-wiring by matching the data types. 

Example of the Autowired Annotation

@Component  
public class Customer  
{  
private Person person;  
@Autowired  
public Customer(Person person)   
{   
this.person=person;  
}  
} 

Custom Annotations in Java

Java also lets you create your own annotations using the syntax:

[Access Specifier] @interface<AnnotationName> {         
  DataType <Method Name>() [default value];
}

A few crucial things to know about custom annotations in Java are as follows:

• They can be created with @interface and the annotation name coming after it.
• The annotation can include elements resembling methods but without any implementation.
• The default value of custom annotations is optional. However, the parameters are not allowed to have a null value.
• The return type can either be string, primitive, enum, array, or class name of the different types. 

Example of Custom Annotation

@interface MyCustomAnnotation {
  String value() default "default value";
}
class Main {
  @MyCustomAnnotation(value = "programiz")
  public void method1() {
    System.out.println("Test method 1");
  }
  public static void main(String[] args) throws Exception {
    Main obj = new Main();
    obj.method1();
  }
}

Output:

Test method 1

Uses of Annotations in Java

The different uses of annotations in Java are as follows:

• Compile-time instructions: They are provided by different annotations to help a software solution develop various tools. The tools are usually developed for generating code, XML files, or similar purposes. 
• Compiler instructions: These annotations are useful for providing instructions to the compiler. They can also help with identifying errors and suppressing warnings. The popular built-in annotations used for these purposes include the @Override, @Deprecated, and @SuppressWarnings. 
• Runtime Instructions: While providing instructions to a program during runtime, you can use multiple annotations in Java. But these annotations can only be accessed with the help of Java Reflection. 

Conclusion

Here, we have learned about annotations in Java. We have also learnt about the types of annotations in Java and their uses which can help Java developers create robust and scalable programs with ease. 

If you’d like to learn more about Java concepts, upGrad’s Job-linked PG Certification in Software Engineering is your best bet to gain a comprehensive understanding of programming languages like Java, HTML, JS, as well as other software development tools and libraries. 

The program is designed for final year students or unemployed graduates looking to secure entry-level positions in the field. The 5-months course covers specialisation in MERN/Cloud-Native and helps students build a top-class portfolio by exposing them to 5 hands-on projects.

So, don’t wait. Head over to upGrad and book your seat today!