nota:
-
Concepto: Descripción del proceso. Para el equipo para ver
-
Notas: La descripción de texto del programa. Para el programador para ver
-
Definición: Notas
Annotation(), también conocidos como metadatos . Describir un nivel de código. EsJDK1.5y una característica introducida en versiones posteriores, las clases, interfaces, enumeraciones están en el mismo nivel. Se puede declarar delante de los paquetes, clases, campos, métodos, variables locales, los parámetros y se describirá similares del método para estos elementos, el comentario. -
El concepto Descripción:
*JDK1.5Nuevas características después de
* Descripción del proceso de
* utilizando anotaciones: @ Nombre de anotación -
Papel Categoría:
① documentación: anotando generar un código de documento [documento de documentación generación doc] identificadas
eran el código anotando análisis de identificación de código [utilizando la reflexión]: análisis de código ②
③ compilador comprueba: notas de código identificado de forma que el compilador puede compilar comprobación básica [Cambiar]
-
package cn.itcast.annotation;
/**
* 注解javadoc演示
*
* @author itcat
* @version 1.0
* @since 1.5
*/
public class AnnoDemo1 {
/**
* 计算两数的和
* @param a 整数
* @param b 整数
* @return 两数的和
*/
public int add(int a, int b ){
return a + b;
}
}
- Algunas notas JDK predefinido
*@Override: método de detección marcado la anotación si hereda de la clase padre (interfaz)
*@Deprecated: el contenido de la etiqueta que indica la anotación obsoleto
*@SuppressWarnings: advertencia de compresión
* General aprobó parámetrosall,@SuppressWarnings("all")
package cn.itcast.annotation;
import java.util.Date;
/**
* JDK中预定义的一些注解
* * @Override ：检测被该注解标注的方法是否是继承自父类(接口)的
* * @Deprecated：该注解标注的内容，表示已过时
* * @SuppressWarnings：压制警告
*
*
*/
@SuppressWarnings("all")
public class AnnoDemo2 {
@Override
public String toString() {
return super.toString();
}
@Deprecated
public void show1(){
//有缺陷
}
public void show2(){
//替代show1方法
}
public void demo(){
show1();
Date date = new Date();
}
}
- anotación personalizada
- Formato:
notas Yuan
- Formato:
public @interface 注解名称{
属性列表;
}
- Esencia: Notas esencia de una interfaz , los hereda interfaz por defecto de anotación Interfaz
public interface MyAnno extends java.lang.annotation.Annotation {}
- Propiedades: métodos de interfaz abstractos
- requisitos:
- Valor de retorno Tipo de característica tienen los siguientes valores
* Los tipos de datos básicos
* cadena
* enumerados
* Notas
* un conjunto de más de un tipo de
- Valor de retorno Tipo de característica tienen los siguientes valores
- requisitos:
public @interface MyAnno {
int value();
Person per();
MyAnno2 anno2();
String[] strs();
/*String name() default "张三";*/
/*String show2();
Person per();
MyAnno2 anno2();
String[] strs();*/
}
- La propiedad se define cuando se utiliza necesidad de dar a la asignación de propiedad
1. Si la definición de la propiedad, el uso dedefaultpalabras clave a valor de inicialización por defecto del atributo, cuando se utiliza anotaciones, no se puede asignar atributos.
2. Si sólo hay una necesidad de asignar atributos, y el valor es el nombre de la propiedad, el valor puede ser omitido, valor directamente definido.
3. asignación de matriz, el valor del paquete {}. Si la matriz tiene sólo un valor, que puede ser omitido {}
- Las anotaciones se utilizan para describir anotación: un meta-anotación
@Target: Anotación puede describir la función de localizaciónElementTypevalor:TYPE: Se puede actuar sobre la claseMETHOD: Se puede actuar sobre el métodoFIELD: Puede actuar sobre las variables miembro
@Retention: Etapa Descripción anotación reservado
*@Retention(RetentionPolicy.RUNTIME): anotación que se describe en la actualidad, se conserva en los archivos de código de bytes de clases, y laJVMlectura@Documented: Si la descripción de las anotaciones son atraídos a la documentación de la API@Inherited: Notas descripción si heredado por las subclases
@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnno3 {
}
- Los usos de programa (Análisis) Nota: para conseguir un valor de propiedad se define en la anotación
- La adquisición de ubicación definida objeto de anotación (clase, método, Field)
- Obtiene el comentario especificado
getAnnotation(Class)
//, de hecho, generar una subclase que implementa la interfaz de anotación de objeto en la memoria
public class ProImpl implements Pro{
public String className(){
return "cn.itcast.annotation.Demo1";
}
public String methodName(){
return "show";
}
}
- valores de las propiedades de anotación Get Resumen de llamadas a métodos configurados
package cn.itcast.annotation;
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();
}
/**
* 框架类
*/
@Pro(className = "cn.itcast.annotation.Demo1",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 "cn.itcast.annotation.Demo1";
}
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);
//3.加载该类进内存
Class cls = Class.forName(className);
//4.创建对象
Object obj = cls.newInstance();
//5.获取方法对象
Method method = cls.getMethod(methodName);
//6.执行方法
method.invoke(obj);
}
}
- Caso: Marco simple prueba
- resumen:
- Después de la mayor parte del tiempo, vamos a utilizar las anotaciones, en lugar de la anotación personalizada
- Que solía comentario?
- compilador
- Los procedimientos analíticos utilizados para
- Anotaciones no son parte del programa, las notas que pueden ser entendidos como una etiqueta
- resumen:
/**
* 小明定义的计算器类
*/
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.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 {
}
/**
* 简单的测试框架
*
* 当主方法执行后，会自动自行被检测的所有方法(加了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();
}
}
