Hence, the aim of this article is to provide an overview of what Java annotations are and how they function, as well as explore the different types of annotations that can be used for improving Java code by developers.
What are the Types of Annotations Available in Java?
Simply put, an annotation is an ‘additional’ non-modifying form of meta-data that can be attached to a code in order to provide specific information regarding the code’s function and usage. There are a number of situations in which the annotation features can be useful. Annotations are used to provide explanatory comments on the code so that at compilation time or run time they can be used by compilers, IDEs (Integrated Development Environment), frameworks, and so on.
You might see annotations as tags that can be fitting on the methods, classes, fields, and parameters. These tags contain some context information about the code which might be useful during code reviews, documentation, and in some cases even in the execution of the code. Annotations indicate to the developers the measures to deploy in order to enhance their code readability, structure and comprehensibility, while also providing information to different tools on how the specific code is designed to run.
Why Use Annotations?
To start with, there are different types of annotations, and each has a unique role in Java programming. For a better understanding, some of the most common patterns involving the use of annotations are:
- Code Documentation: Annotations offer a means to document studies and substantiate the usage of different sections of the code.
- Compile-time Checking: Some annotations assist the compiler in the verification of some conditions and during the invocation of each condition, a warning will be raised and error logs written if the condition has not been satisfied.
- Code Generation: Tools can include annotations and automatically create some portions of code, thus minimizing manual labor.
- Framework Configuration: Most of the Java frameworks (for example: Spring, Hibernate, etc) are configured by the use of annotations to set up various parameters of the application such as the dependency injection, database mapping, web service mapping, etc.
Varieties of Java Annotations
The Java language is rich in terms of the types of annotations which can be divided into a wide range of groupings. Now we will highlight some of the common and important categories of annotations in the Java programming language.
1. Default Annotations
Java offers a list of default Annotations which are included in the Java Library. There are many default annotations but a few of the most commonly used are:
@Override Example
@Override
public String toString() {
return "Custom String Representation";
} - @Override: This is an annotation that notes below that a method enhances the functionality of an already created method that exists in the parent class. This will assist the compiler in detecting when a method would have been defined without being required to.
- @Deprecated: The deprecated tag is like strikethrough text, just that it serves a different purpose in Java. In this case, it marks a class, method, or field as deprecated and presumably out of the current usage.
- @SuppressWarnings: In Java programming, this is used to tell the compiler to suppress comments on the generic types. For that to happen, the annotation has to be placed just before the declaration.
2. Custom Annotations
Java provides plenty of annotations and thus, the developers are free to create their own. Custom annotations are created by making use of
@interface followed by the name of the annotation. After all their definitions are made, they can be used on a method, class, field or a parameter any which way around!3. Tag Annotations
There is another class that uses tagging - marker annotations - which consist exclusively of void methods and fields and provides no useful purposes in those two features. They are simply a flagging mechanism to depict a certain behavior or a certain feature. As an example,
@Override is one of those marker annotations which, although does not carry any additional information, simply states that a particular method is an overriding method of a superclass method.4. Runtime Annotations
Certain annotations are carried over only to the source code level, while certain others are carried over to the execution level. Runtime annotations are those that can be accessed and processed during the execution of the program. Java supports reflection which can be used to read and manipulate runtime annotations. Such annotations are included in the frameworks or the libraries that need to look at the code at runtime for these actions or configurations.
5. Meta-Annotations
In Java, meta-annotations are the annotations which are used to mark other annotations. These meta-annotations contain information about the annotation. Some of the commonly used meta-annotations are:
- @Retention: Specifies whether the annotation will be present at runtime, during compilation or only at the level of the source code.
- @Target: Defines the places where the annotation can be used (methods, fields, classes etc).
- @Inherited: It is used when an annotation is placed on a class and you want all subclasses to inherit that annotation.
- @Documented: Indicates that an annotation should be included in the JNI documentation.
How to Use Annotations
Placing annotations immediately in front of class, method or field is the most common practice. For instance, if it is desired to specify that a particular method is an implementation of a method from the parent class, then the
@Override annotation can be placed:@Override Annotation Example
@Override
public String toString() {
return "Custom String Representation";
} The moment
@Override is specified, the Java compiler will ascertain if the particular method indeed overrides a method from its superclass. Should the case be otherwise, the compiler will flag an error which helps the programmer to avoid blunders.Annotations are also used quite frequently in conjunction with custom annotation processing. This enables developers to build on their tools designed to read and process annotations to generate code or validate it. Annotations are handy for configuring frameworks like Spring or Hibernate in order to associate Java classes with tables in the databases.
Annotation Processing using Reflection
An amazing aspect of annotations is their ability to be fetched and handled even at runtime with the help of reflection. Reflection is a technique that enables Java code to see and alter the attributes of classes, methods and fields during the execution sequence. Using reflection, it’s possible to look for annotations, read their values and act accordingly.
As an illustration, a framework could use reflection to find and register all classes with a certain annotation (like ‘@Entity’ for persistence classes) to the database without the user’s help.
