Java反射机制

类的加载时机

当程序要使用某个类时，如果该类还未被加载到内存中，系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

• 加载
  就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
• 连接
  验证是否有正确的内部结构，并和其他类协调一致，准备负责为类的静态成员分配内存，并设置默认初始化值。
• 初始化
  初始化成员变量等等。

加载时机

• 创建类的实例
• 访问类的静态变量，或者为静态变量赋值
• 调用类的静态方法
• 初始化某个类的子类
• 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

类加载器

什么是类加载器classLoader？
负责将.class文件加载到内存中，并为之生成对应的Class对象。虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。

类加载器分类：

• 根类加载器
  也被称为引导类加载器，负责Java核心类的加载，比如System,String等。在JDK中JRE的lib目录下rt.jar文件中。
• 扩展类加载器
  负责JRE的扩展目录中jar包的加载，在JDK中JRE的lib目录下ext目录。
• 系统类加载器
  负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。

什么是反射

• 创建一个对象的三个阶段
  1.源文件阶段 .java的文件
  2.字节码阶段 .class
  3.创建对象阶段new对象名称

• 内省
  在运行时能够获取JavaBean当中的属性名称和get与set方法

• 反射
  JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；想要使用反射，就必须得要获取字节码文件，这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

• 获取字节码文件
  1.Object类的getClass()方法，判断两个对象是否是同一个字节码文件。
  2.静态属性class，当作静态方法的锁对象。
  3.Class类中静态方法forName()，读取配置文件。

Person.java

public class Person {

    public String name;
    private Integer age;
    
	//一定要定义为public属性，否则带参构造会报错
    public Person(String name, Integer age){
        this.name = name;
        this.age = age;
    }

    public Person(){
       
    }

    public void show(){
        System.out.println(this.name+"---->"+this.age);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

 public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException {
    	/*
    	*获取反射对象(反射入口)
    	*1.Class.forName(全类名) 2.类.class 3.对象.getClass()*/
        Class<?> aClass = Class.forName("org.javaboy.Person");
        Class<Person> personClass = Person.class;
        Person person = new Person();
        Class  aClass1 = person.getClass();
        //结果都相同
        if (aClass == personClass){
            System.out.println("=");
        }
        if (personClass == aClass1){
            System.out.println("=");
        }
  }
}

通过字节码创建对象

• 通过无参构造创建对象
  1.获取字节码
  2.调用字节码的newInstance()方法

 public static void main(String[] args) throws  Exception {
 	 //构造赋值
     Class<?> aClass = Class.forName("org.javaboy.Person");
  	 Person person = (Person) aClass.newInstance();
  	 person.setName("zs");
  	 person.setAge(23);
     person.show();
 }

• 通过有参构造创建对象
  1.获取字节码的构造器

/*因为在反射阶段操作的都是字节码，不知道具体的类型，
只有在创建对象的时候才去给实际参数*/
clazz.getConstructor(type.class)

2.通过构造器创建对象
调用构造器的newInstance方法并传入参数。

public class Test7 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
     	//构造赋值
        Class<?> aClass = Class.forName("org.javaboy.Person");
        Constructor<?> constructor = aClass.getConstructor(String.class,Integer.class);
        Person zs = (Person) constructor.newInstance("zs", 22);
        zs.show();
    }
}

获取字段

1.获取公共的字段

  public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
  		 //构造赋值
        Class<?> aClass = Class.forName("org.javaboy.Person");
        Constructor<?> constructor = aClass.getConstructor(String.class,Integer.class);
        Person zs = (Person) constructor.newInstance("zs", 22);
        Field name = aClass.getField("name");
        name.set(zs,"ls");
        System.out.println(zs);
    }

2.获取私有的字段

 public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
 		 //构造赋值
        Class<?> aClass = Class.forName("org.javaboy.Person");
        Constructor<?> constructor = aClass.getConstructor(String.class,Integer.class);
        Person zs = (Person) constructor.newInstance("zs", 22);
        //反射获取字段
        Field name = aClass.getDeclaredField("age");
        //除去私有权限
        name.setAccessible(true);
        name.set(zs,10);
        System.out.println(zs);
 }

获取方法

 public static void main(String[] args) throws  Exception{
        //构造赋值
        Class<?> clazz = Class.forName("org.javaboy.Person");
        Constructor<?> constructor = clazz.getConstructor(String.class,Integer.class);
        Person person = (Person) constructor.newInstance("zs", 22);
        //获取所有的公有方法(本类，父类，以及接口)
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        /*public属性*/
        Method m = clazz.getMethod("show"); 
        m.invoke(person);
        /*private属性*/
        Method eat = clazz.getDeclaredMethod("eat", String.class);
        eat.setAccessible(true);
        eat.invoke(person,"rice");
 }

越过数组泛型检测

数组如果定义好了泛型就不能添加泛型以外的类型，可以通过反射来去实现添加以外的类型，在一个Integer泛型的数组当中添加字符串类型。

 public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(12);
        integers.add(546);
        Class<?> aClass = Class.forName("java.util.ArrayList");
        Method add = aClass.getMethod("add", Object.class);
        add.invoke(integers,"youyuan");
        System.out.println(integers);
 }