java注解

java内置了三种注解，定义在java.lang包中。 
@Override 表示当前方法是覆盖父类的方法。 
@Deprecated 表示当前元素是不赞成使用的。 
@SuppressWarnings表示关闭一些不当的编译器警告信息。
以下介绍SuppressWarnings的一些参数
1、deprecation 使用了不赞成使用的类或方法时的警告
2、unchecked 执行了未检查的转换时警告
3、fallthrough 当使用switch操作时case后未加入break操作，而导致程序继续执行其他case语句时出现的警告
4、path 当设置一个错误的类路径、源文件路径时出现的警告
5、serial 当在可序列化的类上缺少serialVersionUID定义时的警告
6、fianally 任何finally子句不能正常完成时警告
7、all 关于以上所有情况的警告
接下来利用一个注解实例来体验注解的处理过程

1. 
   import java.lang.annotation.Documented;       
2.  import java.lang.annotation.Inherited;       
3.  import java.lang.annotation.Retention;       
4.  import java.lang.annotation.Target;       
5.  import java.lang.annotation.ElementType;       
6.  import java.lang.annotation.RetentionPolicy;       
7.        
8.  /*    
9.   * 元注解@Target,@Retention,@Documented,@Inherited    
10.   *     
11.   * @Target 表示该注解用于什么地方，可能的 ElemenetType 参数包括：    
12.   * ElemenetType.CONSTRUCTOR 构造器声明    
13.   * ElemenetType.FIELD 域声明（包括 enum 实例）    
14.   * ElemenetType.LOCAL_VARIABLE 局部变量声明    
15.   * ElemenetType.METHOD 方法声明    
16.   * ElemenetType.PACKAGE 包声明    
17.   * ElemenetType.PARAMETER 参数声明    
18.   * ElemenetType.TYPE 类，接口（包括注解类型）或enum声明    
19.   *             
20.   * @Retention 表示在什么级别保存该注解信息。可选的 RetentionPolicy 参数包括：    
21.   * RetentionPolicy.SOURCE 注解将被编译器丢弃    
22.   * RetentionPolicy.CLASS 注解在class文件中可用，但会被VM丢弃    
23.   * RetentionPolicy.RUNTIME VM将在运行期也保留注释，因此可以通过反射机制读取注解的信息。    
24.   *             
25.   *@Documented 将此注解包含在 javadoc 中    
26.   *         
27.   *@Inherited 允许子类继承父类中的注解    
28.   *       
29.   */      
30.  @Target(ElementType.METHOD)       
31.  @Retention(RetentionPolicy.RUNTIME)       
32.  @Documented      
33.  @Inherited      
34.  /*    
35.   * 定义注解 Test    
36.   * 注解中含有两个元素 id 和 description    
37.   * description 元素 有默认值 "no description"    
38.   */      
39.  public @interface Test {       
40.      public int id();       
41.      public String description() default "no description";       
42.  } 

下面是使用注解的实例。

1. 
   package al.annotation;  
2.   
3. import java.lang.annotation.Annotation;  
4. import java.lang.reflect.Method;  
5.   
6. public class Test_1 {    
7.     @Test(id=1,description="m1")  
8.     public void method_1() {    
9.     }  
10.     @Test(id=2,description="m2")  
11.     public void method_2() {      
12.     }  
13.     @Test(id=3,description="m3")  
14.     public void method_3() {      
15.     }  
16.     public static void main(String[] args) {        
17.         try {                
18.             Method[] me = Class.forName("al.annotation.Test_1").getMethods();  
19.             for( Method m:me){                   
20.                 Annotation[] ann = m.getAnnotations();                    
21.                 for(Annotation a:ann){                        
22.                     System.out.println(((Test)a).id());  
23.                     System.out.println(((Test)a).description());  
24.                 }  
25.             }  
26.          } catch (SecurityException e) {  
27.             // TODO Auto-generated catch block  
28.             e.printStackTrace();  
29.         } catch (ClassNotFoundException e) {  
30.             // TODO Auto-generated catch block  
31.             e.printStackTrace();  
32.         }  
33.     }  
34. }  

输出结果

1

m1
2
m2
3
m3