网站宽屏版,网站没有百度快照,网站二维码代码,北京网络科技有限公司官网目录 问题:
作用#xff1a;
原理#xff1a;
注解的限制
拓展#xff1a; 问题:
今天刷面经#xff0c;发现自己不懂注解的原理#xff0c;特此记录。
作用#xff1a;
注解的作用主要是给编译器看的#xff0c;让它帮忙生成一些代码#xff0c;或者是帮忙检查…目录 问题:
作用
原理
注解的限制
拓展 问题:
今天刷面经发现自己不懂注解的原理特此记录。
作用
注解的作用主要是给编译器看的让它帮忙生成一些代码或者是帮忙检查、判断和校验数据。
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 {//获取目标类ClassStudent studentClass Student.class;//判断类有没有注解if(studentClass.isAnnotationPresent(MyAnnotation.class)){//拿到代理对象MyAnnotation annotation studentClass.getAnnotation(MyAnnotation.class);System.out.println(valueannotation.value());System.out.println(priotityannotation.priority());}}
注解的限制
虽然注解看起来像普通的接口但它们有一些特殊的限制
不能继承其他接口 注解不能继承其他接口除了隐式的 Annotation 接口。 public interface MyAnnotation extends SomeOtherInterface {} // 错误 不能包含方法体 注解中的方法只能声明不能有实现。 public interface MyAnnotation {
String value() { return defaultValue; } // 错误
} 不支持泛型 注解中的方法不能使用泛型。 public interface MyAnnotation {
ListString values(); // 正确
ListT 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 inot/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 citeThe 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* liTwo 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}.** liTwo 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}.)** liTwo 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}.)** liTwo 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.)** liTwo 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.** pThe 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* liThe hash code of a primitive value i{code v}/i is equal to* codeiWrapperType/i.valueOf(iv/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}).** liThe hash code of a string, enum, class, or annotation member-value* i{code v}/i is computed as by calling* codeiv/i.hashCode()/code. (In the case of annotation* member values, this is a recursive definition.)** liThe 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* #064;com.example.Name(firstDuke, middleof, lastJava)* /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();
}
