① java如何進行單行注釋和多行注釋
（1）單行注釋：以「 // 」開頭後面接所要加的說明的內容。如下面所示： //定義變數a int a = 10; //定義變數b int b = 20;上面的語句中，在編譯的過程就會直接略過注釋，只會編譯 int a = 10 和 int b = 20這兩句。由此可見注釋只是起著說明的作用。
（2）多行注釋：以「/*」開頭，以「*/」結尾。 假設當你要說明你所寫的代碼的功能時。要說明的內容有很多。如果全部放在同一行會顯得很難看。所以一般會用多行來寫，如下所示// 說明//說明//說明//說明以上是用四個單行注釋來注釋四行說明。但如果有10行說明就要按十個「//」這顯示很麻煩，所以這時就可採用多行注釋。上面的可改成：/*說明說明說明說明*/也可以這樣/* 說明 說明 說明 說明 */
（3）文檔注釋：以「/**」開頭，以「*/」結尾。文檔注釋主要是生成文檔的。
② Java編譯時註解和運行時註解有什麼區別
重寫，重載，泛型，分別是在運行時還是編譯時執行的
1. 方法重載是在編譯時執行的，因為，在編譯的時候，如果調用了一個重載的方法，那麼編譯時必須確定他調用的方法是哪個。如：
當調用evaluate("hello")時候，我們在編譯時就可以確定他調用的method #1.
2.
方法的重寫是在運行時進行的。這個也常被稱為運行時多態的體現。編譯器是沒有辦法知道它調用的到底是那個方法，相反的，只有在jvm執行過程中，才知曉到底是父子類中的哪個方法被調用了當有如下一個介面的時候，我們是無法確定到底是調用父類還是子類的方法
3.
泛型(類型檢測)，這個發生在編譯時。編譯器會在編譯時對泛型類型進行檢測，並吧他重寫成實際的對象類型(非泛型代碼)，這樣就可以被JVM執行了。這個過程被稱為"類型擦除"。
類型擦除的關鍵在於從泛型類型中清除類型參數的相關信息，並且再必要的時候添加類型檢查和類型轉換的方法。
類型擦除可以簡單的理解為將泛型java代碼轉換為普通java代碼，只不過編譯器更直接點，將泛型java代碼直接轉換成普通java位元組碼。類型擦除的主要過程如下：
1). 將所有的泛型參數用其最左邊界(最頂級的父類型)類型替換。
2). 移除所有的類型參數。
在編譯後變成：
4. 註解。註解即有可能是運行時也有可能是編譯時。
如java中的@Override註解就是典型的編譯時註解，他會在編譯時會檢查一些簡單的如拼寫的錯誤(與父類方法不相同)等
同樣的@Test註解是junit框架的註解，他是一個運行時註解，他可以在運行時動態的配置相關信息如timeout等。
5. 異常。異常即有可能是運行時異常，也有可能是編譯時異常。
RuntimeException是一個用於指示編譯器不需要檢查的異常。RuntimeException
是在jvm運行過程中拋出異常的父類。對於運行時異常是不需要再方法中顯示的捕獲或者處理的。
已檢查的異常是被編譯器在編譯時候已經檢查過的異常，這些異常需要在try/catch塊中處理的異常。
6. AOP. Aspects能夠在編譯時，預編譯時以及運行時使用。
1).
編譯時：當你擁有源碼的時候，AOP編譯器(AspectJ編譯器)能夠編譯源碼並生成編織後的class。這些編織進入的額外功能是在編譯時放進去的。
2). 預編譯時：織入過程有時候也叫二進制織入，它是用來織入到哪些已經存在的class文件或者jar中的。
3). 運行時：當被織入的對象已經被載入如jvm中後，可以動態的織入到這些類中一些信息。
7. 繼承：繼承是編譯時執行的，它是靜態的。這個過程編譯後就已經確定
8. 代理(delegate)：也稱動態代理，是在運行時執行。
③ Java編譯時註解和運行時註解有什麼區別
區別如下：
1)編譯時註解，註解內容只存在源文件，在編譯期間將被丟棄，不能通過JVM獲取註解信息；
2)運行時註解，編譯時被存儲在.class位元組碼文件，可以通過JVM運行時獲取註解信息(且只限於被RUNTIME註解的註解)。
④ java中常用註解分別是什麼及漢語意思!
Annotation(註解)是JDK5.0及以後版本引入的。它可以用於創建文檔，跟蹤代碼中的依賴性，甚至執行基本編譯時檢查。注釋是以『@注釋名』在代碼中存在的，根據注釋參數的個數，我們可以將注釋分為：標記注釋、單值注釋、完整注釋三類。它們都不會直接影響到程序的語義，只是作為注釋（標識）存在，我們可以通過反射機制編程實現對這些元數據的訪問。另外，你可以在編譯時選擇代碼里的注釋是否只存在於源代碼級，或者它也能在class文件中出現。
元數據的作用
如果要對於元數據的作用進行分類，目前還沒有明確的定義，不過我們可以根據它所起的作用，大致可分為三類：
編寫文檔：通過代碼里標識的元數據生成文檔。
代碼分析：通過代碼里標識的元數據對代碼進行分析。
編譯檢查：通過代碼里標識的元數據讓編譯器能實現基本的編譯檢查。
基本內置註解
@Override java中覆寫
@Deprecated的作用是對不應該在使用的方法添加註釋，當編程人員使用這些方法時，將會在編譯時顯示提示信息，它與javadoc里的
@deprecated標記有相同的功能，准確的說，它還不如javadoc
@deprecated，因為它不支持參數
@SuppressWarnings,其參數有：
deprecation，使用了過時的類或方法時的警告
unchecked，執行了未檢查的轉換時的警告
fallthrough，當 Switch 程序塊直接通往下一種情況而沒有 Break 時的警告
path，在類路徑、源文件路徑等中有不存在的路徑時的警告
serial，當在可序列化的類上缺少 serialVersionUID 定義時的警告
finally ，任何 finally 子句不能正常完成時的警告
all，關於以上所有情況的警告
自定義注釋
它類似於新創建一個介面類文件，但為了區分，我們需要將它聲明為@interface,如：public @interface NewAnnotation {}............
⑤ Java 什麼是註解及註解原理詳細介紹
1、註解是針對Java編譯器的說明。
可以給Java包、類型(類、介面、枚舉)、構造器、方法、域、參數和局部變數進行註解。Java編譯器可以根據指令來解釋註解和放棄註解，或者將註解放到編譯後的生成的class文件中，運行時可用。
2、註解和註解類型
註解類型是一種特殊的介面類型，註解是註解註解類型的一個實例。
註解類型也有名稱和成員，註解中包含的信息採用鍵值對形式，可以有0個或多個。
3、Java中定義的一些註解：
@Override 告訴編譯器這個方法要覆蓋一個超類方法，防止程序員覆蓋出錯。
@Deprecated 這個標識方法或類(介面等類型)過期，警告用戶不建議使用。
@SafeVarargs JDK7新增，避免可變參數在使用泛型化時候警告」執行時期無法具體確認參數類型「，當然，也可以用@SuppressWarnings來避免檢查，顯然後者的抑制的范圍更大。
@SuppressWarnings(value={"unchecked"}) 抑制編譯警告，應用於類型、構造器、方法、域、參數以及局部變數。 value是類型數組，有效取值為：
all, to suppress all warnings
boxing, to suppress warnings relative to boxing/unboxing operations
cast, to suppress warnings relative to cast operations
dep-ann, to suppress warnings relative to deprecated annotation
deprecation, to suppress warnings relative to deprecation
fallthrough, to suppress warnings relative to missing breaks in switch statements
finally, to suppress warnings relative to finally block that don't return
hiding, to suppress warnings relative to locals that hide variable
incomplete-switch, to suppress warnings relative to missing entries in a switch statement (enum case)
javadoc, to suppress warnings relative to javadoc warnings
nls, to suppress warnings relative to non-nls string literals
null, to suppress warnings relative to null analysis
rawtypes, to suppress warnings relative to usage of raw types
restriction, to suppress warnings relative to usage of discouraged or forbidden references
serial, to suppress warnings relative to missing serialVersionUID field for a serializable class
static-access, to suppress warnings relative to incorrect static access
static-method, to suppress warnings relative to methods that could be declared as static
super, to suppress warnings relative to overriding a method without super invocations
synthetic-access, to suppress warnings relative to unoptimized access from inner classes
unchecked, to suppress warnings relative to unchecked operations
unqualified-field-access, to suppress warnings relative to field access unqualified
unused, to suppress warnings relative to unused code and dead code
4、註解的定義
使用 @interface 關鍵字聲明一個註解
public @interface MyAnnotation1
註解中可以定義屬性
String name default 「defval」;
value是註解中的特殊屬性
註解中定義的屬性如果名稱為 value， 此屬性在使用時可以省寫屬性名
例如，聲明一個註解：
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnno1 {
String msg();
int value();
}
⑥ java註解的類型可以是哪些
使用註解
在一般的Java開發中，最常接觸到的可能就是@Override和@SupressWarnings這兩個註解了。使用@Override的時候只需要一個簡單的聲明即可。這種稱為標記註解（marker annotation ），它的出現就代表了某種配置語義。而其它的註解是可以有自己的配置參數的。配置參數以名值對的方式出現。使用 @SupressWarnings的時候需要類似@SupressWarnings({"uncheck", "unused"})這樣的語法。在括弧裡面的是該註解可供配置的值。由於這個註解只有一個配置參數，該參數的名稱默認為value，並且可以省略。而花括弧則表示是數組類型。在JPA中的@Table註解使用類似@Table(name = "Customer", schema = "APP")這樣的語法。從這里可以看到名值對的用法。在使用註解時候的配置參數的值必須是編譯時刻的常量。
從某種角度來說，可以把註解看成是一個XML元素，該元素可以有不同的預定義的屬性。而屬性的值是可以在聲明該元素的時候自行指定的。在代碼中使用註解，就相當於把一部分元數據從XML文件移到了代碼本身之中，在一個地方管理和維護。
開發註解
在一般的開發中，只需要通過閱讀相關的API文檔來了解每個註解的配置參數的含義，並在代碼中正確使用即可。在有些情況下，可能會需要開發自己的註解。這在庫的開發中比較常見。註解的定義有點類似介面。下面的代碼給出了一個簡單的描述代碼分工安排的註解。通過該註解可以在源代碼中記錄每個類或介面的分工和進度情況。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public@interfaceAssignment{
Stringassignee();
inteffort();
doublefinished()default0;
}
@interface用來聲明一個註解，其中的每一個方法實際上是聲明了一個配置參數。方法的名稱就是參數的名稱，返回值類型就是參數的類型。可以通過default來聲明參數的默認值。在這里可以看到@Retention和@Target這樣的元註解，用來聲明註解本身的行為。@Retention用來聲明註解的保留策略，有CLASS、RUNTIME和SOURCE這三種，分別表示註解保存在類文件、JVM運行時刻和源代碼中。只有當聲明為RUNTIME的時候，才能夠在運行時刻通過反射API來獲取到註解的信息。@Target用來聲明註解可以被添加在哪些類型的元素上，如類型、方法和域等。
處理註解
在程序中添加的註解，可以在編譯時刻或是運行時刻來進行處理。在編譯時刻處理的時候，是分成多趟來進行的。如果在某趟處理中產生了新的Java源文件，那麼就需要另外一趟處理來處理新生成的源文件。如此往復，直到沒有新文件被生成為止。在完成處理之後，再對Java代碼進行編譯。JDK 5中提供了apt工具用來對註解進行處理。apt是一個命令行工具，與之配套的還有一套用來描述程序語義結構的Mirror API。Mirror API（com.sun.mirror.*）描述的是程序在編譯時刻的靜態結構。通過Mirror API可以獲取到被註解的Java類型元素的信息，從而提供相應的處理邏輯。具體的處理工作交給apt工具來完成。編寫註解處理器的核心是AnnotationProcessorFactory和AnnotationProcessor兩個介面。後者表示的是註解處理器，而前者則是為某些註解類型創建註解處理器的工廠。
以上面的註解Assignment為例，當每個開發人員都在源代碼中更新進度的話，就可以通過一個註解處理器來生成一個項目整體進度的報告。 首先是註解處理器工廠的實現。
{
(Set<AnnotationTypeDeclaration>atds,?){
if(atds.isEmpty()){
returnAnnotationProcessors.NO_OP;
}
returnnewAssignmentAp(env);//返回註解處理器
}
publicCollection<String>supportedAnnotationTypes(){
returnCollections.unmodifiableList(Arrays.asList("annotation.Assignment"));
}
publicCollection<String>supportedOptions(){
returnCollections.emptySet();
}
}AnnotationProcessorFactory介面有三個方法：getProcessorFor是根據註解的類型來返回特定的註解處理器；supportedAnnotationTypes是返回該工廠生成的註解處理器所能支持的註解類型；supportedOptions用來表示所支持的附加選項。在運行apt命令行工具的時候，可以通過-A來傳遞額外的參數給註解處理器，如-Averbose=true。當工廠通過 supportedOptions方法聲明了所能識別的附加選項之後，註解處理器就可以在運行時刻通過的getOptions方法獲取到選項的實際值。註解處理器本身的基本實現如下所示。
{
private;
;
publicAssignmentAp(){
this.env=env;
assignmentDeclaration=(AnnotationTypeDeclaration)env.getTypeDeclaration("annotation.Assignment");
}
publicvoidprocess(){
Collection<Declaration>declarations=env.getDeclarationsAnnotatedWith(assignmentDeclaration);
for(Declarationdeclaration:declarations){
processAssignmentAnnotations(declaration);
}
}
(Declarationdeclaration){
Collection<AnnotationMirror>annotations=declaration.getAnnotationMirrors();
for(AnnotationMirrormirror:annotations){
if(mirror.getAnnotationType().getDeclaration().equals(assignmentDeclaration)){
Map<,AnnotationValue>values=mirror.getElementValues();
Stringassignee=(String)getAnnotationValue(values,"assignee");//獲取註解的值
}
}
}
}註解處理器的處理邏輯都在process方法中完成。通過一個聲明（Declaration）的getAnnotationMirrors方法就可以獲取到該聲明上所添加的註解的實際值。得到這些值之後，處理起來就不難了。
在創建好註解處理器之後，就可以通過apt命令行工具來對源代碼中的註解進行處理。 命令的運行格式是apt -classpath bin -factory annotation.apt.AssignmentApf src/annotation/work/*.java，即通過-factory來指定註解處理器工廠類的名稱。實際上，apt工具在完成處理之後，會自動調用javac來編譯處理完成後的源代碼。
JDK 5中的apt工具的不足之處在於它是Oracle提供的私有實現。在JDK 6中，通過JSR 269把自定義註解處理器這一功能進行了規范化，有了新的javax.annotation.processing這個新的API。對Mirror API也進行了更新，形成了新的javax.lang.model包。註解處理器的使用也進行了簡化，不需要再單獨運行apt這樣的命令行工具，Java編譯器本身就可以完成對註解的處理。對於同樣的功能，如果用JSR 269的做法，只需要一個類就可以了。
@SupportedSourceVersion(SourceVersion.RELEASE_6)
@SupportedAnnotationTypes("annotation.Assignment")
{
;
publicsynchronizedvoidinit(){
super.init(processingEnv);
ElementselementUtils=processingEnv.getElementUtils();
assignmentElement=elementUtils.getTypeElement("annotation.Assignment");
}
publicbooleanprocess(Set<?extendsTypeElement>annotations,RoundEnvironmentroundEnv){
Set<?extendsElement>elements=roundEnv.getElementsAnnotatedWith(assignmentElement);
for(Elementelement:elements){
processAssignment(element);
}
}
privatevoidprocessAssignment(Elementelement){
List<?extendsAnnotationMirror>annotations=element.getAnnotationMirrors();
for(AnnotationMirrormirror:annotations){
if(mirror.getAnnotationType().asElement().equals(assignmentElement)){
Map<?extendsExecutableElement,?extendsAnnotationValue>values=mirror.getElementValues();
Stringassignee=(String)getAnnotationValue(values,"assignee");//獲取註解的值
}
}
}
}
仔細比較上面兩段代碼，可以發現它們的基本結構是類似的。不同之處在於JDK 6中通過元註解@SupportedAnnotationTypes來聲明所支持的註解類型。另外描述程序靜態結構的javax.lang.model包使用了不同的類型名稱。使用的時候也更加簡單，只需要通過javac -processor annotation.pap.AssignmentProcess Demo1.java這樣的方式即可。
上面介紹的這兩種做法都是在編譯時刻進行處理的。而有些時候則需要在運行時刻來完成對註解的處理。這個時候就需要用到Java的反射API。反射API提供了在運行時刻讀取註解信息的支持。不過前提是註解的保留策略聲明的是運行時。Java反射API的AnnotatedElement介面提供了獲取類、方法和域上的註解的實用方法。比如獲取到一個Class類對象之後，通過getAnnotation方法就可以獲取到該類上添加的指定註解類型的註解。
實例分析
下面通過一個具體的實例來分析說明在實踐中如何來使用和處理註解。假定有一個公司的雇員信息系統，從訪問控制的角度出發，對雇員的工資的更新只能由具有特定角色的用戶才能完成。考慮到訪問控制需求的普遍性，可以定義一個註解來讓開發人員方便的在代碼中聲明訪問控制許可權。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public@interfaceRequiredRoles{
String[]value();
}
下一步則是如何對註解進行處理，這里使用的Java的反射API並結合動態代理。下面是動態代理中的InvocationHandler介面的實現。
<T>implementsInvocationHandler{
finalTaccessObj;
publicAccessInvocationHandler(TaccessObj){
this.accessObj=accessObj;
}
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
RequiredRolesannotation=method.getAnnotation(RequiredRoles.class);//通過反射API獲取註解
if(annotation!=null){
String[]roles=annotation.value();
Stringrole=AccessControl.getCurrentRole();
if(!Arrays.asList(roles).contains(role)){
(".");
}
}
returnmethod.invoke(accessObj,args);
}
}在具體使用的時候，首先要通過Proxy.newProxyInstance方法創建一個EmployeeGateway的介面的代理類，使用該代理類來完成實際的操作。
⑦ java註解是怎麼實現的
註解的使用一般是與java的反射一起使用，下面是一個例子
註解相當於一種標記，在程序中加了註解就等於為程序打上了某種標記，沒加，則等於沒有某種標記，以後，javac編譯器，開發工具和其他程序可以用反射來了解你的類及各種元素上有無何種標記，看你有什麼標記，就去干相應的事。標記可以加在包，類，欄位，方法，方法的參數以及局部變數上。
自定義註解及其應用
1）、定義一個最簡單的註解
public @interface MyAnnotation {
//......
}
2）、把註解加在某個類上：
@MyAnnotation
public class AnnotationTest{
//......
}
以下為模擬案例
自定義註解@MyAnnotation
1 package com.ljq.test;
2
3 import java.lang.annotation.ElementType;
4 import java.lang.annotation.Retention;
5 import java.lang.annotation.RetentionPolicy;
6 import java.lang.annotation.Target;
7
8 /**
9 * 定義一個註解
10 *
11 *
12 * @author jiqinlin
13 *
14 */
15 //Java中提供了四種元註解，專門負責註解其他的註解，分別如下
16
17 //@Retention元註解，表示需要在什麼級別保存該注釋信息（生命周期）。可選的RetentionPoicy參數包括：
18 //RetentionPolicy.SOURCE: 停留在java源文件，編譯器被丟掉
19 //RetentionPolicy.CLASS：停留在class文件中，但會被VM丟棄（默認）
20 //RetentionPolicy.RUNTIME：內存中的位元組碼，VM將在運行時也保留註解，因此可以通過反射機制讀取註解的信息
21
22 //@Target元註解，默認值為任何元素，表示該註解用於什麼地方。可用的ElementType參數包括
23 //ElementType.CONSTRUCTOR: 構造器聲明
24 //ElementType.FIELD: 成員變數、對象、屬性（包括enum實例）
25 //ElementType.LOCAL_VARIABLE: 局部變數聲明
26 //ElementType.METHOD: 方法聲明
27 //ElementType.PACKAGE: 包聲明
28 //ElementType.PARAMETER: 參數聲明
29 //ElementType.TYPE: 類、介面（包括註解類型)或enum聲明
30
31 //@Documented將註解包含在JavaDoc中
32
33 //@Inheried允許子類繼承父類中的註解
34
35
36 @Retention(RetentionPolicy.RUNTIME)
37 @Target({ElementType.METHOD, ElementType.TYPE})
38 public @interface MyAnnotation {
39 //為註解添加屬性
40 String color();
41 String value() default "我是林計欽"; //為屬性提供默認值
42 int[] array() default {1, 2, 3};
43 Gender gender() default Gender.MAN; //添加一個枚舉
44 MetaAnnotation metaAnnotation() default @MetaAnnotation(birthday="我的出身日期為1988-2-18");
45 //添加枚舉屬性
46
47 }
註解測試類AnnotationTest
1 package com.ljq.test;
2
3 /**
4 * 註解測試類
5 *
6 *
7 * @author jiqinlin
8 *
9 */
10 //調用註解並賦值
11 @MyAnnotation(metaAnnotation=@MetaAnnotation(birthday = "我的出身日期為1988-2-18"),color="red", array={23, 26})
12 public class AnnotationTest {
13
14 public static void main(String[] args) {
15 //檢查類AnnotationTest是否含有@MyAnnotation註解
16 if(AnnotationTest.class.isAnnotationPresent(MyAnnotation.class)){
17 //若存在就獲取註解
18 MyAnnotation annotation=(MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);
19 System.out.println(annotation);
20 //獲取註解屬性
21 System.out.println(annotation.color());
22 System.out.println(annotation.value());
23 //數組
24 int[] arrs=annotation.array();
25 for(int arr:arrs){
26 System.out.println(arr);
27 }
28 //枚舉
29 Gender gender=annotation.gender();
30 System.out.println("性別為："+gender);
31 //獲取註解屬性
32 MetaAnnotation meta=annotation.metaAnnotation();
33 System.out.println(meta.birthday());
34 }
35 }
36 }
枚舉類Gender，模擬註解中添加枚舉屬性
1 package com.ljq.test;
2 /**
3 * 枚舉，模擬註解中添加枚舉屬性
4 *
5 * @author jiqinlin
6 *
7 */
8 public enum Gender {
9 MAN{
10 public String getName(){return "男";}
11 },
12 WOMEN{
13 public String getName(){return "女";}
14 }; //記得有「;」
15 public abstract String getName();
16 }
註解類MetaAnnotation，模擬註解中添加註解屬性
1 package com.ljq.test;
2
3 /**
4 * 定義一個註解，模擬註解中添加註解屬性
5 *
6 * @author jiqinlin
7 *
8 */
9 public @interface MetaAnnotation {
10 String birthday();
11 }
⑧ java開發中常用的註解有哪些
Java 註解全面解析，學習java做一個java工程師不但待遇高，而且前途無可限量。為什麼這樣說呢？因為java程序語言作為最流行的計算機開發語言之一，幾乎所有的系統、軟體、app、網頁等都是需要用到java的。
1.基本語法
註解定義看起來很像介面的定義。事實上，與其他任何介面一樣，註解也將會編譯成class文件。
@Target(ElementType.Method)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {}
除了@符號以外，@Test的定義很像一個空的介面。定義註解時，需要一些元註解（meta－annotation），如@Target和@Retention
@Target用來定義註解將應用於什麼地方（如一個方法或者一個域）
@Retention用來定義註解在哪一個級別可用，在源代碼中（source），類文件中（class）或者運行時（runtime）
在註解中，一般都會包含一些元素以表示某些值。當分析處理註解時，程序可以利用這些值。沒有元素的註解稱為標記註解（marker annotation）
四種元註解，元註解專職負責註解其他的註解，所以這四種註解的Target值都是ElementType.ANNOTATION_TYPE
註解 說明
@Target 表示該註解可以用在什麼地方，由ElementType枚舉定義
CONSTRUCTOR：構造器的聲明
FIELD：域聲明（包括enum實例）
LOCAL_VARIABLE：局部變數聲明
METHOD：方法聲明
PACKAGE：包聲明
PARAMETER：參數聲明
TYPE：類、介面（包括註解類型）或enum聲明
ANNOTATION_TYPE：註解聲明（應用於另一個註解上）
TYPE_PARAMETER：類型參數聲明（1.8新加入）
TYPE_USE：類型使用聲明（1.8新加入）
PS：當註解未指定Target值時，此註解可以使用任何元素之上，就是上面的類型
@Retention 表示需要在什麼級別保存該註解信息，由RetentionPolicy枚舉定義
SOURCE：註解將被編譯器丟棄（該類型的註解信息只會保留在源碼里，源碼經過編譯後，註解信息會被丟棄，不會保留在編譯好的class文件里）
CLASS：註解在class文件中可用，但會被VM丟棄（該類型的註解信息會保留在源碼里和class文件里，在執行的時候，不會載入到虛擬機（JVM）中）
RUNTIME：VM將在運行期也保留註解信息，因此可以通過反射機制讀取註解的信息（源碼、class文件和執行的時候都有註解的信息）
PS：當註解未定義Retention值時，默認值是CLASS
@Documented 表示註解會被包含在javaapi文檔中
@Inherited 允許子類繼承父類的註解
2. 註解元素
– 註解元素可用的類型如下：
– 所有基本類型（int,float,boolean,byte,double,char,long,short）
– String
– Class
– enum
– Annotation
– 以上類型的數組
如果使用了其他類型，那編譯器就會報錯。也不允許使用任何包裝類型。註解也可以作為元素的類型，也就是註解可以嵌套。
元素的修飾符，只能用public或default。
– 默認值限制
編譯器對元素的默認值有些過分挑剔。首先，元素不能有不確定的值。也就是說，元素必須要麼具有默認值，要麼在使用註解時提供元素的值。
其次，對於非基本類型的元素，無論是在源代碼中聲明，還是在註解介面中定義默認值，都不能以null作為值。這就是限制，這就造成處理器很難表現一個元素的存在或缺失狀態，因為每個註解的聲明中，所有的元素都存在，並且都具有相應的值。為了繞開這個限制，只能定義一些特殊的值，例如空字元串或負數，表示某個元素不存在。
@Target(ElementType.Method)
@Retention(RetentionPolicy.RUNTIME)
public @interface MockNull {
public int id() default -1;
public String description() default 「」;
}
3. 快捷方式
何為快捷方式呢？先來看下springMVC中的Controller註解
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
String value() default 「」;
}
可以看見Target應用於類、介面、註解和枚舉上，Retention策略為RUNTIME運行時期，有一個String類型的value元素。平常使用的時候基本都是這樣的：
@Controller(「/your/path」)
public class MockController { }
這就是快捷方式，省略了名－值對的這種語法。下面給出詳細解釋：
註解中定義了名為value的元素，並且在應用該註解的時候，如果該元素是唯一需要賦值的一個元素，那麼此時無需使用名－值對的這種語法，而只需在括弧內給出value元素所需的值即可。這可以應用於任何合法類型的元素，當然了，這限制了元素名必須為value。
4. JDK1.8註解增強
TYPE_PARAMETER和TYPE_USE
在JDK1.8中ElementType多了兩個枚舉成員，TYPE_PARAMETER和TYPE_USE，他們都是用來限定哪個類型可以進行註解。舉例來說，如果想要對泛型的類型參數進行註解：
public class AnnotationTypeParameter<@TestTypeParam T> {}
那麼，在定義@TestTypeParam時，必須在@Target設置ElementType.TYPE_PARAMETER，表示這個註解可以用來標注類型參數。例如：
@Target(ElementType.TYPE_PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestTypeParam {}
ElementType.TYPE_USE用於標注各種類型，因此上面的例子也可以將TYPE_PARAMETER改為TYPE_USE，一個註解被設置為TYPE_USE，只要是類型名稱，都可以進行註解。例如有如下註解定義：
@Target(ElementType.TYPE_USE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {}
那麼以下的使用註解都是可以的:
List<@Test Comparable> list1 = new ArrayList<>();
List<? extends Comparable> list2 = new ArrayList<@Test Comparable>();
@Test String text;
text = (@Test String)new Object();
java.util. @Test Scanner console;
console = new java.util.@Test Scanner(System.in);
PS：以上@Test註解都是在類型的右邊，要注意區分1.8之前的枚舉成員，例如：
@Test java.lang.String text;
在上面這個例子中，顯然是在進行text變數標注，所以還使用當前的@Target會編譯錯誤，應該加上ElementType.LOCAL_VARIABLE。
@Repeatable註解
@Repeatable註解是JDK1.8新加入的，從名字意思就可以大概猜出他的意思（可重復的）。可以在同一個位置重復相同的註解。舉例：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Filter {
String [] value();
}
如下進行註解使用:
@Filter({「/admin」,」/main」})
public class MainFilter { }
換一種風格:
@Filter(「/admin」)
@Filter(「/main」)
public class MainFilter {}
在JDK1.8還沒出現之前，沒有辦法到達這種「風格」，使用1.8，可以如下定義@Filter：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Filters.class)
public @interface Filter {
String value();
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Filters {
Filter [] value();
}
實際上這是編譯器的優化，使用@Repeatable時告訴編譯器，使用@Filters來作為收集重復註解的容器，而每個@Filter存儲各自指定的字元串值。
JDK1.8在AnnotatedElement介面新增了getDeclaredAnnotationsByType和getAnnotationsByType，在指定@Repeatable的註解時，會尋找重復註解的容器中。相對於，getDeclaredAnnotation和getAnnotation就不會處理@Repeatable註解。舉例如下：
@Filter(「/admin」)
@Filter(「/filter」)
public class FilterClass {
public static void main(String[] args) {
Class<FilterClass> filterClassClass = FilterClass.class;
Filter[] annotationsByType = filterClassClass.getAnnotationsByType(Filter.class);
if (annotationsByType != null) {
for (Filter filter : annotationsByType) {
System.out.println(filter.value());
}
}
System.out.println(filterClassClass.getAnnotation(Filter.class));
}
}
日誌如下:
/admin
/filter
null
望採納！