本文目录一览：
- 1、java注解有什么用
- 2、java中常用注解分别是什么及汉语意思!
- 3、java里的注解都有哪些？都有什么用处啊？
- 4、java注解的类型可以是哪些
- 5、java里的注解都有哪些
- 6、java开发中常用的注解有哪些
java注解有什么用
注解常见的作用有以下几种：
1.生成文档。这是最常见的，也是java 最早提供的注解，常用的有@param @return 等；
2.跟踪代码依赖性，实现替代配置文件功能。比较常见的是spring 2.5 开始的基于注解配置，作用就是减少配置，现在的框架基本都使用了这种配置来减少配置文件的数量；
3.在编译时进行格式检查。如@Override放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。
java中常用注解分别是什么及汉语意思!
Annotation(注解)是JDK5.0及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注释是以‘@注释名’在代码中存在的，根据注释参数的个数，我们可以将注释分为：标记注释、单值注释、完整注释三类。它们都不会直接影响到程序的语义，只是作为注释（标识）存在，我们可以通过反射机制编程实现对这些元数据的访问。另外，你可以在编译时选择代码里的注释是否只存在于源代码级，或者它也能在class文件中出现。
元数据的作用
如果要对于元数据的作用进行分类，目前还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类：
编写文档：通过代码里标识的元数据生成文档。
代码分析：通过代码里标识的元数据对代码进行分析。
编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查。
基本内置注解
@Override java中覆写
@Deprecated的作用是对不应该在使用的方法添加注释，当编程人员使用这些方法时，将会在编译时显示提示信息，它与javadoc里的
@deprecated标记有相同的功能，准确的说，它还不如javadoc
@deprecated，因为它不支持参数
@SuppressWarnings,其参数有：
deprecation，使用了过时的类或方法时的警告
unchecked，执行了未检查的转换时的警告
fallthrough，当 Switch 程序块直接通往下一种情况而没有 Break 时的警告
path，在类路径、源文件路径等中有不存在的路径时的警告
serial，当在可序列化的类上缺少 serialVersionUID 定义时的警告
finally ，任何 finally 子句不能正常完成时的警告
all，关于以上所有情况的警告
自定义注释
它类似于新创建一个接口类文件，但为了区分，我们需要将它声明为@interface,如：public @interface NewAnnotation {}............
java里的注解都有哪些？都有什么用处啊？
注释有 3 中基本类型a. 标记注释 -- 没有变量，只有名称标识。例如 @annotationb. 单一值注释 -- 在标记注释的基础上提供一段数据。如 @annotation(“data”)c. 完整注释 -- 可以包括多个数据成员，每个数据成员由名称和值构成。@annotation(val1="data1",val2="data2")Java 中提供 3 个内置注释类型a. Override ，只能用于方法 ( 不能用于类，包声明或者其他构造 )作用：可以保证编译时候 Override 函数的声明正确性用法： @Overridepublic void fun(){..}b.Deprecated 同样只能作用与方法作用：对不应再使用的方法进行注解用法： @Deprecated public void fun{...} // 它们说这个注释跟函数要同一行c.SupressWarnings 可以注释一段代码作用：关闭特定的警告信息，例如你在使用泛型的时候未指定类型用法： @SupressWarnings(value={"unchecked"}).. 代码Java 中还提供了四种元注释，专门负责注释其他的注释@Target 表示该注释可以用于什么地方。可用的 ElementType 参数包括：CONSTRUCTOR : 构造器的声明FIELD : 域声明 ( 包括 enum 实例 )LOCAL_VARIABLE : 局部变量声明METHOD : 方法声明PACKAGE : 包声明PARAMETER : 参数声明TYPE : 类、接口 ( 包括注解类型 ) 或 enum 声明@Retention 表示需要在什么级别保存该注释信息。可选的 RetentionPoicy 参数包括：SOURCE : 注释将被编译器丢掉CLASS : 注释在 class 文件中可用，但会被 VM 丢弃RUNTIME : VM 将在运行时也保留注释，因此可以通过反射机制读取注释的信息。
java注解的类型可以是哪些
使用注解
在一般的Java开发中，最常接触到的可能就是@Override和@SupressWarnings这两个注解了。使用@Override的时候只需要一个简单的声明即可。这种称为标记注解（marker annotation ），它的出现就代表了某种配置语义。而其它的注解是可以有自己的配置参数的。配置参数以名值对的方式出现。使用 @SupressWarnings的时候需要类似@SupressWarnings({"uncheck", "unused"})这样的语法。在括号里面的是该注解可供配置的值。由于这个注解只有一个配置参数，该参数的名称默认为value，并且可以省略。而花括号则表示是数组类型。在JPA中的@Table注解使用类似@Table(name = "Customer", schema = "APP")这样的语法。从这里可以看到名值对的用法。在使用注解时候的配置参数的值必须是编译时刻的常量。
从某种角度来说，可以把注解看成是一个XML元素，该元素可以有不同的预定义的属性。而属性的值是可以在声明该元素的时候自行指定的。在代码中使用注解，就相当于把一部分元数据从XML文件移到了代码本身之中，在一个地方管理和维护。
开发注解
在一般的开发中，只需要通过阅读相关的API文档来了解每个注解的配置参数的含义，并在代码中正确使用即可。在有些情况下，可能会需要开发自己的注解。这在库的开发中比较常见。注解的定义有点类似接口。下面的代码给出了一个简单的描述代码分工安排的注解。通过该注解可以在源代码中记录每个类或接口的分工和进度情况。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Assignment {
String assignee();
int effort();
double finished() default 0;
}
@interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型。可以通过default来声明参数的默认值。在这里可以看到@Retention和@Target这样的元注解，用来声明注解本身的行为。@Retention用来声明注解的保留策略，有CLASS、RUNTIME和SOURCE这三种，分别表示注解保存在类文件、JVM运行时刻和源代码中。只有当声明为RUNTIME的时候，才能够在运行时刻通过反射API来获取到注解的信息。@Target用来声明注解可以被添加在哪些类型的元素上，如类型、方法和域等。
处理注解
在程序中添加的注解，可以在编译时刻或是运行时刻来进行处理。在编译时刻处理的时候，是分成多趟来进行的。如果在某趟处理中产生了新的Java源文件，那么就需要另外一趟处理来处理新生成的源文件。如此往复，直到没有新文件被生成为止。在完成处理之后，再对Java代码进行编译。JDK 5中提供了apt工具用来对注解进行处理。apt是一个命令行工具，与之配套的还有一套用来描述程序语义结构的Mirror API。Mirror API（com.sun.mirror.*）描述的是程序在编译时刻的静态结构。通过Mirror API可以获取到被注解的Java类型元素的信息，从而提供相应的处理逻辑。具体的处理工作交给apt工具来完成。编写注解处理器的核心是AnnotationProcessorFactory和AnnotationProcessor两个接口。后者表示的是注解处理器，而前者则是为某些注解类型创建注解处理器的工厂。
以上面的注解Assignment为例，当每个开发人员都在源代码中更新进度的话，就可以通过一个注解处理器来生成一个项目整体进度的报告。 首先是注解处理器工厂的实现。
public class AssignmentApf implements AnnotationProcessorFactory {
public AnnotationProcessor getProcessorFor(SetAnnotationTypeDeclaration atds,? AnnotationProcessorEnvironment env) {
if (atds.isEmpty()) {
return AnnotationProcessors.NO_OP;
}
return new AssignmentAp(env); //返回注解处理器
}
public CollectionString supportedAnnotationTypes() {
return Collections.unmodifiableList(Arrays.asList("annotation.Assignment"));
}
public CollectionString supportedOptions() {
return Collections.emptySet();
}
}
AnnotationProcessorFactory接口有三个方法：getProcessorFor是根据注解的类型来返回特定的注解处理器；supportedAnnotationTypes是返回该工厂生成的注解处理器所能支持的注解类型；supportedOptions用来表示所支持的附加选项。在运行apt命令行工具的时候，可以通过-A来传递额外的参数给注解处理器，如-Averbose=true。当工厂通过 supportedOptions方法声明了所能识别的附加选项之后，注解处理器就可以在运行时刻通过AnnotationProcessorEnvironment的getOptions方法获取到选项的实际值。注解处理器本身的基本实现如下所示。
public class AssignmentAp implements AnnotationProcessor {
private AnnotationProcessorEnvironment env;
private AnnotationTypeDeclaration assignmentDeclaration;
public AssignmentAp(AnnotationProcessorEnvironment env) {
this.env = env;
assignmentDeclaration = (AnnotationTypeDeclaration) env.getTypeDeclaration("annotation.Assignment");
}
public void process() {
CollectionDeclaration declarations = env.getDeclarationsAnnotatedWith(assignmentDeclaration);
for (Declaration declaration : declarations) {
processAssignmentAnnotations(declaration);
}
}
private void processAssignmentAnnotations(Declaration declaration) {
CollectionAnnotationMirror annotations = declaration.getAnnotationMirrors();
for (AnnotationMirror mirror : annotations) {
if (mirror.getAnnotationType().getDeclaration().equals(assignmentDeclaration)) {
MapAnnotationTypeElementDeclaration, AnnotationValue values = mirror.getElementValues();
String assignee = (String) getAnnotationValue(values, "assignee"); //获取注解的值
}
}
}
}
注解处理器的处理逻辑都在process方法中完成。通过一个声明（Declaration）的getAnnotationMirrors方法就可以获取到该声明上所添加的注解的实际值。得到这些值之后，处理起来就不难了。
在创建好注解处理器之后，就可以通过apt命令行工具来对源代码中的注解进行处理。 命令的运行格式是apt -classpath bin -factory annotation.apt.AssignmentApf src/annotation/work/*.java，即通过-factory来指定注解处理器工厂类的名称。实际上，apt工具在完成处理之后，会自动调用javac来编译处理完成后的源代码。
JDK 5中的apt工具的不足之处在于它是Oracle提供的私有实现。在JDK 6中，通过JSR 269把自定义注解处理器这一功能进行了规范化，有了新的javax.annotation.processing这个新的API。对Mirror API也进行了更新，形成了新的javax.lang.model包。注解处理器的使用也进行了简化，不需要再单独运行apt这样的命令行工具，Java编译器本身就可以完成对注解的处理。对于同样的功能，如果用JSR 269的做法，只需要一个类就可以了。
@SupportedSourceVersion(SourceVersion.RELEASE_6)
@SupportedAnnotationTypes("annotation.Assignment")
public class AssignmentProcess extends AbstractProcessor {
private TypeElement assignmentElement;
public synchronized void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
Elements elementUtils = processingEnv.getElementUtils();
assignmentElement = elementUtils.getTypeElement("annotation.Assignment");
}
public boolean process(Set? extends TypeElement annotations, RoundEnvironment roundEnv) {
Set? extends Element elements = roundEnv.getElementsAnnotatedWith(assignmentElement);
for (Element element : elements) {
processAssignment(element);
}
}
private void processAssignment(Element element) {
List? extends AnnotationMirror annotations = element.getAnnotationMirrors();
for (AnnotationMirror mirror : annotations) {
if (mirror.getAnnotationType().asElement().equals(assignmentElement)) {
Map? extends ExecutableElement, ? extends AnnotationValue values = mirror.getElementValues();
String assignee = (String) getAnnotationValue(values, "assignee"); //获取注解的值
}
}
}
}
仔细比较上面两段代码，可以发现它们的基本结构是类似的。不同之处在于JDK 6中通过元注解@SupportedAnnotationTypes来声明所支持的注解类型。另外描述程序静态结构的javax.lang.model包使用了不同的类型名称。使用的时候也更加简单，只需要通过javac -processor annotation.pap.AssignmentProcess Demo1.java这样的方式即可。
上面介绍的这两种做法都是在编译时刻进行处理的。而有些时候则需要在运行时刻来完成对注解的处理。这个时候就需要用到Java的反射API。反射API提供了在运行时刻读取注解信息的支持。不过前提是注解的保留策略声明的是运行时。Java反射API的AnnotatedElement接口提供了获取类、方法和域上的注解的实用方法。比如获取到一个Class类对象之后，通过getAnnotation方法就可以获取到该类上添加的指定注解类型的注解。
实例分析
下面通过一个具体的实例来分析说明在实践中如何来使用和处理注解。假定有一个公司的雇员信息系统，从访问控制的角度出发，对雇员的工资的更新只能由具有特定角色的用户才能完成。考虑到访问控制需求的普遍性，可以定义一个注解来让开发人员方便的在代码中声明访问控制权限。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequiredRoles {
String[] value();
}
下一步则是如何对注解进行处理，这里使用的Java的反射API并结合动态代理。下面是动态代理中的InvocationHandler接口的实现。
public class AccessInvocationHandlerT implements InvocationHandler {
final T accessObj;
public AccessInvocationHandler(T accessObj) {
this.accessObj = accessObj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
RequiredRoles annotation = method.getAnnotation(RequiredRoles.class); //通过反射API获取注解
if (annotation != null) {
String[] roles = annotation.value();
String role = AccessControl.getCurrentRole();
if (!Arrays.asList(roles).contains(role)) {
throw new AccessControlException("The user is not allowed to invoke this method.");
}
}
return method.invoke(accessObj, args);
}
}
在具体使用的时候，首先要通过Proxy.newProxyInstance方法创建一个EmployeeGateway的接口的代理类，使用该代理类来完成实际的操作。
java里的注解都有哪些
@Target，表示该注解用于什么地方，可能的值在枚举类 ElemenetType 中
@Retention，表示在什么级别保存该注解信息。可选的参数值在枚举类型 RetentionPolicy 中
@Documented，将此注解包含在 javadoc 中 ，它代表着此注解会被javadoc工具提取成文档。在doc文档中的内容会因为此注解的信息内容不同而不同。相当与@see,@param 等。
@Inherited ，允许子类继承父类中的注解，例子中补充。
java开发中常用的注解有哪些
Java 注解全面解析，学习java做一个java工程师不但待遇高，而且前途无可限量。为什么这样说呢？因为java程序语言作为最流行的计算机开发语言之一，几乎所有的系统、软件、app、网页等都是需要用到java的。
1.基本语法
注解定义看起来很像接口的定义。事实上，与其他任何接口一样，注解也将会编译成class文件。
@Target(ElementType.Method)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {}
除了@符号以外，@Test的定义很像一个空的接口。定义注解时，需要一些元注解（meta－annotation），如@Target和@Retention
@Target用来定义注解将应用于什么地方（如一个方法或者一个域）
@Retention用来定义注解在哪一个级别可用，在源代码中（source），类文件中（class）或者运行时（runtime）
在注解中，一般都会包含一些元素以表示某些值。当分析处理注解时，程序可以利用这些值。没有元素的注解称为标记注解（marker annotation）
四种元注解，元注解专职负责注解其他的注解，所以这四种注解的Target值都是ElementType.ANNOTATION_TYPE
注解 说明
@Target 表示该注解可以用在什么地方，由ElementType枚举定义
CONSTRUCTOR：构造器的声明
FIELD：域声明（包括enum实例）
LOCAL_VARIABLE：局部变量声明
METHOD：方法声明
PACKAGE：包声明
PARAMETER：参数声明
TYPE：类、接口（包括注解类型）或enum声明
ANNOTATION_TYPE：注解声明（应用于另一个注解上）
TYPE_PARAMETER：类型参数声明（1.8新加入）
TYPE_USE：类型使用声明（1.8新加入）
PS：当注解未指定Target值时，此注解可以使用任何元素之上，就是上面的类型
@Retention 表示需要在什么级别保存该注解信息，由RetentionPolicy枚举定义
SOURCE：注解将被编译器丢弃（该类型的注解信息只会保留在源码里，源码经过编译后，注解信息会被丢弃，不会保留在编译好的class文件里）
CLASS：注解在class文件中可用，但会被VM丢弃（该类型的注解信息会保留在源码里和class文件里，在执行的时候，不会加载到虚拟机（JVM）中）
RUNTIME：VM将在运行期也保留注解信息，因此可以通过反射机制读取注解的信息（源码、class文件和执行的时候都有注解的信息）
PS：当注解未定义Retention值时，默认值是CLASS
@Documented 表示注解会被包含在javaapi文档中
@Inherited 允许子类继承父类的注解
2. 注解元素
– 注解元素可用的类型如下：
– 所有基本类型（int,float,boolean,byte,double,char,long,short）
– String
– Class
– enum
– Annotation
– 以上类型的数组
如果使用了其他类型，那编译器就会报错。也不允许使用任何包装类型。注解也可以作为元素的类型，也就是注解可以嵌套。
元素的修饰符，只能用public或default。
– 默认值限制
编译器对元素的默认值有些过分挑剔。首先，元素不能有不确定的值。也就是说，元素必须要么具有默认值，要么在使用注解时提供元素的值。
其次，对于非基本类型的元素，无论是在源代码中声明，还是在注解接口中定义默认值，都不能以null作为值。这就是限制，这就造成处理器很难表现一个元素的存在或缺失状态，因为每个注解的声明中，所有的元素都存在，并且都具有相应的值。为了绕开这个限制，只能定义一些特殊的值，例如空字符串或负数，表示某个元素不存在。
@Target(ElementType.Method)
@Retention(RetentionPolicy.RUNTIME)
public @interface MockNull {
public int id() default -1;
public String description() default “”;
}
3. 快捷方式
何为快捷方式呢？先来看下springMVC中的Controller注解
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
String value() default “”;
}
可以看见Target应用于类、接口、注解和枚举上，Retention策略为RUNTIME运行时期，有一个String类型的value元素。平常使用的时候基本都是这样的：
@Controller(“/your/path”)
public class MockController { }
这就是快捷方式，省略了名－值对的这种语法。下面给出详细解释：
注解中定义了名为value的元素，并且在应用该注解的时候，如果该元素是唯一需要赋值的一个元素，那么此时无需使用名－值对的这种语法，而只需在括号内给出value元素所需的值即可。这可以应用于任何合法类型的元素，当然了，这限制了元素名必须为value。
4. JDK1.8注解增强
TYPE_PARAMETER和TYPE_USE
在JDK1.8中ElementType多了两个枚举成员，TYPE_PARAMETER和TYPE_USE，他们都是用来限定哪个类型可以进行注解。举例来说，如果想要对泛型的类型参数进行注解：
public class AnnotationTypeParameter@TestTypeParam T {}
那么，在定义@TestTypeParam时，必须在@Target设置ElementType.TYPE_PARAMETER，表示这个注解可以用来标注类型参数。例如：
@Target(ElementType.TYPE_PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestTypeParam {}
ElementType.TYPE_USE用于标注各种类型，因此上面的例子也可以将TYPE_PARAMETER改为TYPE_USE，一个注解被设置为TYPE_USE，只要是类型名称，都可以进行注解。例如有如下注解定义：
@Target(ElementType.TYPE_USE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {}
那么以下的使用注解都是可以的:
List@Test Comparable list1 = new ArrayList();
List? extends Comparable list2 = new ArrayList@Test Comparable();
@Test String text;
text = (@Test String)new Object();
java.util. @Test Scanner console;
console = new java.util.@Test Scanner(System.in);
PS：以上@Test注解都是在类型的右边，要注意区分1.8之前的枚举成员，例如：
@Test java.lang.String text;
在上面这个例子中，显然是在进行text变量标注，所以还使用当前的@Target会编译错误，应该加上ElementType.LOCAL_VARIABLE。
@Repeatable注解
@Repeatable注解是JDK1.8新加入的，从名字意思就可以大概猜出他的意思（可重复的）。可以在同一个位置重复相同的注解。举例：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Filter {
String [] value();
}
如下进行注解使用:
@Filter({“/admin”,”/main”})
public class MainFilter { }
换一种风格:
@Filter(“/admin”)
@Filter(“/main”)
public class MainFilter {}
在JDK1.8还没出现之前，没有办法到达这种“风格”，使用1.8，可以如下定义@Filter：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Filters.class)
public @interface Filter {
String value();
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Filters {
Filter [] value();
}
实际上这是编译器的优化，使用@Repeatable时告诉编译器，使用@Filters来作为收集重复注解的容器，而每个@Filter存储各自指定的字符串值。
JDK1.8在AnnotatedElement接口新增了getDeclaredAnnotationsByType和getAnnotationsByType，在指定@Repeatable的注解时，会寻找重复注解的容器中。相对于，getDeclaredAnnotation和getAnnotation就不会处理@Repeatable注解。举例如下：
@Filter(“/admin”)
@Filter(“/filter”)
public class FilterClass {
public static void main(String[] args) {
ClassFilterClass filterClassClass = FilterClass.class;
Filter[] annotationsByType = filterClassClass.getAnnotationsByType(Filter.class);
if (annotationsByType != null) {
for (Filter filter : annotationsByType) {
System.out.println(filter.value());
}
}
System.out.println(filterClassClass.getAnnotation(Filter.class));
}
}
日志如下:
/admin
/filter
null
望采纳！