资讯专栏INFORMATION COLUMN

java-Annotation注解

skinner / 3569人阅读

摘要:指定该策略的注解只能修饰成员变量。也可以在定义注解的成员变量时为其指定初始值,指定默认值。根据注解是否可以包含成员变量,可以把注解分为标记注解没有定义成员变量的注解类型被称为标记。

@Override

是告诉编译器检查这个方法,保证父类要包含一个被该方法重写的方法,否则编译出错。

只能修饰方法,不能修饰其他程序元素 。

Java 9 增强的@Deprecated

表示某个程序元素已经过时。

Java 9 为@Deprecated注解增加了如下两个属性

ForRemoval:该boolean类型的属性指定该API在将来是否会被删除。

Since:该String类型的属性指定该API从哪个版本被标记为过时。

</>复制代码

  1. public class DeprecatedS {
  2. //已过时,since是从9版本开始,forRemoval指定该API将来会被删除
  3. @Deprecated(forRemoval=true,since="9")
  4. public void info() {
  5. }
  6. public static void main(String[] args) {
  7. DeprecatedS s = new DeprecatedS();
  8. s.info();
  9. }
  10. }
抑制编译器警告:@SuppressWarnings

指示被该注解修饰的程序元素,以及该程序元素中的所有子元素,取消显示指定的编译器警告。@SuppressWarnings会一直作用于该程序元素的所有子元素。

</>复制代码

  1. //关闭整个类里的编译器警告
  2. @SuppressWarnings(value="unchecked")
  3. public class SuppressWarningsS {
  4. public static void main(String[] args) {
  5. List list = new ArrayList();
  6. }
  7. }
堆污染警告 与 java 9 增强的@SafeVarargs

当把一个不带泛型的对象赋给一个带泛型的变量时,往往就会发生堆污染

</>复制代码

  1. public class SafeVarargsS {
  2. public static void main(String[] args) {
  3. }
  4. //Type safety: Potential heap pollution via varargs parameter list
  5. //类型安全:通过varargs参数列表的潜在堆污染。
  6. public static void ai(List ...list) {
  7. List[] list2 = list;
  8. List myList = new ArrayList<>();
  9. myList.add(new Random().nextInt(100));
  10. list2[0] = myList;
  11. String string = list[0].get(0);
  12. }
  13. }

上面程序中的粗体字代码已经发生了堆污染,由于该方法有个形参是List...类型,个数可变的形参相当于数组,但java又不会支持泛型数组,因此程序只能把List...当成List[]处理,这里发生了堆污染。

使用@SafeVarargs

</>复制代码

  1. @SafeVarargs
  2. public static void ai(List ...list) {}
Java 8的函数式接口 @FuncationInterface

如果接口中只有一个抽象方法,可以包含多个默认方法或多个static方法,该接口就是函数式接口。

@FuncationInterface就是用来指定某个接口必须是函数式接口。

</>复制代码

  1. @FunctionalInterface
  2. public interface Function {}

FuncationInterface只能修饰接口,不能修饰其他元素

JDK的元注解

在java.lang.annotation包下提供了6个Meta注解(元注解),@Repeatable专门用于定义java 8新增的重复注解。

使用@Retention :保留,扣留 Policy:政策,方针

@Retention只能用于修饰注解定义,用于指定被修饰的注解可以保留多长时间,他包含一个RetentionPolicy类型的value成员变量,所以使用时必须为该value成员变量指定值。

Value成员变量的值只能是如下三个

RetentionPolicy.CLASS : 编译器将把注解记录在class中,当运行java程序时,JVM不可获得注解信息,这是默认值。

RetentionPolicy.REUNTIME:编译器将把注解记录在class文件中,当运行java程序时,JVM也可获取注解信息,程序可以通过反射获得该注解信息。

RetentionPolicy.SOURCE:注解只保留在源代码中,编译器直接丢弃这种注解。

使用

</>复制代码

  1. @Retention(value = RetentionPolicy.RUNTIME)
  2. public @interface My1 {}
  3. @Retention(RetentionPolicy.RUNTIME)
  4. public @interface My1 {}

使用@Target

只能修饰注解定义,它用于指定被修饰的注解能用于修饰那些程序单元。

@Target元注解也包含一个value成员变量

成员变量如下

ElementType.ANNOTATION_TYPE:指定该策略的注解只能修饰注解。

ElementType.CONSTRUCTOR:指定该策略的注解只能修饰构造器。

ElementType.FIELD:指定该策略的注解只能修饰成员变量。

ElementType.LOCAL_VARIABLE:指定该策略的注解只能修饰局部变量。

ElementType.METHOD:指定该策略的注解只能修饰方法。

ElementType.PACKAGE:指定该策略的注解只能修饰包定义。

ElementType.PARAMETER:指定该策略的注解只能修饰参数。

ElementType.TYPE:指定该策略的注解只能修饰类,接口,注解类型,枚举定义。

使用

</>复制代码

  1. @Target(value = ElementType.ANNOTATION_TYPE)
  2. public @interface My1 {}

使用@Document

@Document用于指定被该元注解修饰的注解类将被javadoc工具提取城文档,如果定义注解类时使用了@Document,则所有使用该注解修饰的程序元素的API文档中将会包含该注解说明。

使用@Inherited : 可继承的

指定被他修饰的注解将具有继承性。

</>复制代码

  1. @Inherited
  2. public @interface My1 {}

上面程序中代码表明@My1具有继承性,如果某个类使用@My1修饰,则该类的子类将自动使用@My1修饰。

检查其子类是否默认使用@My1修饰。

</>复制代码

  1. @My1
  2. class A{}
  3. public class My1_Test extends A {
  4. public static void main(String[] args) {
  5. System.out.println(My1_Test.class.isAnnotationPresent(My1.class));//true
  6. }
  7. }
自定义注解

定义新的注解使用@Interface关键字定义一个新的注解类型与定义一个接口非常像,如下

</>复制代码

  1. public @interface My1 {}

定义了该注解之后,就可以在程序的任何地方使用该注解。

默认情况下,注解可用于修饰任何程序元素,包括类,接口,方法等。

注解还可以带成员变量,成员变量在注解定义中以无形参的方法形式来声明,其方法名和返回值定义了该成员变量的名字和类型。

</>复制代码

  1. public @interface My1 {
  2. String name();
  3. int id();
  4. }

一旦在注解里定义了成员变量后,使用该注解时就应该为他的成员变量指定值。

</>复制代码

  1. @My1(id=1,name="rrr")
  2. class A{}
  3. (6) 也可以在定义注解的成员变量时为其指定初始值,指定默认值default
  4. public @interface My1 {
  5. String name() default "ccc";
  6. int id() default 123;
  7. }

成员变量指定了值,则默认值就不会起作用。

根据注解是否可以包含成员变量,可以把注解分为

标记注解:没有定义成员变量的注解类型被称为标记。这种注解仅利用自身的存在与否来提供信息,如@Test、

元数据注解:包括成员变量的注解,因为他们可以接受更多的元数据,所以也被称为元数据注解。

提取注解信息

使用注解修饰了类,方法,成员变量等之后,这些注解不会自己生效,必须由开发者提供相应的工具来提取并处理注解信息。

AnnotatedElement接口,该接口代表程序中可以接受注解的程序元素,该接口主要有如下个实现类:

Class:类定义

Constructor:构造器定义

Field:类的成员变量定义

Method:类的方法定义

Package:类的包定义

只有当定义注解时使用了@Retention(RetentionPolicy.RUNTIME)修饰,该注解才会在运行时可见,JVM才会在装载class文件时读取保存在class文件中的注解信息。

获取My2类的方法上的Annotation

</>复制代码

  1. public class My2 {
  2. @My1(id =123,name ="dsds")
  3. public void info() {
  4. }
  5. }
  6. public class GetMy2Annotation{
  7. public static void main(String[] args) throws Exception{
  8. Class forName = Class.forName("annotations.My2");//加载类
  9. Method method = forName.getMethod("info");//得到方法
  10. Annotation[] annotations = method.getAnnotations();//得到方法上所有注解
  11. //@annotations.My1(name="dsds", id=123)
  12. for (Annotation annotation : annotations) {
  13. System.out.println(annotation);
  14. }
  15. }
  16. }

访问注解中的元数据

</>复制代码

  1. public class GetMy2Annotation{
  2. public static void main(String[] args) throws Exception{
  3. Class forName = Class.forName("annotations.My2");//加载类
  4. Method method = forName.getMethod("info");//得到方法
  5. Annotation[] annotations = method.getAnnotations();//得到方法上所有注解
  6. /*
  7. * 123
  8. * dsds
  9. * */
  10. for (Annotation annotation : annotations) {
  11. if (annotation instanceof My1) {
  12. System.out.println(((My1)annotation).id());
  13. System.out.println(((My1)annotation).name());
  14. }
  15. }
  16. }
  17. }

利用注解模拟@Test的JUnit效果

</>复制代码

  1. public class RunTest {
  2. public static void main(String[] args) throws Exception {
  3. Class forName = Class.forName("annotations.RunTest_JUnit");//加载类
  4. Method[] methods = forName.getDeclaredMethods();//获得本类所有方法
  5. int success = 0;//成功方法
  6. int fail = 0;//失败方法
  7. for (Method method : methods) {
  8. System.out.println(method);
  9. System.out.println(method.isAnnotationPresent(Testable.class));
  10. if (method.isAnnotationPresent(Testable.class)) {
  11. try {
  12. //抑制private访问修饰符
  13. method.setAccessible(true);
  14. method.invoke( null);
  15. success++;
  16. } catch (Exception e) {
  17. fail++;
  18. }
  19. }
  20. }
  21. System.out.println("成功方法有:" + success +"个 失败的有:"+fail+"个");
  22. }
  23. }
  24. class RunTest_JUnit{
  25. @Testable
  26. private static void t() {
  27. System.out.println("=========================t");
  28. }
  29. private static void t1() {
  30. }
  31. @Testable
  32. private static void t2() {
  33. System.out.println("=========================t2");
  34. }
  35. @Testable
  36. private static void r2() {
  37. System.out.println("=========================r2");
  38. throw new RuntimeException("出错误啦");
  39. }
  40. }
  41. @Retention(RetentionPolicy.RUNTIME)
  42. @Target(ElementType.METHOD)
  43. public @interface Testable{
  44. }
  45. Output:
  46. private static void annotations.RunTest_JUnit.t1()
  47. false
  48. private static void annotations.RunTest_JUnit.t()
  49. true
  50. =========================t
  51. private static void annotations.RunTest_JUnit.r2()
  52. true
  53. =========================r2
  54. private static void annotations.RunTest_JUnit.t2()
  55. true
  56. =========================t2
  57. 成功方法有:2个 失败的有:1个

上面的@Testable用于标记那些方法是可测试的,该注解可以作为JUnit测试框架的补充,在JUnit框架中他要求测试用例的测试方法必须以test开头。

Java 8 新增的重复注解

</>复制代码

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target(value=ElementType.TYPE)
  3. @Repeatable(value=FkTags.class)//只能可以包容它的容器类
  4. public @interface FkTag {
  5. String name() default "王自强";
  6. int id();
  7. }
  8. @Retention(RetentionPolicy.RUNTIME)
  9. @Target(value=ElementType.TYPE)
  10. public @interface FkTags {
  11. FkTag[] value();
  12. }
  13. //@FkTags({@FkTag(id=1,name="dsd"),@FkTag(id=213)})
  14. @FkTag(id=123)
  15. @FkTag(id=1233)
  16. public class Test_FkTage {
  17. public static void main(String[] args) {
  18. Class cl = Test_FkTage.class;//获取类
  19. //这个方法可以获得多个重复注解,而getDeclaredAnnotation只能获取一个
  20. FkTag[] annotationsByType = cl.getAnnotationsByType(FkTag.class);
  21. for (FkTag fkTag : annotationsByType) {
  22. System.out.println(fkTag.id()+" "+ fkTag.name());
  23. }
  24. FkTags annotation = cl.getAnnotation(FkTags.class);
  25. System.out.println(annotation);
  26. }
  27. }
  28. Output
  29. 123 王自强
  30. 1233 王自强
  31. @fkAnnotation.FkTags(value={@fkAnnotation.FkTag(name="王自强", id=123), @fkAnnotation.FkTag(name="王自强", id=1233)})

如上的重复注解只是一种简便的写法,运用@Repeatable注解来制定他的容器注解类即可。

容器注解类注解的保留期必须比他所包含的注解的保留期更长,否则编译器报错。

Java 8新增的类型注解
编写自定义注解时未写@Inherited的运行结果 编写自定义注解时写了@Inherited的运行结果
子类的类上能否继承到父类的类上的注解?
子类方法,实现了父类上的抽象方法,这个方法能否继承到注解?
子类方法,实现了父类上的方法,这个方法能否继承到注解?
子类方法,覆盖了父类上的方法,这个方法能否继承到注解?

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/69333.html

相关文章

  • Java™ 教程(注解

    注解 注解(一种元数据形式)提供有关不属于程序本身的程序的数据,注解对它们注解的代码的操作没有直接影响。 注解有许多用途,其中包括: 编译器的信息 — 编译器可以使用注解来检测错误或抑制警告。 编译时和部署时处理 — 软件工具可以处理注解信息以生成代码、XML文件等。 运行时处理 — 可以在运行时检查某些注解。 本课程介绍了可以使用注解的位置,以及如何应用注解,Java平台标准版(Java S...

    econi 评论0 收藏0
  • Java 注解实战

    摘要:注解是的一个新特性。很重要,生产中我们开发常用此值表示注解是否可被子元素继承。类注解方法注解通过反射获取方法对象此部分内容可参考通过反射获取注解信息注解处理器实战接下来我通过在公司中的一个实战改编来演示一下注解处理器的真实使用场景。 前言:Java 注解,对于很多人都不陌生了,但是在公司的实际开发中,可能让我们自己去定义注解并应用到生产环境中的机会比较少,所以会导致一部分人对注解的理解...

    Jochen 评论0 收藏0
  • Java注解-元数据、注解分类、内置注解和自定义注解

    摘要:注解有以下几个知识点元数据注解的分类内置注解自定义注解注解处理器本文先介绍前面个知识点元数据注解的分类内置注解自定义注解。注解相当于是一种嵌入在程序中的元数据,可以使用注解解析工具或编译器对其进行解析,也可以指定注解在编译期或运行期有效。 大家好,我是乐字节的小乐,上次说过了Java多态的6大特性|乐字节,接下来我们来看看Java编程里的注解。showImg(https://segme...

    Yujiaao 评论0 收藏0
  • 注解(待完善)

    摘要:中提供了前四个元注解。在中新添加了最后一个注解。指定了注解可以用于的范围。可以默认设置为空字符串如果没有默认值的话,在使用的时候则需要对它进行赋值。反射程序运行时获取注解的值,设置为。可以使用空字符串 分类 元注解(meta-annotation) java元注解就是用来注解其他注解。可以理解为元注解是其他定义的注解的基础。元注解有 @Retention、@Documented、@Ta...

    Channe 评论0 收藏0
  • Java之注解的定义及使用

    摘要:注解添加了注解的注解,所注解的类的子类也将拥有这个注解注解父类子类会把加在上的继承下来在接口上添加注解,然后类实现了接口,类不会拥有接口上的注解。如果父类删除了该方法,则子类会报错。注解表示被注解的元素已被弃用。 Java的注解在实际项目中使用得非常的多,特别是在使用了Spring之后。本文会介绍Java注解的语法,以及在Spring中使用注解的例子。 注解的语法 注解的例子 以Ju...

    songze 评论0 收藏0

发表评论

0条评论

skinner

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<