Java - 註解(1)

大綱：
使用註解的好處；
註解的概念；
Java中的常見註解；
註解的分類；
自定義註解；

註解的好處：讓編程更加簡潔，代碼更加清晰；

註解的概念：Java提供了一種原程序中的元素關聯任何信息和任何元數據的途徑和方法；

Java中的常見註解：
 JDK自帶的註解：
  @Override：
  @Deprecated：會和@Suppvisewarnings一塊兒使用；
  @Suppvisewarnings：

 1 /**
 2  * @Deprecated 和 @SuppressWarnings 兩個註解的使用
 3  */
 4 package annotation;
 5 
 6 public class AnnotationTest01
 7 {
 8     @SuppressWarnings("deprecation")
 9     public void test01()
10     {
11         Person p = new Child();
12         
13         // 加了橫線，表示這個方法已通過時了，有一個警告；
14         // 但爲了去掉警告（通常公司都會要求），能夠加上 @SuppressWarnings("deprecation") 註解，表示忽略這種警告
15         // 注意，註解必須加在方法上面
16         p.sing();
17     }
18 }
19 
20 interface Person
21 {
22     public String name();
23     
24     public int age();
25     
26     // 表示這個方法已通過時了，方法名上會多一個橫線
27     @Deprecated
28     public void sing();
29 }
30 
31 class Child implements Person
32 {
33     // 實現了父類接口，就要重寫（覆蓋）父類的方法，使用 @Override 註解
34     @Override
35     public String name()
36     {
37         return null;
38     }
39 
40     @Override
41     public int age()
42     {
43         return 0;
44     }
45 
46     @Override
47     public void sing()
48     {
49         
50     }
51 }

@Deprecated 和 @SuppressWarnings 兩個註解的使用

 Spring中的經常使用註解：
  @Autowired：
  @Service：
  @Repository：
 SpringMVC中的經常使用註解：
 MyBatis中的經常使用註解：
  @InsertProvider：
  @UpdateProvider：
  @Options：

註解的分類：
 按照運行機制區分：
  源碼註解：註解只在源碼中存在，編譯成.class文件就不存在了；
  編譯時註解：在源碼和.class文件中都存在；
  運行時註解：在運行階段還起做用，甚至會影響運行邏輯的註解；
 按照來源區分：
  來自JDK的註解：
  來自第三方的註解：好比來自Spring、MyBatis等；
  自定義的註解：

自定義註解：
語法：

 1 /**
 2  * 自定義註解
 3  */
 4 package annotation;
 5 
 6 import java.lang.annotation.Documented;
 7 import java.lang.annotation.ElementType;
 8 import java.lang.annotation.Inherited;
 9 import java.lang.annotation.Retention;
10 import java.lang.annotation.RetentionPolicy;
11 import java.lang.annotation.Target;
12 
13 @Target({ElementType.METHOD,ElementType.TYPE})
14 @Retention(RetentionPolicy.RUNTIME)
15 @Inherited
16 @Documented
17 public @interface Description
18 {
19     String desc();
20     
21     String author();
22     
23     int age() default 18;
24 }

自定義註解

元註解：對註解進行註解的註解； 注意：使用繼承註解時，只能繼承類上面的註解（即不能繼承接口上面的註解，也不能繼承父類中方法上的註解）
使用自定義註解：

 

 1 /**
 2  * 使用自定義註解
 3  */
 4 package annotation;
 5 
 6 public class AnnotationTest02
 7 {
 8     @Description(desc="I an eyeColor",author="Mooc boy",age=20)
 9     public String eyeColor()
10     {
11         return "red";
12     }
13     
14     public static void main(String[] args)
15     {
16         AnnotationTest02 test = new AnnotationTest02();
17         System.out.println(test.eyeColor());
18     }
19 }
20 
21 /*
22     結果打印以下：
23 
24     red
25 */

使用自定義註解

解析註解：
 經過反射獲取類、函數或成員上的運行時註解信息，從而實現動態控制程序運行的邏輯；

 1 /**
 2  * 解析註解
 3  */
 4 package annotation;
 5 
 6 import java.lang.annotation.Annotation;
 7 import java.lang.reflect.Method;
 8 
 9 public class AnnotationTest03
10 {
11     public static void main(String[] args)
12     {
13         try
14         {
15             // 1.使用類加載器加載類
16             Class c = Class.forName("annotation.ParseAnnotation");
17             
18             // 2.找到類上面的註解
19             // 判斷這個類上有沒有Description這個註解
20             boolean isExit = c.isAnnotationPresent(Description.class);
21             
22             if(isExit)
23             {
24                 // 3.拿到註解實例
25                 Description d = (Description)c.getAnnotation(Description.class);
26                 
27                 // 4.解析註解，得到的是類註解的解析信息
28                 System.out.println("desc=" + d.desc() + ",author=" + d.author() + ",age=" + d.age());
29                 
30                 // 5.解析方法註解
31                 Method[] m = c.getMethods();  // 先找到全部方法
32                 for(Method ms : m)
33                 {
34                     boolean isExit2 =ms.isAnnotationPresent(Description.class);
35                     if(isExit2)
36                     {
37                         Description d2 = (Description)ms.getAnnotation(Description.class);
38                         System.out.println("desc=" + d2.desc() + ",author=" + d2.author() + ",age=" + d2.age());
39                     }
40                     
41                 }
42                 
43                 // 6.另一種解析方法
44                 for(Method ms2 : m)
45                 {
46                     Annotation[] a = ms2.getAnnotations();  // 得到方法上的全部註解
47                     for(Annotation an : a)
48                     {
49                         if(an instanceof Description)  // 判斷此註解是否是 Description 註解
50                         {
51                             Description d3 = (Description)an;
52                             System.out.println("desc=" + d3.desc() + ",author=" + d3.author() + ",age=" + d3.age());
53                         }
54                     }
55                 }
56             }
57         } catch (ClassNotFoundException e)
58         {
59             e.printStackTrace();
60         }
61     }
62 }
63 
64 @Description(desc="I am class annotation",author="Mooc boy")
65 class ParseAnnotation
66 {
67     @Description(desc="I am method annotation",author="Mooc boy")
68     public String name()
69     {
70         return null;
71     }
72 }

解析註解