在Java中最重要的可以说就是类的加载了。不论我们编写的功能多么复杂，或是多么简单，永远逃离不开的，就是将这个类从class文件加载到JVM中来。
类的加载过程
首先我们要了解一下类的加载过程，包括：加载、连接（验证、准备、解析）、初始化、使用、卸载。
加载：将根据类的全限定名找到对应的Class文件，将它加载进JVM中，并生成Class对象保存在堆中。
连接：
验证：检查加载进来的类信息是否满足我们JVM的规范。
准备：对类中的静态变量分配内存空间，并赋予原始值。对常量直接赋予指定的值。
解析：将类中的符号引用转变为直接引用。
初始化：为类中的静态变量赋值，执行静态代码块。
下面我们用一个类来验证一下：
public class Main7 {
private final int z = ;
private final static int k = ;
private static int i = ;
private int j = ;
static {
i = ;
}
{
i = ;
j=;
}
public static void main(String[] args) {
}
}
如上，我们定义一个Main7类，并对类中的每一步都打上断点：
然后点击debug运行：
第一步：程序最先进入到第9行代码，此时查看我们最下面的静态成员中，k由于是final static，被直接赋予了我们给它指定的值1。而i由于只是一个static，它被先赋予了默认值0。至于我们其他的两个变量z和j，此时是没有被初始化的。
注意：第八行代码在我们的程序运行中并没有被debug进入断点，但是实际上它是最先和i一起被初始化的。即说明，加载和连接两个步骤，是无法被我们的debug进入的。我们这里能进入断点的，也仅仅只是初始化步骤。(第九行之所以能进入是因为我们对i赋予了i=5，如果我们只定义static int i，则这行也不会被进入debug)
第二步：执行静态代码块。
第三步：结束。
由于我们的main方法中并没有内容，因此我们不会创建任何自定义类的对象。Main7中的static变量与static代码块之所以会被初始化，也是因为这是作为main方法所在的类，会被加载进JVM。
总结：由上面的结果可以总结如下几点：
1.类只会在第一次被调用时候进行加载。这个调用包括Main方法所在的类、调用类中的静态成员变量、执行类的静态方法、通过反射创建对象、new一个对象、子类被初始化。
2.类的加载不会初始化非static变量，也不会执行非static代码块。
类加载器
JDK默认给我们提供了三个类加载器：
BootStrap ClassLoad：最*的类加载器，使用C++编写，由JVM启动，默认加载%JAVA_HOME%/lib下的jar包和类。
Extension ClassLoad：扩展加载器，由BootStrap ClassLoad启动，父类加载器是BootStrap ClassLoad，默认加载%JAVA_HOME%/lib/ext下的jar包和类。
Application ClassLoad：应用加载器，由BootStrap ClassLoad启动，父类加载器是Extension ClassLoad。默认加载classpath下的jar包和类。
关系图如下：
我们查看一个自定义类的加载类：
public static void main(String[] args) {
ClassLoader cl = Main7.class.getClassLoader();
while (cl != null) {
System.out.println(cl.toString());
cl = cl.getParent();
}
}
打印结果：
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@77459877
可以看到，上面只打印出来了两个ClassLoader对象，一个是AppClassLoader，这是自定义类的加载器，另一个是ExtClassLoader，这是自定义类加载器的父类加载器。
而我们再次通过getParent()方法获取ExtClassLoader对象的父类加载器时候，返回的结果等于null，因此跳出了循环。
我们再尝试一个由BootStrap ClassLoader加载的类String，查看它的类加载类
public static void main(String[] args) {
ClassLoader cl = String.class.getClassLoader();
System.out.println(cl == null ? "cl is null" : cl.toString());
}
打印结果：
cl is null
虽然BootStrap ClassLoader是ExtClassLoader的父类加载器，但是由于它是C++编写，因此在Java代码中，并没有任何的体现，如果一个类的类加载器是null，那么它就是由BootStrap ClassLoader启动。
下面我们来检验一下上面的说法，首先利用类加载器的双亲委派机制来确认。
双亲委派机制：类加载器加载一个类时，会先交由它的父类加载器加载，如果父类加载器的加载范围中有全限定名相同的类文件，则由父类加载器加载这个类，子类加载器不再加载。
意即：自定义加载器加载一个类Aclass，首先交给父类加载器AppClassLoader，AppClassLoader再交由它的父类加载器ExClassLoader，ExtClassLoader再交由它的父类加载器BootStrapClassLoader，BootStrapClassLoader没有父类加载器，因此检查自己的加载范围%JAVA_HOME%/lib下有没有这个类，没有则再由ExtClassLoader检查它的加载范围%JAVA_HOME%/lib/ext下有没有这个类，没有则再有AppClassLoader检查classpath下有没有这个类，没有则再交由自定义类加载器去它的路径下加载。其中一旦有一个类加载器找到这个类的class文件，就会由这个类加载器进行加载，它的子类加载器而不会在进行处理。
下面我们来查看一下类加载器(ClassLoader)的加载方法：
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
它这里接收一个全限定的二进制类名，然后调用loadClass(name,false)方法
// 这个protected可以看到，是允许我们通过自定义类加载器来重写这个方法。
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) { //这里加锁，每一次只会有一个类被加载进来。而不会同时加载多个类。
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name); //首先检查Class对象中是否已经包含了这个类。即这个类是否已经被加载过了。
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) { //首先判断父类加载器不等于null，也就是说父类加载器不是BootStrap ClassLoader
c = parent.loadClass(name, false); //交由父类加载器加载。双亲委派机制
} else {
c = findBootstrapClassOrNull(name); //否则的话，从BootStrapClassLoader中查找该类
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
} if (c == null) { //父类加载器中没有对应的class文件
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name); //调用findClass(name)从当前的类加载器中加载该类 // this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
从上面的代码里面可以看到，ClassLoader中明确指定了，当parent == null时，会调用findBootstrapClassOrNull(String)方法从BootStrapClassLoader中加载相关的类。
而且从ClassLoader的源码中我们也可以看到，如果我们要自定义自己的类加载器，只要继承ClassLoader，并重写loadclass(String)或findClass(String)方法即可。
下面我们来查看一下ClassLoader自带的findClass(String)方法。
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
可见，ClassLoader在这里采用了模版方法模式，将详细的加载类文件的方法交由它的子类去实现。
我们定义一个自定义类加载器
public class MyClassLoader extends ClassLoader {
// 加载器名称
private String name;
// 加载器的加载路径
private String path;
public MyClassLoader(String name, String path) {
super(); // 采用默认的父类加载器，即为调用它的类的类加载器。一般是appClassLoader
this.name = name;
this.path = path;
}
public MyClassLoader(ClassLoader classLoader, String name, String path) {
super(classLoader); //指定父类加载器
this.name = name;
this.path = path;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] bytes = readClassFile(name); //根据名称找到文件，并转为字节数组
return super.defineClass(name, bytes, , bytes.length); //将字节数组转为Class对象。
}
private byte[] readClassFile(String name) {
byte[] bytes = null;
InputStream is = null;
String filename = path + "/" + name.replaceAll("\\.", "/") + ".class";
File file = new File(filename);
ByteArrayOutputStream os = new ByteArrayOutputStream();
try {
is = new FileInputStream(file);
int tmp = ;
while ((tmp = is.read()) != -) {
os.write(tmp);
}
bytes = os.toByteArray();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (os != null) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return bytes;
}
}
我们定义一个用来被加载的测试类，将它编译后的class文件放在D://tmp目录下
public class Main5 {
Main5() {
System.out.println("Main5:" + this.getClass().getClassLoader().toString());
}
}
客户端调用代码
public class Main11 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
MyClassLoader mcl = new MyClassLoader("yxf", "d://tmp");
Class c = mcl.loadClass("Main5");
c.newInstance();
}
}
输出结果：
Main5:main11.MyClassLoader@5b2133b1
可见打印出来的类加载器正是我们自定义的MyClassLoader。
假如我们在classpath下同样也存放一个Main5的class对象。
再次运行我们的客户端调用代码，输出结果：
Main5:sun.misc.Launcher$AppClassLoader@18b4aac2
这一次由于双亲委派机制，我们Main5类被加载时使用的是AppClassLoader。
我们修改一下客户端代码：
public class Main11 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
MyClassLoader mcl = new MyClassLoader(null, "yxf", "d://tmp"); //指定了父类加载器null，即BootStrapClassLoader
Class c = mcl.loadClass("Main5");
c.newInstance();
}
}
再次运行，输出结果：
Main55:main11.MyClassLoader@5b2133b1
这一次是由于我们给自定义的类加载器指定了它的父类加载器BootStrapClassLoader，因此，即使我们在classpath下存放了一个Main5.class，也不会调用到AppClassLoader中去。