Java基础进阶注解-阿里云开发者社区

注解，或者叫做注释类型，英文单词是：Annotation

注解Annotation是一种引用数据类型。编译之后也是生成xxx.class文件。

怎么自定义注解呢？语法格式？

[修饰符列表] @interface 注解类型名{
 }

注解怎么使用，用在什么地方？

第一：注解使用时的语法格式是：

@注解类型名

第二：注解可以出现在类上、属性上、方法上、变量上等…

注解还可以出现在注解类型上。

JDK内置了哪些注解呢？

java.lang包下的注释类型：

掌握：

Deprecated 用 @Deprecated 注释的程序元素，

不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。

掌握：

Override 表示一个方法声明打算重写超类中的另一个方法声明。

不用掌握：

SuppressWarnings 指示应该在注释元素（以及包含在该注释元素中的

所有程序元素）中取消显示指定的编译器警告。

元注解

什么是元注解？

用来标注“注解类型”的“注解”，称为元注解。

常见的元注解有哪些？

Target

Retention

关于Target注解：

这是一个元注解，用来标注“注解类型”的“注解”

这个Target注解用来标注“被标注的注解”可以出现在哪些位置上。

@Target(ElementType.METHOD)：表示“被标注的注解”只能出现在方法上。

@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER, TYPE})

表示该注解可以出现在：

构造方法上

字段上

局部变量上

方法上

类上…

…

关于Retention注解：

这是一个元注解，用来标注“注解类型”的“注解”

这个Retention注解用来标注“被标注的注解”最终保存在哪里。

@Retention(RetentionPolicy.SOURCE)：表示该注解只被保留在java源文件中。

@Retention(RetentionPolicy.CLASS)：表示该注解被保存在class文件中。

@Retention(RetentionPolicy.RUNTIME)：表示该注解被保存在class文件中，并且可以被反射机制所读取。

Retention的源代码

//元注解 
public @interface Retention {
//属性
  RetentionPolicy value();
}
RetentionPolicy的源代码：
  public enum RetentionPolicy {
   SOURCE,
   CLASS,
   RUNTIME
  }
//@Retention(value=RetentionPolicy.RUNTIME)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation{}

Target的源代码

public @interface Target {
    /**
     * Returns an array of the kinds of elements an annotation type
     * can be applied to.
     * @return an array of the kinds of elements an annotation type
     * can be applied to
     */
    ElementType[] value();
}
public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,
    /** Field declaration (includes enum constants) */
    FIELD,
    /** Method declaration */
    METHOD,
    /** Formal parameter declaration */
    PARAMETER,
    /** Constructor declaration */
    CONSTRUCTOR,
    /** Local variable declaration */
    LOCAL_VARIABLE,
    /** Annotation type declaration */
    ANNOTATION_TYPE,
    /** Package declaration */
    PACKAGE,
    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,
    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

示例代码01:

// 默认情况下，注解可以出现在任意位置。
@MyAnnotation
public class AnnotationTest01 {
    @MyAnnotation
    private int no;
    @MyAnnotation
    public AnnotationTest01(){}
    @MyAnnotation
    public static void m1(){
        @MyAnnotation
        int i = 100;
    }
    @MyAnnotation
    public void m2(@MyAnnotation
                   String name,
                   @MyAnnotation
                   int k){
    }
}
@MyAnnotation
interface MyInterface {
}
@MyAnnotation
enum Season {
    SPRING,SUMMER,AUTUMN,WINTER
}
/*
自定义注解：MyAnnotation
 */
public @interface MyAnnotation {
    // ??????
}
// 注解修饰注解。
@MyAnnotation
public @interface OtherAnnotation {
}

标识性注解，给编译器做参考的。

编译器看到方法上有这个注解的时候，编译器会自动检查该方法是否重写了父类的方法。

如果没有重写，报错。

这个注解只是在编译阶段起作用，和运行期无关！

示例代码02：

// @Override这个注解只能注解方法。
// @Override这个注解是给编译器参考的，和运行阶段没有关系。
// 凡是java中的方法带有这个注解的，编译器都会进行编译检查，如果这个方法不是重写父类的方法，编译器报错。
//@Override
public class AnnotationTest02 {
    //@Override
    private int no;
    @Override
    public String toString() {
        return "toString";
    }
}

示例代码03：

// 表示这个类已过时。
@Deprecated
public class AnnotationTest03 {
    @Deprecated
    private int no;
    @Deprecated
    public void doSome() {
        System.out.println("doSome....");
    }
    // Deprecated这个注解标注的元素已过时。
    // 这个注解主要是向其它程序员传达一个信息，告知已过时，有更好的解决方案存在。
    @Deprecated
    public static void doOther() {
        System.out.println("doOther...");
    }
}
class T{
    public static void main(String[] args) throws ClassNotFoundException {
        AnnotationTest03 an3 = new AnnotationTest03();
        an3.doSome();
        AnnotationTest03.doOther();
    }

运行结果：

示例代码04：

public @interface MyAnnotation {
    /**
     * 我们通常在注解当中可以定义属性，以下这个是MyAnnotation的name属性。
     * 看着像1个方法，但实际上我们称之为属性name。
     * @return
     */
    String name();
    /*
    颜色属性
     */
    String color();
    /*
    年龄属性
     */
    int age() default 25;//属性指定默认值
}
public class MyAnnotationTest {
    // 报错的原因：如果一个注解当中有属性，那么必须给属性赋值。（除非该属性使用default指定了默认值。）
    /*@MyAnnotation
    public void doSome(){
    }*/
    //@MyAnnotation(属性名=属性值,属性名=属性值,属性名=属性值)
    //指定name属性的值就好了。
    @MyAnnotation(name="zhangsan",color="red")
    public void doSome(){
    }
}

示例代码05：

public @interface MyAnnotation {
    /*
   指定一个value属性。
    */
    String value();
    //String email();
}
/*
如果一个注解的属性的名字是value，并且只有一个属性的话，在使用的时候，该属性名可以省略。
 */
public class MyAnnotationTest {
    // 报错原因：没有指定属性的值。
    /*@MyAnnotation
    public void doSome(){
    }*/
    @MyAnnotation(value = "hehe")
    public void doSome(){
    }
    @MyAnnotation("haha")
    public void doOther(){
    }
}
=====================================================================================
public @interface OtherAnnotation {
    String name();
}
// 报错了。因为属性名是name，不能省略。
//@OtherAnnotation("test")
public class OtherAnnotationTest {
    /*@OtherAnnotation(value="hh")
    public void doSome(){
    }*/
    // 正确的。
    @OtherAnnotation(name="test")
    public void doSome(){
    }
}

示例代码06：

public @interface MyAnnotion {
    /*
    注解当中的属性可以是哪一种类型？
        属性的类型可以是：
            byte short int long float double boolean char String Class 枚举类型
            以及以上每一种的数组形式。
     */
    int value1();
    int[] value6();
    String value2();
    String[] value3();
    Season value4();
    Season[] value5();
    Class value7();
    Class[] value8();
}
public @interface MyAnnotion {
    /*
    注解当中的属性可以是哪一种类型？
        属性的类型可以是：
            byte short int long float double boolean char String Class 枚举类型
            以及以上每一种的数组形式。
     */
    int value1();
    int[] value6();
    String value2();
    String[] value3();
    Season value4();
    Season[] value5();
    Class value7();
    Class[] value8();
}
public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER
}
=================================================================================
public @interface OtherAnnotation {
    /**
     * 字符串数组，name数组
     * @return
     */
    String[] name();
    /**
     * 季节数组，Season是枚举类型
     * @return
     */
    Season[] season();
}
public class OtherAnnotationTest {
    // 数组是大括号
    @OtherAnnotation(name={"zahngsan","lisi","wangwu"},season = {Season.SPRING,Season.AUTUMN})
    public void doSome(){
    }
    // 数组是大括号
    @OtherAnnotation(name="zhangsan",season = Season.WINTER)
    public void doOther(){
    }
}

示例代码07：

//元注解
@Target({ElementType.TYPE,ElementType.METHOD})//定义此注解只能出现在类和方法上
@Retention(RetentionPolicy.RUNTIME)//定义此注解保存在字节码（class）文件中，并且能被反射机制读取到
@interface MyAnnotation {
    String value() default "广东深圳";
}
@MyAnnotation("广东省")
class MyAnnotationTest {
    @MyAnnotation("广东省")
    public void doSome(){
    }
}
//通过反射获取注解的属性值
public class ReflectAnnotationTest {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取到MyAnnotation类
        Class c = Class.forName("annotation5.MyAnnotationTest");
        //判断类中是否存在某注解
        boolean flag = c.isAnnotationPresent(MyAnnotation.class);
        //如果存在，通过反射获取类的属性，并输出
        if(flag){
            MyAnnotation Myannotation = (MyAnnotation)c.getAnnotation(MyAnnotation.class);
            String value = Myannotation.value();
            System.out.println("该注解的属性名是：" + value);
        }
        System.out.println(flag);
        //判断字符串类中是否存在该注解
        Class stringclass = Class.forName("java.lang.String");
        boolean flag1 = stringclass.isAnnotationPresent(MyAnnotation.class);
        System.out.println(flag1);
    }
}

运行结果：

示例代码08：

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String username();
    String password();
}
public class MyAnnotationTest {
    @MyAnnotation(username="admin",password="123123")
    public void doSome(){
    }
    public static void main(String[] args) throws Exception{
        //获取MyAnnotationTest类
        Class c = Class.forName("annotation6.MyAnnotationTest");
        //获取类中的方法
        Method doSome = c.getDeclaredMethod("doSome");
        //判断doSome方法上是否有注解，如果有，就输出注解属性值
        if(doSome.isAnnotationPresent(MyAnnotation.class)){
            MyAnnotation Myannotation = doSome.getAnnotation(MyAnnotation.class);
            System.out.println(Myannotation.username());
            System.out.println(Myannotation.password());
        }
    }
}

运行结果：

需求：

假设有这样一个注解，叫做：@Id

这个注解只能出现在类上面，当这个类上有这个注解的时候，

要求这个类中必须有一个int类型的id属性。如果没有这个属性就报异常。

如果有这个属性则正常执行！

示例代码09：

//自定义异常
class HasntIdPropertyException extends RuntimeException{
    public HasntIdPropertyException(){
    }
    public HasntIdPropertyException(String s){
        super(s);
    }
}
public class Test {
    public static void main(String[] args) throws Exception{
        //获取类
        Class c = Class.forName("annotation7.User");
        //判断类中是否存在Id注解
        if(c.isAnnotationPresent(Id.class)){
            //获取类属性
            boolean isOk = false;// 给一个默认的标记
            // 当一个类上面有@MustHasIdPropertyAnnotation注解的时候，要求类中必须存在int类型的id属性
            // 如果没有int类型的id属性则报异常。
            // 获取类的属性
            Field[] fields = c.getDeclaredFields();
            for(Field field : fields) {
                if ("no".equals(field.getName()) && "int".equals(field.getType().getSimpleName())) {
                    // 表示这个类是合法的类。有@Id注解，则这个类中必须有int类型的id
                    isOk = true;// 表示合法
                    break;
                }
            }
            // 判断是否合法
                if(!isOk){
                    throw new HasntIdPropertyException("被@NustHasIdPropertyAnnotation注解标注的类中必须有一个int类型的的的Id属性！");
                }
            }
        }
    }
@Id
class User {
    String no;
    String name;
    int age;
}
// 表示这个注解只能出现在类上面
@Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})
// 该注解可以被反射机制读取到
@Retention(RetentionPolicy.RUNTIME)
@interface Id {
}