Java匹马行天下之JavaSE核心技术——注解

            Java注解

一、什么是注解

            注解(Annotation)相当于一种标记，在程序中加入注解就等于为程序打上某种标记，没有加，则等于没有任何标记，以后，javac编译器、开发工具和其他程序可以通过反射来了解你的类及各种元素上有无何种标记，看你的程序有什么标记，就去干相应的事，标记可以加在包、类，属性、方法，方法的参数以及局部变量上。

 

注解就相当于一个你的源程序要调用一个类，在源程序中应用某个注解，得事先准备好这个注解类。就像你要调用某个类，得事先开发好这个类。

 

 

 

注解的分类

注解根据它的生命周期可以分为，源码注解、编译时注解、运行时注解

       源码注解：只存在于源码中，当源码进行编译以后，注解就不存在了

       编译时注解：存在于源码和字节码文件中，当程序开始运行注解就不存在了

       运行时注解：不仅存在于源码和字节码文件中，在程序运行时依然存在，并且可以影响程序的运行

按照运行机制分

       源码注解：注解只在源码中存在，编译成.class文件就不存在了；

       编译时注解：注解在源码和.class文件中都存在；

       运行时注解：在运行阶段还起作用，甚至会影响运行逻辑的注解；

 

按照来源分

      JDK注解

      第三方注解

      自定义注解

 

二、JDK内部提供的注解

 

注解(Annotation)很重要，未来的开发模式都是基于注解的，JPA是基于注解的，Spring2.5以上都是基于注解的，Hibernate3.x以后也是基于注解的，现在的Struts2有一部分也是基于注解的了，注解是一种趋势，现在已经有不少的人开始用注解了，注解是JDK1.5之后才有的新特性

JDK1.5之后内部提供的三个注解

       @Deprecated 意思是“废弃的，过时的”

       @Override 意思是“重写、覆盖”

       @SuppressWarnings 意思是“压缩警告”

 

@Deprecated

Java API中是这样定义的@Deprecated的

?
1
2
3
1 @Documented
2 @Retention(value=RUNTIME)
3 public @interface Deprecated

　　

@Override

Java API中是这样定义的@Override的

 

?
1
2
3
1 @Target(value=METHOD)
2 @Retention(value=SOURCE)
3 public @interface Override

 

@SuppressWarnings 　　

 

 Java API中是这样定义的@SuppressWarnings的

 

?
1
2
3
1 @Target(value={TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
2 @Retention(value=SOURCE)
3 public @interface SuppressWarnings

 

　　@SuppressWarnings是给javac(java编译器)看的，编译器编译完java文件后，@SuppressWarnings注解就没有用了，所以@SuppressWarnings的Retention的属性值是RetentionPolicy.SOURCE

 

 

?
1
2
3
4
5
6
7
package com.my.zhujiedemo;
 
public class FuLei {
    public void print(){
        System.out.println("我是父类中的方法");
    }
}

 

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.my.zhujiedemo;
 
public class A extends FuLei{
    @Override
    public void print() {
        System.out.println("我重写了父类中的方法");
    }
 
    @Deprecated
    public void say(){
        System.out.println("我是过时的方法");
    }
    @SuppressWarnings("depracation")
    public void speak(){
        System.out.println("我是没过时的方法");
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
package com.my.zhujiedemo;
 
public class ZhujieDemo {
    public static void main(String[] args) {
        A a = new A();
        a.print();
        a.say();
        a.speak();
    }
}

　　在这出不来效果，我截图表示，以图为主

 

?
1
2
3
4
5
运行结果：
 
我重写了父类中的方法
我是过时的方法
我是没过时的方法

　　

 

三、自定义注解

 

注解的定义及应用

 

?
1
2
3
4
注解通过 @interface关键字进行定义。
 
public @interface AnnotationZhuJie {
}

 

　　

它的形式跟接口很类似，不过前面多了一个 @ 符号。上面的代码就创建了一个名字为 AnnotaionZhuJie 的注解。

你可以简单理解为创建了一张名字为 AnnotationZhuJie 的标签

 

上面创建了一个注解，那么注解的的使用方法是什么呢?

 

?
1
2
3
@AnnotationZhuJie
public class Test {
}

 

　　

 

 

 

 

         当我们发现JDK为我们提供的注解并不能满足我们的某些需求的时候，比如，想要让程序在运行的时候获得信息，这时候，我们就需要使用一个工具来制作符合我们需求的注解，这个工具叫做元注解。

       元注解：给注解进行注解的注解

       元标签有 @Retention、@Documented、@Target、@Inherited、@Repeatable 5 种

 

 

 

@Retention


Retention 的英文意为保留期的意思。当 @Retention 应用到一个注解上的时候，它解释说明了这个注解的的存活时间。

 

      它的取值如下：

 

             RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
             RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM 中。
             RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到 JVM 中，所以在程序运行时可以获取到它们。

我们可以这样的方式来加深理解，@Retention 去给一张标签解释的时候，它指定了这张标签张贴的时间。@Retention 相当于给一张标签上面盖了一张时间戳，时间戳指明了标签张贴的时间周期。

 

 

?
1
2
3
@Retention(RetentionPolicy.RUNTIME)
public @interface AnnotationZhuJie {
}

 

　　

@Documented

顾名思义，这个元注解肯定是和文档有关。它的作用是能够将注解中的元素包含到 Javadoc 中去。

 

 

@Target


Target 是目标的意思，@Target 指定了注解运用的地方。

 

你可以这样理解，当一个注解被 @Target 注解时，这个注解就被限定了运用的场景。

 

@Target元注解决定了一个注解可以标识到哪些成分上，如标识在在类身上，或者属性身上，或者方法身上等成分，@Target默认值为任何元素(成分)

 

 

类比到标签，原本标签是你想张贴到哪个地方就到哪个地方，但是因为 @Target 的存在，它张贴的地方就非常具体了，比如只能张贴到方法上、类上、方法参数上等等。@Target 有下面的取值

 

       ElementType.ANNOTATION_TYPE 可以给一个注解进行注解
       ElementType.CONSTRUCTOR 可以给构造方法进行注解
       ElementType.FIELD 可以给属性进行注解
       ElementType.LOCAL_VARIABLE 可以给局部变量进行注解
       ElementType.METHOD 可以给方法进行注解
       ElementType.PACKAGE 可以给一个包进行注解
       ElementType.PARAMETER 可以给一个方法内的参数进行注解
       ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举

?
1
2
3
1 @Target(value={TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
2 @Retention(value=SOURCE)
3 public @interface AnnotationZhuJie

　　

 

 

 

@Inherited

 

Inherited 是继承的意思，但是它并不是说注解本身可以继承，而是说如果一个超类被 @Inherited 注解过的注解进行注解的话，那么如果它的子类没有被任何注解应用的话，那么这个子类就继承了超类的注解。
说的比较抽象。代码来解释。

 

?
1
2
3
4
5
6
7
8
9
10
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@interface Test {}
 
 
@Test
public class A {}
 
 
public class B extends A {}

 

　　注解 Test 被 @Inherited 修饰，之后类 A 被 Test 注解，类 B 继承 A,类 B 也拥有 Test 这个注解。

 

 

@Repeatable

 

Repeatable 自然是可重复的意思。@Repeatable 是 Java 1.8 才加进来的，所以算是一个新的特性。

 

什么样的注解会多次应用呢？通常是注解的值可以同时取多个。

 

举个例子，一个人他既是程序员又是产品经理,同时他还是个画家。

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@interface Persons {
    Person[]  value();
}
 
 
@Repeatable(Persons.class)
@interface Person{
    String role default "";
}
 
 
@Person(role="artist")
@Person(role="coder")
@Person(role="PM")
public class SuperMan{
     
}

 

　　

注意上面的代码，@Repeatable 注解了 Person。而 @Repeatable 后面括号中的类相当于一个容器注解。

什么是容器注解呢？就是用来存放其它注解的地方。它本身也是一个注解。

我们再看看代码中的相关容器注解。

 

?
1
2
3
@interface Persons {
    Person[]  value();
}

 

　　

按照规定，它里面必须要有一个 value 的属性，属性类型是一个被 @Repeatable 注解过的注解数组，注意它是数组。

如果不好理解的话，可以这样理解。Persons 是一张总的标签，上面贴满了 Person 这种同类型但内容不一样的标签。把 Persons 给一个 SuperMan 贴上，相当于同时给他贴了程序员、产品经理、画家的标签。

我们可能对于 @Person(role=“PM”) 括号里面的内容感兴趣，它其实就是给 Person 这个注解的 role 属性赋值为 PM ，大家不明白正常，马上就讲到注解的属性这一块。

 

 

 

 

 

 

四、注解的属性

注解可以看成是一种特殊的类，既然是类，那自然可以为类添加属性

注解的属性也叫做成员变量。注解只有成员变量，没有方法。注解的成员变量在注解的定义中以“无形参的方法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该成员变量的类型。

 

 

value属性

 

　　如果一个注解中有一个名称为value的属性，且你只想设置value属性(即其他属性都采用默认值或者你只有一个value属性)，那么可以省略掉“value=”部分。

 

 

 

?
1
2
3
4
5
6
7
package com.my.zhujie;
 
public class Aaa {
    public void print(){
        System.out.println("A中的方法");
    }
}

 

　　

?
1
2
3
4
5
6
7
8
9
package com.my.zhujie;
@Anno(name="小花",sex="女")
public class Bbb extends Aaa {
    @Override
    @Anno(name="小明",sex="男",age=30)
    public void print() {
        super.print();
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.my.zhujie;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//注解的作用域
@Target({ElementType.METHOD,ElementType.TYPE})
//注解的生命周期
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno {
    //成员以无参无异常的方式声明
    String name();
    String sex();
    //可以用default为成员指定一个默认值
    int age() default 20;
}

　　

?
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
package com.my.zhujie;
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
public class ZhuJie {
    public static void main(String[] args) {
        try {
            Class c = Class.forName("com.my.zhujie.Bbb");
            Bbb b = (Bbb)c.newInstance();
            Method method = c.getMethod("print");
            method.invoke(b);
            //获得类上的注解
            boolean b1 = c.isAnnotationPresent(Anno.class);
            if (b1){
                //获得注解对象
                Anno a = (Anno)c.getAnnotation(Anno.class);
                //打印注解成员的值
                System.out.println(a.name());
                System.out.println(a.sex());
                System.out.println(a.age());
            }
            //获得方法上的注解
            Anno anno = method.getAnnotation(Anno.class);
            System.out.println(anno.name());
            System.out.println(anno.sex());
            System.out.println(anno.age());
 
 
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
 
 
    }
}

　　

?
1
2
3
4
5
6
7
8
9
运行结果：
 
A中的方法
小花
女
20
小明
男
30

　　如果一个注解内仅仅只有一个名字为 value 的属性时，应用这个注解时可以直接接属性值填写到括号内。

 

?
1
2
3
4
5
6
7
8
//注解的作用域
@Target({ElementType.METHOD,ElementType.TYPE})
//注解的生命周期
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno {
    String value();
   
}

 

　　

上面代码中，Check 这个注解只有 value 这个属性。所以可以这样应用。

 

?
1
2
3
4
5
6
7
8
9
package com.my.zhujie;
@Anno("值")
public class Bbb extends Aaa {
    @Override
    @Anno("值")
    public void print() {
        super.print();
    }
}

 

　　

最后，还需要注意的一种情况是一个注解没有任何属性。比如

 

?
1
2
3
4
5
@Target({ElementType.METHOD,ElementType.TYPE})
//注解的生命周期
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno {
}

 

　　

那么在应用这个注解的时候，括号都可以省略。

 

?
1
2
3
4
5
6
7
8
9
package com.my.zhujie;
@Anno
public class Bbb extends Aaa {
    @Override
    @Anno
    public void print() {
        super.print();
    }
}

 

　　

本人原创，转载请说明出处https://www.cnblogs.com/zyx110/

如若对你有用，记得推荐，如若有误，欢迎改正!

 

posted @   泰斗贤若如  阅读(696)  评论(0)  编辑  收藏  举报
编辑推荐：
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
阅读排行：
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 分享 3 个 .NET 开源的文件压缩处理库，助力快速实现文件压缩解压功能！
· Ollama——大语言模型本地部署的极速利器
· DeepSeek如何颠覆传统软件测试？测试工程师会被淘汰吗？
点击右上角即可分享
微信分享提示
AI IDE Trae