一、类加载机制
（一）虚拟机类加载机制
1、引言：
虚拟机是运行Java代码的容器, 而实际运行的是对应的class字节码文件,
因此虚拟机类加载机制就是将class文件加载进入内存, 然后从class文件中获取
出数据, 并对数据进行【校验,转换解析和初始化】,最终形成可以被java虚拟机
直接使用的java类型
2、类的加载机制：一个类, 如果需要使用, 就一定会被加载到内存中, 因此其
加载过程分为三个步骤：加载, 连接, 初始化
（二）类加载过程
1、当程序要使用某个类时,如果该类还未被加载到内存中,系统会通过：加载，
连接，初始化三步来实现对这个类的加载.
（1）加载：就是指将class文件读入内存,并为之创建一个Class对象（字节
码对象）。任何类被使用时系统都会建立一个Class对象
（2）连接：验证是否有正确的内部结构,并和其他类协调一致(比如父类)。准备负责为
类的静态成员分配内存,并设置默认初始化值。解析将类的二进制数据中的符号
引用替换为直接引用
（3）初始化：就是我们以前讲过的初始化步骤(初始化创建对象)
2、类的初始化时机：
（1）创建类的实例
（2）类的静态成员使用
（3）类的静态方法调用
（4）使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
（5）初始化某个类的子类
（6）直接使用java.exe命令来运行某个主类
二、类加载器
（一）类加载器概述
1、类加载器是负责加载类的对象，将class文件(硬盘)加载到内存中，并为之生
成对应的java.lang.Class对象
（二）类加载器分类
1、Bootstrap ClassLoader 引导类加载器
也被称为根类加载器,负责Java核心类的加载,比如System,String等.
2、Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载,在JDK中JRE的lib目录下ext目录.
3、Application ClassLoader 系统类加载器
负责在JVM启动时加载来自java命令的class文件,以及classpath环境变
量所指定的jar包和类路径.
4、自定义类加载器
开发人员可以通过继承java.lang.ClassLoader类的方式实现自己的类加载器,以
满足一些特殊的需求.
5、类加载器之间的继承关系
-Bootstrap ClassLoader
-Extension ClassLoader
-Application ClassLoader
（三）双亲委派机制
1、双亲委派机制是指当一个类加载器收到一个类加载请求时，该类加载器首先
会把请求委派给父类加载器。每个类加载器都是如此，只有在父类加载器在自己
的搜索范围内找不到指定类时，子类加载器才会尝试自己去加载
2、双亲委派模型工作过程:
（1）当Application ClassLoader 收到一个类加载请求时,他首先不会自己
去尝试加载这个类,而是将这个请求委派给父类加载器Extension ClassLoader去
完成
（2）当Extension ClassLoader收到一个类加载请求时,他首先也不会自己
去尝试加载这个类,而是将请求委派给父类加载器Bootstrap ClassLoader去完成
（3）如果Bootstrap ClassLoader加载失败(在<JAVA_HOME>lib中未找到所
需类),就会让Extension ClassLoader尝试加载
（4）如果Extension ClassLoader也加载失败,就会使用Application
ClassLoader加载
（5）如果Application ClassLoader也加载失败,就会使用自定义加载器去
尝试加载.
（6）如果均加载失败,就会抛出ClassNotFoundException异常
3、例子:
当一个Hello.class这样的文件要被加载时。不考虑我们自定义类加载器,首
先会在AppClassLoader中检查是否加载过,如果有那就无需再加载了。如果没加
有,那么会拿到父载器,然后调用父加载器的loadClass方法。父类中同理会先检
查自己是否已经加载过，如果没有再往上.注意这个过程,直到到达Bootstrap
classLoader之前，都是没有哪个加载器自己选择加载的.如果父加载器无法加
载，会下沉到子加载器去加载，一直到最底层,如果没有任何加载器能加载,就会
抛出ClassNotFoundException
（四）CLassLoader类
1、常用方法:
（1）static ClassLoader getSystemClassLoader() 返回用于委派的系统
类加载器
（2）ClassLoader getParent() 返回父类加载器进行委派
（3）getResourceAsStream(String name) 返回读取指定资源的输入流
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class Demo01_ClassLoader {
public static void main(String[] args) throws IOException {
//根据类加载器，获取流对象，使用流对象可以读取指定的文件
//getResourceAsStream(String name)
//可以根据具体的Java类的字节码对象通过getClassLoader() 获取加载这个Java类的类加载器
//同步锁获取：可以用类的字节码对象，字节码对象：类名.class
Class<Person> clazz = Person.class;
//字节码对象表示Person类，可以通过Person类获取加载它的类加载器
ClassLoader classLoader = clazz.getClassLoader();
System.out.println(classLoader);
//通过类加载器可以获取到一个关联到指定文件的流对象
InputStream is = classLoader.getResourceAsStream("config.properties");
//通过流对象加载配置文件信息
Properties pro = new Properties();
pro.load(is);
String name = pro.getProperty("name");
String age = pro.getProperty("age");
System.out.println(name + "..." + age);
}
public static void test1() {
//获取应用类加载器：AppClassLoader -》ApplicationClassLoader
ClassLoader loader = ClassLoader.getSystemClassLoader();
System.out.println(loader);
//getParent() 获取当前类加载器的父类加载器
ClassLoader parent = loader.getParent();
System.out.println(parent);//ExtClassLoader -> ExtensionClassloader
//尝试获取Bootstrap Classloader
ClassLoader boot = parent.getParent();
System.out.println(boot);
}
}
三、反射
（一）反射概述
1、java反射：在程序运行过程中（动态），可以对任意一个类型进行任意的操
作。例如：加载任意类型、调用类型的任意方法、获取任意的成员变量、构造方
法，可以创建该类型的对象。
2、对于任意一个对象，都能调用这个对象的任意一个方法【不知道要使用什么
类型】
3、如果要获取一个类型的各种内容，首先要获取这个类的字节码对象(字节码对
象属于 Class类型)
4、解剖这个类型，获取类中的成员，需要使用Class类型中定义的方法
5、这种【动态】获取信息以及【动态】访问成员的这种方式，称为：反射
（二）获取类的字节码对象（Class类型对象）的三种方式
1、要想获取和操作类中的内容，首先要获取类的字节码对象
2、这些对象（类的字节码对象，也称为.class对象），都是Class类型的对象
3、获取字节码对象的方式：
（1）对象名.getClass()：返回的是某个引用指向的具体对象所属的运行时
类，的字节码对象。获取到的是那个真正用来创建对象的类的字节码对象。
（2）类名.class：如果已经有了类名，可以通过.class的方式获取这个类
的字节码对象。
（3）通过Class.forName(String className)：Class类中的一个静态方
法，可以根据一个类的全类名，动态的加载某个类型。传入一个类的全类名，将
类名描述的字节码文件，加载到内存中，形成一个字节码对象，并且把这个对象
作为该方法的返回值。（在调用方法之前，是内存中没有这个字节码对象的）。
字符串的来源非常广泛，来源于代码，可以来源于键盘录入、网络传输、文件读
取、数据库
public class Demo02_GetInstanceOfClass {
public static void main(String[] args) throws ClassNotFoundException {
//方式一：类名.class
Class clazz = Person.class;
System.out.println("clazz = " + clazz);
//方式二：使用Object类中的getClass()方法获取
//任何类型都能继承Object类的getClass方法，即任何类型的对象都能调用此方法获取到调用者对象所属类型本身
//对象可以通过文件读取到、通过集合获取到、通过new创建、通过传参传入、通过返回值返回...
Person p = new Person();
Class<? extends Person> clazz1 = p.getClass();
System.out.println("clazz1 = " + clazz1);
//方式三：static forName(String className) 通过参数表示的名称，获取到对应的Java类的字节码对象
Class<?> clazz2 = Class.forName("com.offcn.demos.Person");
System.out.println("clazz2 = " + clazz2);
}
}（三）Class类型的理解
1、Class类型的实例表示正在运行的java应用程序的类或者接口
2、举例：
（ 张三，23），（李四， 24），姓名和年龄都不相同，但是都有年龄和姓
名的描述，因此将姓名和年龄抽取到一个类型中，就形成了Person类型，的概念
（yellow，4），（white，2），颜色和腿的个数各不相同，但是都有颜色
和腿个数的描述，因此将颜色和腿个数的描述抽取到一个类型中，就形成了
Animal类型，的概念
（姓名， 年龄），（颜色， 腿个数），成员变量和成员方法各不相同，但
是都有成员变量和成员方法的描述，因此将成员变量和成员方法抽取到一个类型
中，就形成Class类型，的概念（用于描述类的一个类）
3、反射的举例：
房屋设计图纸---->实体房屋，反射：有了房屋，获取设计图纸
汽车设计图纸---->实体汽车，反射：有了汽车，获取设计图纸
无论是房屋设计图纸，还是汽车的设计图纸，都是图纸：抽取一个图纸类型
（四）Class类中的方法
1、一旦获取了类的字节码对象，就可以使用这个对象的所有方法，这些方法都
定义在Class类型中。
2、成员方法：获取这个类的各种信息
成员变量、成员方法、构造方法、内部类、类的注解、类所在的包、类的修
饰符、判断类的类型
以上内容获取出来以后，又是一些对象，有专门的数据类型，描述这些对象
3、其中，有一个非常常用的方法：newInstance()
创建这个字节码描述的类型的实例对象，例如使用Person.class字节码对
象，调用newInstance方法，就可以创建一个真正的Person对象
import java.util.Scanner;
public class Demo03_NewInstance {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
//利用反射创建Person类的对象
Scanner sc = new Scanner(System.in);
String className = sc.nextLine();
//1.获取Person类的字节码对象
Class<?> clazz = Class.forName(className);
//2.为获取到的Java类，创建对象
Object o = clazz.newInstance();//Object o = new Person();
//3.为对象的成员变量赋值（此处不使用反射，用常规的方式）
/*Person p = (Person)o;
p.setName("张三");
p.setAge(23);
System.out.println(p.getName() + "..." + p.getAge());*/
}
}
（五）获取类中的构造方法并使用
1、通过Class类中的：
getConstructor(Class...paramTypes)
参数列表：Class...paramTypes，表示一个可变参数，需要传入构造方法的
类型的字节码对象
返回值类型：Constructor，表示一个构造方法类型的对象
2、Constructor类型：
（1）表示构造方法类型，这个类的每个对象，都是一个确定的，具体的构
造方法
（2）构造方法对象应该具有的功能：获取构造方法各种信息（构造方法修
饰符、构造方法名称、构造方法的参数列表、构造方法的注解），最基本的一个
功能就是，创建对象
newInstance(Object...objs)
返回一个Object类型的对象
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Demo02_GetConstructor {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//getConstructor(Class<?>... parameterTypes) 获取一个类型的构造方法，是哪个构造方法要通过参数列表指定
//参数使用了可变参数，即参数的类型是0~无穷个，多个构造，参数的个数肯定都不一样
//此处可变参数的类型定成了Class，即要书写想要获取的构造方法参数的字节码对象
//反射获取一个类的构造方法，之后为这个类按照构造创建对象
//1.获取指定类型的字节码对象
Class<?> clazz = Class.forName("com.xxxx.demos.Student");
//2.获取类的构造方法
Constructor<?> con = clazz.getConstructor(String.class, int.class);
//3.使用反射获取到的类的构造方法，创建对象
//newInstance(Object... initargs)
Object o = con.newInstance("张三", 18);
//Object o = new Student("张三", 18);
System.out.println("o = " + o);
}
}
（六）获取类中的成员变量并使用
1、通过Class类中的：
getField(String propertyName)
参数列表：属性的名称
返回值类型：Field，表示一个成员变量对象，所属的类型
2、Field类型：表示一个成员变量类型，每个对象都是一个具体的成员变量
作用：获取成员变量的各种信息（修饰符、注解、名称）；做各种数据类型
的转换
赋值：set(Object obj, Object value)，用于给obj对象的，该成员变量，
赋value值
import java.lang.reflect.Field;
public class Demo03_GrtFields {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InstantiationException {
//getField(String name) 获取公共字段(字段只能是public修饰的)
//1.获取类（类的字节码对象）
Class clazz = Student.class;
//2.获取指定名称的字段
Field field = clazz.getField("score");
//3.为获取到的字段赋值
//不能直接赋值？因为成员变量随着对象的创建而创建，如果对象没有创建，则成员变量无法赋值
//创建当前类型的对象
Object o = clazz.newInstance();
//为对象的这个成员变量赋值
/*set(Object obj, Object value) 调用者是指定字段（int score），
第一个参数是拥有调用者字段的对象（new Student），第二个参数是具体的字段值*/
//动态：运行过程中 反射就是在运行中才能起作用
System.out.println("o = " + o);
field.set(o, 98);
System.out.println("o = " + o);
}
}（七）获取类中的成员方法并且执行
1、通过Class类中：
getMethod(String methodName, Class...paramTypes)
参数列表：methodName表示方法名称，paramTypes表示参数列表的数据类型
返回值类型：Method
2、Method类型：
（1）表示成员方法的类型，该类型的每个对象，都是一个具体的成员方法
（2）成员方法对象的方法：获取成员方法信息（方法的注解、方法的修饰
符、方法的返回值类型、方法的名称、方法的参数）3、其中，最重要的一个方法，就是该方法的执行：
invoke(Object obj, Object...values)
在obj对象上，执行该方法，使用的实际参数是values
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Demo05_GetMethod {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
//通过反射获取类的方法并操作
/*
getMethod(String name, Class<?>... parameterTypes) 获取公共的方法
name：方法名称
parameterTypes：写明参数列表
*/
//1.获取类（的字节码对象）
Class<?> clazz = Class.forName("com.offcn.demos.Student");
//2.获取类的指定方法
Method method = clazz.getMethod("setName", String.class);
//3.创建对象，使用反射获取到的方法为这个对象指定的成员变量赋值
Object o = clazz.newInstance();
/*
invoke(Object obj, Object... args)
调用者：获取到的方法对象
第一个参数：要操作哪个对象
第二个参数：要为传入的参数
*/
System.out.println("o = " + o);
method.invoke(o, "老顽童");
System.out.println("o = " + o);
}
}（八）暴力反射（不推荐）
1、通过Class类中：
getDeclaredXxx方法：可以获取类中的所有声明的成员（属性、方法、内部
类），私有的成员也可以获取到。
2、修改该对象的访问权限：
成员变量、构造方法还是成员方法，都是AccessibleObject类型的子类，就
具有判断是否可以访问，和设置是否可以访问的方法
isAccessible()：判断当前对象是否可以访问
setAccessible(boolean flag)：设定当前对象是否可以访问
3、一旦设定当前对象可以访问，私有的成员也可以被访问，被修改