Java 注解总结_java注解

Java 注解总结

概述

Java注解是JDK1.5引入的，提供有关于程序但不属于程序本身的数据。注解对它们注解的代码的操作没有直接影响。

Java内置注解

• @Override
• @Deprecated
• @SuppressWarnings

@Override

@Override注解是用于修饰方法上，表示当前方法不是当前类最先声明的，而是从父类继承过来的，进行的方法重写操作：

class Base{
    public void eat(){}
}

class Person extends Base{
    @Override
    public void eat() {

    }
}
1
2
3
4
5
6
7
8
9
10

@Deprecated

@Deprecated注解修饰范围广，可以用在类、方法、常量等，该注解表示被修饰的元素已经过时：

class Base {
    @Deprecated
    public void hello() { }
}

class Person extends Base {
    //会显示过时警告
    @Override
    public void hello() {

    }
}
1
2
3
4
5
6
7
8
9
10
11
12

@SuppressWarnings

@SuppressWarnings注解表示压制编译器中的警告，当使用一些过期或会有风险的方法时，编译器可能会提示黄线，这时可以添加该注解消除警告：

@SuppressWarnings({"描述信息", "不建议使用"})
Date date = new Date(2008, 9, 9);
1
2

元注解

Java中有四个元注解：

• @Target：表示注解的目标。
• @Retention：表示注解的保留级别。
• @Documented：表示注解信息是否保存到文档。
• @Inherited：表示注解之间的继承关系。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
1
2
3
4
5

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
1
2
3
4

@Target

@Target注解表示当前注解使用在什么类型的元素上：

• ElementType.TYPE：类、接口、枚举
• ElementType.FIELD：属性
• ElementType.METHOD：类中的方法
• ElementType.PARAMETER：方法参数
• ElementType.CONSTRUCTOR：构造器
• ElementType.LOCAL_VARIABLE：局部变量
• ElementType.ANNOTATION_TYPE：注解
• ElementType.PACKAGE：包

@Retention

@Retention注解表示当前注解的保留级别：

• RetentionPolicy.SOURCE：源码级别，编译后丢失注解。
  • 在编译期能回去注解和注解声明的类包括类中所有成员信息，一般用于生成额外的辅助类。如：APT技术。
• RetentionPolicy.CLASS：字节码级别。
  • 在编译出Class后，通过修改Class数据以实现修改代码逻辑目的。如：字节码增强技术。
• RetentionPolicy.RUNTIME：运行时可用。
  • 在程序运行期间，通过反射技术动态获取注解信息。

@Inherited

@Inherited注解表示是否可以被继承，默认为false

@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
}
1
2
3
4

@MyAnnotation
class Base {
}

class Child extends Base {
}

public class Demo {
    public static void main(String[] args) {
        boolean b = Child.class.isAnnotationPresent(MyAnnotation.class);
        System.out.println(b);//true
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

使用自定义注解

• 定义新注解需要关键字@interface
• 注解是无参无异常的
• 类型只能是基本数据类型、String类型、Class类型、Annotation类型、Enum枚举
• 可以使用关键字default指定初始值
• 当只有一个参数时，建议使用value()做参数名

定义注解

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.FIELD)
public @interface Label {
    String value() default "";
}
1
2
3
4
5
6
7
8
9
10

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.FIELD)
public @interface Formatter {
    String format() default "yyyy-MM-dd HH:mm:ss";
}
1
2
3
4
5
6
7
8
9
10

使用注解

public class User {
    @Label("姓名")
    private String name;

    @Label("生日")
    @Formatter(format = "yyyy年MM月dd日")
    private Date birthday;

    @Label("现在时间")
    @Formatter
    private Date nowDate;

    public User(String name, Date birthday, Date nowDate) {
        this.name = name;
        this.birthday = birthday;
        this.nowDate = nowDate;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

定义注解处理器

import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.Date;

public class UserProcess {
    public static String parse(User user) {
        Class<? extends User> clz = user.getClass();
        StringBuilder builder = new StringBuilder();
        //获取所有成员变量
        Field[] declaredFields = clz.getDeclaredFields();
        for (Field field : declaredFields) {
            //设置访问权限
            if (!field.isAccessible()) {
                field.setAccessible(true);
            }
            //是否被@Label注解
            if (field.isAnnotationPresent(Label.class)) {
                //获取Label注解
                Label label = field.getAnnotation(Label.class);
                //获取注解值
                String name = label.value();
                try {
                    //获取变量值
                    Object value = field.get(user);
                    if (value != null) {
                        //变量类型为String
                        if (field.getType() == String.class) {
                            builder.append(name).append(":").append(value).append("\n");
                        }
                        //变量类型为Date
                        else if (field.getType() == Date.class) {
                            value = formatDate(field, value);
                            builder.append(name).append(":").append(value).append("\n");
                        }
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        return builder.toString();
    }

    private static Object formatDate(Field field, Object value) {
        //是否被@Formatter注解
        if (field.isAnnotationPresent(Formatter.class)) {
            Formatter formatter = field.getAnnotation(Formatter.class);
            String format = formatter.format();
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            return sdf.format(value);
        }
        return value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

使用：

public class Demo {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthday = sdf.parse("2008-09-10");
        User user = new User("小明", birthday, new Date());
        String userInfo = UserProcess.parse(user);
        System.out.println(userInfo);
    }
}
1
2
3
4
5
6
7
8
9

输出：

姓名:小明
生日:2008年09月10日
现在时间:2023-08-24 13:59:01
1
2
3

APT技术使用