The Project | About Us | Contribute | Donations | License

HOME

Annotations in Java provide a powerful way to add metadata to your code. They can be used to give information to the compiler, generate code, or even influence the runtime behavior of your application. This topic will cover the basics of annotations, how to create custom annotations, and how to use built-in annotations effectively.

What are Annotations?

Annotations are a form of metadata that can be added to Java code elements such as classes, methods, variables, parameters, and packages. They do not directly affect the execution of the code but can be used by the compiler and runtime to perform various tasks.

Key Concepts

Metadata: Information about the code that is not part of the code itself.
Retention Policy: Determines at what point annotation information is available (source, class, or runtime).
Target: Specifies the kinds of program elements to which an annotation type is applicable.

Built-in Annotations

Java provides several built-in annotations that are commonly used:

@Override

Indicates that a method is intended to override a method in a superclass.

class Parent {
    void display() {
        System.out.println("Parent display");
    }
}

class Child extends Parent {
    @Override
    void display() {
        System.out.println("Child display");
    }
}

@Deprecated

Marks a method, class, or field as deprecated, indicating that it should no longer be used.

class Example {
    @Deprecated
    void oldMethod() {
        System.out.println("This method is deprecated");
    }
}

@SuppressWarnings

Instructs the compiler to suppress specific warnings.

class Example {
    @SuppressWarnings("unchecked")
    void method() {
        List rawList = new ArrayList();
        rawList.add("String");
    }
}

Custom Annotations

You can create your own annotations to add custom metadata to your code.

Defining a Custom Annotation

To define a custom annotation, use the @interface keyword.

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MyCustomAnnotation {
    String value();
    int number() default 0;
}

Using a Custom Annotation

Once defined, you can use your custom annotation in your code.

class Example {
    @MyCustomAnnotation(value = "Test", number = 5)
    void annotatedMethod() {
        System.out.println("This method is annotated");
    }
}

Accessing Annotations at Runtime

You can use reflection to access annotations at runtime.

import java.lang.reflect.Method;

class Example {
    @MyCustomAnnotation(value = "Test", number = 5)
    void annotatedMethod() {
        System.out.println("This method is annotated");
    }

    public static void main(String[] args) throws Exception {
        Method method = Example.class.getMethod("annotatedMethod");
        MyCustomAnnotation annotation = method.getAnnotation(MyCustomAnnotation.class);
        System.out.println("Value: " + annotation.value());
        System.out.println("Number: " + annotation.number());
    }
}

Practical Exercises

Exercise 1: Create and Use a Custom Annotation

Define a custom annotation @Info with two elements: author and date.
Annotate a class with the @Info annotation.
Use reflection to print the values of the @Info annotation at runtime.

Solution

import java.lang.annotation.*;
import java.lang.reflect.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Info {
    String author();
    String date();
}

@Info(author = "John Doe", date = "2023-10-01")
class AnnotatedClass {
    // Class content
}

public class Main {
    public static void main(String[] args) throws Exception {
        Class<AnnotatedClass> obj = AnnotatedClass.class;
        Info info = obj.getAnnotation(Info.class);
        System.out.println("Author: " + info.author());
        System.out.println("Date: " + info.date());
    }
}

Exercise 2: Use Built-in Annotations

Create a class with a method that overrides a method from a superclass.
Mark a method as deprecated.
Suppress a warning in a method.

Solution

class SuperClass {
    void display() {
        System.out.println("SuperClass display");
    }
}

class SubClass extends SuperClass {
    @Override
    void display() {
        System.out.println("SubClass display");
    }

    @Deprecated
    void oldMethod() {
        System.out.println("This method is deprecated");
    }

    @SuppressWarnings("unchecked")
    void suppressWarningMethod() {
        List rawList = new ArrayList();
        rawList.add("String");
    }
}

Summary

In this section, we covered the basics of annotations in Java, including built-in annotations like @Override, @Deprecated, and @SuppressWarnings. We also learned how to create and use custom annotations, and how to access annotation information at runtime using reflection. Annotations are a powerful tool for adding metadata to your code, and understanding how to use them effectively can greatly enhance your Java programming skills.

Annotations

What are Annotations?

Key Concepts

Built-in Annotations

@Override

@Deprecated

@SuppressWarnings

Custom Annotations

Defining a Custom Annotation

Using a Custom Annotation

Accessing Annotations at Runtime

Practical Exercises

Exercise 1: Create and Use a Custom Annotation

Solution

Exercise 2: Use Built-in Annotations

Solution

Summary

Java Programming Course

Module 1: Introduction to Java

Module 2: Control Flow

Module 3: Object-Oriented Programming

Module 4: Advanced Object-Oriented Programming

Module 5: Data Structures and Collections

Module 6: Exception Handling

Module 7: File I/O

Module 8: Multithreading and Concurrency

Module 9: Networking

Module 10: Advanced Topics

Module 11: Java Frameworks and Libraries

Module 12: Building Real-World Applications