javaSE高级篇6 — 注解（ 附：注解底层解析 ） —— 更新完毕

注解 ———— 英文：annotation

1、注解长什么样子？

• @xxxxxxx( 一些信息 ） ————— 这个信息可有可无

2、注解可以放在什么地方？

• 类本身的上面、属性的上面、方法的上面、参数的前面

3、注解的作用是什么？

• 1、用来标识一个事物（ 方法、属性、参数...）有特殊的含义
• 2、用来消灭配置文件
  • 详细点就是这样的：
    • 1）、用来充当注释的作用，仅仅相当于是一个文字的说明
      • 如：@Deprecated        ———— 表示该方法是废弃的

• • • 2）、用来做代码的检测
      • 如：@override            ———— 表示检测该方法是否 是重写的

• • • 3）、携带一些信息 （ 内容 ）
      • 如：Properties 和 xml

4、java中提供的现有注解

• 1）、@Depracated          ———— 用于说明方法是废弃的，这种备注之后，方法会有一根横线（ 可以用，只是不建议，不然出了问题不能怪java的设计 ———这就相当于是甩锅，别人设计java也要考虑用了会不会出问题嘛 ） ———— 自己设计方法的时候也可以这么玩儿啊，当然，也得身居得有那个层次，不然自己设计的方法就用来搞项目的而已，还设计个锤子的废弃方法
  • 举个例子：Data工具类
    • 

• 2）、@Override           ———— 用来检测该方法是否 是重写的 （ 是检测啊，别乱用啊 ，不是什么地方都可以用的 ） ———— 这个已经见过太多次了
  • 举个例子：让一个类实现Comparable接口
    • 

       如果我自己乱整一个方法，然后用这个注解得不得吃诶？

      • 

         是会报错的哟，所以这个@Override是带有检测的

        
        

• 3）、@SuppressWarnings(  携带的信息  )
  • 携带信息的类型只能是String[ ]，即：写法为 ———— @SuppressWarnings( {" 某某信息 "} )   ———— 当然：如果{ }这里面的元素只有一个的话，可以省略{ }，如：@SuppressWarnings( 某一个信息 )

• • 这个信息的内容可为以下信息
    • （1）、unUsed     ———— 表示变量定义后未被使用
      • 举个例子：
        • 

          

           当然：不建议玩儿啊，因为，这是编辑器告诉自己，这个变量未被使用，要是加了这个的话，那么那些变量用了，那些变量没用都不知道了

• • • (2)、serial      ———— 指的是类实现了序列化接口，但是不添加序列化ID号
      • 

        
        

    • （3）、rawtypes    ———— 表示集合不用泛型
      • 

        

• • • (4)、unchecked    ———— 表示出现泛型问题不检测 ———— 但是这个东西不建议玩儿，所以不展示了，有兴趣的可以故意把泛型弄错，然后加@suppressWarnings( " unchecked " ) 试一下就知道效果是怎么样的了

• • • (5)、all ———— 包含了上述的所有问题（ 也不建议使用，所以也不展示了 ）

5、注解中能够携带的信息是哪些？

• 注解中可以携带信息，也可以不携带 ———— 如：@Override 和 suppressWarning( { " " } )

• 如果要携带信息的话，那么只能是如下这几种类型
  • 1）、基本数据类型    如：（ 100 ）
  • 2）、String类型        如：（ " 纳尼 " )
  • 3）、枚举类型           如：（ enum ） ———— 这里是说enum类型，不是说携带的是enum这几个字母
  • 4）、注解类型           如：（ @xxxx )
  • 5）、数组类型           如：（ [ ] )    ———— 注意：这个数组里面的类型，又只能是前四种类型

6、自定义注解

• 想要自定义注解的话，需要用到@interface，注意啊：这不是接口啊，多了一个@符号呢，举个例子：
• 

  从这可以看出：注解也是一种类结构，只是把class关键字改成了@interface而已

• 同时：注解这玩意儿和接口贼像，所以可以对照着接口来记嘛，接口有的东西，注解应该也有 （ 接口中有什么？ ———— 属性和抽象方法呗，所以注解有吗？ ）
• 测试一下咯：接口中的属性是public static final 修饰的常量（ 虽然我在面向对象编程篇中讲过 public static final 可以去掉，默认就是这个，但是还是需要再次说明，不写不代表没有修饰符 ）———— 那么就来看一下@interface注解中的属性是什么样的？
• 

   但是：虽然可以这么玩儿，但是很少使用 ^ _  ^

• @interface注解中的方法是怎么样的？
  • 照样对照接口来玩儿 ———— 接口中的方法是：public abstract类型的方法 （ 这两个修饰符也是可以省略不写的 ） ，但是：接口中的方法可以没有返回值，如：void test()，那么@interface中的方法是什么修饰的、有没有返回值？ ———— 来测试一下嘛
    • 

       从这个测试中就可以得出结论：

      • @interface中的方法是public abstract修饰的，同时：这个方法必须有返回值

　　　　　　　　

• • • • • 另外这个方法其实是可以设置默认值的，不过需要使用default关键字
          • 好处：使用注解的使用就不用强制要求赋值了，利用反射解析就可以使用默认值（ 同时：这也就告知了 注解是怎么实现的，即：利用反射解析出来的 ，后续会进行演示 ）

• • 最后补充一点：虽然@interface中有属性 和 方法（ 已经测试过了 ），但是：注解中只能有属性（ 即：这个抽象方法也是属性，只是这个属性其实就是我们以前所说的抽象方法而已，至于叫法为什么是这样，是因为学术性的问题，所以对于@interface注解，它里面有什么，只有属性（ 虽然实质是抽象方法 ） ） ———— 这个很重要

• • 因此：总结一下 怎么自定义注解、注解中有什么？
    • 1）、通过@interface实现自定义注解
    • 2）、public static final修饰的属性（ 当然：这里一定是这样吗？【 可以自行尝试一下 】—— 会有新发现 ） ———— 同时：搞这个属性很少见（ 不常用 ）
    • 3）、public abstract修饰的 有返回值的 方法
      • 补充一点：如果有返回值，则：这个返回值类型必须是前面讲的那些类型 （ 基本、String、枚举、注解、数组 ）

• • 自定义了自己的注解之后，可以用吗？
    • 还不可以嘛，所以在这里需要再学几个小东西 ———— 元注解 

7、元注解

• 元注解是什么？
  • 就是用来给自定义的注解 再 注解 （ 即：解释自定义注解的 ）

• 必会的两个元注解
• 1）、@Target ( { ElementType[ ] value } )  ———— 目标 ，即：是解释自定义的注解是放在什么地方的 （ 类上、属性上、方法上、参数前面 ）
  • 注意参数：是一个ElementType类型的，什么意思？ ———— 看一下源码
    • 

       发现是个枚举类 ———— 那就好办了，说明这里面存储的就是一些固定的对象嘛，那就直接用 ElementType. 调用嘛

      • // 1、@Target( { } ) ———— 这个是说：声明我的这个注解 能够作用在哪些地方（ 类上、属性上、方法上（ 含构造 ）、参数的前面 ）
        //  @Target( { ElementType.FIELD } )  // 这表明：这个自定义注解可以放在属性上
        //  @Target( { ElementType.METHOD } )   // 这表明：这个自定义注解可以方法上————想要看其他放置位置可以直接 ElementType. 就出来了
        
        @Target( { ElementType.FIELD , ElementType.METHOD } )

        
        

• 2）、Retention （ RetentionPolicy value )  ———— 这个是解释：自定义的注解持续到什么地方都还有效【 还存在 】（ 即：自定义注解的作用域 ）
  • java代码经过的几个阶段
    • 

      同时也注意：这个Retention中的参数是RetentionPolicy类型（ 这也是一个枚举类 ，因此：一样的通过 类名. 就可以调用了），由这个图就可以理解作用域了，即：自定义的这个注解要一直持续到哪一个阶段都还存在 （ 有效 ），过了这个阶段，自定义的注解就没了（ 被回收了 ）

      • // 2、@Retention( ) ———— 这个是说：声明的这个注解 在什么作用域也存在（ 作用域： 其实真正需要的注明的阶段是 —— 源码阶段、字节码阶段、运行阶段 )
        // @Retention( RetentionPolicy.SOURCE )    // 这个是说：这个自定义注解 在源码阶段也存在（ 过了这个阶段就被JVM丢弃 ）
        // @Retention( RetentionPolicy.CLASS )     // 这个是说：这个自定义注解 在字节码阶段也可存在
        // @Retention( RetentionPolicy.RUNTIME )   // 这个是说：这个自定义注解 在运行阶段也还存在
        
        @Retention( RetentionPolicy.RUNTIME )

• 了解即可的元注解
• 3）、@Inherited  ———— 这个元注解是让自定义的注解，可以被子类继承

• 4）、@Decumented ———— 这个元注解是说 自定义的注解可以被文档记录 （ 即：以前在基础篇中说过的文档注释，不是最后可以被生成一个文档吗 （ 最典型就是API，它就是一个生成文档 ），因此：这个元注解的作用就是为了：生成文档的时候也可以把自定义注解生成进去

8、有了上述的知识，那么就来模拟自定义一个注解

• package cn.xieGongZi.customAnnotation;
  
  import java.lang.annotation.*;
  
  // 自定义注解
  
  @Target( {ElementType.FIELD,ElementType.METHOD} )  // 这个自定义注解可以方法属性上、方法上
  
  @Retention(RetentionPolicy.RUNTIME)  // 这个自定义注解可以一直存在于运行时
  
  @Inherited // 这个自定义注解可以被子类继承
  
  @Documented // 这个注解可以被文档记录
  
  @interface MyAnnotation {
  
      // 注解中有的东西 ———— 属性（ 即：抽象方法 ）
      String value();
  
      // 一个自定义的注解也就完成了
      // 现在也就开始用这个自定义的注解
  }

• package cn.xieGongZi.customAnnotation;
  
  // 使用自定义注解
  public class UseMyAnnotation {
  
      @MyAnnotation( value = "邪公子" )
      private String name;
  
      @MyAnnotation( value = "19" )
      private Integer age;
  
      @MyAnnotation( value = "女" )
      private String sex;
  
      public String getName() { return name; }
  
      public void setName(String name) { this.name = name; }
  
      public Integer getAge() { return age; }
  
      public void setAge(Integer age) { this.age = age; }
  
      public String getSex() { return sex; }
  
      public void setSex(String sex) { this.sex = sex; }
  
      @Override
      public String toString() {
          return "UseMyAnnotation{" +
                  "name='" + name + '\'' +
                  ", age=" + age +
                  ", sex='" + sex + '\'' +
                  '}';
      }
  }

• package cn.xieGongZi.customAnnotation;

  
  // 开始解析注解
  public class resolvAnnotation {
  
      public static void main(String[] args) {
  
          UseMyAnnotation useMyAnnotation = new UseMyAnnotation();
  
          System.out.println( useMyAnnotation.getName() );
          System.out.println( useMyAnnotation.getSex() );
          System.out.println( useMyAnnotation.getAge() );
      }
  }

   效果如下：

  • 

     哦豁 ~ 没有值！！！！这尼玛注解是假的吧，别急，还差最后一步，也是底层之中需要做的事情，利用反射把注解中的值真正赋给属性

    • package cn.xieGongZi.customAnnotation;
      
      import java.lang.reflect.Field;
      
      // 开始解析注解
      public class resolvAnnotation {
      
          public static void main(String[] args) throws IllegalAccessException {
      
              UseMyAnnotation useMyAnnotation = new UseMyAnnotation();
      
      //        System.out.println( useMyAnnotation.getName() );
      //        System.out.println( useMyAnnotation.getSex() );
      //        System.out.println( useMyAnnotation.getAge() );
      
              // 获取类对象
              Class<UseMyAnnotation> aClass = UseMyAnnotation.class;
      
              // 获取这个类的属性（ 私有的嘛，所以需要用如下方法 ———— 在反射中已经讲解过了
              Field[] fields = aClass.getDeclaredFields();    // 这就获取这个类的所有属性了 （ 包括private修饰的 ）
      
              // 然后查看这个属性头上有没有存在注解
              // 但是这是一个属性组成的数组涩 ———— 所以需要遍历，这样才可以查看每一个属性头上有没有注解嘛
              for (Field field : fields) {
      
                  // 现在才查看这一个属性上面有没有存在自定义的注解 ———— 自定义注解是MyAnnotation涩，所以获取这个注解的类对象
                  // 因此：获取这个注解的类对象
                  MyAnnotation fieldClass = field.getAnnotation( MyAnnotation.class );// 这里面需要一个注解的类对象，因此：获取自定义注解的类对象
      
                  // 看看这个属性头上有没有注解
                  if ( fieldClass != null ){
      
                      // 这就说明，这个属性头上存在自定义的注解
      
                      // 那么获取这个自定义注解携带的数据
                      String value = fieldClass.value();
      
                      // 获取自定义注解携带的数据后，准备开始给相应属性赋值
                      // 但是： 从自定义注解中获得的数据是一个字符串，而每一个属性的类型也不一样，因此：需要再做一件事
                      // 那就是判断属性对应的数据类型是什么
                      // 但是属性是private修饰的，所以还得提供修改private属性的权限涩
                      field.setAccessible(true);
                      Class fieldType = field.getType();
      
                      // 现在才给对应类型的属性赋值
                      // fieldType就是每一个属性 的对应数据类型 ———— 现在开始考虑用什么选择语句涩 ———— Switch ？ if ？
                      // Switch支持的是byte、short、int 及对应包装类、String、枚举，所以好像不满足所有的需求
                      // 因此：选择if
                     if ( fieldType == String.class ){  // 由于获取到的fieldType是一个Class类型的
                                                        // 因此：属性的对应数据类型也要用它的Class类型
      
                         // 给String类型的属性赋值
                         field.set( useMyAnnotation,value );     // 这里建议使用set()，别用setXxx() ———— 其中Xxx是要转的对应数据类型，如：setInt()
                                         // 因为set是支持任意类型（ 还不容易报错 ） ———— 其中：set()里面需要传递两个参数，
                                        // 第一个参数是属性所在的 类的对象、第二个是注解中携带的那个数据（ 即：要传递的那个值 ）
                                       // 另外，set（）方法需要处理异常
                     }
      
                     if ( fieldType == Integer.class ){   // 注意：如果属性是int类型的，那么：属性的类型记得用integer
                                                         // 虽然不是必须，但：建议用，好处就在这里体现1出来了，不然可以尝试用int、byte试一下就知道效果了
                                                        // 因此，这又回到以前说过的：属性若是基本数据类型 则：最好用对应的包装类
                         // 然后这里有个坑儿，因为我们定义的类 属性age是Integer类型，而注解中携带的数据是String类型的，所以这里还需要进行一件事
                         // 把String 转为 Integer
                         field.set( useMyAnnotation,Integer.parseInt(value) );
                     }
      
                     // 其他类型就是一样的，这样对应类型赋值就可以了，这里由于我自定义的useAnnotation类中只有String 和 int 类型，所以就只展示这两种
                  }
              }
      
              System.out.println( " UseAnnotation类中的各个属性值如下：\n" + useMyAnnotation );
          }
      }

      效果图如下 （ 这就把注解中携带的数据 真正地 给了对应属性 ）：

      •  
        
        

 最后：再补充两点

• 第一点：前面已经提到了，就是自定义的注解中，那个属性 （ 即：抽象方法 ）是可以设置默认值的，但是需要使用default关键字
  • 使用默认值的好处就是，在使用注解的时候，不需要强制要求给自定义注解中的属性 （ 抽象方法 ） 赋值
    • 如：我上面是只定义了一个value()属性，所以在使用这个注解时，只需要传递一个值给这个value()即可
      • 但是，如果我在自定义注解中再定义一个属性 （ 抽象方法 ）———— 此时没有使用default关键字
      • 那么，在使用这个自定义注解时，就必须传递两个值 （ 这两个值分别给了自定义注解中的那两个没用default修饰的属性 ）
•  怎么使用这个default关键字
  • 

•  第二点就是：如果自定义注解中的属性 （ 抽象方法 ）名是value，那么：在使用这个自定义注解传值时（ 即：value = ....... ），不需要写value = 
  • 如：

     原因：

    • 底层中用的就是这个名字，所以不需要

 至此，注解的相关知识就完毕了，掌握这些知识之后，

其他没提到的注解知识就都没问题了，那些就是一看就懂、还带会用了