原文： http://blog.chinaunix.net/uid-21227800-id-65873.html
Java在需要使用类的时候，才会将类加载，Java的类加载是由类加载器来完成的。
当在命令行模式下执行java XXX.class指令后，java运行程序会尝试找到JRE安装的所在目录，然后寻找jvm.dll(默认是在JRE目录下bin\client目录中)，
接着启动JVM并进行初始化动作，产生Bootstrap Loader, Bootstrap Loader会加载Extended Loader，并设定Extende Loader的parent为Bootstrap Loader。接着Bootstrap Loader会加载System Loader，并将System Loader的parent设定为Extended Loader。
Bootstrap Loader通常由C编写而成，
Extended Loader是由Java编写而成，实际是对应于 sun.misc.LauncherAppClassLoader(Launcher中的内部类)。
Bootstrap Loader会搜索系统参数sun.boot.class.path中指定位置的类，默认是JRE所在目录的classes下的.class文件，或lib目录下.jar文件中（如tr.jar）的类并加载。
可用System.getProperty("sun.boot.class.path")来显示sun.boot.class.path中指定的路径。
Extended Loader是由Java编写而成，会搜索系统参数java.ext.dirs中指定位置的类，默认是JRE目录下的lib\ext\classes目录下的.class文件，或lib\ext目录下的.jar文件中的类并加载。
System Loader是由java编写而成，会搜索系统参数java.class.path中指定位置的类，也就是Classpath所指定的路径，默认是当前工作路径下的.class文件。
在加载类时，每个类加载器会先将加载类的任务交给其parent，如果parent找不到，再由自己负责加载。所以在加载类顺序为：Bootstrap Loader ——> Extended Loader ——> System Loader的顺序来寻找类，若都找不到，会抛出NoClassDefFoundError.
类加载器在Java中是以java.lang.ClassLoader类型存在，每一个类被加载后，都会有一个Class的实例来代表，而每个Class的实例都会记得自己是由哪个ClassLoader加载的。可以由Class的getClassLoader()取得加载该类的ClassLoader，而从ClassLoader的getParent()方法可以取得自己的parent。
我们把test1文件放在D：\盘根目录下
例子：
public class test1 {
public static void main(String args[]){
test1 t = new test1();
Class c = t.getClass();
ClassLoader loader = c.getClassLoader();
System.out.println(loader);
System.out.println(loader.getParent());
System.out.println(loader.getParent().getParent());
}
}
结果
sun.misc.Launcher$AppClassLoader@197d257
sun.misc.Launcher$ExtClassLoader@7259da
null
依次以Bootstrap Loader ——> ExtClass Loader ——> AppClass Loader的顺序来寻找类，由于前两者都找不到，最后在Classpath中找到了类并加载。此时，它的Classloader就是AppClassLoader,而其parent为ExtClassLoader,再parent为BootstrapLoader，由于BootStrapLoader是C语言写的，所以此处为null。
如果我们把test1.java放在lib\ext\classes下，
因为此时的class可在ExtClassLoader的设定路径下找到，所以会由ExtClassLoader来加载test1类，而其parent肯定为null了，再取parent报错了。
Class.forName()和classloader.loadClass()的比较
测试代码：
Test.java
package ying;
public class test {
static{
System.out.println("静态代码块运行");
int x=1;
}
public test(){
System.out.println("构造方法运行");
}
}
Main.java
package ying;
public class main {
public static void main(String args[]) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
//ClassLoader loader=test.class.getClassLoader();
//可以用别的classloader来load其他类
ClassLoader loader = main.class.getClassLoader();
/*
System.out.println("before load");
Class c=loader.loadClass("ying.test");
System.out.println("after load");
System.out.println("------华丽的-----------------------分割线-----");
System.out.println("before load newInstance");
test t=(test) c.newInstance();
System.out.println("after load newInstance");*/
System.out.println("before forName");
Class c2 = Class.forName("ying.test");
System.out.println("after forName");
c2.newInstance();
System.out.println("------华丽的-----------------------分割线-----");
System.out.println("before forName false");
Class c3 = Class.forName("ying.test", false, loader);
System.out.println("after forName false");
c3.newInstance();
}
}
此时时调用Class.forName，结果如下：
before forName
静态代码块运行
after forName
构造方法运行
------华丽的-----------------------分割线-----
before forName false
after forName false
构造方法运行
可以看出Class.forName(String className)方法默认是加载静态代码块的，而它的另一个方法Class.forName(String className,boolean initialize,ClassLoader loader)则可以控制是否调用静态代码块。Class.forName只是让类加载，并没有把类初始化，只有当调用newInstance时才初始化类，调用构造方法等。
调用ClassLoader时：
package ying;
public class main {
public static void main(String args[]) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
//ClassLoader loader=test.class.getClassLoader();
//可以用别的classloader来load其他类
ClassLoader loader = main.class.getClassLoader();
System.out.println("before load");
Class c = loader.loadClass("ying.test");
System.out.println("after load");
System.out.println("------华丽的-----------------------分割线-----");
System.out.println("before load newInstance");
test t = (test) c.newInstance();
System.out.println("after load newInstance");
/* System.out.println("before forName");
Class c2=Class.forName("ying.test");
System.out.println("after forName");
c2.newInstance();
System.out.println("------华丽的-----------------------分割线-----");
System.out.println("before forName false");
Class c3=Class.forName("ying.test",false, loader);
System.out.println("after forName false");
c3.newInstance();*/
}
}
结果：
before load
after load
------华丽的-----------------------分割线-----
before load newInstance
静态代码块运行
构造方法运行
变量a初始化1
after load newInstance
可见，当我们用ClassLoader进行类加载时，不会调用静态代码块，相当于Class.forName的第二个方法，只有在newInstance时才调用静态代码块——>初始化变量——>调用构造方法——>生成类实例。
事实上，JVM在加载类时，需要经过如下几个步骤。
- 加载——找到相应的class字节码文件，读入JVM
- 链接——包括进行验证，准备和解析
a) 验证： 确信引入类型的正确性，即class是否符合java规范并且不会损害JVM的完整性。
b) 准备： 为类变量分配内存同时设置默认初始值，如上例中加载test时，会初始化a=0;x=0;
c) 解析（可选）：根据loadClass方法的第二个参数来判断是否需要解释。解析是把符号引用转为直接引用的过程，如原来JVM知道类test中有一个成员叫"a"，通过解析则知道了该成员的地址是0xBBEDF，以后使用这个成员时，就直接去这个内存地址去找了。同时这个阶段，类的其他方法也会被映射到某个内存地址以待调用。 - 初始化——激活类变量的初始化java代码。 利用类定义的java代码确定成员变量的初值（若没有相应的java代码对其进行初始赋值操作，则会沿用准备阶段获得的该类型默认值），在这个阶段，所有的静态代码都会被执行，事实上，类在编译时期编译器会把这些静态代码封装到一个方法中去，在使用这个类的时候，初始化过程就会调用这个方法。这个方法程序员不能调用，只能被JVM调用。
事实上，ClassLoader也有两种方法，只是第二个带参数的方法是受保护的。
如下：
protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException
{
// 首先检查该name指定的class是否有被加载
Class c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
//如果parent不为null，则调用parent的loadClass进行加载
c = parent.loadClass(name, false);
} else {
//parent为null，则调用BootstrapClassLoader进行加载
c = findBootstrapClass0(name);
}
} catch (ClassNotFoundException e) {
//如果仍然无法加载成功，则调用自身的findClass进行加载
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
而用户使用的是一个参数的方法，而一个参数的方法实际调用了两个参数的方法，第二个，因此在这里可以看出通过loadClass加载类实际上就是加载的时候并不对该类进行解释，因此也不会初始化该类。而Class类的forName方法则是相反，使用forName加载的时候就会将Class进行解释。
例子：JDBC Driver的加载，网上都说JDBC驱动是通过DriverManager，必须在DriverMangaer中注册，如果驱动类没被初始化，则不能注册到DriverManager中，因此必须用forName而非loadClass。事实上这种说法是错误的，forName并没有把类初始化，类的初始化只能通过两种方式：
a) 隐式：使用New关键字，new一个对象
b) 显示：通过class的New Instance方法。
事实上forName和loadClass的区别也就在于那个"解释"的过程是否调用。ForName调用了，loadClass没调用，如此而已。
大家可以看下DriverManger的源码：
private static void loadInitialDrivers() {
String drivers;
try {
drivers = (String) java.security.AccessController.doPrivileged(
new sun.security.action.GetPropertyAction("jdbc.drivers"));
} catch (Exception ex) {
drivers = null;
}
println("DriverManager.initialize: jdbc.drivers = " + drivers);
if (drivers == null) {
return;
}
while (drivers.length() != 0) {
int x = drivers.indexOf(':');
String driver;
if (x < 0) {
driver = drivers;
drivers = "";
} else {
driver = drivers.substring(0, x);
drivers = drivers.substring(x+1);
}
if (driver.length() == 0) {
continue;
}
try {
println("DriverManager.Initialize: loading " + driver);
Class.forName(driver, true, ClassLoader.getSystemClassLoader());
} catch (Exception ex) {
println("DriverManager.Initialize: load failed: " + ex);
}
}
}
我们发现，其内部其实也是调用了 forName 方法。
LoadClass（）方法加载类及初始化过程：
类加载（loadclass（））（加载）——>newInstance（）（链接+初始化）
newInstance（）:
（开始连接）静态代码块——>普通变量分配准备（a=0;b=0;c=null）——>（开始初始化）普通变量赋值（a=1;b=2;c="haha"）——>构造方法——>初始化成功。
Class.forName(Stirng className)一个参数方法加载类及初始化过程：
类加载(Class.forName())（加载）——>静态代码块——>newInstance（）（链接+初始化）
newInstance（）：
（开始连接）普通变量分配准备（a=0;b=0;c=null）——>（开始初始化）普通变量赋值（a=1;b=2;c="haha"）——>构造方法——>初始化成功。
Class.forName()三个参数的加载类及初始化过程同classLoader一样。
从上边的断点调试可以看出，静态代码块不是在初始化阶段完成的，它陷于类初始化，先于普通变量默认分配（整型分配为0，字符串分配为null），这也就是为什么我们不能在静态代码块中引用普通变量的原因之一，这与上面所谓的"分配"、"初始化"相违背。
所以我觉得JVM的类加载及初始化过程应该是这样的。
- 类加载：Bootstrap Loader——>Extended Loader——>System Loader
- 静态代码块初始化
- 链接：
a) 验证：是否符合java规范
b) 准备：默认初始值
c) 解析：符号引用转为直接引用，解析地址 - 初始化
a) 赋值：java代码中的初始值
b) 构造:构造函数
因此ClassLoader.loadClass(String className)和Class.forName(String className)两者的区别就一目了然了。如下：
而loadClass直接就干"加载类"的这些事，不干多余的事儿。
而class.forName默认是老好人，就把加载静态代码块的工作也一并做了。但是又有一个带3个参数的方法，用来决定静态代码块的位置变化，加载（true）的话就把的位置提到"类加载"部分，不加载（false）的话就把它的位置滞后到newInstance的时候。
