Type Use Annotations

Create a new class for this lesson called TypeUseAnnotationsExample.
From the Java documentation, the TYPE_USE target type was included as a convenience for type check designers. To use the module and package annotations (if target type is module or PACKAGE), you first need a module-info.java and/or package-info.java file.
Create a new module for your project and call it TestModuleAnnotations.
In this module we are going to create 3 classes. 2 annotations and an annotations package
In this class, we are not using any annotations.

public class TestClass {
    public static void main(String[] args) {
        new TestClass().doSomething();
    }
    public void doSomething() {
        System.out.println("Do Something");
    }
}

I have not talked about the package-info file. It has other reasons for existence, but for our purposes, you should know that annotations for the runtime package are read from package-info.class. Additional information for this file can be found at:

@PackageAnnotation
package test;

import annotations.PackageAnnotation;
Create a new module called TestDeprecatedModule A module being deprecated does not cause warnings to be issued.
In the previous two lessons, I have covered some of the nuances of using

1. @Inherited,
2. @Target meta-annotations, and
3. @Deprecated.

I have also shown you that you can annotate practically anything, Including modules and packages.

In Java annotations, the TYPE_USE target type is used to indicate that an annotation can be applied to any type, including class instances, types, and values. The purpose of the TYPE_USE target type is to provide more fine-grained control over the types of elements that can be annotated. Before the introduction of the TYPE_USE target type in Java 8, annotations could only be applied to declarations such as classes, fields, and methods. The TYPE_USE target type expands the scope of annotations, allowing them to be applied to any type of element that is used in a program.
Some common uses of the TYPE_USE target type include:

1. Type Annotations: Type annotations allow annotations to be applied to the type of a variable, parameter, or return value, providing additional information about the intended use of the type. For example, an annotation could indicate that a certain parameter must not be null.
2. Generics: Annotations can be used to apply constraints to generic types, ensuring that the types used in a program meet certain criteria. For example, an annotation could specify that a generic type must be serializable.
3. Constrained Types: Annotations can be used to enforce constraints on types that are used in a program, ensuring that they are used correctly. For example, an annotation could indicate that a certain type should only be used for specific purposes, such as encryption or authentication.

The TYPE_USE target type provides greater flexibility and control over the use of annotations in Java programs, allowing developers to apply annotations to a wider range of types and elements. This can help improve the quality and safety of Java programs by providing additional information and constraints on the types used in the program.