java中常見註解,java常用的註解有哪些

本文目錄一覽：

• 1、java註解有什麼用
• 2、java中常用註解分別是什麼及漢語意思!
• 3、java里的註解都有哪些？都有什麼用處啊？
• 4、java註解的類型可以是哪些
• 5、java里的註解都有哪些
• 6、java開發中常用的註解有哪些

java註解有什麼用

註解常見的作用有以下幾種：

1.生成文檔。這是最常見的，也是java 最早提供的註解，常用的有@param @return 等；

2.跟蹤代碼依賴性，實現替代配置文件功能。比較常見的是spring 2.5 開始的基於註解配置，作用就是減少配置，現在的框架基本都使用了這種配置來減少配置文件的數量；

3.在編譯時進行格式檢查。如@Override放在方法前，如果你這個方法並不是覆蓋了超類方法，則編譯時就能檢查出。

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里的註解都有哪些？都有什麼用處啊？

注釋有 3 中基本類型a. 標記注釋 — 沒有變數，只有名稱標識。例如 @annotationb. 單一值注釋 — 在標記注釋的基礎上提供一段數據。如 @annotation(「data」)c. 完整注釋 — 可以包括多個數據成員，每個數據成員由名稱和值構成。@annotation(val1=”data1″,val2=”data2″)Java 中提供 3 個內置注釋類型a. Override ，只能用於方法 ( 不能用於類，包聲明或者其他構造 )作用：可以保證編譯時候 Override 函數的聲明正確性用法： @Overridepublic void fun(){..}b.Deprecated 同樣只能作用與方法作用：對不應再使用的方法進行註解用法： @Deprecated public void fun{…} // 它們說這個注釋跟函數要同一行c.SupressWarnings 可以注釋一段代碼作用：關閉特定的警告信息，例如你在使用泛型的時候未指定類型用法： @SupressWarnings(value={“unchecked”}).. 代碼Java 中還提供了四種元注釋，專門負責注釋其他的注釋@Target 表示該注釋可以用於什麼地方。可用的 ElementType 參數包括：CONSTRUCTOR : 構造器的聲明FIELD : 域聲明 ( 包括 enum 實例 )LOCAL_VARIABLE : 局部變數聲明METHOD : 方法聲明PACKAGE : 包聲明PARAMETER : 參數聲明TYPE : 類、介面 ( 包括註解類型 ) 或 enum 聲明@Retention 表示需要在什麼級別保存該注釋信息。可選的 RetentionPoicy 參數包括：SOURCE : 注釋將被編譯器丟掉CLASS : 注釋在 class 文件中可用，但會被 VM 丟棄RUNTIME : VM 將在運行時也保留注釋，因此可以通過反射機制讀取注釋的信息。

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 @interface Assignment {

    String assignee();

    int effort();

    double finished() default 0;

}

@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為例，當每個開發人員都在源代碼中更新進度的話，就可以通過一個註解處理器來生成一個項目整體進度的報告。 首先是註解處理器工廠的實現。

public class AssignmentApf implements AnnotationProcessorFactory {  

    public AnnotationProcessor getProcessorFor(SetAnnotationTypeDeclaration atds,? AnnotationProcessorEnvironment env) {

        if (atds.isEmpty()) {

           return AnnotationProcessors.NO_OP;

        }

        return new AssignmentAp(env); //返回註解處理器

    } 

    public CollectionString supportedAnnotationTypes() {

        return Collections.unmodifiableList(Arrays.asList(“annotation.Assignment”));

    }

    public CollectionString supportedOptions() {

        return Collections.emptySet();

    }

}

AnnotationProcessorFactory介面有三個方法：getProcessorFor是根據註解的類型來返回特定的註解處理器；supportedAnnotationTypes是返回該工廠生成的註解處理器所能支持的註解類型；supportedOptions用來表示所支持的附加選項。在運行apt命令行工具的時候，可以通過-A來傳遞額外的參數給註解處理器，如-Averbose=true。當工廠通過 supportedOptions方法聲明了所能識別的附加選項之後，註解處理器就可以在運行時刻通過AnnotationProcessorEnvironment的getOptions方法獲取到選項的實際值。註解處理器本身的基本實現如下所示。

public class AssignmentAp implements AnnotationProcessor { 

    private AnnotationProcessorEnvironment env;

    private AnnotationTypeDeclaration assignmentDeclaration;

    public AssignmentAp(AnnotationProcessorEnvironment env) {

        this.env = env;

        assignmentDeclaration = (AnnotationTypeDeclaration) env.getTypeDeclaration(“annotation.Assignment”);

    }

    public void process() {

        CollectionDeclaration declarations = env.getDeclarationsAnnotatedWith(assignmentDeclaration);

        for (Declaration declaration : declarations) {

           processAssignmentAnnotations(declaration);

        }

    }

    private void processAssignmentAnnotations(Declaration declaration) {

        CollectionAnnotationMirror annotations = declaration.getAnnotationMirrors();

        for (AnnotationMirror mirror : annotations) {

            if (mirror.getAnnotationType().getDeclaration().equals(assignmentDeclaration)) {

                MapAnnotationTypeElementDeclaration, AnnotationValue values = mirror.getElementValues();

                String assignee = (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”)

public class AssignmentProcess extends AbstractProcessor {

    private TypeElement assignmentElement; 

    public synchronized void init(ProcessingEnvironment processingEnv) {

        super.init(processingEnv);

        Elements elementUtils = processingEnv.getElementUtils();

        assignmentElement = elementUtils.getTypeElement(“annotation.Assignment”);

    } 

    public boolean process(Set? extends TypeElement annotations, RoundEnvironment roundEnv) {

        Set? extends Element elements = roundEnv.getElementsAnnotatedWith(assignmentElement);

        for (Element element : elements) {

            processAssignment(element);

        }

    }

    private void processAssignment(Element element) {

        List? extends AnnotationMirror annotations = element.getAnnotationMirrors();

        for (AnnotationMirror mirror : annotations) {

            if (mirror.getAnnotationType().asElement().equals(assignmentElement)) {

                Map? extends ExecutableElement, ? extends AnnotationValue values = mirror.getElementValues();

                String assignee = (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 @interface RequiredRoles {

    String[] value();

}

下一步則是如何對註解進行處理，這裡使用的Java的反射API並結合動態代理。下面是動態代理中的InvocationHandler介面的實現。

public class AccessInvocationHandlerT implements InvocationHandler {

    final T accessObj;

    public AccessInvocationHandler(T accessObj) {

        this.accessObj = accessObj;

    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        RequiredRoles annotation = method.getAnnotation(RequiredRoles.class); //通過反射API獲取註解

        if (annotation != null) {

            String[] roles = annotation.value();

            String role = AccessControl.getCurrentRole();

            if (!Arrays.asList(roles).contains(role)) {

                throw new AccessControlException(“The user is not allowed to invoke this method.”);

            }

        }

        return method.invoke(accessObj, args);

    } 

}

在具體使用的時候，首先要通過Proxy.newProxyInstance方法創建一個EmployeeGateway的介面的代理類，使用該代理類來完成實際的操作。

java里的註解都有哪些

@Target，表示該註解用於什麼地方，可能的值在枚舉類 ElemenetType 中

@Retention，表示在什麼級別保存該註解信息。可選的參數值在枚舉類型 RetentionPolicy 中

@Documented，將此註解包含在 javadoc 中 ，它代表著此註解會被javadoc工具提取成文檔。在doc文檔中的內容會因為此註解的信息內容不同而不同。相當與@see,@param 等。

@Inherited ，允許子類繼承父類中的註解，例子中補充。

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) {

ClassFilterClass 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

望採納！