Java注解

注解

1.概念

注解：说明程序的，给计算机看的

注释：用文字描述程序。给程序员看的

2.定义

注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。

概念描述

• JDK1.5之后的新特性
• 说明程序的
• 使用注解：@注解名称

作用分类

​ ①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
​ ②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
​ ③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

JDK中预定义的一些注解

• @Override ：检测被该注解标注的方法是否是继承自父类(接口)的

@Override
public String toString(){
    return super.toString();
}

• @Deprecated：该注解标注的内容，表示已过时

  @Deprecated
  public void show(){
      // 有缺陷
  }
  
  public void show02(){
      // 替代show方法
  }
  

• @SuppressWarnings：压制警告

  • 一般传递参数all @SuppressWarnings("all")

3.自定义注解

1.格式

元注解
public @interface 注解名称{
属性列表;
}

本质：注解本质上就是一个接口，该接口默认继承Annotation接口

public interface MyAnno extends java.lang.annotation.Annotation {}

2.属性

属性：接口中的抽象方法

要求

1. 属性的返回值类型有下列取值
   • 基本数据类型
     • String
     • 枚举
     • 注解
     • 以上类型的数组
2. 定义了属性，在使用时需要给属性赋值
   1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
   2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
   3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略

3.元注解

用于描述注解的注解

• @Target：描述注解能够作用的位置
  • ElementType取值：
    • TYPE：可以作用于类上
    • METHOD：可以作用于方法上
    • FIELD：可以作用于成员变量上
• @Retention：描述注解被保留的阶段
  • @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
    • @Documented：描述注解是否被抽取到api文档中
    • @Inherited：描述注解是否被子类继承

4.解析注解

在程序中（解析）注解

获取注解中定义的属性值

1. 获取注解定义的位置的对象 （Class，Method,Field）

2. 获取指定的注解

   getAnnotation(Class)
   //其实就是在内存中生成了一个该注解接口的子类实现对象

   示例代码

   注解

   /**
    * 定义一个注解
    * 描述需要执行的类名，和方法名
    */
   // 直接可以做用于类上
   @Target({ElementType.TYPE})
   // 能够保留在RUNTIME阶段
   @Retention(RetentionPolicy.RUNTIME)
   public @interface Pro {
       String className();
       String methodName();
   
   }
   

   被调用的类和方法

   public class Demo01 {
       public void show(){
           System.out.println("demo01...show...");
       }
   }
   

   框架类

   /**
    * 框架类
    */
   @Pro(className = "jiexizhujie.Demo01",methodName = "show")
   public class ReflectTest {
       public static void main(String[] args) throws Exception {
           /*
               前提：不能改变该类的任何代码，可以创建任意类对象，可以执行任意方法
            */
           // 1.解析注解
           // 1.1获取该类的字节码文件对象
           Class<ReflectTest> reflectTestClass = ReflectTest.class;
           // 2.获取上边的注解对象
           // 其实就是内存中生成了一个该类注解接口的子类实现对象
            /*
           相当于
        public class ProImpl implements Pro{
        public String className();{
           return "jiexizhujie.Demo01";
           }
           public String methodName(){
           return "show";
           }
        }
        */
           Pro an = reflectTestClass.getAnnotation(Pro.class);
           // 3.调用注解对象中定义的抽象方法，获取返回值
           String className = an.className();
           String methodName = an.methodName();
           System.out.println(className);
           System.out.println(methodName);
           // 4.加载该类进内存
           Class cls = Class.forName(className);
           // 5.创建对象
           Object obj = cls.newInstance();
           // 6.获取对象方法
           Method method = cls.getMethod(methodName);
           // 7.执行方法
           method.invoke(obj);
   
       }
   }
   
   
   

案例

简单的测试框架

示例代码

测试的类

public class Calculator {
    // 加法
    @Check
    public void add(){
        String str = null;
        str.toString();
        System.out.println("1+0 = " + (1+0));
    }
    // 减法
    @Check
    public void sub(){
        System.out.println("1-0 = " + (1-0));
    }
    // 成法
    @Check
    public void mul(){
        System.out.println("1*0 = " + (1*0));
    }
    // 除法
    @Check
    public void div(){
        System.out.println("1/0 = " + (1/0));
    }

    public void show(){
        System.out.println("永无bug....");
    }
}

注解

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

测试框架

/**
 * 简单的框架测试
 *
 * 当方法执行后，会自动自行检测所有的方法（加了check注解的方法），判断方法是否有异常，记录到文件中
 */
public class TestCheck {

    public static void main(String[] args) throws IOException {
        // 1.先创建计算器对象
        Calculator c = new Calculator();
        // 2.获取字节码文件对象
        Class  cls = c.getClass();
        // 3.获取所有方法
        Method[] methods = cls.getMethods();

        //记录出现异常的次数,存到文件中
        int number = 0;
        BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));

        for (Method method : methods) {
            // 4.判断是否有Check注解
            if (method.isAnnotationPresent(Check.class)){
                // 5.有执行
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    // 6.捕获异常
                    // 记录到文件中
                    number++;

                    bw.write(method.getName()+"方法异常了");
                    bw.newLine();
                    bw.write("异常的名称："+e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因："+e.getCause().getMessage());
                    bw.newLine();
                    bw.write("----------------------");
                    bw.newLine();
                }
            }
        }
        bw.write("本次测试一共出现了："+number+"次异常");

        bw.flush();
        bw.close();
    }

}

运行结果

// 生成bug.txt
add方法异常了
异常的名称：NullPointerException
异常的原因：null
----------------------
div方法异常了
异常的名称：ArithmeticException
异常的原因：/ by zero
----------------------
本次测试一共出现了：2次异常

小结

1. 以后大多数时候，我们会使用注解，而不是自定义注解

2. 注解给谁用？

   1. 编译器
   2. 给解析程序用

3. 注解不是程序的一部分，可以理解为注解就是一个标签