原 http://blog.csdn.net/github_35180164/article/details/52171135
前面介紹了關(guān)于編譯時注解的使用方式，這里再補充一個關(guān)于注解處理器開發(fā)中的一些常用類、接口的使用方式和概念。
Element和TypeMirror
我覺得這兩個是開發(fā)注解處理器最重要的兩個概念，理解這兩個的概念和使用是非常有必要的。
這兩個都是接口，先來看一下Element的定義：
/**
* 表示一個程序元素，比如包、類或者方法，有如下幾種子接口：
* ExecutableElement：表示某個類或接口的方法、構(gòu)造方法或初始化程序（靜態(tài)或?qū)嵗?，包括注解類型元?；
* PackageElement：表示一個包程序元素；
* TypeElement：表示一個類或接口程序元素；
* TypeParameterElement：表示一般類、接口、方法或構(gòu)造方法元素的形式類型參數(shù)；
* VariableElement：表示一個字段、enum 常量、方法或構(gòu)造方法參數(shù)、局部變量或異常參數(shù)
*/
public interface Element extends AnnotatedConstruct {
/**
* 返回此元素定義的類型
* 例如，對于一般類元素 C<N extends Number>，返回參數(shù)化類型 C<N>
*/
TypeMirror asType();
/**
* 返回此元素的種類：包、類、接口、方法、字段...,如下枚舉值
* PACKAGE, ENUM, CLASS, ANNOTATION_TYPE, INTERFACE, ENUM_CONSTANT, FIELD, PARAMETER, LOCAL_VARIABLE, EXCEPTION_PARAMETER,
* METHOD, CONSTRUCTOR, STATIC_INIT, INSTANCE_INIT, TYPE_PARAMETER, OTHER, RESOURCE_VARIABLE;
*/
ElementKind getKind();
/**
* 返回此元素的修飾符,如下枚舉值
* PUBLIC, PROTECTED, PRIVATE, ABSTRACT, DEFAULT, STATIC, FINAL,
* TRANSIENT, VOLATILE, SYNCHRONIZED, NATIVE, STRICTFP;
*/
Set<Modifier> getModifiers();
/**
* 返回此元素的簡單名稱,例如
* 類型元素 java.util.Set<E> 的簡單名稱是 "Set"；
* 如果此元素表示一個未指定的包，則返回一個空名稱；
* 如果它表示一個構(gòu)造方法，則返回名稱 "<init>"；
* 如果它表示一個靜態(tài)初始化程序，則返回名稱 "<clinit>"；
* 如果它表示一個匿名類或者實例初始化程序，則返回一個空名稱
*/
Name getSimpleName();
/**
* 返回封裝此元素的最里層元素。
* 如果此元素的聲明在詞法上直接封裝在另一個元素的聲明中，則返回那個封裝元素；
* 如果此元素是頂層類型，則返回它的包；
* 如果此元素是一個包，則返回 null；
* 如果此元素是一個泛型參數(shù)，則返回 null.
*/
Element getEnclosingElement();
/**
* 返回此元素直接封裝的子元素
*/
List<? extends Element> getEnclosedElements();
/**
* 返回直接存在于此元素上的注解
* 要獲得繼承的注解，可使用 getAllAnnotationMirrors
*/
@Override
List<? extends AnnotationMirror> getAnnotationMirrors();
/**
* 返回此元素針對指定類型的注解（如果存在這樣的注解），否則返回 null。注解可以是繼承的，也可以是直接存在于此元素上的
*/
@Override
<A extends Annotation> A getAnnotation(Class<A> annotationType);
}
Element 代表程序的元素，在注解處理過程中，編譯器會掃描所有的Java源文件，并將源碼中的每一個部分都看作特定類型的 Element。它可以代表包、類、接口、方法、字段等多種元素種類，具體看getKind()方法中所指代的種類，每個Element 代表一個靜態(tài)的、語言級別的構(gòu)件。
Element 有五個直接子接口，它們分別代表一種特定類型的元素，如下：
PackageElement
表示一個包程序元素
TypeElement
表示一個類或接口程序元素
VariableElement
表示一個字段、enum 常量、方法或構(gòu)造方法參數(shù)、局部變量或異常參數(shù)
ExecutableElement
表示某個類或接口的方法、構(gòu)造方法或初始化程序（靜態(tài)或?qū)嵗?，包括注解類型元?/p>
TypeParameterElement
表示一般類、接口、方法或構(gòu)造方法元素的泛型參數(shù)
在開發(fā)中Element可根據(jù)實際情況強轉(zhuǎn)為以上5種中的一種，它們都帶有各自獨有的方法，來看個簡單的例子：
ackage com.example; // PackageElement
import java.util.List;
public class Sample // TypeElement
<T extends List> { // TypeParameterElement
private int num; // VariableElement
String name; // VariableElement
public Sample() {} // ExecuteableElement
public void setName( // ExecuteableElement
String name // VariableElement
) {}
}
源碼中的每個部分都作為一個Element，而TypeElement對應(yīng)著一種更具體的類型元素。根據(jù)上面的表格可以知道，一種特定的元素一般不止指代一種元素種類(ElementKind)，比如TypeElement可以指代類或接口，要知道一個元素的準(zhǔn)確的種類需要調(diào)用getKind()方法，該方法返回一個ElementKind枚舉值來表示具體種類，如下：
public enum ElementKind {
/** A package. */
PACKAGE,
/** An enum type. */
ENUM,
/** A class not described by a more specific kind (like {@code ENUM}). */
CLASS,
/** An annotation type. */
ANNOTATION_TYPE,
/** An interface not described by a more specific kind */
INTERFACE,
// Variables
/** An enum constant. */
ENUM_CONSTANT,
/** A field not described by a more specific kind */
FIELD,
/** A parameter of a method or constructor. */
PARAMETER,
/** A local variable. */
LOCAL_VARIABLE,
/** A parameter of an exception handler. */
EXCEPTION_PARAMETER,
// Executables
/** A method. */
METHOD,
/** A constructor. */
CONSTRUCTOR,
/** A static initializer. */
STATIC_INIT,
/** An instance initializer. */
INSTANCE_INIT,
/** A type parameter. */
TYPE_PARAMETER,
/** An implementation-reserved element. This is not the element you are looking for. */
OTHER,
/**
* A resource variable.
* @since 1.7
*/
RESOURCE_VARIABLE;
}
上面管ElementKind稱作元素的種類，因為它和元素的類型TypeMirror很容易混掉。TypeMirror表示的是 Java 編程語言中的類型，比如上面例子中的字段String name，它的元素種類為FIELD，而它的元素類型為DECLARED表示一個類類型，這里對應(yīng)Java 編程語言中的類型為java.lang.String。Element代表的是源代碼上的元素，TypeMirror代表的是Element對應(yīng)Java 編程語言中的類型。
/**
* 表示 Java 編程語言中的類型
*/
public interface TypeMirror {
/**
* 返回此類型的種類，一個 TypeKind 枚舉值：
*/
TypeKind getKind();
}
TypeMirror和Element一樣有一個getKind()方法來獲取具體的類型，方法返回一個枚舉值，如下：
public enum TypeKind {
/** The primitive type {@code boolean}. */
BOOLEAN,
/** The primitive type {@code byte}. */
BYTE,
/** The primitive type {@code short}. */
SHORT,
/** The primitive type {@code int}. */
INT,
/** The primitive type {@code long}. */
LONG,
/** The primitive type {@code char}. */
CHAR,
/** The primitive type {@code float}. */
FLOAT,
/** The primitive type {@code double}. */
DOUBLE,
/** The pseudo-type corresponding to the keyword {@code void}. */
VOID,
/** A pseudo-type used where no actual type is appropriate. */
NONE,
/** The null type. */
NULL,
/** An array type. */
ARRAY,
/** A class or interface type. */
DECLARED,
/** A class or interface type that could not be resolved. */
ERROR,
/** A type variable. */
TYPEVAR,
/** A wildcard type argument. */
WILDCARD,
/** A pseudo-type corresponding to a package element. */
PACKAGE,
/** A method, constructor, or initializer. */
EXECUTABLE,
/** An implementation-reserved type. This is not the type you are looking for. */
OTHER,
/** A union type. */
UNION,
/** An intersection type. */
INTERSECTION;
}
可以看到和ElementKind所描述的是不同的方面。不知道這樣說明的清不清楚，其實這種概念上的東西自己用幾次會有更好理解，這東西就說到這。
Element的直接子接口
這里列一下5個Element子接口常用方法，大部分描述是從JDK PAI手冊中截取。這東西你也沒必要一次看完，大概了解一下，等到需要用的時候能夠知道有這么個東西就行了。
TypeElement
/**
* 表示一個類或接口程序元素
*/
public interface TypeElement {
/**
* 返回此類型元素的嵌套種類
* 某一類型元素的嵌套種類 (nesting kind)。類型元素的種類有四種：top-level（頂層）、member（成員）、local（局部）和 anonymous（匿名）
*/
NestingKind getNestingKind();
/**
* 返回此類型元素的完全限定名稱。更準(zhǔn)確地說，返回規(guī)范 名稱。對于沒有規(guī)范名稱的局部類和匿名類，返回一個空名稱.
* 一般類型的名稱不包括對其形式類型參數(shù)的任何引用。例如，接口 java.util.Set<E> 的完全限定名稱是 "java.util.Set"
*/
Name getQualifiedName();
/**
* 返回此類型元素的直接超類。如果此類型元素表示一個接口或者類 java.lang.Object，則返回一個種類為 NONE 的 NoType
*/
TypeMirror getSuperclass();
/**
* 返回直接由此類實現(xiàn)或直接由此接口擴(kuò)展的接口類型
*/
List<? extends TypeMirror> getInterfaces();
/**
* 按照聲明順序返回此類型元素的形式類型參數(shù)
*/
List<? extends TypeParameterElement> getTypeParameters();
}
PackageElement
/**
* 表示一個包程序元素.
*/
public interface PackageElement {
/**
* 返回此包的完全限定名稱。該名稱也是包的規(guī)范名稱
*/
Name getQualifiedName();
/**
* 如果此包是一個未命名的包，則返回 true，否則返回 false
*/
boolean isUnnamed();
}
ExecutableElement
/**
* 表示某個類或接口的方法、構(gòu)造方法或初始化程序（靜態(tài)或?qū)嵗?，包括注解類型元?
*/
public interface ExecutableElement {
/**
* 獲取按照聲明順序返回形式類型參數(shù)元素
*/
List<? extends TypeParameterElement> getTypeParameters();
/**
* 獲取返回的類型元素
*/
TypeMirror getReturnType();
/**
* 獲取形參元素
*/
List<? extends VariableElement> getParameters();
/**
* 如果此方法或構(gòu)造方法接受可變數(shù)量的參數(shù)，則返回 true，否則返回 false
*/
boolean isVarArgs();
/**
* 按聲明順序返回此方法或構(gòu)造方法的 throws 子句中所列出的異常和其他 throwable
*/
List<? extends TypeMirror> getThrownTypes();
/**
* 如果此 executable 是一個注解類型元素，則返回默認(rèn)值。如果此方法不是注解類型元素，或者它是一個沒有默認(rèn)值的注解類型元素，則返回 null
*/
AnnotationValue getDefaultValue();
}
VariableElement
/**
* 表示一個字段、enum 常量、方法或構(gòu)造方法參數(shù)、局部變量或異常參數(shù)
*/
public interface VariableElement {
/**
* 如果此變量是一個被初始化為編譯時常量的 static final 字段，則返回此變量的值。否則返回 null。
* 該值為基本類型或 String，如果該值為基本類型，則它被包裝在適當(dāng)?shù)陌b類中（比如 Integer）。
* 注意，并非所有的 static final 字段都將具有常量值。特別是，enum 常量不 被認(rèn)為是編譯時常量。要獲得一個常量值，字段的類型必須是基本類型或 String
*/
Object getConstantValue();
}
TypeParameterElement
/**
* 表示一般類、接口、方法或構(gòu)造方法元素的泛型參數(shù).
*/
public interface TypeParameterElement {
/**
* 返回由此類型參數(shù)參數(shù)化的一般類、接口、方法或構(gòu)造方法
*/
Element getGenericElement();
/**
* 返回此類型參數(shù)的邊界。它們是用來聲明此類型參數(shù)的 extends 子句所指定的類型。
* 如果沒有使用顯式的 extends 子句，則認(rèn)為 java.lang.Object 是唯一的邊界
*/
List<? extends TypeMirror> getBounds();
}
注解處理器的輔助接口
在自定義注解處理器的初始化接口，可以獲取到以下4個輔助接口：
public class MyProcessor extends AbstractProcessor {
private Types typeUtils;
private Elements elementUtils;
private Filer filer;
private Messager messager;
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
typeUtils = processingEnv.getTypeUtils();
elementUtils = processingEnv.getElementUtils();
filer = processingEnv.getFiler();
messager = processingEnv.getMessager();
}
}
其中Filer之前有用過，一般我們會用它配合JavaPoet來生成我們需要的.java文件，這里就不再提它的用法。
Messager
Messager提供給注解處理器一個報告錯誤、警告以及提示信息的途徑。它不是注解處理器開發(fā)者的日志工具，而是用來寫一些信息給使用此注解器的第三方開發(fā)者的。在官方文檔中描述了消息的不同級別中非常重要的是Kind.ERROR，因為這種類型的信息用來表示我們的注解處理器處理失敗了。很有可能是第三方開發(fā)者錯誤的使用了注解。這個概念和傳統(tǒng)的Java應(yīng)用有點不一樣，在傳統(tǒng)Java應(yīng)用中我們可能就拋出一個異常Exception。如果你在process()中拋出一個異常，那么運行注解處理器的JVM將會崩潰（就像其他Java應(yīng)用一樣），使用我們注解處理器第三方開發(fā)者將會從javac中得到非常難懂的出錯信息，因為它包含注解處理器的堆棧跟蹤（Stacktace）信息。因此，注解處理器就有一個Messager類，它能夠打印非常優(yōu)美的錯誤信息。除此之外，你還可以連接到出錯的元素。在像現(xiàn)在的IDE（集成開發(fā)環(huán)境）中，第三方開發(fā)者可以直接點擊錯誤信息，IDE將會直接跳轉(zhuǎn)到第三方開發(fā)者項目的出錯的源文件的相應(yīng)的行。
看下接口代碼：
public interface Messager {
void printMessage(Diagnostic.Kind kind, CharSequence msg);
void printMessage(Diagnostic.Kind kind, CharSequence msg, Element e);
void printMessage(Diagnostic.Kind kind, CharSequence msg, Element e, AnnotationMirror a);
void printMessage(Diagnostic.Kind kind, CharSequence msg, Element e, AnnotationMirror a, AnnotationValue v);
}
方法都比較好懂，主要需要指定打印的信息類型和描述字符串。
Types
Types是一個用來處理TypeMirror的工具，看下代碼就好了，提供的方法如下：
/**
* 一個用來處理TypeMirror的工具
*/
public interface Types {
/**
* 返回對應(yīng)于類型的元素。該類型可能是 DeclaredType 或 TypeVariable。如果該類型沒有對應(yīng)元素，則返回 null.
*/
Element asElement(TypeMirror t);
/**
* 測試兩個 TypeMirror 對象是否表示同一類型.
* 警告：如果此方法兩個參數(shù)中有一個表示通配符，那么此方法將返回 false
*/
boolean isSameType(TypeMirror t1, TypeMirror t2);
/**
* 測試一種類型是否是另一個類型的子類型。任何類型都被認(rèn)為是其本身的子類型.
*
* @return 當(dāng)且僅當(dāng)?shù)谝环N類型是第二種類型的子類型時返回 true
* @throws IllegalArgumentException 如果給定一個 executable 或 package 類型
*/
boolean isSubtype(TypeMirror t1, TypeMirror t2);
/**
* 測試一種類型是否可以指派給另一種類型.
*
* @return 當(dāng)且僅當(dāng)?shù)谝环N類型可以指派給第二種類型時返回 true
* @throws IllegalArgumentException 如果給定一個 executable 或 package 類型
*/
boolean isAssignable(TypeMirror t1, TypeMirror t2);
/**
* 測試一個類型參數(shù)是否包含 另一個類型參數(shù).
*
* @return 當(dāng)且僅當(dāng)?shù)谝环N類型包含第二種類型時返回 true
* @throws IllegalArgumentException 如果給定一個 executable 或 package 類型
*/
boolean contains(TypeMirror t1, TypeMirror t2);
/**
* 測試一個方法的簽名是否是另一個方法的子簽名.
*
* @return 當(dāng)且僅當(dāng)?shù)谝粋€簽名是第二個簽名的子簽名時返回 true
*/
boolean isSubsignature(ExecutableType m1, ExecutableType m2);
/**
* 返回類型的直接超類型。interface 類型將出現(xiàn)在列表的最后（如果有）.
*
* @return 直接超類型；如果沒有，則返回一個空列表
* @throws IllegalArgumentException 如果給定一個 executable 或 package 類型
*/
List<? extends TypeMirror> directSupertypes(TypeMirror t);
/**
* 返回刪除狀態(tài)的類型.
*
* @return 刪除狀態(tài)的給定類型
* @throws IllegalArgumentException 如果給定一個 package 類型
*/
TypeMirror erasure(TypeMirror t);
/**
* 返回給定基本類型的裝箱 (boxed) 值類型的類。即應(yīng)用 boxing 轉(zhuǎn)換.
*
* @param p 要轉(zhuǎn)換的基本類型
* @return 類型 p 的裝箱值類型的類
*/
TypeElement boxedClass(PrimitiveType p);
/**
* 返回給定類型的拆箱 (unboxed) 值類型（基本類型）。即應(yīng)用 unboxing 轉(zhuǎn)換.
*
* @param t 要拆箱的類型
* @return 類型 t 的拆箱值類型
* @throws IllegalArgumentException 如果給定類型無法進(jìn)行 unboxing 轉(zhuǎn)換
*/
PrimitiveType unboxedType(TypeMirror t);
/**
* 對類型應(yīng)用 capture 轉(zhuǎn)換.
*
* @return 應(yīng)用 capture 轉(zhuǎn)換的結(jié)果
* @throws IllegalArgumentException 如果給定 executable 或 package 類型
*/
TypeMirror capture(TypeMirror t);
/**
* 返回基本類型.
*
* @param kind 要返回的基本類型的種類
* @return 一個基本類型
* @throws IllegalArgumentException 如果 kind 不是基本種類
*/
PrimitiveType getPrimitiveType(TypeKind kind);
/**
* 返回 null 類型。該類型是 null 的類型.
*/
NullType getNullType();
/**
* 返回在實際類型不適用的地方所使用的偽類型。
* 要返回的類型的種類可以是 VOID 或 NONE。對于包，可以使用 Elements.getPackageElement(CharSequence).asType() 替代.
*
* @param kind 要返回的類型的種類
* @return 種類 VOID 或 NONE 的偽類型
* @throws IllegalArgumentException 如果 kind 無效
*/
NoType getNoType(TypeKind kind);
/**
* 返回具有指定組件類型的數(shù)組類型.
*
* @throws IllegalArgumentException 如果組件類型對于數(shù)組無效
*/
ArrayType getArrayType(TypeMirror componentType);
/**
* 返回新的通配符類型參數(shù)。可以指定通配符邊界中的一個，也可以都不指定，但不能都指定.
*
* @param extendsBound 擴(kuò)展（上）邊界；如果沒有，則該參數(shù)為 null
* @param superBound 超（下）邊界；如果沒有，則該參數(shù)為 null
* @return 新的通配符
* @throws IllegalArgumentException 如果邊界無效
*/
WildcardType getWildcardType(TypeMirror extendsBound,
TypeMirror superBound);
/**
* 返回對應(yīng)于類型元素和實際類型參數(shù)的類型。例如，如果給定 Set 的類型元素和 String 的類型鏡像，那么可以使用此方法獲取參數(shù)化類型 Set<String>.
*
* 類型參數(shù)的數(shù)量必須等于類型元素的形式類型參數(shù)的數(shù)量，或者等于 0。如果等于 0，并且類型元素是泛型，則返回該類型元素的原始類型.
*
* 如果返回一個參數(shù)化類型，則其類型元素不得包含在一般外部類中。
* 例如，首先使用此方法獲取類型 Outer<String>，然后調(diào)用 getDeclaredType(DeclaredType, TypeElement, TypeMirror...)，
* 可以構(gòu)造參數(shù)化類型 Outer<String>.Inner<Number>.
*
* @param typeElem 類型元素
* @param typeArgs 實際類型參數(shù)
* @return 對應(yīng)于類型元素和實際類型參數(shù)的類型
* @throws IllegalArgumentException 如果給定的類型參數(shù)太多或太少，或者提供不合適的類型參數(shù)或類型元素
*/
DeclaredType getDeclaredType(TypeElement typeElem, TypeMirror... typeArgs);
/**
* 根據(jù)給定的包含類型，返回對應(yīng)于類型元素和實際類型參數(shù)的類型（它是給定包含類型的成員）.例子如上
* 如果包含類型是一個參數(shù)化類型，則類型參數(shù)的數(shù)量必須等于 typeElem 的形式類型參數(shù)的數(shù)量。
* 如果包含類型不是參數(shù)化的，或者為 null，則此方法等效于 getDeclaredType(typeElem, typeArgs）.
*
* @param containing 包含類型；如果沒有，則該參數(shù)為 null
* @param typeElem 類型元素
* @param typeArgs 實際類型參數(shù)
* @return 對應(yīng)于類型元素和實際類型參數(shù)的類型，該類型包含在給定類型中
* @throws IllegalArgumentException 如果給定的類型參數(shù)太多或太少，或者提供了不合適的類型參數(shù)、類型元素或包含類型
*/
DeclaredType getDeclaredType(DeclaredType containing,
TypeElement typeElem, TypeMirror... typeArgs);
/**
* 當(dāng)元素被視為給定類型的成員或者直接由給定類型包含時，返回該元素的類型。
* 例如，被視為參數(shù)化類型 Set<String> 的成員時，Set.add 方法是參數(shù)類型為 String 的 ExecutableType.
*
* @param containing 包含類型
* @param element 元素
* @return 從包含類型來看的元素的類型
* @throws IllegalArgumentException 如果元素對于給定類型無效
*/
TypeMirror asMemberOf(DeclaredType containing, Element element);
}
Elements
Elements是一個用來處理Element的工具，提供的方法如下：
/**
* 一個用來處理Element的工具
*/
public interface Elements {
/**
* 返回已給出其完全限定名稱的包.
*
* @param name 完全限定的包名稱；對于未命名的包，該參數(shù)為 ""
* @return 指定的包；如果沒有找到這樣的包，則返回 null
*/
PackageElement getPackageElement(CharSequence name);
/**
* 返回已給出其規(guī)范名稱的類型元素.
*
* @param name 規(guī)范名稱
* @return 指定的類型元素；如果沒有找到這樣的元素，則返回 null
*/
TypeElement getTypeElement(CharSequence name);
/**
* 返回注釋元素的值，包括默認(rèn)值.
* 此值是以映射的形式返回的，該映射將元素與其相應(yīng)的值關(guān)聯(lián)。只包括那些注釋中明確存在其值的元素，不包括那些隱式假定其默認(rèn)值的元素。
* 映射的順序與值出現(xiàn)在注釋源中的順序匹配
*
* @see AnnotationMirror#getElementValues()
* @param a 要檢查的注釋
* @return 注釋元素的值，包括默認(rèn)值
*/
Map<? extends ExecutableElement, ? extends AnnotationValue>
getElementValuesWithDefaults(AnnotationMirror a);
/**
* 返回元素的文檔（"Javadoc"）注釋文本
*
* @param e 將被檢查的元素
* @return 元素的文檔注釋；如果沒有，則返回 null
*/
String getDocComment(Element e);
/**
* 如果元素已過時，則返回 true，否則返回 false.
*
* @param e 將被檢查的元素
* @return 如果元素已過時，則返回 true，否則返回 false
*/
boolean isDeprecated(Element e);
/**
* 返回類型元素的二進(jìn)制名稱.
*
* @param type 將被檢查的類型元素
* @return 二進(jìn)制名稱
*/
Name getBinaryName(TypeElement type);
/**
* 返回元素的包。包的包是它本身.
*
* @param type 將被檢查的元素
* @return 元素的包
*/
PackageElement getPackageOf(Element type);
/**
* 返回類型元素的所有成員，不管是繼承的還是直接聲明的。對于一個類，結(jié)果還包括其構(gòu)造方法，但不包括局部類或匿名類.
*
* 注意，使用 ElementFilter 中的方法可以隔離某個種類的元素.
*
* @param type 將被檢查的類型
* @return 類型的所有成員
*/
List<? extends Element> getAllMembers(TypeElement type);
/**
* 返回元素的所有注釋，不管是繼承的還是直接存在的.
*
* @param e 將被檢查的元素
* @return 元素的所有注釋
*/
List<? extends AnnotationMirror> getAllAnnotationMirrors(Element e);
/**
* 測試一個類型、方法或字段是否隱藏了另一個類型、方法或字段.
*
* @param hider 第一個元素
* @param hidden 第二個元素
* @return 當(dāng)且僅當(dāng)?shù)谝粋€元素隱藏了第二個元素時返回 true
*/
boolean hides(Element hider, Element hidden);
/**
* 測試一個方法（作為給定類型的成員）是否重寫了另一個方法。當(dāng)非抽象方法重寫抽象方法時，還可以說成是前者實現(xiàn) 了后者.
*
* @param overrider 第一個方法，可能是 overrider
* @param overridden 第二個方法，可能被重寫
* @param type 第一個方法是其成員的類型
* @return 當(dāng)且僅當(dāng)?shù)谝粋€方法重寫第二個方法時返回 true
*/
boolean overrides(ExecutableElement overrider, ExecutableElement overridden,
TypeElement type);
/**
* 返回表示基本值或字符串的常量表達(dá)式 文本。返回文本的形式是一種適合于表示源代碼中的值的形式.
*
* @param value 基本值或字符串
* @return 常量表達(dá)式的文本
* @throws IllegalArgumentException 如果參數(shù)不是基本值或字符串
*
* @see VariableElement#getConstantValue()
*/
String getConstantExpression(Object value);
/**
* 按指定順序?qū)⒃氐谋硎拘问酱蛴〉浇o定 writer。此方法的主要用途是診斷。輸出的具體格式?jīng)]有 指定并且是可以更改的.
*
* @param w 輸出打印到的 writer
* @param elements 要打印的元素
*/
void printElements(java.io.Writer w, Element... elements);
/**
* 返回與參數(shù)具有相同字符序列的名稱.
*
* @param cs 將以名稱形式返回的字符序列
* @return 返回與參數(shù)具有相同字符序列的名稱
*/
Name getName(CharSequence cs);
/**
* 如果類型是一個泛型接口則返回 true，否則返回 false
*
* @param type 將被檢查的類型
* @return 如果類型是一個泛型接口則返回 true，否則返回 false
* @since 1.8
*/
boolean isFunctionalInterface(TypeElement type);
}
