Java注解详解

最新推荐文章于 2025-04-14 21:41:15 发布
最新推荐文章于 2025-04-14 21:41:15 发布
阅读量1.7k 收藏 5
点赞数
分类专栏： Java 文章标签： 注解 Annotation
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IO_Field/article/details/89400348
版权
本文详细介绍了Java注解的各个方面，包括注解的定义、元素、默认值、用途，以及元注解如@Documented、@Target、@Retention、@Inherited等的用法。此外，还讲解了注解的检索方法和如何处理重复注解。

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

文章目录

参考资料

  1. Java中的注解是如何工作的？
  2. Java基础加强总结(一)——注解(Annotation)
  3. Java注解教程
  4. Java Annotation认知(包括框架图、详细介绍、示例说明)
  5. Java Language Specification - Chapter 9. Interfaces
  6. Java魔法堂：注解用法详解——@SuppressWarnings

源码地址

java_annotations

概述

对于注解而言，可以用一个词描述，那就是元数据，即一种描述数据的数据。Annotations仅仅是元数据，和业务逻辑无关。Annotations仅仅提供它定义的属性(类/方法/包/域)的信息。
Annotations的使用者(javac编译器、开发工具和其他程序)来读取这些信息并实现必要的逻辑。

Annotation

public interface Annotation {

    boolean equals(Object obj);

    int hashCode();

    String toString();

    Class<? extends Annotation> annotationType();
}

Annotation是所有注解类型的公共接口,而且所有的注解必须实现这个接口。需要注意的是，由于注解类型声明是一种特殊的接口声明。为了区分注解类型声明与普通接口的声明，在关键字前面添加了@用以区别，即@infterface。 例如：

public @interface A {
	
}

上面代码中，声明了注解A,通过@infterface表明其实现了Annotation接口及其是一个注解类。

元素

注解的本身是一种数据类型，是Annotation的实现类，当然也可以在其内声明被称为元素的成员。与普通数据类型不同的是，注解类型通过方法声明定义注解类型的元素。例如：

public @interface B {
	String name();
	
	int version();
}

在注解B中，声明了两个元素name和version,它们都是通过方法声明的。

值的注意的是：

  1. 注解类型可以包含零个或多个元素。
  2. 注解类型的元素的数据类型为：基本类型、字符串(String)、类、类的任何参数化调用、枚举类型、注解类型或数组类型。
  3. 在注解类型中声明的任何方法不能覆盖在类Object或接口java.lang.annotation.Annotation中声明的任何公共或受保护的方法，否则出现编译时错误。
  4. 注解类型不能直接或间接泛型元素，否则出现编译时错误。

默认值

注解类型元素可以为其指定的默认值。在指定默认值时使用使用关键字default和元素的默认值(空值或值列表)。其中

  1. 未指定默认值的元素，必须在使用时对该元素赋值。
  2. 给定的元素默认值的数据类型必须与元素的数据类型一致。

例如：

public @interface C {
	String name() default "tea";
	
	int version();
}


@C(version = 1)
public class CC {
	
	@C(name = "2", version = 2)
	String a;
}

在注解类型C,中声明了两个元素name和version，其中，name指定了默认值tea。当使用C时，可以不对元素name赋值。当未对元素version赋值时，IDE会报错，提示"version是必要的但是没有找到"，也就意味着未指定默认值的元素，必须在使用时对该元素赋值。

image

用途

注解有多种用途，包括：

  • 向编译器提供信息 —— 编译器使用注解检查错误或忽略警告
  • 编译时和部署时处理 —— 注解处理工具可以处理注解信息来生成代码，XML文件等等
  • 运行时处理 —— 一些注解在运行时进行审查

元注解

在注解类上使用另一个注解类，那么被使用的注解类就称为元注解.

Java SE API预定义了一组注解类型。某些注解用于Java编译器，一些适用于其他注解。

  • @Documented
  • @Target
  • @Retention
  • @Inherited
  • @Override
  • @SuppressWarnings
  • @Deprecated
  • @SafeVarargs
  • @FunctionalInterface
  • @Repeatable

@Documented

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

@Documented用于注解类型的声明,表示是否将注解信息添加在java文档中。如果将@Documented用于注解类型声明,那么该注解将成为javadoc的API中.声明Annotation时，@Documented可有可无;若没有定义，则Annotation不会出现在javadoc中。

@Target

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    ElementType[] value();
}

public enum ElementType {
    // 用于描述类、接口或enum声明
    TYPE,

    // 用于描述实例变量
    FIELD,

    // 用于描述方法
    METHOD,

    // 用于描述参数
    PARAMETER,

    // 用于描述构造函数
    CONSTRUCTOR,

    // 用于描述局部变量
    LOCAL_VARIABLE,

    // 用于描述注解类型
    ANNOTATION_TYPE,

    // 用于记录java文件的package信息
    PACKAGE,

    /**
     * 用于注解类型参数(泛型)
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

@Target用于注解类型的声明,表明注解类型用于注解哪些位置(Class、实例变量、方法、参数 、构造函数、局部变量、注解类型、包及任何位置)。如果不明确指出，该注解可以放在任何地方。需要说明的是：属性的注解是兼容的，如果想注解哪些类型，只需将其一一添加至value值列表即可。

  • ElementType.TYPE:用于注解类、接口或enum声明
  • ElementType.FIELD:用于注解实例变量
  • ElementType.METHOD:用于注解方法
  • ElementType.PARAMETER:用于注解参数
  • ElementType.CONSTRUCTOR:用于注解构造函数
  • ElementType.LOCAL_VARIABLE:用于注解局部变量
  • ElementType.ANNOTATION_TYPE:用于注解注解类型
  • ElementType.PACKAGE:用于注解java文件的package信息
  • ElementType.TYPE_PARAMETER：用于注解类型参数(泛型)
  • ElementType.TYPE_USE:用于注解任何类型

@Retention

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    RetentionPolicy value();
}

@Retention用于注解类型的声明,表明注解类型的注解的保留时长,也可以认为被其注解的注解类型的生命周期.对于保留策略,通过其RetentionPolicy类型的value元素指定.如果注解类型声明中没有被@Retention注解，保留策略默认为RetentionPolicy.CLASS。

public enum RetentionPolicy {
    SOURCE,
    CLASS,
    RUNTIME
}

其中:

  • RetentionPolicy.SOURCE —> 注解只保留在源文件，当.java文件编译成.class文件时，注解被遗弃。
  • RetentionPolicy.CLASS —> 注解被保留到.class文件中，但JVM加载.class文件时被遗弃，这是默认的生命周期。
  • RetentionPolicy.RUNTIME —> 注解不仅被保存到.class文件中，JVM加载.class文件之后，注解仍然存在。

为什么会有保留策略这个概念呢？因为Java程序从源文件创建到程序运行要经过3个阶段:

  1. Java源文件,即.java文件
  2. javac把java源文件(.java文件)编译成字节码文件即.class文件
  3. java虚拟机(JVM)解释运行字节码,此时字节码已加载到内存,为了便于理解,称之为内存中的字节码

对于注解而言,在每个阶段中,都可能将注解去掉,也有可能把注解保留下来,这样造成了注解的3个阶段:

  1. .java源文件
  2. .class文件
  3. 内存中的字节码

在编写代码时通过注解检查代码，需要在编写Java源码时运行，对应的就是SOURCE阶段。

需要在编译前进行一些预处理，对应的是CLASS阶段，编译时注解对代码的预处理发生在此阶段。

在程序运行后，想要动态获取一些注解信息，只能在RUNTIME阶段，例如，EventBus 2.x
通过动态注解获取事件信息并添加到事件列表中 。

@Inherited

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}

@Inherited用于声明自定义注解(比如C)，当C注解超类时，其子类可以从超类继承C。如果C没有被@Inherited注解，当C注解超类时，子类不可以从超类继承C。例如：

// 声明的此注解没有使用@Inherited，表示此注解用在类上时，不会被子类所继承
@Retention(RetentionPolicy.RUNTIME)
public @interface C {
	String name() default "tea";
	
	int version();
}

// 声明的此注解使用了@Inherited，表示此注解用在类上时，会被子类所继承
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface D {
	
}

@D
@C(version = 1)
public class Person 

public class Student extends Person

public class TestInherited {
	
	public static void main(String[] args) {
		Class clz = Student.class;
		
		// Log: Student is annotated by C: false
		System.out.println("Student is annotated by C: " + clz.isAnnotationPresent(C.class));
		// Student is annotated by D: true
		System.out.println("Student is annotated by D: " + clz.isAnnotationPresent(D.class));
	}
	
}

输出结果：

Student is annotated by C: false
Student is annotated by D: true

注意：

  • 使用@Inherited声明的自定义注解只能用于注解Class.

@Override

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

@Override用于注解方法，表明该方法继承自父类。使用该注解的用途为：

  1. 检查是否正确重写父类的方法
  2. 便于阅读代码，表明该方法继承父类

比如，在父类Person中声明方法doSwim()

public class Person {
	
	public void doSwim() {
	
	}
}

此时，创建子类Student，继承自Person，当重写doSwim()时，如果没有使用@Override注解，在不看Person源码的前提下，第一反映应该是，doSwim()是Student的成员方法，而不是重写父类的方法：

public class Student extends Person{
	
	public void doSwim() {
	}
}

但是，如果使用了@Override注解，任何看代码的人都知道doSwim()的是继承自父类的。

public class Student extends Person{
	
	@Override
	public void doSwim() {
	}
}

另外，在重写父类方法时，参数写错，如果没有添加@Override注解，IDE不会有任何提示。

public class Student extends Person{
	
	@Override
	public void doSwim(float a) {
	}
}

当添加@Override注解后，IDE会给出错误提示，如下：

image

@SuppressWarnings

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

@SuppressWarnings用于在注解的元素(以及注解元素中所有程序代码)中抑制编译器产生的指定警告信息，不用在编译完成后出现警告信息。从@SuppressWarnings的源码中可以看出其注解目标为类、字段、函数、函数入参、构造函数和函数的局部变量。

例如：

  1. 抑制单类型的警告
@SuppressWarnings("unchecked")
public void addItems(String item){
  @SuppressWarnings("rawtypes")
   List items = new ArrayList();
   items.add(item);
}
  1. 抑制多类型的警告
@SuppressWarnings(value={"unchecked", "rawtypes"})
public void addItems(String item){
   List items = new ArrayList();
   items.add(item);
}
  1. 抑制所有类型的警告
@SuppressWarnings("all")
public void addItems(String item){
   List items = new ArrayList();
   items.add(item);
}

抑制警告的关键字

关键字用途
allto suppress all warnings
boxingto suppress warnings relative to boxing/unboxing operations
castto suppress warnings relative to cast operations
dep-annto suppress warnings relative to deprecated annotation
deprecationto suppress warnings relative to deprecation
fallthroughto suppress warnings relative to missing breaks in switch statements
finallto suppress warnings relative to finally block that don’t return
hidingto suppress warnings relative to locals that hide variable
incomplete-switchto suppress warnings relative to missing entries in a switch statement (enum case)
nlsto suppress warnings relative to non-nls string literals
nullto suppress warnings relative to null analysis
rawtypesto suppress warnings relative to un-specific types when using generics on class params
restrictionto suppress warnings relative to usage of discouraged or forbidden references
serialto suppress warnings relative to missing serialVersionUID field for a serializable class
static-accessto suppress warnings relative to incorrect static access
synthetic-accessto suppress warnings relative to unoptimized access from inner classes
uncheckedto suppress warnings relative to unchecked operations
unqualified-field-accessto suppress warnings relative to field access unqualified
unusedto suppress warnings relative to unused code

@Deprecated

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

@Deprecated用于注解构造函数、成员变量、局部变量、方法、包、参数以及类、接口或enum声明，表明其注解的元素(以及注解元素中所有程序代码)存在隐患或者存在更好的替代方案，不再建议使用。在新版本中有其他方法或类可以代替这个使用，以后的版本也不会再更新。在使用@Deprecated注解的元素时，IDE会给出警告,以删除线提示。例如：

@Deprecated
public class Student extends Person{
	
	@Deprecated
	public void doStudy() {
	
	}
}

在Student中，使用@Deprecated注解了Class和方法doStudy(),IDE会给出警告提示，如下所示：

image

@SafeVarargs

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})
public @interface SafeVarargs {}

@SafeVarargs用于可变参数注解构造函数或方法，断言代码不会对其varargs参数执行潜在的不安全操作。当使用此注解时，将抑制与varargs使用相关的未检查的警告,并禁止在调用位置创建有关参数化数组的未经检查的警告。

public class SafeVarargsDemo {
	
	@SafeVarargs
	public SafeVarargsDemo(List<String> ...args) {
	}
	
	@SafeVarargs
	public static void doSwim(List<String>... args) {
		System.out.println(Arrays.toString(args));
	}
	
	public static void main(String[] args) {
		Class clz = SafeVarargsDemo.class;
		
		try {
			Method method = clz.getMethod("doSwim", List[].class);
			System.out.println("parameter type: " + Arrays.toString(method.getParameterTypes()));
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		}
	}
}

// Log

constructor - name: com.teaphy.demo.SafeVarargsDemo, parameter type: [class [Ljava.util.List;]
method - name: doSwim, parameter type: [class [Ljava.util.List;]

因为泛型的擦除原则，当使用泛型作为可变参数时,参数数组中存储的是不可具体化的泛型类对象，在编译之后泛型会被擦出掉，那么参数数组存在类型安全问题。因此编译器会给出相应的警告消息。

值得注意的是：

  1. @SafeVarargs注解的元素必须是可变参数方法和构造器
  2. 如果@SafeVarargs注解的是可变参数的方法，那么该方法必须是被static或final修饰的

@FunctionalInterface

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

@FunctionalInterface用于注解接口类型声明，表明其为Java语言规范定义的函数式接口。所谓函数式接口就是只有一个抽象方法的接口。不管是默认方法还是静态方法都是有实现的，它们都不是抽象的。另外，如果接口覆盖了java.lang.Object的方法，也不计入抽象方法的的计数。

例如：

@FunctionalInterface
public interface TestFunctionalInterface {
	
	void doTes();
	
	/**
	 * default不是抽象方法
	 */
	default void doA() {
	
	}
	
	/**
	 * static不是抽象方法
	 */
	static void doB() {
	
	}
	
	/**
	 * java.lang.Object中的方法不是抽象方法
	 */
	@Override
	boolean equals(Object obj);
	
}

值得注意的是：

1. `@FunctionalInterface`注解的类型只能是接口类型声明，而不是类型是注解类型，枚举或类。 2. `@FunctionalInterface`注解的类型必须满足函数式接口的要求。

@Repeatable

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Repeatable {
    /**
     * Indicates the <em>containing annotation type</em> for the
     * repeatable annotation type.
     * @return the containing annotation type
     */
    Class<? extends Annotation> value();
}

@Repeatable用于注解注解类型，表明该注解可以重复注解同一个元素。@Repeatable的值表示可重复注解类型的容器，其元素为可重复注解类型。

@Repeatable是JDK 1.8新增的元注解，在此之前一个类型的注解不能重复修饰在相同的注解。

可重复注解的实现：

  1. 声明可重复注解类型的容器 - Es
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
public @interface Es {
	E[] value();
}

值得注意的是：

  • 可重复注解类型的容器的也是一个注解，表明它可以直接注解元素，而其value值就是可重复注解的数组。
  • 可重复注解类型的容器的value方法(默认方法)需要返回其元注解(即可重复注解类)的列表，否则这个容器类创建的不符合需求。
  1. 声明可重复注解类型 - E
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
@Repeatable(Es.class)
public @interface E {
	String value();
}

可重复注解与普通注解没有太大区别，值得注意的是，使用@Repeatable表示其可以重复注解元素，还要指定可重复注解类型的容器，比如这里指定的是Es.class

  1. 使用可重复注解
@E("A")
@E("B")
@E("C")
@E("D")
public class EE {
	
}

使用E注解EE，共重复了4次，其value值分别为A，B，C，D。

  1. 获取重复注解
public class RepeatableDemo {
	
	public static void main(String[] args) {
		Class<EE> clz = EE.class;
		
		if (clz.isAnnotationPresent(Es.class)) {
			// 返回重复注解(E.class)列表
			E[] annotationsByType = clz.getAnnotationsByType(E.class);
			System.out.println("annotationsByType: " + Arrays.toString(annotationsByType));
		}
	}
	
}

// 运行结果

annotationsByType: [
@com.teaphy.annotation.E(value=A),
@com.teaphy.annotation.E(value=B),
@com.teaphy.annotation.E(value=C),
@com.teaphy.annotation.E(value=D)]

通过反射获取了EE中的返回重复注解(E.class)列表。但是，在断言EE是否被某个注解类型注解时，使用的是Es.class(即可重复注解类型的容器)而不是E.class，这是为什么呢？如果查看编译后的EE.class,可以发现，编译器将重复的注解E装入了可重复注解类型的容器Es，实际注解EE.class的是Es而不是E。

image

检索注解

java.lang.reflect
Interface AnnotatedElement

    子接口:
        AnnotatedArrayType, AnnotatedParameterizedType, AnnotatedType, AnnotatedTypeVariable, AnnotatedWildcardType, GenericDeclaration, TypeVariable<D>

    直接实现类:
        AccessibleObject, Class, Constructor, Executable, Field, Method, Package, Parameter

在java.lang.reflect中定义了AnnotatedElement接口，从而允许在带有注解的元素通过反射的API获取注解。此接口中的方法返回的所有注解都是不可变的和可序列化的。

其中，getAnnotationsByType(Class)和getDeclaredAnnotationsByType(Class)方法允许元素获取相同类型的多个注解。如果任一方法的参数是可重复的注解类型，那么该方法将搜索可重复注解类型的容器是否存在，如果存在，将返回可重复注解类型的容器内的所有注解。

使用直接存在、间接存在、存在和关联的术语来精确描述方法返回的注解和元素之间的关系：

  • 直接存在 - 如果E具有RuntimeVisibleAnnotations或RuntimeVisibleParameterAnnotations或RuntimeVisibleTypeAnnotations属性，并且该属性包含A，则注解A直接存在元素E上。
  • 间接存在 - 如果E具有RuntimeVisibleAnnotations或RuntimeVisibleParameterAnnotations或RuntimeVisibleTypeAnnotations属性，并且A的类型是可重复的，并且该属性仅包含一个注解，其值元素包含A且其类型包含A注解类型(这个注解其实就是可重复注解A的容器)，则注解A间接存在于元素E上。
  • 存在 - 注解A存在元素E上,那么
    • A直接存在于元素E上
    • A的类型没有注解元素E,但,E是一个类，A的类型是可继承的，A存在于E的超类中。
  • 关联 - 注解A与元素E关联,那么
    • A直接或间接存在于E
    • A没有直接或间接存在于E上,但,E是一个类，A的类型是可继承的，A与E的超类相关联。
方法直接存在间接存在存在关联
T getAnnotation(Class)X
Annotation[] getAnnotations()X
T[] getAnnotationsByType(Class)X
T getDeclaredAnnotation(Class)X
Annotation[] getDeclaredAnnotations()X
T[] getDeclaredAnnotationsByType(Class)XX

比如：

@Retention(RetentionPolicy.RUNTIME)
public @interface C {
	String name() default "tea";
	
	int version();
}

@C(version = 1)
public class Person {
}


public class AnnotationDemo {
    public static void main(String[] args) {
        Class clzPerson = Person.class;

        Annotation annotation = clzPerson.getAnnotation(C.class);
        if (null != annotation) {
            C c = (C) annotation;
            System.out.println("c: " + c);
        }
    }
}
【Java知识点详解 6】Java注解详解
2401_84006757的博客
05-01 679
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的MyBtis知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的MyBtis知识脑图原件（包括上方的面试解析xmind文档）
JAVA 注解示例 详解
04-22
NULL 博文链接：https://wangming2012.iteye.com/blog/1941123
java注解例子_java注解实例
weixin_39705794的博客
02-25 210
JDK注解Override，覆盖父类同名方法Deprected，表示此方法以及废弃SupperssWarnings，去掉警告提示第三方注解：Spring的@Autowired，@service,@repositoryMybatis的@InsertProvider,@UpdateProvider,@options自定义注解：@Target({ElementType.METHOD,ElementTyp...
Java注解(Annotation)详解
最新发布
斗锋在干嘛的博客
04-14 988
内置注解：Java语言提供元注解：用于注解其他注解自定义注解：开发者定义的注解// 注解参数// 带默认值的参数。
10-2 枚举类与注解----注解(Annotation)（1）概述
wp_886的博客
02-09 168
10-2 枚举类与注解----注解(Annotation)（1）概述 一、概述 从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是Annotation(注解)  Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。 Annotat
java注解例子
panther的专栏
08-08 1460
java注解在web框架中使用比较广泛，这使得对象之间的关系配置起来更加容易 目前web框架中最常用的两种配置对象依赖关系的方式就是注解和xml配置文件的方法，api配置相对来说用的少一些， 下面实现一个Table注解来实现数据库表和实体bean之间的对应关系，实现一个Column注解来实现数据库表中每个字段和实体bean每个属性之间的 对应关系。java中的orm基本上就是根据这种思想来实
Java 注解实例
Sampson的专栏
02-19 492
package com.annotation; import java.lang.annotation.Retention; import java.lang.annotation.Target; import static java.lang.annotation.ElementType.*; import static java.lang.annotation.RetentionPolicy.
JAVA 注解详解及简单实例
08-30
* @Deprecated：如果程序员使用被这个注解注释的元素，则编译器会进行提示 * @Suppress Warnings：忽略编译器的警告 四种元注解分别是： * @Target：表示注解的适用范围，例如 @Target(ElementType.FIELD) * @...
java注解详解[文].pdf
10-11
Java 注解详解 Java 注解（Annotation）是 JDK 5.0 及以后版本引入的一个特性。它是一个新的类型，与接口类似，位于同一个层次，称为 Java 的一个类型（TYPE）。注解可以声明在包、类、字段、方法、局部变量、方法...
java注解详解，十分有用。
04-03
Java 注解详解 Java 注解（Annotation）是 JDK 5.0 及以后版本引入的一个特性，它是一个新的类型，与类、接口、枚举是在同一个层次。注解可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些...
Java自定义注解实例
11-03
包括Java自定义注解以及包括自定义注解的应用实例。以及注解相关知识的注解
注解javademo演示
11-30
java注解详解demo具体博客：http://blog.csdn.net/wzgiceman/article/details/53406248
Java注解实例
IT1995的博客
02-27 5010
目录 理论 例子 理论 注解的作用范围：@Target 生命周期：@Retention 作用范围：包、类、字段、方法、方法的参数、局部变量 生命周期：源文件SOURCE、编译CLASS、运行RUNTIME 例子 这里来一个简单的实例（本实例来源与mooc网，本人只是抄了一遍，和进行了简单的修改，在此感谢下mooc的老师） 程序运行截图如下： 程序结...
java 注解例子
星空中的一颗星
04-27 231
结构在同一个包下面三个文件 注解MyAnnotation Demo给注解赋值 Test读取注解赋值 1.MyAnnotation类定义注解 package com.atguigu.test; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; @Retention(RetentionPolicy.RUNTIME) public @interface MyAnnotation
java注解完整实例
mofsfely2的博客
07-08 1632
背景 java注解，网上的实例千篇一律，感觉大多都没有抓到重点。最糟糕的是，示例不全，不能完全让别人把示例做出来。 起因：希望通过自定义一个字段校验的注解，来理解注解。 什么是注解 意如其名，其本来的意思就是用来做标注用：可以在类、字段变量、方法、接口等位置进行一个特殊的标记，为后续做一些诸如：代码生成、数据校验、资源整合等工作做铺垫。 注解一旦对代码标注完成，后续我们就可以结合Java强大的反射机制，在运行时动态地获取到注解的标注信息，从而可以执行很多其他逻辑，完成我们想要的自动化工作。 总的来说就是先标
java注解demo
bruce2018的专栏
02-21 876
package org.annation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;
Java注解demo
weixin_30398227的博客
09-10 161
# 为了熟悉了解注解，写的一个小demo# demo的主要功能是扫描一个class中的包含我们自定义注解的方法，然后把他们的返回值放到一个map中 public class QQ { public static void main(String[] args) throws IllegalAccessException, IllegalArg...
java注解详解
03-18
### Java 注解的使用详解 #### 一、注解的基本概念 Java 注解是一种元数据形式，它提供了关于程序代码的信息，但并不直接影响其执行逻辑。它可以应用于类、方法、字段以及参数等多种场景中[^1]。 #### 二、注解的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值