一、类加载做了哪些事？

之前没有进行类加载
1.类加载,同时初始化类中静态的属性(赋默认值)
2.执行静态代码块
3.分配内存空间,同时初始化非静态的属性(赋默认值)
4.如果声明属性的同时有显示的赋值,那么进行显示赋值把默认值覆盖
5.执行匿名代码块
6.执行构造器
7.返回内存地址

二、类加载的顺序

1.static 变量
2.static 代码块
3.成员变量
4.匿名块
5.构造器
ps:先加载父类,再加载子类;

三、一个具体说明的例子

其中D继承C，C继承B，E,F是单独的类，主方法在ExaminationDemo 中。

public class ExaminationDemo {
    public static void main(String[] args) {
        System.out.println("1运行 ExaminationDemo 中的 main 函数， 创建 D 类实例");
        new D();
    }
}
class E {
    // E的构造器
    E() {
        System.out.println("8执行 E 的构造函数");
    }
    // E的普通成员方法
    public void funcOfE() {
        System.out.println("12执行 E 的函数");
    }
}
class F {
    // F的构造器
    F() {
        System.out.println("2执行 F 的构造函数");
    }
    // F的普通成员方法
    public void funcOfF() {
        System.out.println("4执行 F 的函数");
    }
}
class B {
    //new了一个E对象
    E e = new E();
    //B的静态成员变量
    static F f = new F();
    //B的普通成员变量
    public String sb = getSb();
    //B的静态代码块
    static {
        System.out.println("3执行 B 类的 static 块(B 包含 E 类的成员 变量,包含静态 F 类成员变量)");
        f.funcOfF();
    }
    //B的匿名代码块
    {
        System.out.println("10执行 B 实例的普通初始化块");
    }
    //B的构造器
    B() {
        System.out.println("11执行 B 类的构造函数(B 包含 E 类的成员变 量,包含静态 F 类成员变量)");
    }
    //B的普通成员方法
    public String getSb() {
        System.out.println("9初始化 B 的实例成员变量 sb");
        return "sb";
    }
}
class C extends B {
    // C的静态代码块
    static {
        System.out.println("5执行 C 的 static 块(C 继承 B)");
    }
    // C的匿名代码块
    {
        System.out.println("13执行 C 的普通初始化块");
    }
    // C的构造器
    C() {
        System.out.println("14执行 C 的构造函数(C 继承 B)");
    }
}
class D extends C {
    // D的静态成员变量
    public String sd1 = getSd1();
    // D的普通成员变量
    public static String sd = getSd();
    // D的静态代码块
    static {
        System.out.println("7执行 D 的 static 块(D 继承 C)");
    }
    // D的匿名代码块
    {
        System.out.println("16执行 D 实例的普通初始化块");
    }
    // D的构造器
    D() {
        System.out.println("17执行 D 的构造函数(D 继承 C);父类 B 的实 例成员变量 sb 的值为：" + sb + ";本类 D 的 static 成员变量 sd 的值为：" + sd
                + "; 本类 D 的实例成员变量 sd1 的值是：" + sd1);
    }
    // D的静态成员方法（调用时才加载）
    static public String getSd() {
        System.out.println("6初始化 D 的 static 成员变量 sd");
        return "sd";
    }
    // D的普通成员方法
    public String getSd1() {
        System.out.println("15初始化 D 的实例成员变量 sd1");
        return "sd1";
    }
}

从上面的代码我们可以看出，加载主方法时，先执行了输出语句，然后是new D（），由此进行加载顺序的分析。

执行结果如下:

/*
 * 1运行 ExaminationDemo 中的 main 函数， 创建 D 类实例 
 * 2执行 F 的构造函数 
 * 3执行 B 类的 static 块(B 包含 E类的成员 变量,包含静态 F 类成员变量) 
 * 4执行 F 的函数 
 * 5执行 C 的 static 块(C 继承 B) 
 * 6初始化 D 的 static 成员变量sd 
 * 7执行 D 的 static 块(D 继承 C) 
 * 8执行 E 的构造函数 
 * 9初始化 B 的实例成员变量 sb 
 * 10执行 B 实例的普通初始化块
 * 11执行 B 类的构造函数(B 包含 E 类的成员变 量,包含静态 F 类成员变量) 
 * 13执行 C 的普通初始化块 
 * 14执行 C 的构造函数(C 继承B) 
 * 15初始化 D 的实例成员变量 sd1 
 * 16执行 D 实例的普通初始化块 
 * 17执行 D 的构造函数(D 继承 C);父类 B 的实 例成员变量 sb的值为：sb;本类 D 的 static 成员变量 sd 的值为：sd; 本类 D 的实例成员变量 sd1 的值是：sd1
 */

这个结果是怎么来的，看下图：

总体上还是按照二的加载顺序来的，需要注意的是，当遇到子父类时，加载顺序是：

父类的静态成员变量，静态代码块——>子类的静态成员变量，静态代码块——>父类的普通成员变量，匿名代码块，构造器

——>子类的普通成员变量，匿名代码块，构造器

静态变量，和静态代码块的顺序先后，主要看谁先写，先写的先加载

new对象和成员变量的顺序，谁写在前面就先加载谁（我理解的是两者都属于成员变量）

成员方法不调用就不加载

而，当成员变量是方法时，就要调用该方法。

无论是静态成员方法，还是普通成员方法，只有在调用时才被加载

四、类加载前和加载后的执行顺序（转自http://blog.csdn.net/mrzhoug/article/details/51581994）

如果类还没有被加载：
1、先执行父类的静态代码块和静态变量初始化，并且静态代码块和静态变量的执行顺序只跟代码中出现的顺序有关。
2、执行子类的静态代码块和静态变量初始化。
3、执行父类的实例变量初始化
4、执行父类的构造函数
5、执行子类的实例变量初始化
6、执行子类的构造函数

如果类已经被加载：
则静态代码块和静态变量就不用重复执行，再创建类对象时，只执行与实例相关的变量初始化和构造方法。