Java注解

JDK中预定义的注解

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

@Deprecated：表示被该注解标注的方法已过时，即建议使用更好的方法，但其只起标注作用，如果执意要使用该方法也是可以的

@SuppressWarnings：压制警告

func2方法被警告，使用@SuppressWarnings警告将消失，一般传参"all"

 1 @SuppressWarnings("all")
 2 public class jdk_demo {
 3     @Override
 4     public String toString() {
 5         return super.toString();
 6     }
 7 
 8     @Deprecated
 9     public void func1() {
10         // 该方法有缺陷，已过时，但为了兼容旧版本不能删除
11     }
12 
13     public void func2() {
14         // func1的替代方法
15     }
16 }

自定义注解

格式：
//元注解
//public @interface 注解名 {}

public @interface MyAnnotation {
}

在cmd中编译MyAnnotation.java得到MyAnnotation.class，再用javap将其反编译得到如下结果

因此我们可以知道，注解本质上就是一个接口，一个默认继承自Annotation的接口

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

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

定义属性后，使用注解时需要给属性赋值，定义属性时可用default给属性设定默认值；如果注解只有一个需要赋值的属性且该属性名叫value，可直接写属性值

1 public @interface Annotation {
2     int value();
3 }
4 
5 @Annotation(12)
6 public void function() {}

属性的返回值类型：

　　*所有基本数据类型

　　*String

　　*枚举

　　*注解

　　*以上类型的数组

/* MyAnnotation.java */
package annotation;

public @interface MyAnnotation {
    int func1();
    String func2();
    String func3() default "moren";
    String[] func4();
    Person p();
    MyAnnotation_2 anno();
}


/* jdk_demo.java */
package annotation;

@SuppressWarnings("all")
public class jdk_demo {
    @Override
    public String toString() {
        return super.toString();
    }

    @Deprecated
    public void func1() {
        // 该方法有缺陷，已过时，但为了兼容旧版本不能删除
    }

    @MyAnnotation(func1 = 0, func2 = "", func4 = {}, p = Person.p1, anno = @MyAnnotation_2)
    public void func2() {
        // func1的替代方法
    }
}

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

　　@Target：描述注解能够作用的位置（类Type、方法Method、成员变量Field）

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

　　@Documented：描述注解是否被抽取到API文档中

　　@Inherited：描述注解是否被子类继承，如果A注解被@Inherited注解，B类又被A注解注解，当C类继承了B类，C类自动被A注解注解

在程序中使用(解析)注解：获取注解中定义的属性值（代替配置文件）

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

2.获取指定的注解（getAnnotation(class)）

3.调用注解中的抽象方法获取配置的属性值

 1 /* Pro.java */
 2 import java.lang.annotation.ElementType;
 3 import java.lang.annotation.Retention;
 4 import java.lang.annotation.RetentionPolicy;
 5 import java.lang.annotation.Target;
 6 
 7 // 描述需要执行的类名和方法名
 8 @Target(value = {ElementType.TYPE})
 9 @Retention(RetentionPolicy.RUNTIME)
10 public @interface Pro {
11     String className();
12     String methodName();
13 }

1 /* Demo_1.java */
2 package annotation;
3 
4 public class Demo_1 {
5     public void show_1() {
6         System.out.println("Demo_1 show");
7     }
8 }

 1 /* ReflectTest.java */
 2 import java.lang.reflect.Method;
 3 
 4 @SuppressWarnings("all")
 5 @Pro(className = "annotation.Demo_1", methodName = "show_1")
 6 public class ReflectTest {
 7     public static void main(String[] args) throws Exception{
 8         /* 解析注解 */
 9         // 1.获取该类的字节码文件对象，即 ReflectTest.class
10         Class<ReflectTest> reflectTestClass = ReflectTest.class;
11         // 2.获取上边的注解对象
12         /*
13             在内存中生成一个该注解接口的子类实现对象，并返回
14             public class ProImpl implements Pro{
15                 // 对注解Pro属性的重写，返回上面注解中配置的属性值
16                 public String className() {
17                     return "annotation.Demo_1";
18                 }
19                 public String methodName() {
20                     return "show_1";
21                 }
22             }
23         */
24         Pro annotation = reflectTestClass.getAnnotation(Pro.class);
25         // 3.调用注解对象中定义的抽象方法(注解的属性就是抽象方法，只不过我们给这些抽象方法取名叫属性)，获取返回值
26         String className = annotation.className();
27         String methodName = annotation.methodName();
28 
29         Class<?> c = Class.forName(className);
30         Object o = c.newInstance();
31         Method m = c.getMethod(methodName);
32         m.invoke(o);
33     }
34 }