java反射

反射

• Reflection是java语言被视为动态语言的关键，反射机制允许程序在执行期借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性和方法

• 加载类的方法Class c = Class.forName("");

• 加载完之后，在堆内存的方法区就会产生一个Class类型的对象(一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，通过这个镜子按到类的结构，所以，我们形象的称之为反射

反射机制提供的功能

• 运行时判断任何一个对象所属的类
• 运行时构造任何一个类的对象
• 运行时判断任何一个类所具有的成员变量和方法
• 运行时获取泛型信息
• 运行时调用任何一个对象的成员变量和方法
• 运行时处理注解
• 生成动态代理

反射相关的API

• java.lang.Class：代表一个类
• java.lang.reflect.Method：代表类的方法
• java.lang.reflect.Field：代表类的成员变量
• java.lang.reflect.Constructor：代表类的构造器

获取Class类的实例

• Class clazz = 类名.class;
• Class clazz = 对象.class;
• Class clazz = Class.forName(“类路径”);
• Class clazz = Integer.TYPE;基本内置类型的包装类都有一个TYPE属性
• Class clazz = class对象.getSuperclass(); 获得父类class类

所有类型的Class

• Object.class 类

• Comparable.class 接口

• String[].class 一维数组

• int[ ] [ ].class 二维数组

• Override.class 注解

• ElementType.class 枚举

• Integer.class 基本类型

• void.class void

• Class.class Class

• 只要元素类型与维度一样，就是同一个Class

类的加载和ClassLoader的理解

• 加载：将class文件字节码内容加载到内存之中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象

• 链接：将Java类的二进制代码合并到JVM的运行状态之中的过程

  • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题
  • 准备：正式为类变量（static）分配内存并设置类变量的默认初始值的阶段，这些内存都将在方法区中进行分配
  • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程

• 初始化：

  • 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类的信息的，不是构造该对象的构造器）
  • 当初始化一个类的时候，如果发现其父类还没有初始化，则需要先触发其父类的初始化
  • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

• class A{
  	static{
      	System.out.println("A类静态代码块初始化");
          m = 300;
      }
      
      static int m = 100;
      
      public A{
          System.out.println("A类的无参构造初始化")
      }
  }
  
  public class Test{
  	public static void main(String[] args){
          A a = new A();
          System.out.println(A.m);
      }
  }
  
  /*
  1.加载到内存，会产生一个对应的Class对象
  2.链接，链接结束后m=0
  3.初始化
  	<clinit>(){
  		System.out.println("A类静态代码块初始化");
          m = 300；
          m = 100；
  	}
  	m = 100;
  */
  
  A类静态代码块初始化
  A类的无参构造初始化
  100
  

什么时候发生类的初始化

• 类的主动引用（一定会发生类的初始化）
  • 当虚拟机启动，先初始化Main方法所在的类
  • new一个类的对象
  • 调用类的静态成员（除了final常量）和静态方法
  • 使用java.lang.reflect包的方法对类进行反射调用
  • 当初始化一个类，如果其父类还未初始化，则会先初始化它的父类
• 类的被动引用（不会发生类的初始化）
  • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。例如通过子类引用父类的静态变量，不会导致子类初始化
  • 通过数组定义类引用，不会触发此类初始化
  • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池了）

类加载器的作用

• 类加载的作用：将class文件字节码内容加载到内存之中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中数据的访问入口

• 类缓存：标准的JavaSE类加载器可以按照要求查找类，但一旦某一个类被加载到了类加载器中，他将维持加载（缓存）一段时间，不过JVM垃圾回收机制可以回收这些Class对象

• 类加载器

  • 引导类加载器
  • 扩展类加载器
  • 系统类加载器
  • 自定义类加载器

获取运行时类的完整结构

package test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class classreflect {

    public static void main(String[] args) throws Exception {
        Class c1 = Class.forName("test.User");

        //获取类的名字
        System.out.println(c1.getName());//获取类名和包名
        System.out.println(c1.getSimpleName());//获取类名

        //获取类的属性
        System.out.println();

        Field[] fields = c1.getFields();//只能找到public属性
        for (Field field : fields) {
            System.out.println(field);
        }

        fields = c1.getDeclaredFields();//能找到全部属性
        for (Field field : fields) {
            System.out.println(field);
        }

        c1.getField("id");//获取指定的属性

        //获得类的方法
        Method[] methods = c1.getMethods();//获取本类以及父类的全部public方法
        for (Method method : methods) {
            System.out.println("Methods:" + method);
        }

        methods = c1.getDeclaredMethods();//获取本类的所有方法
        for (Method method : methods) {
            System.out.println("DeclaredMethods:" + method);
        }

        //获取指定的方法
        //重载
        c1.getMethod("getId", null);
        c1.getMethod("getId", String.class);

        //获得指定的构造器
        Constructor[] constructors = c1.getConstructors();//只能获取public方法
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        constructors = c1.getDeclaredConstructors();//获取全部方法
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        
    }

}

通过class类创建对象后使用方法和调用属性

package test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class classreflect1 {

    public static void main(String[] args) throws Exception {
        //获取class对象
        Class c1 = Class.forName("test.User");

        //构造一个对象
        User user = (User) c1.newInstance();//本质上是调用了类的无参构造器
        System.out.println(user);

        //通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String.class);
        User user1 = (User) constructor.newInstance("hello");
        System.out.println(user1);

        //通过反射调用方法
        User user2 = (User) c1.newInstance();
        Method setId = c1.getDeclaredMethod("setId", String.class);
        //invoke 激活的意思
        //（对象，"方法的值"）
        setId.invoke(user2,"world");
        System.out.println(user2);

        //通过反射获取操作属性
        User user3 = (User) c1.newInstance();
        Field id = c1.getDeclaredField("id");

        id.setAccessible(true);//不能直接操作私有属性，我们需要关闭程序的安全检测，属性或方法的setACcessible(true)
        id.set(user3,"wangjunqin");
        System.out.println(user3);
    }
}