annotationjava
1. java怎麼查看annotation 實現
深入理解Java：註解（Annotation）自定義註解入門
要深入學習註解，我們就必須能定義自己的註解，並使用註解，在定義自己的註解之前，我們就必須要了解Java為我們提供的元註解和相關定義註解的語法。
元註解：
元註解的作用就是負責註解其他註解。Java5.0定義了4個標準的meta-annotation類型，它們被用來提供對其它 annotation類型作說明。Java5.0定義的元註解：
1.@Target,
2.@Retention,
3.@Documented,
4.@Inherited
這些類型和它們所支持的類在java.lang.annotation包中可以找到。下面我們看一下每個元註解的作用和相應分參數的使用說明。
@Target：
@Target說明了Annotation所修飾的對象范圍：Annotation可被用於 packages、types（類、介面、枚舉、Annotation類型）、類型成員（方法、構造方法、成員變數、枚舉值）、方法參數和本地變數（如循環變數、catch參數）。在Annotation類型的聲明中使用了target可更加明晰其修飾的目標。
作用：用於描述註解的使用范圍（即：被描述的註解可以用在什麼地方）
取值(ElementType)有：
1.CONSTRUCTOR:用於描述構造器
2.FIELD:用於描述域
3.LOCAL_VARIABLE:用於描述局部變數
4.METHOD:用於描述方法
5.PACKAGE:用於描述包
6.PARAMETER:用於描述參數
7.TYPE:用於描述類、介面(包括註解類型) 或enum聲明
使用實例：
@Target(ElementType.TYPE)
public @interface Table {
/**
* 數據表名稱註解，默認值為類名稱
* @return
*/
public String tableName() default "className";
}
@Target(ElementType.FIELD)
public @interface NoDBColumn {
}
註解Table 可以用於註解類、介面(包括註解類型) 或enum聲明,而註解NoDBColumn僅可用於註解類的成員變數。
@Retention：
@Retention定義了該Annotation被保留的時間長短：某些Annotation僅出現在源代碼中，而被編譯器丟棄；而另一些卻被編譯在class文件中；編譯在class文件中的Annotation可能會被虛擬機忽略，而另一些在class被裝載時將被讀取（請注意並不影響class的執行，因為Annotation與class在使用上是被分離的）。使用這個meta-Annotation可以對 Annotation的「生命周期」限制。
作用：表示需要在什麼級別保存該注釋信息，用於描述註解的生命周期（即：被描述的註解在什麼范圍內有效）
取值（RetentionPoicy）有：
1.SOURCE:在源文件中有效（即源文件保留）
2.CLASS:在class文件中有效（即class保留）
3.RUNTIME:在運行時有效（即運行時保留）
Retention meta-annotation類型有唯一的value作為成員，它的取值來自java.lang.annotation.RetentionPolicy的枚舉類型值。具體實例如下：
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
public String name() default "fieldName";
public String setFuncName() default "setField";
public String getFuncName() default "getField";
public boolean defaultDBValue() default false;
}
Column註解的的RetentionPolicy的屬性值是RUTIME,這樣註解處理器可以通過反射，獲取到該註解的屬性值，從而去做一些運行時的邏輯處理
@Documented:
@Documented用於描述其它類型的annotation應該被作為被標注的程序成員的公共API，因此可以被例如javadoc此類的工具文檔化。Documented是一個標記註解，沒有成員。
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Column {
public String name() default "fieldName";
public String setFuncName() default "setField";
public String getFuncName() default "getField";
public boolean defaultDBValue() default false;
}
@Inherited：
@Inherited 元註解是一個標記註解，@Inherited闡述了某個被標注的類型是被繼承的。如果一個使用了@Inherited修飾的annotation類型被用於一個class，則這個annotation將被用於該class的子類。
注意：@Inherited annotation類型是被標注過的class的子類所繼承。類並不從它所實現的介面繼承annotation，方法並不從它所重載的方法繼承annotation。
當@Inherited annotation類型標注的annotation的Retention是RetentionPolicy.RUNTIME，則反射API增強了這種繼承性。如果我們使用java.lang.reflect去查詢一個@Inherited annotation類型的annotation時，反射代碼檢查將展開工作：檢查class和其父類，直到發現指定的annotation類型被發現，或者到達類繼承結構的頂層。
2. JAVA中Annotation是什麼，有什麼用
請輸入你Annotation提供了一條與程序元素關聯任何或者任何元數據（metadata）的途徑。從某些方面看，annotation就像修飾符一樣被使用，並應用於包、類型、構造方法、方法、成員變數、參數、本地變數的聲明中。這些被存儲在annotation的「name=value」結構對中。annotation類型是一種介面，能夠通過反射API的方式提供對其的訪問。annotation能被用來為某個程序元素（類、方法、成員變數等）關聯任何的。需要注意的是，這里存在著一個基本的潛規則：annotaion不能影響程序代碼的執行，無論增加、刪除annotation，代碼都始終如一的執行。另外，盡管一些annotation通過java的反射api方法在運行時被訪問，而java語言解釋器在工作時忽略了這些annotation。正是由於忽略了annotation，導致了annotation類型在代碼中是「不起作用」的；只有通過某種配套的工具才會對annotation類型中的進行訪問和處理。本文中將涵蓋標準的annotation和meta-annotation類型，陪伴這些annotation類型的工具是java編譯器（當然要以某種特殊的方式處理它們）。由於上述原因，annotation在使用時十分簡便。一個本地變數可以被一個以NonNull命名的annotation類型所標注，來作為對這個本地變數不能被賦予null值的斷言。而我們可以編寫與之配套的一個annotation代碼，使用它來對具有前面變數的代碼進行解析，並且嘗試驗證這個斷言。當然這些代碼並不必自己編寫。在JDK安裝後，在JDK/bin目錄中可以找到名為「apt」的工具，它提供了處理annotation的框架：它啟動後掃描源代碼中的annotation，並調用我們定義好的annotation處理器完成我們所要完成的工作（比如驗證前面例子中的斷言）。說到這里，annotation的強大功能似乎可以替代XDoclet這類的工具了，隨著我們的深入，大家會更加堅信這一點的答案... 拿別人的，希望可以幫到你~
3. 註解的JAVA中的註解
java.lang.annotation.Retention可以在您定義Annotation型態時，指示編譯器如何對待您的自定義 Annotation，預設上編譯器會將Annotation資訊留在class檔案中，但不被虛擬機器讀取，而僅用於編譯器或工具程式運行時提供資訊。
在使用Retention型態時，需要提供java.lang.annotation.RetentionPolicy的列舉型態：
package java.lang.annotation;
public enum RetentionPolicy {
SOURCE, //編譯器處理完Annotation資訊後就沒事了
CLASS, //編譯器將Annotation儲存於class檔中，預設
RUNTIME //編譯器將Annotation儲存於class檔中，可由VM讀入
}
RetentionPolicy為SOURCE的例子是SuppressWarnings，這個資訊的作用僅在告知編譯器抑制警訊，所以不必將這個資訊儲存於class檔案。
RetentionPolicy為RUNTIME的時機，可像是您使用Java設計一個程式碼分析工具，您要VM讀出Annotation資訊，以在分析程式中使用，搭配Reflection機制，就可以達到這個目的。
在J2SE 5.0中新增了java.lang.reflect.AnnotatedElement這個界面，當中定義有四個方法：
public Annotation getAnnotation(Class annotationType);
public Annotation[] getAnnotations();
public Annotation[] getDeclaredAnnotations();
public boolean isAnnotationPresent(Class annotationType);
Class、Constructor、Field、Method、Package等類別，都實作了AnnotatedElement這個介面，所以您可以從這些類別的實例上，分別取得標示於其上的Annotation與其資訊，如果RetentionPolicy為RUNTIME的話。
舉個例子來說，假設您設計了以下的Debug Annotation：
* Debug.java
package onlyfun.caterpillar;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
public @interface Debug {
String value();
String name();
}
由於RetentionPolicy為RUNTIME，編譯器在處理Debug Annotation時，會將之編譯至class檔中，並可以VM讀出Annotation資訊，接著我們將Debug用於程式中：
* SomeObject.java
package onlyfun.caterpillar;
public class SomeObject {
@Debug(
value = unit,
name = debug1
)
public void doSomething() {
// ....
}
}
可以設計一個工具程式來讀取Annotation資訊：
* DebugTool.java
package onlyfun.caterpillar;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
public class DebugTool {
public static void main(String[] args)
throws NoSuchMethodException {
Class<SomeObject> c = SomeObject.class;
Method method = c.getMethod(doSomething);
if(method.isAnnotationPresent(Debug.class)) {
System.out.println(@Debug is found.);
Debug debug = method.getAnnotation(Debug.class);
System.out.println( value = + debug.value());
System.out.println( name = + ());
}
else {
System.out.println(@Debug is not found.);
}
Annotation[] annotations = method.getAnnotations();
for(Annotation annotation : annotations) {
System.out.println(
annotation.annotationType().getName());
}
}
}
程式的執行結果如下：
@Debug is found.
value = unit
name = debug1
onlyfun.caterpillar.Debug
4. java內部註解是如何實現的
用一個詞就可以描述註解，那就是元數據，即一種描述數據的數據。所以，可以說註解就是源代碼的元數據。比如，下面這段代碼：
@Override
public String toString() {
return "This is String Representation of current object.";
}
上面的代碼中，我重寫了toString()方法並使用了@Override註解。但是，即使我不使用@Override註解標記代碼，程序也能夠正常執行。那麼，該註解表示什麼？這么寫有什麼好處嗎？事實上，@Override告訴編譯器這個方法是一個重寫方法(描述方法的元數據)，如果父類中不存在該方法，編譯器便會報錯，提示該方法沒有重寫父類中的方法。如果我不小心拼寫錯誤，例如將toString()寫成了toStrring(){double r}，而且我也沒有使用@Override註解，那程序依然能編譯運行。但運行結果會和我期望的大不相同。現在我們了解了什麼是註解，並且使用註解有助於閱讀程序。
Annotation是一種應用於類、方法、參數、變數、構造器及包聲明中的特殊修飾符。它是一種由JSR-175標准選擇用來描述元數據的一種工具。
為什麼要引入註解？
使用Annotation之前(甚至在使用之後)，XML被廣泛的應用於描述元數據。不知何時開始一些應用開發人員和架構師發現XML的維護越來越糟糕了。他們希望使用一些和代碼緊耦合的東西，而不是像XML那樣和代碼是松耦合的(在某些情況下甚至是完全分離的)代碼描述。如果你在Google中搜索「XML vs. annotations」，會看到許多關於這個問題的辯論。最有趣的是XML配置其實就是為了分離代碼和配置而引入的。上述兩種觀點可能會讓你很疑惑，兩者觀點似乎構成了一種循環，但各有利弊。下面我們通過一個例子來理解這兩者的區別。
假如你想為應用設置很多的常量或參數，這種情況下，XML是一個很好的選擇，因為它不會同特定的代碼相連。如果你想把某個方法聲明為服務，那麼使用Annotation會更好一些，因為這種情況下需要註解和方法緊密耦合起來，開發人員也必須認識到這點。
另一個很重要的因素是Annotation定義了一種標準的描述元數據的方式。在這之前，開發人員通常使用他們自己的方式定義元數據。例如，使用標記interfaces，注釋，transient關鍵字等等。每個程序員按照自己的方式定義元數據，而不像Annotation這種標準的方式。
目前，許多框架將XML和Annotation兩種方式結合使用，平衡兩者之間的利弊。
Annotation是如何工作的？怎麼編寫自定義的Annotation？
在講述這部分之前，建議你首先下載Annotation的示例代碼AnnotationsSample.zip 。下載之後放在你習慣使用的IDE中，這些代碼會幫助你更好的理解Annotation機制。
編寫Annotation非常簡單，可以將Annotation的定義同介面的定義進行比較。我們來看兩個例子：一個是標準的註解@Override，另一個是用戶自定義註解@Todo。
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
對於@Override注釋你可能有些疑問，它什麼都沒做，那它是如何檢查在父類中有一個同名的函數呢。當然，不要驚訝，我是逗你玩的。@Override註解的定義不僅僅只有這么一點代碼。這部分內容很重要，我不得不再次重復：Annotations僅僅是元數據，和業務邏輯無關。理解起來有點困難，但就是這樣。如果Annotations不包含業務邏輯，那麼必須有人來實現這些邏輯。元數據的用戶來做這個事情。Annotations僅僅提供它定義的屬性(類/方法/包/域)的信息。Annotations的用戶(同樣是一些代碼)來讀取這些信息並實現必要的邏輯。
當我們使用Java的標注Annotations(例如@Override)時，JVM就是一個用戶，它在位元組碼層面工作。到這里，應用開發人員還不能控制也不能使用自定義的註解。因此，我們講解一下如何編寫自定義的Annotations。
我們來逐個講述編寫自定義Annotations的要點。上面的例子中，你看到一些註解應用在註解上。
J2SE5.0版本在 java.lang.annotation提供了四種元註解，專門註解其他的註解：
@Documented –註解是否將包含在JavaDoc中
@Retention –什麼時候使用該註解
@Target? –註解用於什麼地方
@Inherited – 是否允許子類繼承該註解
@Documented–一個簡單的Annotations標記註解，表示是否將註解信息添加在java文檔中。
@Retention– 定義該註解的生命周期。
RetentionPolicy.SOURCE – 在編譯階段丟棄。這些註解在編譯結束之後就不再有任何意義，所以它們不會寫入位元組碼。@Override, @SuppressWarnings都屬於這類註解。
RetentionPolicy.CLASS – 在類載入的時候丟棄。在位元組碼文件的處理中有用。註解默認使用這種方式。
RetentionPolicy.RUNTIME– 始終不會丟棄，運行期也保留該註解，因此可以使用反射機制讀取該註解的信息。我們自定義的註解通常使用這種方式。
@Target – 表示該註解用於什麼地方。如果不明確指出，該註解可以放在任何地方。以下是一些可用的參數。需要說明的是：屬性的註解是兼容的，如果你想給7個屬性都添加註解，僅僅排除一個屬性，那麼你需要在定義target包含所有的屬性。
ElementType.TYPE:用於描述類、介面或enum聲明
ElementType.FIELD:用於描述實例變數
ElementType.METHOD
ElementType.PARAMETER
ElementType.CONSTRUCTOR
ElementType.LOCAL_VARIABLE
ElementType.ANNOTATION_TYPE 另一個注釋
ElementType.PACKAGE 用於記錄java文件的package信息
@Inherited – 定義該注釋和子類的關系
那麼，註解的內部到底是如何定義的呢？Annotations只支持基本類型、String及枚舉類型。注釋中所有的屬性被定義成方法，並允許提供默認值。
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface Todo {
public enum Priority {LOW, MEDIUM, HIGH}
public enum Status {STARTED, NOT_STARTED}
String author() default "Yash";
Priority priority() default Priority.LOW;
Status status() default Status.NOT_STARTED;
}
下面的例子演示了如何使用上面的註解。
@Todo(priority = Todo.Priority.MEDIUM, author = "Yashwant", status = Todo.Status.STARTED)
public void incompleteMethod1() {
//Some business logic is written
//But it』s not complete yet
}
如果註解中只有一個屬性，可以直接命名為「value」，使用時無需再標明屬性名。
@interface Author{
String value();
}
@Author("Yashwant")
public void someMethod() {
}
但目前為止一切看起來都還不錯。我們定義了自己的註解並將其應用在業務邏輯的方法上。現在我們需要寫一個用戶程序調用我們的註解。這里我們需要使用反射機制。如果你熟悉反射代碼，就會知道反射可以提供類名、方法和實例變數對象。所有這些對象都有getAnnotation()這個方法用來返回註解信息。我們需要把這個對象轉換為我們自定義的注釋(使用 instanceOf()檢查之後)，同時也可以調用自定義注釋裡面的方法。看看以下的實例代碼，使用了上面的註解:
Class businessLogicClass = BusinessLogic.class;
for(Method method : businessLogicClass.getMethods()) {
Todo todoAnnotation = (Todo)method.getAnnotation(Todo.class);
if(todoAnnotation != null) {
System.out.println(" Method Name : " + method.getName());
System.out.println(" Author : " + todoAnnotation.author());
System.out.println(" Priority : " + todoAnnotation.priority());
System.out.println(" Status : " + todoAnnotation.status());
}
5. java 中的Annotation()方法是什麼意思，，干什麼的
是註解
干什麼的就是不用再去配置XML文件
6. java Annotation @lazy是什麼意思
首先要說明的是，@lazy這個註解通常指的是hibernate庫的lazy，通常稱為懶載入。
在Hibernate框架中，當我們要訪問的數據量過大時，明顯用緩存不太合適， 因為內存容量有限 ，為了減少並發量，減少系統資源的消耗，這時Hibernate用懶載入機制來彌補這種缺陷，但是這只是彌補而不是用了懶載入總體性能就提高了。
我們所說的懶載入也被稱為延遲載入，它在查詢的時候不會立刻訪問資料庫，而是返回代理對象，當真正去使用對象的時候才會訪問資料庫。
下面幾種可以實現懶載入功能：
1、 通過Session.load()實現懶載入
load(Object, Serializable)：根據id查詢 。查詢返回的是代理對象，不會立刻訪問資料庫，是懶載入的。當真正去使用對象的時候才會訪問資料庫。
用load()的時候會發現不會列印出查詢語句，而使用get()的時候會列印出查詢語句。
使用load()時如果在session關閉之後再查詢此對象，會報異常：could not initialize proxy - no Session。處理辦法：在session關閉之前初始化一下查詢出來的對象：Hibernate.initialize(user);
使用load()可以提高效率，因為剛開始的時候並沒有查詢資料庫。但很少使用。
2、 one-to-one(元素)實現了懶載入。
在一對一的時候，查詢主對象時默認不是懶載入。即：查詢主對象的時候也會把從對象查詢出來。
需要把主對象配製成lazy="true" constrained="true" fetch="select"。此時查詢主對象的時候就不會查詢從對象，從而實現了懶載入。
一對一的時候，查詢從對象的是默認是懶載入。即：查詢從對象的時候不會把主對象查詢出來。而是查詢出來的是主對象的代理對象。
3、 many-to-one（元素）實現了懶載入。
多對一的時候，查詢主對象時默認是懶載入。即：查詢主對象的時候不會把從對象查詢出來。
多對一的時候，查詢從對象時默認是懶載入。即：查詢從對象的時候不會把主對象查詢出來。
hibernate3.0中lazy有三個值，true，false，proxy,默認的是lazy="proxy".具體設置成什麼要看你的需求，並不是說哪個設置就是最好的。在<many-to-one>與<one-to-one>標簽上:當為true時,會有懶載入特性,當為false時會產生N+1問題,比如一個學生對應一個班級,用一條SQL查出10個學生,當訪問學生的班級屬性時Hibernate會再產生10條SQL分別查出每個學生對應的班級.
lazy= 什麼時候捉取
fetch= 捉取方式:select=關聯查詢;join=連接表的方式查詢(效率高)
fetch=join時,lazy的設置將沒有意義.
4、 one-to-many(元素)懶載入：默認會懶載入，這是必須的，是重常用的。
一對多的時候，查詢主對象時默認是懶載入。即：查詢主對象的時候不會把從對象查詢出來。
一對多的時候，查詢從對象時默認是懶載入。即：查詢從對象的時候不會把主對象查詢出來。
需要配置主對象中的set集合lazy="false" 這樣就配置成是不懶載入了。或者配置抓取方式fetch="join"也可以變成不懶載入。
7. java中的 Annotation類。希望高手能夠簡單明了解釋下用法和作用
java.lang.annotation，介面 Annotation。對於Annotation，是Java5的新特性，JDK5引入了Metedata(元數據)很容易的就能夠調用Annotations.Annotations提供一些本來不屬於程序的數據，比如:一段代碼的作者或者告訴編譯器禁止一些特殊的錯誤。An annotation 對代碼的執行沒有什麼影響。Annotations使用@annotation的形勢應用於代碼：類(class),屬性(field),方法(method)等等。一個Annotation出現在上面提到的開始位置，而且一般只有一行,也可以包含有任意的參數。
public interface Annotation所有 annotation 類型都要擴展的公共介面。注意，手動擴展該公共介面的介面不 定義 annotation 類型。還要注意此介面本身不定義 annotation 類型。 對於Annotation，是Java5的新特性，下面是Sun的Tutorial的描述，因為是英文，這里我翻譯下，希望能夠比較清晰的描述一下Annotation的語法以及思想。Annotation:Release 5.0 of the JDK introced a metadata facility called annotations. Annotations provide data about a program that is not part of the program, such as naming the author of a piece of code or instructing the compiler to suppress specific errors. An annotation has no effect on how the code performs. Annotations use the form @annotation and may be applied to a program's declarations: its classes, fields, methods, and so on. The annotation appears first and often (by convention) on its own line, and may include optional arguments: JDK5引入了Metedata(元數據)很容易的就能夠調用Annotations.Annotations提供一些本來不屬於程序的數據，比如:一段代碼的作者或者告訴編譯器禁止一些特殊的錯誤。An annotation 對代碼的執行沒有什麼影響。Annotations使用@annotation的形勢應用於代碼：類(class),屬性(field),方法(method)等等。一個Annotation出現在上面提到的開始位置，而且一般只有一行,也可以包含有任意的參數。@Author("MyName")class myClass() { } or @SuppressWarnings("unchecked")void MyMethod() { } Defining your own annotation is an advanced technique that won't be described here, but there are three built-in annotations that every Java programmer should know: @Deprecated, @Override, and @SuppressWarnings. The following example illustrates all three annotation types, applied to methods: 定義自己的Annotation是一個比較高級的技巧，這里我們不做討論，這里我們僅僅討論每一個Java programer都應該知道的內置的annotations:@Deprecated, @Override, and @SuppressWarnings。下面的程序闡述了這三種annotation如何應用於methods。import java.util.List; class Food {} class Hay extends Food {} class Animal { Food getPreferredFood() { return null; } /** * @deprecated document why the method was deprecated */ @Deprecated static void deprecatedMethod() { } } class Horse extends Animal { Horse() { return; } @Override Hay getPreferredFood() { return new Hay(); } @SuppressWarnings("deprecation") void useDeprecatedMethod() { Animal.deprecateMethod(); //deprecation warning - suppressed }} } } @DeprecatedThe @Deprecated annotation indicates that the marked method should no longer be used. The compiler generates a warning whenever a program uses a deprecated method, class, or variable. When an element is deprecated, it should be documented using the corresponding @deprecated tag, as shown in the preceding example. Notice that the tag starts with a lowercase "d" and the annotation starts with an uppercase "D". In general, you should avoid using deprecated methods — consult the documentation to see what to use instead. @Deprecated@Deprecated annotation標注一個method不再被使用。編譯器在一個program(程序？)使用了不贊成的方法，類，變數的時候會產生警告(warning)。如果一個元素(element:method, class, or variable)不贊成被使用，應該像前面的例子里使用相應的@deprecated 標簽，並且注意標簽的首字母是小寫的"d",而annotation時大寫的"D"。一般情況下，我們應該避免使用不贊成使用的方法(deprecated methods)，而應該考慮替代的方法。 @OverrideThe @Override annotation informs the compiler that the element is meant to override an element declared in a superclass. In the preceding example, the override annotation is used to indicate that the getPreferredFood method in the Horse class overrides the same method in the Animal class. If a method marked with @Override fails to override a method in one of its superclasses, the compiler generates an error. While it's not required to use this annotation when overriding a method, it can be useful to call the fact out explicitly, especially when the method returns a subtype of the return type of the overridden method. This practice, called covariant return types, is used in the previous example: Animal.getPreferredFood returns a Food instance. Horse.getPreferredFood (Horse is a subclass of Animal) returns an instance of Hay (a subclass of Food). For more information, see Overriding and Hiding Methods. @Override@Override annotation 告訴編譯器當前元素是重寫(override)自父類的一個元素。在前面的例子中，override annotation用來說明Horse類中的getPreferredFood這個方法重寫(override)自Animal類中相同的方法。如果一個方法被標注了@Override，但是其父類中沒有這個方法時，編譯器將會報錯。但是並不是說我們一定要使用這個annotation，但是它能夠很明顯的給出實際行為，尤其是在方法返回一個被重寫的方法返回類型的子類型的時候。上面的例子中，Animal.getPreferredFood 返回一個 Food實例，Horse.getPreferredFood 返回一個Hay實例，這里Horse是Animal的子類，Hay是Food的子類。 @SuppressWarningsThe @SuppressWarnings annotation tells the compiler to suppress specific warnings that it would otherwise generate. In the previous example, the useDeprecatedMethod calls a deprecated method of Animal. Normally, the compiler generates a warning but, in this case, it is suppressed. Every compiler warning belongs to a category. The Java Language Specification lists two categories: "deprecation" and "unchecked". The "unchecked" warning can occur when interfacing with legacy code written before the advent of generics. To suppress more than one category of warnings, use the following syntax: @SuppressWarnings@SuppressWarnings annotation 告訴編譯器禁止別的元素產生的特殊的警告(warnings)，在前面的例子里，useDeprecatedMethod調用了Animal的不贊成使用的一個方法。一般情況下，編譯器會給出一個警告(warning)，但是在這種情況下，不會產生這個警告，也就是說被suppress。每個編譯器的警告都屬於一個類型。Java Language Specification列出了兩種類型："deprecation" 和 "unchecked"。"unchecked" warning 發生在使用非generic的舊代碼交互的generic collection類時。為了禁止不止一種的警告時，使用下面的語法:@SuppressWarnings({"unchecked", "deprecation"})
8. Annotation 註解開發介紹優勢 與好處java為什麼採用註解開發
簡單的舉例一下，
Annotation的作用:
編寫文檔
代碼分析
編譯檢查。
如使用註解注入bean，好處是
1,使用時，不再以平常的new 構造器來創建類的一個實例，丟棄了右邊的new 。。。，只有左邊的bean聲明 ，並在聲明上方添加@resource（name=「。。。。」）注入。只要在編寫程序時添加一些要用到註解，以及註解的說明，就可以生成相應的javaDoc文檔，以便開發人員快速了解程序的整體輪廓。這是不用註解難以做到的
2.java虛擬機可以識別註解，通過註解告訴虛擬機要實現的功能，修正一些編譯期人為的錯誤，如我們要重寫toString,但是卻寫成tostring,如果沒有註解，編譯器就不會作編譯時檢查，就把這個tostring當初普通的方法，不會報錯。
3.使用主流框架開發時，通常會在xml文件配置bean等的注入類型，而xml文件開啟註解支持後自動配置，不需要人工配置，減少開發時間，提高開發效率
等。。。。
9. java annotation屬性為什麼有括弧
請輸入你Annotation提供了一條與程序元素關聯任何或者任何元數據（metadata）的途徑。從某些方面看，annotation就像修飾符一樣被使用，並應用於包、類型、構造方法、方法、成員變數、參數、本地變數的聲明中。這些被存儲在annotation的「name=value」結構對中。annotation類型是一種介面，能夠通過反射API的方式提供對其的訪問。
annotation能被用來為某個程序元素（類、方法、成員變數等）關聯任何的。需要注意的是，這里存在著一個基本的潛規則：annotaion不能影響程序代碼的執行，無論增加、刪除annotation，代碼都始終如一的執行。另外，盡管一些annotation通過java的反射api方法在運行時被訪問，而java語言解釋器在工作時忽略了這些annotation。正是由於忽略了annotation，導致了annotation類型在代碼中是「不起作用」的；只有通過某種配套的工具才會對annotation類型中的進行訪問和處理。本文中將涵蓋標準的annotation和meta-annotation類型，陪伴這些annotation類型的工具是java編譯器（當然要以某種特殊的方式處理它們）。
10. java annotation有什麼作用
Annontation是Java5開始引入的新特徵。中文名稱一般叫註解。它提供了一種安全的類似注釋的機制，用來將任何的信息或元數據（metadata）與程序元素（類、方法、成員變數等）進行關聯。
annotation一般作為一種輔助途徑，應用在軟體框架或工具中，在這些工具類中根據不同的 annontation註解信息採取不同的處理過程或改變相應程序元素（類、方法及成員變數等）的行為。
例如：Junit、Struts、Spring等流行工具框架中均廣泛使用了annontion。使代碼的靈活性大提高。
從java5版本開始，自帶了三種標准annontation類型,
（1）、Override
java.lang.Override 是一個marker annotation類型，它被用作標注方法。它說明了被標注的方法重載了父類的方法，起到了斷言的作用。如果我們使用了這種annotation在一個沒有覆蓋父類方法的方法時，java編譯器將以一個編譯錯誤來警示。
這個annotaton常常在我們試圖覆蓋父類方法而確又寫錯了方法名時加一個保障性的校驗過程。
（2）、Deprecated
Deprecated也是一種marker annotation。當一個類型或者類型成員使用@Deprecated修飾的話，編譯器將不鼓勵使用這個被標注的程序元素。所以使用這種修飾具有一定的 「延續性」：如果我們在代碼中通過繼承或者覆蓋的方式使用了這個過時的類型或者成員，雖然繼承或者覆蓋後的類型或者成員並不是被聲明為@Deprecated，但編譯器仍然要報警。
注意：@Deprecated這個annotation類型和javadoc中的 @deprecated這個tag是有區別的：前者是java編譯器識別的，而後者是被javadoc工具所識別用來生成文檔（包含程序成員為什麼已經過時、它應當如何被禁止或者替代的描述）。
（3）、SuppressWarnings
此註解能告訴Java編譯器關閉對類、方法及成員變數的警告。
有時編譯時會提出一些警告，對於這些警告有的隱藏著Bug，有的是無法避免的，對於某些不想看到的警告信息，可以通過這個註解來屏蔽。
SuppressWarning不是一個marker annotation。它有一個類型為String[]的成員，這個成員的值為被禁止的警告名。對於javac編譯器來講，被-Xlint選項有效的警告名也同樣對@SuppressWarings有效，同時編譯器忽略掉無法識別的警告名。