JavaSE笔记28：注解

最新推荐文章于 2022-11-17 17:01:33 发布

最爱琴女E

最新推荐文章于 2022-11-17 17:01:33 发布

阅读量140

点赞数

CC 4.0 BY-SA版权

分类专栏： JavaSE java 文章标签： java 反射

本文链接：https://blog.youkuaiyun.com/qwq_666/article/details/110439354

JavaSE 同时被 2 个专栏收录

28 篇文章

订阅专栏

java

28 篇文章

订阅专栏

本文围绕Java注解展开，介绍了注解的基本概念、使用语法及出现位置。阐述了JDK内置注解如Override、Deprecated等，还讲解了注解属性、元注解（Target、Retention）。通过反射获取注解的示例，展示了获取用户名和密码的过程，并说明了注解在开发中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

注解

注解，或者叫做注释类型，英文单词是Annotation
注解Annotation是一种引用数据类型，编译之后也是生成xxx.class文件
怎么自定义注解

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

}

package se7;
/*
自定义注解：MyAnnotation
 */
public @interface MyAnnotation {
    //????????
}

如何使用，用在什么地方？

注解使用时的语法格式：@注解类型名

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

package se7;

//默认情况下，注解可以出现在任意位置
@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
}

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

package se7;

//注解修饰注解
@MyAnnotation
public @interface OtherAnnotation {
}

JDK内置注解

JDK内置了哪些注解？

java.lang包下的注释类型：

掌握：Deprecated 用 @Deprecated 注释的程序元素，表示已经过时，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。

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

不要掌握：SuppressWarnings 指示应该在注释元素（以及包含在该注释元素中的所有程序元素）中取消显示指定的编译器警告。

Override注解

package se7;
/*
关于JDK lang包下的Override注解
源代码：
    public @interface Override { }

标识性注解：给编译器做参考的，编译器看到方法上有这个注解的时候，编译器会自动检查该方法是否重写了父类的方法，如果没有重写，报错。

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

//@Override这个注解只能注解方法
//Override这个注解是给编译器参考的，和运行阶段没有关系
//凡是java中的方法带有这个注解的，编译器都会进行编译检查，如果这个方法不是重写父类的方法，编译器报错。

public class AnnotationTest02 {

    @Override
    public String toString(){
        return "toString";
    }
    /*
    //方法名写错会报错，提示你进行重写
    @Override
    public String toString2(){
        return "toString";
    }
    */
}

Deprecated注解

package se7;

//表示这个类已过时
@Deprecated
public class AnnotationTest03 {
    public static void main(String[] args) {

        AnnotationTest03 at = new AnnotationTest03();
        at.doSome();
    }
    //表示这个方法已过时
    @Deprecated
    public void doSome(){
        System.out.println("do Something!");
    }
    /*
    Deprecated这个注解标注的元素已过时
    这个注解主要是向其他程序员传达一个信息，告知已过时，有更好的解决方案存在
     */
    @Deprecated
    public static void doOther(){
        System.out.println("do Other...");
    }
}
class T{
    public static void main(String[] args) {
        AnnotationTest03 at = new AnnotationTest03();
        at.doSome();

        AnnotationTest03.doOther();

        try {
            Class c = Class.forName("java.util.Date");
            Object obj = c.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注解当中的属性

package se7.annotation;

public @interface MyAnnotation {
    /**
     * 通常在注解当中可以定义属性，以下是MyAnnotation的name属性
     * 看着像一个方法，但实际上我们称之为属性name
     * @return
     */
    String name();
    //颜色属性
    String color();
    //年龄属性
    int age() default 78;//默认值是78，这里写了，测试程序可以不用写
}

package se7.annotation;

public class MyAnnotationTest {

    //报错原因：如果一个注解当中有属性，必须给属性赋值
    /*
    @MyAnnotation
    public void doSome(){}
    */

    //@MyAnnotation(属性名=属性值,属性名=属性值)
    @MyAnnotation(name="阿波",color = "黄色")//age因为指定了默认值，可以不写
    public void doSome(){

    }
}

value属性名省略

package se7.annotation2;

public @interface MyAnnotation {

    /*
    指定一个value属性
     */
    String value();

    //String email();
}

package se7.annotation2;

public class MyAnnotationTest {

    @MyAnnotation(value = "hehe")
    public void doSome(){

    }
    /*
    如果一个注解的属性的名字是value,
    并且只有一个属性的话，在使用的时候，
    该属性名可以省略，如下所示。
     */
    @MyAnnotation("haha")
    public void doOther(){

    }
}

注解中属性的类型

package se7.annotation3;

public @interface MyAnnotation {
    /*
    注解当中的属性可以是哪种类型？
    可以是：byte short int long float double boolean char String Class 枚举类型，以及这些类型的数组形式。
     */
    int value1();

    String value2();

    int[] value3();

    String[] value4();

    Season value5();

    Season[] value6();

    Class parameterType();

    Class[] parameterTypes();
}

package se7.annotation3;

public class OtherAnnotationTest {

    //数组是大括号
    @OtherAnnotation(age = 25,email = {"阿波@123.com","波波@321.com"},seasonArray = {Season.SPRING,Season.SUMMER})
    public void doSome(){

    }

    //如果数组中只有1个元素，大括号可以省略
    @OtherAnnotation(age = 25,email = "阿波@123.com",seasonArray = Season.WINTER)
    public void doOther(){

    }
}

package se7.annotation3;

public @interface OtherAnnotation {

    int age();

    //邮箱地址属性，支持多个（数组）
    String[] email();

    /**
     * 季节数组，Season是枚举类型
     * @return
     */
    Season[] seasonArray();
}

package se7.annotation3;

public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER
}

元注解

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

常见的元注解：Target、Retention

关于Target注解

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

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

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

@Target（Value={CONSTRUCTOR},FIELD,LOCAL_VARIABLE,METHOD,PACKAGE,NODUKE,PARAMETER,TYPE）
//这个表示该注解可以出现在：构造方法上、字段上、局部变量上、方法上...类上...

关于@Retention注解

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

@Retention（RetentionPolicy.SOURCE）//表示该注解只能被保留在java源文件中。
@Retention（RetentionPolicy.CLASS）//表示该注解被保留在class文件中
@Retention（RetentionPolicy.RUNTIME）//表示该注解被保存在class文件中并且可以被反射机制所读取

通过反射获取注解

package se7.annotation4;

public class ReflectAnnotationTest {
    public static void main(String[] args) throws Exception {
        //获取类
        Class c = Class.forName("se7.annotation4.MyAnnotationTest");

        //判断类上面是否有@MyAnnotation
        System.out.println(c.isAnnotationPresent(MyAnnotation.class));//true

        if (c.isAnnotationPresent(MyAnnotation.class)){
            //获取该注解对象
            MyAnnotation myAnnotation = (MyAnnotation) c.getAnnotation(MyAnnotation.class);
            System.out.println("类上面的注解对象" + myAnnotation);//类上面的注解对象@se7.annotation4.MyAnnotation()

            //获取注解对象的属性，和调接口没区别
            String value = myAnnotation.value();
            System.out.println(value);//上海浦东区,指定了新的值，不然还是默认值
        }

        //判断String类上面是否存在这个注解
        Class stringClass = Class.forName("java.lang.String");
        System.out.println(stringClass.isAnnotationPresent(MyAnnotation.class));//false
    }
}

package se7.annotation4;

@MyAnnotation("上海浦东区")//默认是广州天河区，这里指定了新的值
public class MyAnnotationTest {

    //@MyAnnotation,报错
    int i;

    //@MyAnnotation,报错
    public MyAnnotationTest() {
    }

    @MyAnnotation
    public void doSome(){
        //@MyAnnotation,报错
        int i;
    }
}

package se7.annotation4;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//只允许该注解可以标注类、方法
@Target({ElementType.TYPE,ElementType.METHOD})
//希望这个注解可以被反射
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    /*
    value属性
     */
    String value() default "广州天河区";//默认值
}

获取用户名和密码例子

package se7.annotation5;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    /*
    username属性
     */
    String username();
    /*
    password属性
     */
    String password();
}

import java.lang.reflect.Method;

public class MyAnnotationTest {

    @MyAnnotation(username = "admin",password = "123")
    public void doSome(){

    }

    public static void main(String[] args) throws Exception {

        //获取MyAnnotationTest的doSome()方法上面的注解信息
        Class c = Class.forName("se7.annotation5.MyAnnotationTest");
        //获取doSome方法
        Method doSomeMethod = c.getDeclaredMethod("doSome");
        //判断该方法上是否存在这个注解
        if (doSomeMethod.isAnnotationPresent(MyAnnotation.class)){
            MyAnnotation myAnnotation = doSomeMethod.getAnnotation(MyAnnotation.class);
            System.out.println(myAnnotation.username());//admin
            System.out.println(myAnnotation.password());//123
        }
    }
}

注解在开发中的作用

需求：假设有这样一个注解，叫做：@ID，这个注解只能出现在类上面，当这个类上有这个注解的时候，要求类中必须有一个int类型的id属性，如果没有这个属性就包异常，如果有这个属性则正常执行。

例子

package se7.annotation6;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//表示这个注解只能出现在类上面
@Target(ElementType.TYPE)
//表示该注解可以被反射机制读取到
@Retention(RetentionPolicy.RUNTIME)
public @interface Id {

}
//这个注解@ID用来标注类，被标注的类中必须有一个int类型的id属性，没有就报异常

package se7.annotation6;

@Id
public class User {

    //int id;
    String name;
    String password;
}

package se7.annotation6;

/*
自定义异常
 */
public class HasNotIdPropertyException extends RuntimeException{
    public HasNotIdPropertyException(){

    }
    public HasNotIdPropertyException(String s){
        super(s);
    }
}

package se7.annotation6;

import java.lang.reflect.Field;

public class Test {
    public static void main(String[] args) throws Exception {
        //获取类
        Class userClass = Class.forName("se7.annotation6.User");
        //判断类上是否存在ID注解
        if (userClass.isAnnotationPresent(Id.class)){
            //当一个类上面有ID注解的时候，要求类中必须存在int类型的id属性
            //如果没有int类型的id属性则报异常
            //获取类的属性
            Field[] fields = userClass.getDeclaredFields();
            boolean isOk = false;//给一个默认的标记
            for (Field field : fields){
                if("id".equals(field.getName()) && "int".equals(field.getType().getSimpleName())){
                    //表示这个类是合法的类，有@ID注解，则这个类中必须有int类型的id
                    isOk = true;//表示合法
                    break;
                }
            }
            //判断是否合法
            if (!isOk){
                throw new HasNotIdPropertyException("被@ID注解标注的类中必须要有一个int类型的id属性");
            }
            //若没有id属性，如下
            //Exception in thread "main" se7.annotation6.HasNotIdPropertyException: 被@ID注解标注的类中必须要有一个int类型的id属性
        }
    }
}