类的加载机制和反射机制

目录：
一.类的加载机制
1.类的加载过程
2.class文件的加载步骤
3.什么是类加载器，有哪些种类的类加载器
4.获得class对象的四种方式
5.数组类型、基本类型及其对应包装类的class对象

二.类的反射机制
1.如何通过Class对象获得构造方法对象
2.如何通过构造方法对象实例化
3.如何通过Class对象获得属性对象和方法对象

一.类的加载机制
1.类的加载过程
1）启动JVM
2）将需要运行的class文件加载到虚拟机内存中
3）找到主类，开始执行主函数
Tip：class文件加载的过程中，会先执行父类的静态代码块和静态变量初始化，并且静态代码块和静态变量的执行顺序只跟代码中出现的顺序有关。

2.class文件的加载步骤
1）先委托父类加载类，如果父类已经加载，就不需要再次加载，如果父类没有加载，再由本加载器加载
2）解析类路径，将类路径转换成文件路径
3）通过文件输入流来读取class文件，得到字节数组
4）将字节数组转换成类对象,对象的类型是Class类型

3.什么是类加载器，有哪些种类的类加载器
类加载器是将class文件加载到JVM内存中的工具，加载到内存中之后，以Class对象的形式存在。
类加载器（ClassLoader）的种类有：
1）AppClassLoader
应用类加载器，负责加载核心类，加载自己写的类
2）ExtClassLoader
扩展类加载器，负责加载扩展类库
3）Bootstrap----JVM内置的加载器
Bootstrap类加载器是JVM的一部分，是由C++编写的，随着虚拟机的启动就会创建一个bootstrap类加载器对象

4.获得class对象的方式
1）通过类名.class
Class c1 = Student.class;
2）通过对象的getClass()方法
Class c2 = stu.getClass();
3）通过类加载器获得class对象
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
Class c3 = classLoader.loadClass(“com.newer.test.Student”);
4)通过 Class.forName()获得Class对象;
Class c4 = Class.forName(“com.newer.test.Student”);
5)可以自定义加载类，然后通过自己写的加载方法来加载class类
先写MyClassLoader继承ClassLoader

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;

public class MyClassLoader extends ClassLoader {
	// class文件的根路径
	String parent = "F:\\JAVA\\lianxi06\\bin\\cn\\gn0812\\lx";

	// 加载Class的方法
	public Class<?> loadClass(String name) {
		Class c = null;
		try {
			// 先委托给父类加载器加载
			c = super.loadClass(name);
			// 如果父类加载器未加载
			if (c == null) {
				byte[] bs = loadClassData(name);
				c = this.defineClass(name, bs, 0, bs.length);
			}
		} catch (Exception ef) {
			ef.printStackTrace();
		}
		return c;
	}

	// 通过类名来从class文件中读取字节数据
	// cn.gn0812.lx.Student
	private byte[] loadClassData(String name) {
		name = name.replace(".", "\\");
		name = name + ".class";
		String path = parent + "\\" + name;

		try {
			// 建立文件字节输入路
			FileInputStream fis = new FileInputStream(path);
			// 创建一个字节数组输出流来缓存读入的数据
			ByteArrayOutputStream bos = new ByteArrayOutputStream();

			int t = fis.read();
			while (t != -1) {
				bos.write(t);
				t = fis.read();
			}
			// 将字节数组输出流转换成字节数组
			byte[] bs = bos.toByteArray();

			fis.close();
			bos.close();
			return bs;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
}

学生类

public class Student {
	private int num;
	private String name;
	private int age;

	public Student() {

	}

	private Student(int num) {
		this.num = num;
	}

	public Student(int num, String name, int age) {
		this.num = num;
		this.name = name;
		this.age = age;
	}

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

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

	@Override
	public String toString() {
		return "Student{" + "num=" + num + ", name='" + name + '\'' + ", age=" + age + '}';
	}

}

运行主函数

public class Test {

	public static void main(String[] args) {
		MyClassLoader mcl = new MyClassLoader();
		Class c = mcl.findClass("cn.gn0812.lx.Student");
		System.out.println(c);
	}
}

运行结果

class cn.gn0812.lx.Student

Tips：因为类的加载过程只会执行一次，所以任何一个类都能会被加载一次。（除自定义加载类以外）

5.数组类型、基本类型及其对应包装类的class对象
1）数组类型的Class对象
int[].class
数组对象.getClass();
2）基本类型的Class对象
int.class
3）基本类型对应的包装类的Class对象
Integer.class
对象.getClass();
Integer t = 100;
t.getClass();
Class.forName(“java.lang.Integer”);
loadClass(“java.lang.Integer”);
拿到包装类对应的基本类型的Class对象
Integer.TYPE;（由于是直接从int.class处获得的属性，故Integer.TYPE类型就是int.class）

二.类的反射机制
1.如何通过Class对象获得构造方法对象
程序在运行时能够动态的获得类的相关信息的机制，叫做反射机制。
JVM中，类的所有的信息都在Class对象中，Class类是反射机制中的核心类。
一般来说，我们是先知道类的相关信息，再使用这个类；而反射机制，是我们不清楚类的具体信息，只是知道有这么个类，我们先直接使用这个类，再慢慢去获得这个类的信息。
2.如何通过构造方法对象实例化
1）获得所有可见的构造方法
Constructor[] cons= c.getConstructors();
2）获得所有已经声明的构造方法
Constructor[] cons2= c.getDeclaredConstructors();
3）获得指定的可见的某一个构造方法
Constructor cc = c.getConstructor(int.class,String.class,int.class);
4）从声明的方法中获得指定的构造方法
Constructor cc2 = c.getDeclaredConstructor(int.class);
3.如何通过Class对象获得属性对象和方法对象
未完待续。。。