Quels types peuvent être utilisés pour les membres d'annotation Java ?

Question

Aujourd'hui, je voulais créer ma première interface d'annotation suivante cette documentation et j'ai obtenu cette erreur de compilation

Invalid type for annotation member":
public @interface MyAnnotation {
    Object myParameter;
    ^^^^^^
}

Évidemment Object ne peut pas être utilisé comme type d'un membre d'annotation. Malheureusement, je n'ai pas pu trouver d'informations sur les types qui peuvent être utilisés en général.

Je l'ai découvert par essais et erreurs :

• String Valable
• int Valable
• Integer Invalide (de manière surprenante)
• String[] Valable (de manière surprenante)
• Object Invalide

Peut-être quelqu'un peut-il nous éclairer sur les types de produits qui sont effectivement autorisés et pourquoi.

Answer 1

Il est spécifié par section 9.6.1 de la JLS . Les types de membres de l'annotation doivent être l'un des suivants :

• primitivo
• Chaîne de caractères
• un Enum
• une autre annotation
• Classe
• un tableau de l'un des éléments ci-dessus

Cela semble restrictif, mais il y a sans doute des raisons à cela.

Notez également que les tableaux multidimensionnels (par ex. String[][] ) sont implicitement interdits par la règle ci-dessus.

Les tableaux de classes ne sont pas autorisés, comme décrit dans le document suivant cette réponse .

Answer 2

Je suis d'accord avec Skaffman pour les types disponibles.

Restriction supplémentaire : il doit s'agir d'une constante de temps de compilation. .

Par exemple, les éléments suivants sont interdits :

@MyAnnot("a" + myConstantStringMethod())
@MyAnnot(1 + myConstantIntMethod())

Answer 3

N'oubliez pas non plus que les annotations elles-mêmes peuvent faire partie d'une définition d'annotation . Cela permet une imbrication simple des annotations - pratique dans les cas où vous souhaitez qu'une annotation soit présente plusieurs fois.

Par exemple :

@ComplexAnnotation({
    @SimpleAnnotation(a="...", b=3),
    @SimpleAnnotation(a="...", b=3),
    @SimpleAnnotation(a="...", b=3)
})
public Object foo() {...}

donde SimpleAnnotation es

@Target(ElementType.METHOD)
public @interface SimpleAnnotation {
    public String a();
    public int b();
)

y ComplexAnnotation est

@Target(ElementType.METHOD)
public @interface ComplexAnnotation {
    public SimpleAnnotation[] value() default {};
)

Exemples tirés de : http://web.archive.org/web/20131216093805/https://blogs.oracle.com/toddfast/entry/creating_nested_complex_java_annotations

_(URL original : https://blogs.oracle.com/toddfast/entry/creating_nested_complex_java_annotations )_

Answer 4

Le concept des annotations s'adapte très bien à la conception de mon projet, jusqu'à ce que je réalise qu'il n'est pas possible d'avoir des types de données complexes dans l'annotation. J'ai contourné ce problème en utilisant la classe de ce que je voulais instancier plutôt qu'un objet instancié de cette classe. Ce n'est pas parfait, mais Java l'est rarement.

@interface Decorated { Class<? extends PropertyDecorator> decorator() }

interface PropertyDecorator { String decorate(String value) }

class TitleCaseDecorator implements PropertyDecorator {
    String decorate(String value)
}

class Person {
    @Decorated(decorator = TitleCaseDecorator.class)
    String name
}

Answer 5

Selon Oracle, les types valides pour les éléments d'annotation sont les suivants :

1. Primitives (byte, char, int, long float, double)
2. Enums
3. Class (Think generics here Class <?>, Class<? extends/super T>>)
4. String
5. Array of the above (array[] of primitives, enums, String, or Class)
5. Another annotation.

Un plus à noter, tous les éléments sont par nature considérés comme publics et abstraits.

Par conséquent,

 static final variable(s) allowed as well.