IAnnotatedElement Interface

Définition

[Android.Runtime.Register("java/lang/reflect/AnnotatedElement", "", "Java.Lang.Reflect.IAnnotatedElementInvoker")]
public interface IAnnotatedElement : Android.Runtime.IJavaObject, IDisposable, Java.Interop.IJavaPeerable

[<Android.Runtime.Register("java/lang/reflect/AnnotatedElement", "", "Java.Lang.Reflect.IAnnotatedElementInvoker")>]
type IAnnotatedElement = interface
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Dérivé

Java.Lang.Class

Java.Lang.Package

Java.Lang.Reflect.AccessibleObject

Java.Lang.Reflect.Constructor

Java.Lang.Reflect.Executable

Plus…

Attributs

RegisterAttribute

Implémente

IJavaObject IJavaPeerable IDisposable

Remarques

Représente un élément annoté du programme en cours d’exécution dans cette machine virtuelle. Cette interface permet de lire les annotations de manière réfléchie. Toutes les annotations retournées par les méthodes de cette interface sont immuables et sérialisables. Les tableaux retournés par les méthodes de cette interface peuvent être modifiés par les appelants sans affecter les tableaux retournés à d’autres appelants.

Remarque Android : méthodes qui retournent plusieurs annotations de différents types tels que #getAnnotations() et #getDeclaredAnnotations() peuvent être affectées par l’ordre explicite du code caractère des types d’annotations spécifiés par le format DEX. Les annotations de différents types sur un seul élément ne sont pas garanties d’être retournées dans l’ordre dans lequel elles sont déclarées dans la source.

Les #getAnnotationsByType(Class) méthodes et #getDeclaredAnnotationsByType(Class) les méthodes prennent en charge plusieurs annotations du même type sur un élément. Si l’argument de l’une ou l’autre méthode est un type d’annotation reproductible (JLS 9.6), la méthode « examine » une annotation conteneur (JLS 9.7), le cas échéant, et retourne toutes les annotations à l’intérieur du conteneur. Les annotations de conteneur peuvent être générées au moment de la compilation pour encapsuler plusieurs annotations du type d’argument.

Les termes <em>directement présent</em>, <em>indirectement présent</em>, <em>present</em, et >em<associé>/em<> sont utilisés tout au long de cette interface pour décrire précisément quelles annotations sont retournées par des méthodes :

<ul>

<li> Une annotation A est <em>directement présente</em> sur un élément E si E est annoté par A dans la source d’origine.

<Li>An annotation A is <em>indirect present</em> on an element E if E is annotated by a container annotation of A.

<li>Une annotation A est présente sur un élément E si l’un des éléments suivants :

<ul>

<li>A est directement présent sur E ; ou

<Li>No annotation of A 's type is direct present on E, and E is a class, and A 's type is inheritable, and A is present on the superclass of E.

</ul>

<li>Une annotation A est <>associée/em< à> un élément E si :

<ul>

<li>A est directement ou indirectement présent sur E ; ou

<Li>Aucune annotation du type A n’est directement ou indirectement présente sur E, et E est une classe, et le type d’A est hérité, et A est associé à la superclasse de E.

</ul>

</ul>

Le tableau ci-dessous récapitule le type de présence d’annotations différentes méthodes dans cette interface.

<table class="plain">caption Overview of kind of presence détectée par différentes méthodes< AnnotatedElement/caption><thead><tr>th colspan=2 scope="col"<method></><th th colspan=4 scope="col">Kind of Presence</th><>tr th scope="col"<Return Type></th th><scope="col">Signature</th th><scope="col">Direct Present/th th scope="col"Direct Present</th><th scope="col »><>Indirect Present</th><scope="col">Present</th th><scope="col">Associated</th></thead><tbody><tr><td style="text-align :right"/td>Tth scope="row » style="font-weight :normal ; text-align :left"<><td>#getAnnotation(Class) getAnnotation(Class<T>)/td<td>< style="text-align :center><"><><>X/td td td/td td-td"X</td><td td></td/td/tr><><>< style= » text-align :right">Annotation[]</td><th scope="row » style="font-weight :normal ; text-align :left">#getAnnotations getAnnotations()<td><></td><td>< td style="text-align :center">X</td><td/><td/td></tr><><td style="text-align :right">T[]</td><th scope="row » style="font-weight :normal ; text-align :left">#getAnnotationsByType(Class) getAnnotationsByType(Class<T>)<td></td/td><><><>< td/><td td style= » text-align :center">X</td></tr tr><><td style="text-align :right">T</td><th scope="row » style="font-weight :normal ; text-align :left">#getDeclaredAnnotation(Class) getDeclaredAnnotation(Class<T>)<td style="text-align :center">X</td><td></td><td/><><><>td td< td/td/td tr><><td style="text-align :right">Annotation[]</td><th scope="row » style= » font-weight :normal ; text-align :left"td style="text-align :center"X>/td td#getDeclaredAnnotations getDeclaredAnnotations()</td><><>< td/><><tr tr><><>style="<><text-align :right"><>T[]/td<>th scope="row » style="font-weight :normal ; text-align :left"<>#getDeclaredAnnotationsByType(Class) getDeclaredAnnotationsByType(Class<T>)td style="text-align :center"<X>/td<td style="text-align :center :center"><X>/<td td><><><></td></tr></tbody></table>

Pour un appel de get[Declared]AnnotationsByType( Class < T >), l’ordre des annotations qui sont directement ou indirectement présentes sur un élément E est calculé comme si les annotations présentes indirectement sur E sont directement présentes sur E à la place de leur annotation conteneur, dans l’ordre dans lequel elles apparaissent dans l’élément valeur de l’annotation conteneur.

Il existe plusieurs problèmes de compatibilité à garder à l’esprit si un type d’annotation T n’est initialement pas</em> reproductible et modifié ultérieurement <>pour être reproductible.

Le type d’annotation contenant pour T est TC.

<ul>

<Li>Modifying T to be repeatable is source and binary compatible with existing use of T and with existing use of TC.

Autrement dit, pour la compatibilité source, le code source avec des annotations de type T ou de type TC est toujours compilé. Pour la compatibilité binaire, les fichiers de classe avec des annotations de type T ou de type TC (ou avec d’autres types d’utilisations de type T ou de type TC) sont liés à la version modifiée de T s’ils sont liés à la version antérieure.

(Un type d’annotation TC peut servir de type d’annotation de manière informelle contenant le type d’annotation avant que T ne soit modifié pour être formellement reproductible. Sinon, lorsque T est rendu reproductible, TC peut être introduit en tant que nouveau type.)

<li>If an annotation type TC is present on an element, and T is modified to be repeatable with TC as its containing annotation type then :

<ul>

<li>Le changement de T est compatible avec le get[Declared]Annotation(Class<T>) comportement par rapport au (appelé avec un argument de T ou TC) et get[Declared]Annotations() les méthodes, car les résultats des méthodes ne changeront pas en raison du fait que TC devient le type d’annotation contenant pour T.

<Li>La modification apportée à T modifie les résultats des get[Declared]AnnotationsByType(Class<T>) méthodes appelées avec un argument de T, car ces méthodes reconnaissent désormais une annotation de type TC comme annotation conteneur pour T et l’examinent pour exposer des annotations de type T.

</ul>

<li>If an annotation of type T is present on an element and T is made repeatable and more annotations of type T are added to the element :

<ul>

<li> L’ajout des annotations de type T est à la fois compatible source et binaire compatible.

<li>L’ajout des annotations de type T modifie les résultats des get[Declared]Annotation(Class<T>) méthodes et get[Declared]Annotations() des méthodes, car ces méthodes ne voient maintenant qu’une annotation conteneur sur l’élément et ne voit pas une annotation de type T.

<li>L’ajout des annotations de type T modifie les résultats des get[Declared]AnnotationsByType(Class<T>) méthodes, car leurs résultats exposent les annotations supplémentaires de type T alors qu’auparavant, elles n’ont exposé qu’une seule annotation de type T.

</ul>

</ul>

Si une annotation retournée par une méthode dans cette interface contient (directement ou indirectement) un Classmembre -valued faisant référence à une classe qui n’est pas accessible dans cette machine virtuelle, toute tentative de lecture de la classe en appelant la méthode de retour de classe pertinente sur l’annotation retournée entraîne un TypeNotPresentException.

De même, la tentative de lecture d’un membre enum entraîne une EnumConstantNotPresentException si la constante d’énumération dans l’annotation n’est plus présente dans le type d’énumération.

Si un type d’annotation T est (méta-)annoté avec une @Repeatable annotation dont l’élément valeur indique un type TC, mais TC ne déclare pas de value() méthode avec un type de retour T[], une exception de type java.lang.annotation.AnnotationFormatError est levée.

Enfin, la tentative de lecture d’un membre dont la définition a évolué de façon incompatible entraîne une ou une java.lang.annotation.AnnotationTypeMismatchExceptionjava.lang.annotation.IncompleteAnnotationException.

Ajouté à la version 1.5.

Java documentation pour java.lang.reflect.AnnotatedElement.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.