Web--(6)反射

类的加载时机

1. 当程序要使用某个类时，如果该类还未被加载到内存中
2. 系统会通过加载，连接，初始化三步来实现对这个类进行初始化
   加载
   就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
   连接
  验证 是否有正确的内部结构，并和其他类协调一致
     准备负责为类的静态成员分配内存，并设置默认初始化值
   初始化
   初始化成员变量等等
3. 加载时机
   1. 创建类的实例
   2. 访问类的静态变量，或者为静态变量赋值
   3. 调用类的静态方法
   4. 初始化某个类的子类
   5. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

类加载器

1. 什么是类加载器classLoader
   1. 负责将.class文件加载到内存中，并为之生成对应的Class对象。
   2. 虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。
2. 类加载器分类
   1. 根类加载器
      也被称为引导类加载器，负责Java核心类的加载
      比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
   2. 扩展类加载器
      负责JRE的扩展目录中jar包的加载。
      在JDK中JRE的lib目录下ext目录
   3. 系统类加载器
      负责在JVM启动时加载来自java命令的class文件
      以及classpath环境变量所指定的jar包和类路径

什么是反射

1. 创建一个对象的三个阶段
   1. 源文件阶段 .java的文件
   2. 字节码阶段 .class
   3. 创建对象阶段 new 对象名称
2. 内省
   在运行时能够获取JavaBean当中的属性名称和get与set方法
3. 反射
   1. JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
   2. 对于任意一个对象，都能够调用它的任意一个方法和属性；
   3. 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
   4. 想要使用反射，就必须得要获取字节码文件
4. 获取字节码文件

   1. Object类的getClass()方法
      判断两个对象是否是同一个字节码文件

   2. 静态属性class：当作静态方法的锁对象

   3. Class类中静态方法forName() 读取配置文件

   4. 示例

Class clazz1 = Class.forName("com.iris.reflect.Person");
Class clazz2 = Person.class;

Person P = new Person();
Class clazz3 = p.getClss();

System.out.println(clazz1 == class2);
System.out.println(clazz2 == clazz3);

获取字节码演示

创建一个普通的JAVA项目
在src 在创建包 com.iris.reflect
在该包下创建两个类
Person.java

package com.iris.reflect;

public class Person {
	public String name;
	public Integer age;
	private String gender;
	public Person() {
		super();
	}
	public Person(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public void show() {
		System.out.println("我是"+this.name+"年龄"+this.age+this.gender);
	}
	
	private void eat(String food) {
		System.out.println("我吃..."+food);
	}
}

Test.java

package com.iris.reflect;

public class Test {
	
	public static void main(String[] args) throws Exception {
		// 获取字节码
		Class clazz1 = Class.forName("com.iris.reflect.Person");
		
		Class clazz2 = Person.class;
		
		Person p = new Person();
		Class clazz3 = p.getClass();
		
		System.out.println(clazz1 == clazz2);
		System.out.println(clazz2 == clazz3);
	}
}

通过字节码创建对象

Test.java

package com.iris.reflect;

public class Test {
	
	public static void main(String[] args) throws Exception {
		// 获取字节码
		Class clazz1 = Class.forName("com.iris.reflect.Person");
		//通过字节码创建对象
		Person p =(Person)clazz1.newInstance();
		p.name = "zs";
		p.age = 10;
		p.show();
		
		//通过有参数的构造器创建对象
		//1.获取构造器
		Constructor c =clazz1.getConstructor(String.class,Integer.class);
		//2.通过构造器创建对象
		Person p2 =(Person) c.newInstance("ls",7);
		p2.show();
	}
}

通过反射获取字段

public Stirng name;
public Integer age;
private String gender;

获取共有字段public

package com.iris.reflect;

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

public class Test {
	
	public static void main(String[] args) throws Exception {
		// 获取字节码
		Class<?> clazz1 = Class.forName("com.iris.reflect.Person");
		//通过有参数的构造器创建对象
		//1.获取构造器
		Constructor c =clazz1.getConstructor(String.class,Integer.class);
		//2.通过构造器创建对象
		Person p2 =(Person) c.newInstance("ls",7);
		p2.show();
		
		//获取公共字段public
		Field f = clazz1.getField("name");
		f.set(p2, "李白");
		p2.show();
	}
}

获取私有字段 private

package com.iris.reflect;

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

public class Test {
	
	public static void main(String[] args) throws Exception {
		// 获取字节码
		Class<?> clazz1 = Class.forName("com.iris.reflect.Person");
		//通过有参数的构造器创建对象
		//1.获取构造器
		Constructor c =clazz1.getConstructor(String.class,Integer.class);
		//2.通过构造器创建对象
		Person p2 =(Person) c.newInstance("ls",7);

		//获取私有字段private
		Field f2 = clazz1.getDeclaredField("gender");
		f2.setAccessible(true); //去除私有的权限
		f2.set(p2, "男");
		p2.show();
	}
}

通过反射获取方法

获取公共方法public

package com.iris.reflect;

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

public class Test {
	
	public static void main(String[] args) throws Exception {
		// 获取字节码
		Class<?> clazz1 = Class.forName("com.iris.reflect.Person");
		//通过有参数的构造器创建对象
		//1.获取构造器
		Constructor c =clazz1.getConstructor(String.class,Integer.class);
		//2.通过构造器创建对象
		Person p2 =(Person) c.newInstance("ls",7);
		
		//获取共有方法
		Method m1 = clazz1.getMethod("show");
		System.out.println(m1.getName());
		m1.invoke(p2);  //执行方法
	}
}

获取私有方法 private

package com.iris.reflect;

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

public class Test {
	
	public static void main(String[] args) throws Exception {
		// 获取字节码
		Class<?> clazz1 = Class.forName("com.iris.reflect.Person");
		//通过有参数的构造器创建对象
		//1.获取构造器
		Constructor c =clazz1.getConstructor(String.class,Integer.class);
		//2.通过构造器创建对象
		Person p2 =(Person) c.newInstance("ls",7);
		
		//获取私有方法
		Method m2 = clazz1.getDeclaredMethod("eat", String.class);
		m2.setAccessible(true);//去除私有权限
		m2.invoke(p2, "apple");
	}
}

通过反射越过数组泛型检测

package com.iris.reflect;

import java.lang.reflect.Method;
import java.util.ArrayList;

public class Test2 {
	public static void main(String[] args) throws Exception {
		ArrayList<Integer> list = new ArrayList<>();
		list.add(1);
//		list.add("my stirng");
		
		//获取Arraylist的字节码
		Class<?> clazz = Class.forName("java.util.ArrayList");
		Method m1 = clazz.getMethod("add", Object.class);
		m1.invoke(list, "mystring");
		System.out.println(list);
	}
}