自定义注解

自定义注解是指在编写代码时，我们可以自己定义一种注解类型，以满足特定的需求。自定义注解可以通过使用Java的注解机制来实现。

要定义一个自定义注解，需要使用@interface关键字来声明注解类型，并在注解中定义一些成员变量。这些成员变量可以有默认值，也可以在使用注解时进行赋值。同时，可以在注解中定义一些方法，用于获取注解成员的值。

下面是一个简单的自定义注解的示例：

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value() default "";
    int count() default 0;
}

在上面的示例中，我们定义了一个名为MyAnnotation的注解。该注解具有两个成员变量：value和count，分别表示注解的值和计数。这两个成员变量都有默认值。

我们可以在代码中使用自定义注解，例如：

@MyAnnotation(value = "Hello", count = 5)
public void myMethod() {
    // 方法体
}

通过在方法上添加@MyAnnotation注解，并给成员变量赋值，我们就可以使用自定义注解了。

需要注意的是，自定义注解的元注解（即修饰注解的注解）@Retention和@Target用于指定注解的保留策略和作用目标。在上面的示例中，我们将保留策略设置为RUNTIME，表示注解在运行时仍然可用；作用目标设置为METHOD，表示注解可以应用于方法上。

通过自定义注解，我们可以为程序添加一些额外的信息，以便在编译时、运行时或其他工具中使用。这样可以增强代码的可读性和可维护性，并且可以实现一些自定义的功能。

元注解

元注解（Meta-Annotation）是指用于修饰其他注解的注解。元注解提供了对注解进行更精细控制和定义的能力。Java中提供了一些内置的元注解，用于修饰其他注解。

以下是几个常见的元注解：

@Retention：指定注解的保留策略，即注解在什么时候可见。常用的保留策略包括：
- RetentionPolicy.SOURCE：注解仅在源代码中可见，在编译后会被丢弃。
- RetentionPolicy.CLASS：注解在编译时可见，但在运行时会被丢弃（默认策略）。
- RetentionPolicy.RUNTIME：注解在运行时可见，可以通过反射获取注解信息。
@Target：指定注解的作用目标，即注解可以应用于哪些元素上。常用的作用目标包括：
- ElementType.TYPE：类、接口、枚举等。
- ElementType.FIELD：字段、枚举常量等。
- ElementType.METHOD：方法。
- ElementType.PARAMETER：方法参数。
- ElementType.CONSTRUCTOR：构造方法。
- ElementType.LOCAL_VARIABLE：局部变量。
- ElementType.ANNOTATION_TYPE：注解。
- ElementType.PACKAGE：包。
@Documented：指定注解是否包含在Java文档中。
@Inherited：指定注解是否可以被继承。

通过使用元注解，我们可以对自定义注解进行更加精细的控制和定义。例如，通过使用@Retention(RetentionPolicy.RUNTIME)元注解，我们可以使自定义注解在运行时可见，从而可以在运行时获取注解信息。

需要注意的是，元注解本身也是注解，它们可以应用于其他注解上，但不能应用于普通的类、方法等元素上。

@Target 元注解

@Target 是 Java 中的一个元注解，用于指定注解可以应用的目标元素类型。通过在注解上使用 @Target 注解，我们可以限定注解可以应用在类、方法、字段等不同的元素上。

@Target 元注解有以下几个常见的取值：

ElementType.TYPE：可以应用在类、接口、枚举类上。
ElementType.FIELD：可以应用在字段上。
ElementType.METHOD：可以应用在方法上。
ElementType.PARAMETER：可以应用在方法的参数上。
ElementType.CONSTRUCTOR：可以应用在构造函数上。
ElementType.LOCAL_VARIABLE：可以应用在局部变量上。
ElementType.ANNOTATION_TYPE：可以应用在注解上。
ElementType.PACKAGE：可以应用在包上。

通过在注解上使用 @Target(ElementType.XXX) 的形式，我们可以明确指定注解可以应用的目标元素类型。这样一来，当我们在使用注解时，如果违反了 @Target 指定的目标元素类型，编译器就会给出错误提示。

例如，我们定义了一个注解 @MyAnnotation，希望它只能应用在类和方法上，可以这样使用 @Target 元注解：

@Target({ElementType.TYPE, ElementType.METHOD})
public @interface MyAnnotation {
    // 注解的成员变量和方法
}

这样，当我们在使用 @MyAnnotation 时，如果将它应用在字段或者参数上，编译器就会报错。

@Retention 元注解

@Retention 是 Java 中的一个元注解，用于指定注解的保留策略，即注解在代码运行时的生命周期。

@Retention 元注解有以下几个常见的取值：

RetentionPolicy.SOURCE：注解仅在源代码中存在，编译时会被丢弃。这种注解一般用于辅助代码分析、生成文档等工具。
RetentionPolicy.CLASS：注解在编译时被保留，但在运行时不可访问。这种注解一般用于字节码增强、代码生成等工具。
RetentionPolicy.RUNTIME：注解在运行时被保留，可以通过反射机制在运行时访问。这种注解一般用于框架、库等需要在运行时进行动态处理的场景。

通过在注解上使用 @Retention(RetentionPolicy.XXX) 的形式，我们可以明确指定注解的保留策略。不同的保留策略决定了注解的可见性和可访问性。

例如，我们定义了一个注解 @MyAnnotation，希望它在运行时可以通过反射机制访问，可以这样使用 @Retention 元注解：

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    // 注解的成员变量和方法
}

这样，我们就可以在运行时通过反射机制获取到被 @MyAnnotation 注解标注的元素，并进行相应的处理。

@Repeatable 元注解

@Repeatable 是一个元注解，它用于标记一个注解是否可以在同一个地方重复使用。在 Java 8 中引入了 @Repeatable 元注解，它允许我们将同一个注解应用于同一个目标多次。

在使用 @Repeatable 元注解时，我们需要定义一个容器注解，用来包含重复的注解。容器注解需要使用 @Repeatable 注解，并指定一个注解类型作为参数，表示可以重复的注解类型。

举个例子，假设我们有一个注解 @Tag，用于给方法或类添加标签。在 Java 8 之前，我们只能通过数组的方式来添加多个标签，如 @Tag({"A", "B", "C"})。但是在 Java 8 及之后的版本，我们可以使用 @Repeatable 元注解来简化这个过程。

首先，我们需要定义一个容器注解 @Tags，用来包含多个 @Tag 注解。代码示例如下：

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Tag {
    String value();
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Repeatable(Tags.class)
public @interface Tags {
    Tag[] value();
}

然后，我们就可以在类或方法上使用 @Tag 注解，或者直接使用 @Tags 注解来添加多个标签。示例如下：

@Tag("A")
@Tag("B")
@Tag("C")
public class MyClass {
    // 类的内容...
}

@Tags({@Tag("A"), @Tag("B"), @Tag("C")})
public class MyClass {
    // 类的内容...
}

使用 @Repeatable 元注解可以使我们的代码更加简洁和易读，特别是在需要重复使用同一个注解的场景下。

@Inherited 元注解

@Inherited 是 Java 中的一个元注解（meta-annotation），用于修饰其他注解。它的作用是指示注解是否可以被继承。当一个注解标记在一个父类上时，如果该注解使用了 @Inherited 元注解，那么它将被子类继承。

换句话说，如果一个类继承了一个被标记了 @Inherited 的注解的父类，那么该类也会被自动标记上相同的注解。这样可以使得注解在继承关系中自动传递，方便在继承结构中共享注解的信息。

下面是一个示例，展示了如何使用 @Inherited 元注解：

import java.lang.annotation.*;

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String value();
}

@MyAnnotation("父类注解")
class Parent {
}

class Child extends Parent {
}

public class Main {
    public static void main(String[] args) {
        Class<?> parentClass = Parent.class;
        Class<?> childClass = Child.class;

        MyAnnotation parentAnnotation = parentClass.getAnnotation(MyAnnotation.class);
        MyAnnotation childAnnotation = childClass.getAnnotation(MyAnnotation.class);

        System.out.println("父类注解: " + parentAnnotation.value());
        System.out.println("子类注解: " + childAnnotation.value());
    }
}

在这个例子中，我们定义了一个 MyAnnotation 注解，并在 Parent 类上标记了该注解。由于 MyAnnotation 使用了 @Inherited 元注解，所以 Child 类也会继承该注解。在 Main 类中，我们使用反射获取了 Parent 和 Child 类上的 MyAnnotation 注解，并打印了注解的值。

输出结果将是：

父类注解: 父类注解
子类注解: 父类注解

可以看到，子类继承了父类的注解。如果 MyAnnotation 没有使用 @Inherited 元注解，那么子类上将无法获取到该注解。

小提示 Tis：

在注解中使用语法String value();，即定义了value这个变量。也定义了String value() 这个方法。

public @interface MyAnnotation { 
String value(); 
 }

public @interface MyAnnotation { 
String value;

public String value(){

};

自定义Annotation的步骤

自定义注解的步骤如下：

导入 java.lang.annotation.Annotation 包。
使用 @interface 关键字定义一个注解，注解的名称应以大写字母开头。
在注解内部定义注解的元素，可以包括基本数据类型、字符串、枚举类型、Class 类型、其他注解类型以及它们的数组。
可以为注解的元素指定默认值，使用 default 关键字。
可以为注解添加元注解，如 @Retention、@Target、@Inherited 等，以控制注解的行为。
使用自定义注解时，可以在类、方法、字段等元素上使用注解，并为注解的元素提供值。

下面是一个示例，演示如何自定义一个注解：

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.TYPE)
public @interface MyAnnotation {
    String value() default "";
    int count() default 0;
}

在上面的示例中，我们定义了一个名为 MyAnnotation 的注解。它有两个元素：value 和 count。value 元素是一个字符串类型，默认值为空字符串；count 元素是一个整数类型，默认值为 0。我们还使用了 @Retention 和 @Target 元注解来控制注解的行为，指定了注解的保留策略和可以使用注解的目标类型。

使用自定义注解时，可以在类、方法、字段等元素上使用注解，并为注解的元素提供值。例如：

@MyAnnotation(value = "Hello", count = 5)
public class MyClass {
    @MyAnnotation(value = "World", count = 10)
    private String message;

    @MyAnnotation(count = 2)
    public void printMessage() {
        // 方法体
    }
}

在上面的示例中，我们在类 MyClass 上使用了 @MyAnnotation 注解，并为注解的元素 value 和 count 提供了值。同时，在类的字段 message 和方法 printMessage() 上也使用了 @MyAnnotation 注解，并为注解的元素提供了值。