1. Java 的类加载器的种类都有哪些？

1、根类加载器(Bootstrap) --C++写的 ，看不到源码
2、扩展类加载器（Extension） --加载位置 ：jre\lib\ext 中
3、系统(应用)类加载器(System\App) --加载位置 ：classpath 中
4、自定义加载器(必须继承 ClassLoader)

2. 类什么时候被初始化？

1）创建类的实例，也就是 new 一个对象
2）访问某个类或接口的静态变量，或者对该静态变量赋值
3）调用类的静态方法
4）反射（Class.forName("com.lyj.load")）
5）初始化一个类的子类（会首先初始化子类的父类）
6）JVM 启动时标明的启动类，即文件名和类名相同的那个类
只有这 6 中情况才会导致类的类的初始化。
类的初始化步骤：
1）如果这个类还没有被加载和链接，那先进行加载和链接
2）假如这个类存在直接父类，并且这个类还没有被初始化（注意：在一个类加载器中，类只能初始化一
次），那就初始化直接的父类（不适用于接口）

3. 假如类中存在初始化语句（如 static 变量和 static 块），那就依次执行这些初始化语句。

3. Java 类加载体系之 ClassLoader 双亲委托机制

java 是一种类型安全的语言，它有四类称为安全沙箱机制的安全机制来保证语言的安全性，这四类安全
沙箱分别是：
1） 类加载体系
2） .class 文件检验器
3） 内置于 Java 虚拟机（及语言）的安全特性
4） 安全管理器及 Java API
主要讲解类的加载体系：
java 程序中的 .java 文件编译完会生成 .class 文件，而 .class 文件就是通过被称为类加载器的 ClassLoader
加载的，而 ClassLoder 在加载过程中会使用“双亲委派机制”来加载 .class 文件，先上图：

image.png

• BootStrapClassLoader： 启 动 类 加 载 器 ， 该 ClassLoader 是 jvm 在 启 动 时 创 建 的 ， 用 于 加载$JAVA_HOME$/jre/lib下面的类库（或者通过参数-Xbootclasspath 指定）。由于启动类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不能直接通过引用进行操作。
• ExtClassLoader：扩展类加载器，该ClassLoader是在sun.misc.Launcher里作为一个内部类ExtClassLoader
  定义的（即sun.misc.Launcher$ExtClassLoader），ExtClassLoader 会加载$JAVA_HOME/jre/lib/ext下的类库（或者通过参数-Djava.ext.dirs 指定）。
• AppClassLoader：应用程序类加载器，该 ClassLoader 同样是在 sun.misc.Launcher 里作为一个内部类
  AppClassLoader 定义的（即sun.misc.Launcher$AppClassLoader），AppClassLoader 会加载 java 环境变量CLASSPATH 所 指 定 的 路 径 下 的 类 库 ， 而 CLASSPATH 所 指 定 的 路 径 可 以 通 过System.getProperty("java.class.path")获取；当然，该变量也可以覆盖，可以使用参数-cp，例如：java -cp 路径 （可以指定要执行的 class 目录）。
• CustomClassLoader：自定义类加载器，该 ClassLoader 是指我们自定义的 ClassLoader，比如 tomcat 的StandardClassLoader 属于这一类；当然，大部分情况下使用 AppClassLoader 就足够了。

前面谈到了ClassLoader的几类加载器，而ClassLoader是用双亲委派机制来加载class文件的。ClassLoader
的双亲委派机制是这样的（这里先忽略掉自定义类加载器 CustomClassLoader）：
1）当 AppClassLoader 加载一个 class 时，它首先不会自己去尝试加载这个类，而是把类加载请求委派给父
类加载器 ExtClassLoader 去完成。
2）当 ExtClassLoader 加载一个 class 时，它首先也不会自己去尝试加载这个类，而是把类加载请求委派给
BootStrapClassLoader 去完成。
3）如果 BootStrapClassLoader 加载失败（例如在$JAVA_HOME$/jre/lib里未查找到该 class），会使用
ExtClassLoader 来尝试加载；
4）若 ExtClassLoader 也加载失败，则会使用 AppClassLoader 来加载，如果 AppClassLoader 也加载失败，则会报出异常 ClassNotFoundException。
下面贴下 ClassLoader 的 loadClass(String name, boolean resolve)的源码：

1．protected synchronized Class<?> loadClass(String name, boolean resolve)
2． throws ClassNotFoundException {
3． // 首先找缓存是否有 class
4． Class c = findLoadedClass(name);
5． if (c == null) {
6． //没有判断有没有父类
7． try {
8． if (parent != null) {
9． //有的话，用父类递归获取 class
10． c = parent.loadClass(name, false);
11． } else {
12． //没有父类。通过这个方法来加载
13． c = findBootstrapClassOrNull(name);
14． }
15． } catch (ClassNotFoundException e) {
16． // ClassNotFoundException thrown if class not found
17． // from the non-null parent class loader
18． }
19． if (c == null) {
20． // 如果还是没有找到，调用 findClass(name)去找这个类
21． c = findClass(name);
22． }
23． }
24． if (resolve) {
25． resolveClass(c);
26． }
27． return c;
28． }

代码很明朗：首先找缓存（findLoadedClass），没有的话就判断有没有 parent，有的话就用 parent 来递归
的 loadClass，然而 ExtClassLoader 并没有设置 parent，则会通过 findBootstrapClassOrNull 来加载 class，而
findBootstrapClassOrNull 则会通过 JNI 方法”private native Class findBootstrapClass(String name)“来使
用 BootStrapClassLoader 来加载 class。然后如果 parent 未找到 class，则会调用 findClass 来加载 class，findClass 是一个 protected 的空方法，可以覆盖它以便自定义 class 加载过程。

另 外 ， 虽 然 ClassLoader 加 载 类 是 使 用 loadClass 方 法 ， 但 是 鼓 励 用 ClassLoader 的 子 类 重写
findClass(String)，而不是重写 loadClass，这样就不会覆盖了类加载默认的双亲委派机制。

双亲委派托机制为什么安全?
举个例子，ClassLoader 加载的 class 文件来源很多，比如编译器编译生成的 class、或者网络下载的字节码。而一些来源的 class 文件是不可靠的，比如我可以自定义一个 java.lang.Integer 类来覆盖 jdk 中默认的 Integer类，例如下面这样：

1. package java.lang;
2. public class Integer {
3. public Integer(int value) {
4. System.exit(0);
5. }
6. }

初始化这个 Integer 的构造器是会退出 JVM，破坏应用程序的正常进行，如果使用双亲委派机制的话该Integer 类永远不会被调用，因为委托 BootStrapClassLoader 加载后会加载 JDK 中的 Integer 类而不会加载自定义的这个，可以看下下面这测试个用例：

1．public static void main(String... args) {
2． Integer i = new Integer(1);
3． System.err.println(i);
4． }

执行时 JVM 并未在 new Integer(1)时退出，说明未使用自定义的 Integer，于是就保证了安全性。

4. 描述一下 JVM 加载 class

JVM 中类的装载是由类加载器（ClassLoader）和它的子类来实现的，Java 中的类加载器是一个重要的 Java 运行时系统组件，它负责在运行时查找和装入类文件中的类。由于 Java 的跨平台性，经过编译的 Java 源程序并不是一个可执行程序，而是一个或多个类文件。当 Java 程序需要使用某个类时,JVM 会确保这个类已经被加载、连接（验证、准备和解析）和初始化。

类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class 文件，然后产生与所加载类对应的 Class 对象。加载完成后，Class 对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备（为静态变量分配内存并设置默认的初始值）和解析（将符号引用替换为直接引用）三个步骤。最后 JVM 对类进行初始化，包括：

• 如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；
• 如果类中存在初始化语句，就依次执行这些初始化语句。

类的加载是由类加载器完成的，类加载器包括：根加载器（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自定义类加载器（java.lang.ClassLoader的子类）。从 Java 2（JDK 1.2）开始，类加载过程采取了父亲委托机制（PDM）。PDM 更好的保证了 Java 平台的安全性，在该机制中，JVM 自带的 Bootstrap 是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM 不会向 Java 程序提供对 Bootstrap 的引用。
下面是关于几个类加载器的说明：

• Bootstrap：一般用本地代码实现，负责加载 JVM 基础核心类库（rt.jar）；
• Extension：从 java.ext.dirs 系统属性所指定的目录中加载类库，它的父加载器是 Bootstrap；
• System：又叫应用类加载器，其父类是 Extension。它是应用最广泛的类加载器。它从环境变量 classpath
  或者系统属性 java.class.path 所指定的目录中记载类，是用户自定义加载器的默认父加载器。

5. 获得一个类对象有哪些方式？

类型.class，例如：String.class
对象.getClass()，例如：”hello”.getClass()
Class.forName()，例如：Class.forName(“java.lang.String”)