Java 之 注解一、注解介绍二、JDK 中预定义注解三、自定义注解四、在程序使用（解析）注解五、案例

一、注解介绍

　　注解概念：注解是说明程序的，给计算机看的。

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

　　注解定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是 JDK1.5 及以后版本引入的一个特效，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等前面，用来对这些元素进行说明，注释。

　　概念描述：

• • 　JDk 1.5之后的新特性
    
  •     说明程序的
  •     使用注解：@注解名称

　　注解作用分类：

• • 　编写文档：通过代码里标识的注解生成文档【生成文档 doc 文档】
    

　　　　　　Demo：编写一个类，然后通过 javadoc 文件名.java 来生成 doc文档

/**
 * 注解javadoc演示
 *
 * @author ks
 * @version 1.0
 * @since 1.5

*/
public class AnnoDemo1 {


/**

* 计算两数的和

* @param a 整数

* @param b 整数

* @return 两数的和

*/

public int add(int a, int b ){

return a + b;

}
}

 

• •     代码分析：通过代码里标识的注解对代码进行分析【使用反射】
  •     编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

二、JDK 中预定义注解

　　JDk 中预定义的一些注解：

• • 　@Override：检测被该注解标注的方法是否是继承自父类（接口）的
    
  • 　@Deprecated：该注解标注的内容，表示已过时
  •     @SuppressWarnings：压制警告，一般传递参数 all,压制所有的警告（@SuppressWarnings("all")）

　　　Demo :

/**
 *
内置注解

*/
@SuppressWarnings("all")
// 表示压制所有的警告，可以作用与类与方法
public class AnnoDemo {


@Override
// 表示方法重写

public String toString() {

return super.toString();

}


@Deprecated
// 表示方法已经过时了，但是不能删除，为了向下兼容

public void show1() {

// 有缺陷

}


public void show2() {

// 替代 show1方法

}


public void demo() {

show1();

}
}

 

三、自定义注解

　　1、自定义注解格式

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

　　　　首先创建一个 MyAnno 类，然后在 cmd 窗口通过 javac 文件名.java 编译文件，接着再使用 javap 文件名.class 进行反编译。

public @interface MyAnno {}

　　　　通过反编译，我们得到一个信息：

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

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

　　2、属性

　　　　注解既然是一个接口，那么就可以在接口中声明方法。

　　　　属性：接口中的抽象方法。

　　　　属性的返回值类型有下列取值：

　　　　　　① 基本数据类型

　　　　　　② String 类型

　　　　　　③ 枚举 Enum 类型

　　　　　　④ 注解类型

　　　　　　⑤ 以上类型的数组

　　　　属性的赋值：

　　　　　　在注解中定义了属性，在使用时需要给属性赋值：

　　　　　　① 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。

　　　　　　② 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。

　　　　　　③ 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略

　　3、元注解

　　　　元注解：用于描述注解的注解

　　　　常用的元注解：

　　　　（1） @Target：描述注解能够作用的位置

　　　　　　　　Target 里面是一个 ElementType[] value() 枚举数组，有如下取值：

• • • • •  TYPE：可以作用于类上
        •  METHOD：可以作用于方法上
        •  FIELD：可以作用于成员变量上 　
          

　　　　（2） @Retention：描述注解被保留的阶段

　　　　　　　　 Retention 里面是 RetentionPolicy value()，取值有：

• • • • •  RetentionPolicy.SOURCE：当前被描述的注解，不会存在 class 字节码文件中（不常用）
        •  RetentionPolicy.CLASS：当前被描述的注解，会保留到class字节码文件中，但是不会被JVM读取。（不常用）
        •  RetentionPolicy.RUNTIME：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到（自定义常用）

 

　　　　（3） @Documented：描述注解是否被抽取到api文档中

　　　　　　　　如果在被描述的注解A上添加了该元注解，那么当一个类B使用注解A时，注解A会被抽取到 api 文档中。

　　　　（4） @Inherited：描述注解是否被子类继承

　　　　　　　　如果在被描述的注解A上添加了该元注解，那么当一个类B使用注解A时，这个类B的子类C也会使用注解A。

四、在程序使用（解析）注解

　　　　需求：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法

　　　　创建一个类：

public class Demo1 {

public void show() {

System.out.println("hello world");

}
}

　　　　  自定义一个注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 描述需要执行的类名和方法名

*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {


String className();

String methodName();
}

 

　　　　测试类：

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

@Pro(className = "cn.ks.annotation.Demo1",methodName = "show")
//给类添加注解，并给属性赋值
public class ReflectTest {

public static void main(String[] args) throws Exception {

/*

前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法

*/


//1、解析注解

//1.1 获取该类的字节码文件

Class<ReflectTest2> re = ReflectTest2.class;

//2 获取上面注解对象

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

Pro an = re.getAnnotation(Pro.class);


/*

public class ProImpl implements Pro {

public String className() {

return

}


public String methodName() {

return

}

}

*/


//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);

}
}

 

五、案例

　　需求：给一个 Calculator 类，测试类中的方法是否都正常。

　　自定义一个注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

 

　　给 Calculator 类中的每一个方法添加 @check 注解

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...");

}

}

 

　　测试类：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Method;

/**
 *
 * 当主方法执行后，会自动自行被检测的所有方法(加了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();




}

}

 

 　　总结：注解是给编译器，解析程序使用的；注解不是程序的一部分。