AnnotationTypeMismatchException in Java

java.lang.annotation.AnnotationTypeMismatchException

Thrown to indicate that a program has attempted to access an element of an annotation whose type has changed after the annotation was compiled. This exception can be thrown by the API used to read annotations reflectively.

Declaration

public class AnnotationTypeMismatchException 
                              extends RuntimeException {
    @java.io.Serial
    private static final long serialVersionUID = 
                                        8125925355765570191L;

    private final transient Method element;

    private final String foundType;

    public AnnotationTypeMismatchException(Method element, 
                                   String foundType) {
        super("Incorrectly typed data found for annotation 
       element " + element + " (Found data of type " + foundType
                + ")");
        this.element = element;
        this.foundType = foundType;
    }

    public Method element() {
        return this.element;
    }

    public String foundType() {
        return this.foundType;
    }
}

Methods

1. AnnotationTypeMismatchException(Method element, String foundType)

java.lang.annotation.AnnotationTypeMismatchException.AnnotationTypeMismatchException(Method element, String foundType)

This method takes two arguments. This method constructs an AnnotationTypeMismatchException for the specified annotation type element and found data type.

Parameters: Two parameters are required for this method.

element: the Method object for the annotation element, may be null.

foundType: the type of data found in the annotation. This string may, but is not required to, contain the value as well. The exact format of the string is unspecified and may be null.

Exceptions: NA

Approach

Java

package com.AnnotationTypeMismatchException;

import java.lang.annotation.AnnotationTypeMismatchException;

public class AnnotationTypeMismatchException1 {
    public static void main(String[] args) {

        AnnotationTypeMismatchException exception = 
       new AnnotationTypeMismatchException(null, "hello");

        System.out.println(exception);
    }
}

Output:

java.lang.annotation.AnnotationTypeMismatchException: Incorrectly typed data found for annotation element null (Found data of type hello)

2. element()

Method java.lang.annotation.AnnotationTypeMismatchException.element()

This method returns the Method object for the incorrectly typed element. The value may be unavailable if this exception has been serialized and then read back in.

Parameters: NA

Returns: the Method object for the incorrectly typed element, or null if unavailable.

Exceptions: NA

Approach

Java

package com.AnnotationTypeMismatchException;

import java.lang.annotation.AnnotationTypeMismatchException;

public class AnnotationTypeMismatchExceptionelement {
    public static void main(String[] args) {

        AnnotationTypeMismatchException exception = 
            new AnnotationTypeMismatchException(null, "hello");

        System.out.println(exception.element());
    }
}

Output:

null

3. foundType()

String java.lang.annotation.AnnotationTypeMismatchException.foundType()

This method returns the type of data found in the incorrectly typed element. The returned string may, but is not required to, contain the value as well. The exact format of the string is unspecified and the string may be null.

Parameters: NA

Returns: the type of data found in the incorrectly typed element.

Exceptions: NA

Approach

Java

package com.AnnotationTypeMismatchException;

import java.lang.annotation.AnnotationTypeMismatchException;

public class AnnotationTypeMismatchExceptionfoundType {
    public static void main(String[] args) {

        AnnotationTypeMismatchException exception = 
          new AnnotationTypeMismatchException(null, "hello");

        System.out.println(exception.foundType());
    }
}

Output:

hello

Some other classes/interfaces of java.lang.annotation

Native: Indicates that a field defining a constant value may be referenced from native code.

Inherited: Indicates that an annotation type is automatically inherited.

IncompleteAnnotationException: Thrown to indicate that a program has attempted to access an element of an annotation type that was added to the annotation type definition after the annotation was compiled (or serialized). 

AnnotationFormatError: Thrown when the annotation parser attempts to read an annotation from a class file and determines that the annotation is malformed.

ElementType: The constants of this enumerated type provide a simple classification of the syntactic locations where annotations may appear in a Java program.

Documented: If the annotation @Documented is present on the declaration of an annotation type A, then any @A annotation on an element is considered part of the element's public contract.

AnnotationTypeMismatchException: Thrown to indicate that a program has attempted to access an element of an annotation whose type has changed after the annotation was compiled.

Annotation: The common interface is extended by all annotation types.

Repeatable: The annotation type is java.lang.annotation.Repeatable is used to indicate that the annotation type whose declaration it(meta-)annotates is repeatable.

Retention: Indicates how long annotations with the annotated type are to be retained. If no Retention annotation is present on an annotation-type declaration, the retention policy defaults to RetentionPolicy.CLASS.

RetentionPolicy: Annotation retention policy. The constants of this enumerated type describe the various policies for retaining annotations.

Target: Indicates the contexts in which an annotation type is applicable.