Java 注解 和 反射

注解

• 注解的作用是：对注解对象增加了额外的辅助功能，配合反射机制访问元数据；
  可以被其他程序读取，格式是：@…
• 使用位置：package、class、method、filed,

元注解

作用是：定义其他注解的注解；
元注解存在 annotation 包下；四个元注解：

• @Target
• @Retention
• @Documented
• @Inherited

/**
 * ElementType 注解可以作用的地方
 */
@Target(value = {ElementType.METHOD, ElementType.TYPE})
// 运行时起作用 runtime > calss > source
@Retention(value = RetentionPolicy.RUNTIME)
// 是否将注解生成在 java 文档中
@Documented
// 子类可以继承父类的注解
@Inherited
@interface MyAnnotation {


}

@Target

@MyAnnotation
public class TestAnnotation {

    @MyAnnotation
    public void test(){

    }
}

/**
 * ElementType 注解可以作用的地方
 */
@Target(value = {ElementType.METHOD, ElementType.TYPE})
@interface MyAnnotation {

}

自定义注解

@interface 表示时自定义注解

public class TestAnnotation {

    @MyAnnotation(name = "xx")
    public void test(){

    }
}
 
@Target(value = {ElementType.METHOD, ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
@Documented
@Inherited
@interface MyAnnotation {
	// 注解的参数
    String name();

}

类加载过程

1. 加载阶段 - 类加载器将类的 class 文件读入内存，并为之创建一个 java.lang.Class 对象
2. 链接阶段 - 将类的二进制数据合并到 JRE 中，为属性赋值默认值
3. 初始化阶段 - JVM 对类进行初始化， 合并静态代码块的初始值，同时先对父类进行初始化

public class Test2 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.a);
    }
}
class A{
    static {
        a = 10;
        System.out.println("静态代码块加载");
    }
    static int a = 1;
    public A(){
        System.out.println("无参构造器加载");
    }
}
# 结果
静态代码块加载
无参构造器加载
1

public class Test2 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.a);
    }
}

class A{
    static int a = 1;
    static {
        a = 10;
        System.out.println("静态代码块加载");
    }
    public A(){
        System.out.println("无参构造器加载");
    }
}

# 结果：
静态代码块加载
无参构造器加载
10

什么时候会进行类的初始化？

• 类被主动引用
  • 当虚拟机启动
  • new
  • 调用 static 和静态方法
  • 反射

反射

反射机制允许程序在执行，借助 Reflection API 取得任意类的内部信息，并直接操作任意对象的内部属性和方法。

反射的使用

		// 获取反射对象
        //Class c2 = User.class;
        //Class c3 = new User().getClass();
        Class c1 = Class.forName("reflection.User");
        // 动态创建对象
        User user = (User) c1.newInstance();
        // 获取对象的构造方法

        // 获取 public 修饰的
        Constructor constructor = c1.getConstructor();
        Constructor[] constructor1 = c1.getConstructors();
        for (Constructor con: constructor1) {
            System.out.println(con);
        }

        // 获取所有的
        Constructor[] constructors = c1.getDeclaredConstructors();
        for (Constructor con: constructors) {
            System.out.println(con);
        }
        System.out.println(constructors);
        Constructor declaredConstructor = c1.getDeclaredConstructor();
        System.out.println(declaredConstructor);

        // 获取方法
        Method[] method = c1.getMethods();
        for (Method m:method) {
            System.out.println(m);
        }

        Method[]  declaredMethods = c1.getDeclaredMethods();
        for (Method m:declaredMethods) {
            System.out.println(m);
        }

        // 获取方法
        Field[] fields =c1.getFields();
        c1.getDeclaredFields();