Java注解之Retention、Documented、Inherited介绍

Retention注解

Retention(保留)注解说明,这种类型的注解会被保留到那个阶段. 有三个值:
1.RetentionPolicy.SOURCE —— 这种类型的Annotations只在源代码级别保留,编译时就会被忽略
2.RetentionPolicy.CLASS —— 这种类型的Annotations编译时被保留,在class文件中存在,但JVM将会忽略
3.RetentionPolicy.RUNTIME —— 这种类型的Annotations将被JVM保留,所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用.
示例演示了 RetentionPolicy.RUNTIME 的声明:

@Retention(RetentionPolicy.RUNTIME)

public @interface Test_Retention {

   String doTestRetention();

}

 在这个示例中, @Retention(RetentionPolicy.RUNTIME)注解表明 Test_Retention注解将会由虚拟机保留,以便它可以在运行时通过反射读取.

 

Documented 注解

Documented 注解表明这个注解应该被 javadoc工具记录. 默认情况下,javadoc是不包括注解的. 但如果声明注解时指定了 @Documented,则它会被 javadoc 之类的工具处理, 所以注解类型信息也会被包括在生成的文档中.

示例进一步演示了使用 @Documented:

@Documented

public @interface Test_Documented {

   String doTestDocument();

}

 

public class TestAnnotations {

   public static void main(String arg[]) {

      new TestAnnotations().doSomeTestRetention();

      new TestAnnotations().doSomeTestDocumented();

   }

   @Test_Retention (doTestRetention="保留注解信息测试")

   public void doSomeTestRetention() {

      System.out.printf("测试注解类型 'Retention'");

   }

   @Test_Documented(doTestDocument="Hello document")

   public void doSomeTestDocumented() {

      System.out.printf("测试注解类型 'Documented'");

   }

}

 现在,如果你使用 javadoc命令生成 TestAnnotations.html文件,你将看到类似于图的结果.

 

从截图可以看到,文档中没有 doSomeTestRetention() 方法的 annotation-type信息()方法. 但是, doSomeTestDocumented() 方法的文档提供了注解的描述信息. 这是因为 @Documented标签被加到了Test_Documented注解上. 之前的注解Test_Retention并没有指定 @Documented 标记(tag).

Inherited 注解

这是一个稍微复杂的注解类型. 它指明被注解的类会自动继承. 更具体地说,如果定义注解时使用了 @Inherited 标记,然后用定义的注解来标注另一个父类, 父类又有一个子类(subclass),则父类的所有属性将被继承到它的子类中. 在示例7中,你会看到使用 @Inherited 标签的好处.

@Inherited

public @interface MyParentObject { 

      boolean isInherited() default true;

      String doSomething() default "Do what?";

}

 

@MyParentObject

public Class MyChildObject {

}

 正如你看到的,你不需要在实现类中定义接口方法. 因为使用 @Inherited标记，这些都自动继承了. 如果你使用一种古老的方式定义实现类,会是什么样子呢? 看看下面这张 古老的实现方式吧:

public class MyChildObject implements MyParentObject {

   public boolean isInherited() {

      return false;

   }

   public String doSomething() {

      return "";

   }

   public boolean equals(Object obj) {

      return false;

   }

   public int hashCode() {

      return 0;

   }

   public String toString() {

      return "";

   }

   public Class annotationType() {

      return null;

   }

}

 看到的区别吗? 可以看到,你必须实现父接口的所有方法. 除了isInherited()和从myParentObject doSomething()方法外,你还需要实现 java.lang.Object的 equals(),toString()和hasCode()方法. 还有 java.lang.annotation.Annotation 类的 annotationType()方法. 不管你是不是想要实现这些方法,你必须在继承的对象中包含这些.

 

from:http://www.jb51.net/article/55371.htm

   我们自定义注解(Annotation)时，把自定义的注解标注在父类上不会被子类所继承，但是我们可以在定义注解时给我们自定义的注解标注一个@Inherited注解来实现注解继承。 

自定义的注解代码如下: 

Java代码  

1. package com.xdf.annotation;  
2.   
3. import java.lang.annotation.Inherited;  
4. import java.lang.annotation.Retention;  
5.   
6. @Inherited  
7. @Retention(java.lang.annotation.RetentionPolicy.RUNTIME)  
8.   
9. public @interface InheritedAnnotation {  
10.   
11.     String value();  
12.   
13. }  

接着定义一个抽象父类 
代码如下: 

Java代码  

1. package com.xdf.annotation;  
2.   
3. public abstract class AbstractParent {  
4.   
5.     @InheritedAnnotation(value = "parent abstractMethod ")  
6.      public abstract void abstractMethod();  
7.       
8.     @InheritedAnnotation(value = "Parent's doExtends")  
9.      public void doExtends() {  
10.       System.out.println(" AbstractParent doExtends ...");  
11.      }  
12.   
13.       
14. }  

我们把自定义的注解父类里的方法上。 

接着定义一个继承抽象父类(AbstractParent)的子类 
代码如下: 

Java代码  

1. package com.xdf.annotation;  
2.   
3. public class SubClassImpl extends AbstractParent{  
4.   
5.     @Override  
6.     public void abstractMethod() {  
7.     System.out.println("子类实现抽象父类的抽象方法");  
8.           
9.     }  
10.   
11. }  

在子类中实现了abstractMethod抽象方法，没有重写doExtends方法。 

测试类代码如下: 

Java代码  

1. package com.xdf.annotation;  
2.   
3. import java.lang.reflect.Method;  
4.   
5. public class InheritedAnnotationTest {  
6.   
7.     public static void main(String[] args) throws SecurityException, NoSuchMethodException {  
8.           
9.           Class<SubClassImpl> clazz=SubClassImpl.class;  
10.            
11.             
12.             //abstractMethod  
13.           Method method = clazz.getMethod("abstractMethod", new Class[]{});  
14.           if(method.isAnnotationPresent(InheritedAnnotation.class)){  
15.               InheritedAnnotation ma = method.getAnnotation(InheritedAnnotation.class);  
16.            System.out.println("子类实现的抽象方法继承到父类抽象方法中的Annotation,其信息如下：");  
17.            System.out.println(ma.value());  
18.           }else{  
19.            System.out.println("子类实现的抽象方法没有继承到父类抽象方法中的Annotation");  
20.           }  
21.             
22.             
23.             
24.           
25.           Method methodOverride = clazz.getMethod("doExtends", new Class[]{});  
26.           if(methodOverride.isAnnotationPresent(InheritedAnnotation.class)){  
27.               InheritedAnnotation ma = methodOverride.getAnnotation(InheritedAnnotation.class);  
28.            System.out.println("子类doExtends方法继承到父类doExtends方法中的Annotation,其信息如下：");  
29.            System.out.println(ma.value());  
30.           }else{  
31.            System.out.println("子类doExtends方法没有继承到父类doExtends方法中的Annotation");  
32.           }  
33.   
34.           
35.   
36.     }       
37.                
38. }  

运行结果如下: 

Java代码  

1. 子类实现的抽象方法没有继承到父类抽象方法中的Annotation  
2. 子类doExtends方法继承到父类doExtends方法中的Annotation,其信息如下：  
3. Parent's doExtends  

从以上代码运行的结果可以得到如下结论： 
1.如果子类继承父类，并且重写了父类中的带有注解的方法，那么父类方法上的注解是不会被子类继承的。 
2.如果子类继承父类，但是没有重写父类中带有注解的方法，那么父类方法上的注解会被子类继承，就是说在子类中可以得到父类方法上的注解。 

但是.....但是....当我把自定义的注解上的@Inherited注解去掉运行，结果还是一样，也就是说这个@Inherited注解根本没有起作用。这是什么神马情况呢？ 

接着我把没有标注@Inherited注解的自定义的注解标注在类级别上(不是方法级别上)，把抽象父类改成下面这样： 

Java代码  

1. package com.xdf.annotation;  
2.   
3.   
4. @InheritedAnnotation(value="parent")   //把自定义注解标注在父类上  
5. public abstract class AbstractParent {  
6.   
7.     @InheritedAnnotation(value = "parent abstractMethod ")  
8.      public abstract void abstractMethod();  
9.       
10.     @InheritedAnnotation(value = "Parent's doExtends")  
11.      public void doExtends() {  
12.       System.out.println(" AbstractParent doExtends ...");  
13.      }  
14.   
15.       
16. }  

然后在测试类的main方法里加了如下测试代码: 

Java代码  

1. if(clazz.isAnnotationPresent(InheritedAnnotation.class)){  
2.               InheritedAnnotation cla = clazz.getAnnotation(InheritedAnnotation.class);  
3.            System.out.println("子类继承到父类类上Annotation,其信息如下：");  
4.            System.out.println(cla.value());  
5.           }else{  
6.               System.out.println("子类没有继承到父类类上Annotation");  
7.           }  

这是出现情况了,运行main方法得到结果: 

Java代码  

1. 子类实现的抽象方法没有继承到父类抽象方法中的Annotation  
2. 子类doExtends方法继承到父类doExtends方法中的Annotation,其信息如下：  
3. Parent's doExtends  
4. 子类没有继承到父类类上Annotation  

从运行结果中可以发现子类并没有继承父类类级别的注解，于是我又把@Inherited注解标注在自定义注解上，然后运行一下，得到如下结果: 

Java代码  

1. 子类实现的抽象方法没有继承到父类抽象方法中的Annotation  
2. 子类doExtends方法继承到父类doExtends方法中的Annotation,其信息如下：  
3. Parent's doExtends  
4. 子类继承到父类类上Annotation,其信息如下：  
5. parent  

注意运行结果，子类继承了父类类级别的注解了。 

这说明什么呢？ 
说明这种标有@Inherited注解的自定义的注解运用到类级别上和方法级别上是不一样的，如果把标有@Inherited注解的自宝义的注解标注在类级别上，子类则可以继承父类类级别的注解，反之，则不行。

 from:http://xiangdefei.iteye.com/blog/1044199