java 注解

注解是什么？

注解是元数据的一种模式，，为程序提供了一些数据，然而并不是程序的一部分。注解对代码并不间接地提供操作。

作用：

• 告知编译器一些信息，例如查看重写（@Override）、克制正告（@SuppressWarnings）
• 编译器以及部署期 的解决：软件工具能够解决注解去生成代码，xml 文件
• 运行时解决：一些注解能够在运行时被查看到

根底

注解的格局

@Entity

@Author(name = "Benjamin Franklin", date = "3/27/2003")

哪里能够被应用：

能够被用在 类、办法、字段、或者参数

public enum ElementType {
/* Class, interface (including annotation type), or enum declaration /
TYPE,
/* Field declaration (includes enum constants) /
FIELD,
/* Method declaration /
METHOD,
/* Formal parameter declaration /
PARAMETER,
/* Constructor declaration /
CONSTRUCTOR,
/* Local variable declaration /
LOCAL_VARIABLE,
/* Annotation type declaration /
ANNOTATION_TYPE,
/* Package declaration /
PACKAGE,
/*Type parameter declaration/
TYPE_PARAMETER,
/* Use of a type/
TYPE_USE
}

在 java8 中，注解也能够用到 type 上

Class instance creation expression:
new @Interned MyObject();
Type cast:
myString = (@NonNull String) str;
implements clause:
class UnmodifiableList<T> implements
@Readonly List<@Readonly T> {…}
Thrown exception declaration:
void monitorTemperature() throws
@Critical TemperatureException {…}

申明一个注解类型

用于代替正文

public class Generation3List extends Generation2List {
​
// Author: John Doe
// Date: 3/17/2002
// Current revision: 6
// Last modified: 4/12/2004
// By: Jane Doe
// Reviewers: Alice, Bill, Cindy
​
// class code goes here
​
}

‎要增加此雷同的元数据与正文‎，首先须要去定义一个注解类型。语法如下：

注：注解里只容许根本类型，加上枚举，注解，String。

public @interface ClassPreamble {
String author();
String date();
int currentRevision() default 1;
String lastModified() default “N/A”;
String lastModifiedBy() default “N/A”;
// 应用数组
String[] reviewers();
}

注解的定义有点像 interface，其实注解也是 interface 的一种模式。

注解的元素申明有点像接口的办法，注解的元素能够设置默认值。如果要使其呈现在 javadoc 中，须要加上 @Document 注解

预约义注解类型

有些注解在 java se api 中曾经被定义好了。一些注解类型是被 java 编译器所应用，有一些注解被用于其余注解上。

java 语言中被应用

@Deprecated

@Override

@SuppressWarnings

@SafeVarargs

@FunctionalInterface

利用于其余注解

使用于其余注解的注解叫 元注解 。在.java.lang.annotation 中被定义了一些元注解。

@Retention 注解用于指定注解被存储的期间

RetentionPolicy.SOURCE 这个意味着注解仅仅在源码中被保留，将会被编译器所疏忽

RetentionPolicy.CLASS 这个意味着注解会被保留到编译期，然而会被 jvm 所疏忽

RetentionPolicy.RUNTIME 这个意味着注解将会被保留到 jvm 中，也就是说能够在运行时中应用。

@Documented 在生成 javadoc 文档的时候，会显示这个注解的内容

@Target 示意这个注解作用的中央

• ElementType.ANNOTATION_TYPE 能够被使用到注解类型
• ElementType.CONSTRUCTOR 能够使用到构造方法上.
• ElementType.FIELD 能够使用到字段或属性上
• ElementType.LOCAL_VARIABLE 能够被用到局部变量上.
• ElementType.METHOD 能够使用到办法上.
• ElementType.PACKAGE 能够在包门路上 .
• ElementType.PARAMETER 能够使用到办法参数上.
• ElementType.TYPE 能够被用到类 .

@Inherited 示意这个注解类能够从他的父类被继承，仅仅能够被用于类的申明。

@Repeatable 在 java8 中被引入，这个标记的注解能够被屡次申明

Type Annotation and pluggable type system

类型注解（type annotation）被创立进去是为了反对改良对 java 程序的剖析，是一种保障强类型查看的形式。在 java8 版本中没有提供一种查看的框架，然而 java 8 容许咱们去写一个类型查看的框架，这个框架实现一个或多个模块，这些模块作为 java 编译器的插件。

例如：你想要去保障程序中特定的参数永远不为 null，你想要去防止登程空指针异样，能够去自定义一个插件去查看。你只须要去批改你的代码，把特定的变量加上标记能用 null 赋值的注解。就像这样

@Notnull String str;

当你去编译这个代码的时候，当这个编译器探测到一些潜在的问题的时候，会打印出正告。容许你去批改代码避免出现谬误。当代码修改后，这个谬误将不会呈现在这个程序中。

反复注解（repeating annotation）

很多时候，咱们想在一个申明或类型上屡次应用一个注解。在 java8 中，反复注解提供了咱们须要的这种性能。

为了兼容，反复注解是存储在注解容器（container annotation）中的，这个容器是由编译器主动生成的。为了编译器去实现这个，在代码中须要去实现两步申明。

第一步：定义一个反复注解类

这个反复注解类肯定要备 Repeatable 元注解去标记。上面是定义一个@Schedule 反复注解：

@Repeatable(Schedules.class)  // 容器类型
public @interface Schedule {
String dayOfMonth() default “first”;
String dayOfWeek() default “Mon”;
int hour() default 12;
}

这个元注解的值（圆括号中的值），就是 java 编译器生成的注解容器（container annotation 存储注解 的类。（就是说，这个值，就是容器的类型，这个容器是用来寄存的是注解）。在这个例子中，这个注解容器（container annotation）的类型就是 Schedules，因而，反复注解 @Schedule 被存储在@Schedules 注解中。

第二步：申明一个容器注解类型

这个容器注解类型肯定要蕴含一个 value 元素，他的类型是数组类型的。这个组件类型肯定是反复注解的类型，申明 Schedules 这个容器注解类型如下：

public @interface Schedules {
Schedule[] value(); // 一个 Schedule 的数组
}

获取注解（Retrieving Annotation）

在反射 api 中有好几种获取注解的办法。有些办法能够获取一个注解。例如

[AnnotatedElement.getAnnotation(Class)] 如果圆括号中仅仅有一个注解（值），那就一成不变地返回一个注解（值），如果圆括号中有多个注解，也能够通过去获取注解容器去获取。以这种形式，代码能够持续运行。另一个就是，java 8 中新添的，能够一次性返回多个注解，例如AnnotatedElement.getAnnotations(Class<T>)。

参考资料：java lesson

1. What is wrong with the following interface?

   public interface House {
       @Deprecated
       void open();
       void openFrontDoor();
       void openBackDoor();}

2. Consider this implementation of the House interface, shown in Question 1.

   public class MyHouse implements House {public void open() {}
       public void openFrontDoor() {}
       public void openBackDoor() {}
   }