目录
问题:
作用：
原理：
注解的限制
拓展：
问题:
今天刷面经，发现自己不懂注解的原理，特此记录。
作用：
注解的作用主要是给编译器看的，让它帮忙生成一些代码，或者是帮忙检查、判断和校验数据。
1.给编译器看：
- 帮助编译器进行语法检查（如 @Override、@Deprecated)。
- 通过注解处处理器生成代（如Lombok的@Getter,@Setter)。
2.给运行时框架看
- 通过反射机制动态读取注解信息，实现功能增强（如依赖注入、AOP、配置管理、数据验证）等。
原理：
注解的本质一个特殊的接口，继承了java.lang.annotation.Annotation 接口。当定义一个注解时，Java 编译器会将其转换为一个实现了 Annotation 接口的代理类。
import java.lang.annotation.*;@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {String value() default "defaultValue";int priority() default 1;
}//伪代码
public interface MyAnnotation extends Annotation {String value(); // 对应注解中的 value 属性int priority(); // 对应注解中的 priority 属性
}//验证
@Retention(RetentionPolicy.RUNTIME) 可以通过反射机制拿去值public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, UnknownHostException {//获取目标类Class<Student> studentClass = Student.class;//判断类有没有注解if(studentClass.isAnnotationPresent(MyAnnotation.class)){//拿到代理对象MyAnnotation annotation = studentClass.getAnnotation(MyAnnotation.class);System.out.println("value："+annotation.value());System.out.println("priotity："+annotation.priority());}}注解的限制
虽然注解看起来像普通的接口，但它们有一些特殊的限制：
- 不能继承其他接口 ：注解不能继承其他接口（除了隐式的
Annotation接口）。public @interface MyAnnotation extends SomeOtherInterface {} // 错误！
- 不能包含方法体 ：注解中的方法只能声明，不能有实现。
public @interface MyAnnotation { String value() { return "defaultValue"; } // 错误！ }
- 不支持泛型 ：注解中的方法不能使用泛型。
public @interface MyAnnotation { List<String> values(); // 正确 List<T> values(); // 错误！ }
拓展：
java.lang.annotation.Annotation 是所有注解的父接口。它定义了一些通用的方法，用于处理注解的元数据。
package java.lang.annotation;/*** The common interface extended by all annotation interfaces. Note that an* interface that manually extends this one does <i>not</i> define* an annotation interface. Also note that this interface does not itself* define an annotation interface.** More information about annotation interfaces can be found in section* {@jls 9.6} of <cite>The Java Language Specification</cite>.** The {@link java.lang.reflect.AnnotatedElement} interface discusses* compatibility concerns when evolving an annotation interface from being* non-repeatable to being repeatable.** @author Josh Bloch* @since 1.5*/
/*** 所有注解接口继承的公共接口。注意：手动扩展此接口的接口<i>不会</i>成为注解接口。* 此接口自身也不作为注解接口。* * 更多注解接口的详细信息，请参阅《Java语言规范》第{@jls 9.6}节。* * 当注解接口从不可重复变为可重复时，{@link java.lang.reflect.AnnotatedElement}* 接口讨论了相关的兼容性问题。* * 作者：Josh Bloch* 自版本：1.5*/
public interface Annotation {
public interface Annotation {/*** Returns true if the specified object represents an annotation* that is logically equivalent to this one. In other words,* returns true if the specified object is an instance of the same* annotation interface as this instance, all of whose members are equal* to the corresponding member of this annotation, as defined below:* <ul>* <li>Two corresponding primitive typed members whose values are* {@code x} and {@code y} are considered equal if {@code x == y},* unless their type is {@code float} or {@code double}.** <li>Two corresponding {@code float} members whose values* are {@code x} and {@code y} are considered equal if* {@code Float.valueOf(x).equals(Float.valueOf(y))}.* (Unlike the {@code ==} operator, NaN is considered equal* to itself, and {@code 0.0f} unequal to {@code -0.0f}.)** <li>Two corresponding {@code double} members whose values* are {@code x} and {@code y} are considered equal if* {@code Double.valueOf(x).equals(Double.valueOf(y))}.* (Unlike the {@code ==} operator, NaN is considered equal* to itself, and {@code 0.0} unequal to {@code -0.0}.)** <li>Two corresponding {@code String}, {@code Class}, enum, or* annotation typed members whose values are {@code x} and {@code y}* are considered equal if {@code x.equals(y)}. (Note that this* definition is recursive for annotation typed members.)** <li>Two corresponding array typed members {@code x} and {@code y}* are considered equal if {@code Arrays.equals(x, y)}, for the* appropriate overloading of {@link java.util.Arrays#equals Arrays.equals}.* </ul>** @return true if the specified object represents an annotation* that is logically equivalent to this one, otherwise false*/boolean equals(Object obj);/*** Returns the hash code of this annotation.** <p>The hash code of an annotation is the sum of the hash codes* of its members (including those with default values).** The hash code of an annotation member is (127 times the hash code* of the member-name as computed by {@link String#hashCode()}) XOR* the hash code of the member-value.* The hash code of a member-value depends on its type as defined below:* <ul>* <li>The hash code of a primitive value <i>{@code v}</i> is equal to* <code><i>WrapperType</i>.valueOf(<i>v</i>).hashCode()</code>, where* <i>{@code WrapperType}</i> is the wrapper type corresponding* to the primitive type of <i>{@code v}</i> ({@link Byte},* {@link Character}, {@link Double}, {@link Float}, {@link Integer},* {@link Long}, {@link Short}, or {@link Boolean}).** <li>The hash code of a string, enum, class, or annotation member-value* <i>{@code v}</i> is computed as by calling* <code><i>v</i>.hashCode()</code>. (In the case of annotation* member values, this is a recursive definition.)** <li>The hash code of an array member-value is computed by calling* the appropriate overloading of* {@link java.util.Arrays#hashCode(long[]) Arrays.hashCode}* on the value. (There is one overloading for each primitive* type, and one for object reference types.)* </ul>** @return the hash code of this annotation*/int hashCode();/*** Returns a string representation of this annotation. The details* of the representation are implementation-dependent, but the following* may be regarded as typical:* <pre>* @com.example.Name(first="Duke", middle="of", last="Java")* </pre>** @return a string representation of this annotation*/String toString();/*** Returns the annotation interface of this annotation.** @apiNote Implementation-dependent classes are used to provide* the implementations of annotations. Therefore, calling {@link* Object#getClass getClass} on an annotation will return an* implementation-dependent class. In contrast, this method will* reliably return the annotation interface of the annotation.** @return the annotation interface of this annotation* @see Enum#getDeclaringClass*/Class<? extends Annotation> annotationType();
}