Java提供了5个基本的Annotation的用法，在使用Annotation时要在其前面增加@符号。
@Override
限定重写父类方法，它可以强制一个子类必须覆盖父类的方法。写在子类的方法上，在编译期，编译器检查这个方法，检查父类必须包含该方法，否则编译出错。该注解只能修饰方法，在编译期被读取。
/**
* Indicates that a method declaration is intended to override a
* method declaration in a supertype. If a method is annotated with
* this annotation type compilers are required to generate an error
* message unless at least one of the following conditions hold:
*
* <ul><li>
* The method does override or implement a method declared in a
* supertype.
* </li><li>
* The method has a signature that is override-equivalent to that of
* any public method declared in {@linkplain Object}.
* </li></ul>
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
@Deprecated
用于表示某个程序元素（类、方法等）已过时。编译时读取，编译器编译到过时元素会给出警告。
/**
* A program element annotated @Deprecated is one that programmers
* are discouraged from using, typically because it is dangerous,
* or because a better alternative exists. Compilers warn when a
* deprecated program element is used or overridden in non-deprecated code.
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
@SuppressWarnings
抑制编译警告，被该注解修饰的程序元素（以及该程序元素中的所有子元素）取消显示指定的编译警告。
比如：如果程序使用没有泛型限制的集合会引起编译器警告，为了避免这种警告课可以使用该注解。
-
unchecked异常：运行时异常。是RuntimeException的子类，不需要在代码中显式地捕获unchecked异常做处理。
/**
- Indicates that the named compiler warnings should be suppressed in the
- annotated element (and in all program elements contained in the annotated
- element). Note that the set of warnings suppressed in a given element is
- a superset of the warnings suppressed in all containing elements. For
- example, if you annotate a class to suppress one warning and annotate a
- method to suppress another, both warnings will be suppressed in the method.
-
As a matter of style, programmers should always use this annotation
- on the most deeply nested element where it is effective. If you want to
- suppress a warning in a particular method, you should annotate that
- method rather than its class.
/
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
/*
- The set of warnings that are to be suppressed by the compiler in the
- annotated element. Duplicate names are permitted. The second and
- successive occurrences of a name are ignored. The presence of
- unrecognized warning names is not an error: Compilers must
- ignore any warning names they do not recognize. They are, however,
- free to emit a warning if an annotation contains an unrecognized
- warning name.
-
The string {@code "unchecked"} is used to suppress
- unchecked warnings. Compiler vendors should document the
- additional warning names they support in conjunction with this
- annotation type. They are encouraged to cooperate to ensure
- that the same names work across multiple compilers.
- @return the set of warnings to be suppressed */ String[] value(); }
@SafeVarargs (java7新增）
去除“堆污染”警告
堆污染：把一个不带泛型的对象赋给一个带泛型的变量时就会发生堆污染。 例如：下面代码引起堆污染，会给出警告
List l2 = new ArrayList<Number>();
List<String> ls = l2;
三种方式去掉上面方法产生的警告
1.使用注解@SafeVarargs修饰引发该警告的方法或构造器。
2.使用@SuppressWarnings("unchecked") 修饰。
3.使用编译器参数命令：-Xlint:varargs
/**
* A programmer assertion that the body of the annotated method or
* constructor does not perform potentially unsafe operations on its
* varargs parameter. Applying this annotation to a method or
* constructor suppresses unchecked warnings about a
* <i>non-reifiable</i> variable arity (vararg) type and suppresses
* unchecked warnings about parameterized array creation at call
* sites.
*
* <p> In addition to the usage restrictions imposed by its {@link
* Target @Target} meta-annotation, compilers are required to implement
* additional usage restrictions on this annotation type; it is a
* compile-time error if a method or constructor declaration is
* annotated with a {@code @SafeVarargs} annotation, and either:
* <ul>
* <li> the declaration is a fixed arity method or constructor
*
* <li> the declaration is a variable arity method that is neither
* {@code static} nor {@code final}.
*
* </ul>
*
* <p> Compilers are encouraged to issue warnings when this annotation
* type is applied to a method or constructor declaration where:
*
* <ul>
*
* <li> The variable arity parameter has a reifiable element type,
* which includes primitive types, {@code Object}, and {@code String}.
* (The unchecked warnings this annotation type suppresses already do
* not occur for a reifiable element type.)
*
* <li> The body of the method or constructor declaration performs
* potentially unsafe operations, such as an assignment to an element
* of the variable arity parameter's array that generates an unchecked
* warning. Some unsafe operations do not trigger an unchecked
* warning. For example, the aliasing in
*
* <blockquote><pre>
* @SafeVarargs // Not actually safe!
* static void m(List<String>... stringLists) {
* Object[] array = stringLists;
* List<Integer> tmpList = Arrays.asList(42);
* array[0] = tmpList; // Semantically invalid, but compiles without warnings
* String s = stringLists[0].get(0); // Oh no, ClassCastException at runtime!
* }
* </pre></blockquote>
*
* leads to a {@code ClassCastException} at runtime.
*
* <p>Future versions of the platform may mandate compiler errors for
* such unsafe operations.
*
* </ul>
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})
public @interface SafeVarargs {}
@Functionlnterface （java8新增）
修饰函数式接口 使用该注解修饰的接口必须是函数式接口，不然编译会出错。那么什么是函数式接口？答：如果接口中只有一个抽象方法（可以包含多个default方法或static方法），就是函数式接口。
/**
* An informative annotation type used to indicate that an interface
* type declaration is intended to be a <i>functional interface</i> as
* defined by the Java Language Specification.
*
* Conceptually, a functional interface has exactly one abstract
* method. Since {@linkplain java.lang.reflect.Method#isDefault()
* default methods} have an implementation, they are not abstract. If
* an interface declares an abstract method overriding one of the
* public methods of {@code java.lang.Object}, that also does
* <em>not</em> count toward the interface's abstract method count
* since any implementation of the interface will have an
* implementation from {@code java.lang.Object} or elsewhere.
*
* <p>Note that instances of functional interfaces can be created with
* lambda expressions, method references, or constructor references.
*
* <p>If a type is annotated with this annotation type, compilers are
* required to generate an error message unless:
*
* <ul>
* <li> The type is an interface type and not an annotation type, enum, or class.
* <li> The annotated type satisfies the requirements of a functional interface.
* </ul>
*
* <p>However, the compiler will treat any interface meeting the
* definition of a functional interface as a functional interface
* regardless of whether or not a {@code FunctionalInterface}
* annotation is present on the interface declaration.
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}
