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 =
- 如：
  原因：
  - 底层中用的就是这个名字，所以不需要

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

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

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

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