1，预定义注解

1.@Override : 注释能实现编译时检查，你可以为你的方法添加该注释，以声明该方法是用于覆盖父类中的方法。如果 该方法不是覆盖父类的方法，将会在编译时报错。例如我们为某类重写 toString() 方法却写成了 tostring() ，并且我们为该方法添加了@Override 注释，那么编译是无法通过的。

2.@Deprecated ：的作用是对不应该在使用的方法添加注释，当编程人员使用这些方法时，将会在编译时显示提示信息， 它与 javadoc 里的 @deprecated 标记有相同的功能。

3.@SuppressWarnings：压制警告

4.deprecation：使用了过时的类或方法时的警告

5.unchecked: 执行了未检查的转换时的警告，例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型

6.fallthrough ：当 Switch 程序块直接通往下一种情况而没有 Break 时的警告

7.serial ：当在可序列化的类上缺少 serialVersionUID 定义时的警告

8.finally：任何 finally 子句不能正常完成时的警告

9.all：忽略以上所有情况的警告

2，元注解

@Target （指定注解生效的位置）  

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
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

@Retention （指定注解生效的范围）

public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

@Documented （注解在文档中生效）

如果你要使用@Documented 元注释，你就得为该注释设置 RetentionPolicy.RUNTIME 保持性策略。  

@Inherited （注解是否被继承）

 

3，读取注释信息

当我们想读取某个注释信息时，我们是在运行时通过反射来实现的，所以我们需要将保持性策略设置为 RUNTIME ，也就是说只有注释标记了@Retention(RetentionPolicy.RUNTIME) 的，我们才能通过反射来获得相关信息

4，注释解析

Calc

package com.luoyi;

public class Calc {
    @Check
    public void add(){
        System.out.println(1+1);
    }
    @Check
    public void sub(){
        System.out.println(1-1);
    }
    @Check
    public void mul(){
        System.out.println(1*0);
    }
    @Check
    public void div(){
        System.out.println(1/0);
    }
    public void show(){
        System.out.println("ok");
    }
}

 Check

package com.luoyi;

import java.lang.annotation.*;


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Check {}

 解释程序

import com.luoyi.Calc;
import com.luoyi.Check;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.annotation.Target;
import java.lang.reflect.*;

public class Test {
        public static void main(String[] args) throws IOException {

            Calc calc = new Calc();
            Class cls = calc.getClass();

            Method[] methods = cls.getMethods();
            int num = 0 ;
            BufferedWriter buffer = new BufferedWriter(new FileWriter("bug.txt"));
            for(Method method:methods){
                System.out.println(method.getName());
                if(method.isAnnotationPresent(Check.class)){

                    try {
                        method.invoke(calc);
                    } catch (Exception e) {

                        num++;
                        buffer.write(method.getName() + "出现异常");
                        buffer.newLine();
                        buffer.write(e.getClass().getSimpleName());
                        buffer.newLine();
                        buffer.write(e.getMessage());
                        buffer.newLine();
                        buffer.write("-----------------");
                    }

                }

                buffer.write("本次出现" + num + "异常");
            }
            buffer.flush();
            buffer.close();
        }
    }