类是在任何static成员被访问时加载的（构造器也是static方法）。类的整个加载过程包括加载、验证、准备、解析、初始化5个阶段。我这里只讨论我们在笔试题中比较关心的、影响程序输出的部分。

类加载：

在准备阶段，static变量在方法区被分配内存，然后内存被初始化零值（注意和static变量初始化的区别）。

在初始化阶段，执行类构造器<clinit>()方法（注意和实例构造器<init>()方法不同）。虚拟机会保证子类的<clinit>()方法执行之前，父类的<clinit>()方法已经执行。

在执行<clinit>()方法时，按照类定义中static变量的赋值语句和static代码段的书写顺序，依次执行。

子类调用基类的静态方法时，相当于基类调用自己的静态方法，所以子类的static不会初始化。例子如下：

Child.sMethodBase(); // 类的定义在最后面

这一句的执行结果为：

基类initPrint2 静态变量s4:null
基类静态方法sMethodBase 静态变量s4：基类静态变量s4

创建对象：

虚拟机在遇到new指令时，首先检查类是否加载过，在类加载检查通过后，虚拟机为对象分配内存，分配完内存后会将内存空间初始化为零值（不包括对象头）。所以对象的实例字段在初始化之前就有了零值。

执行new指令之后会接着执行实例构造器<init>方法，这时才开始对象的初始化。

进入构造器时，如果有基类，会进入基类的无参构造器（或者用super()显式指定的基类构造器）。在构造之前，先按照实例字段和非static代码段的书写顺序，依次初始化，最后执行构造器的语句。

super()语句要按基类的次序，放在构造器最前面，否则编译器会报错。

创建子类对象的例子如下：

Child child = new Child("s");

输出结果为：

基类initPrint2 静态变量s4:null
子类initPrint2 静态变量s2:null
基类initPrint1 实例变量s3:null
基类initPrint1 静态变量s4:基类静态变量s4
基类构造器 int i
子类initPrint1 实例变量s1:null
子类initPrint1 静态变量s2:子类静态变量s2
子类构造器

可见，确实是先加载类（第1、2行发生在static变量的初始化阶段），然后再创建对象（第3行及以后）。创建的过程也是从父类到子类，先是非static变量的初始化（初始化前已经有默认值了，如第3行和第6行所示），然后执行构造器语句。

上面用到的类的定义如下：

class Base {
    private int x3 = initPrint1();
    public String s3 = "基类实例变量s3";
 
    private static int x4 = initPrint2();
    private static String s4 = "基类静态变量s4";
 
    private int initPrint1() {
        System.out.println("基类initPrint1 实例变量s3:" + s3);
        System.out.println("基类initPrint1 静态变量s4:" + s4);
        return 11;
    }
 
    private static int initPrint2() {
        System.out.println("基类initPrint2 静态变量s4:" + s4);
        return 21;
    }
 
    public Base(int i) {
        System.out.println("基类构造器 int i");
    }
 
    public void callName() {
        System.out.println(s3);
    }
 
    public static void sMethodBase() {
        System.out.println("基类静态方法sMethodBase 静态变量s4："+s4);
    }
}

class Child extends Base {
    private int x1 = initPrint1();
    public String s1 = "子类实例变量s1";
 
    private static int x2 = initPrint2();
    private static String s2 = "子类静态变量s2";
 
    private int initPrint1() {
        System.out.println("子类initPrint1 实例变量s1:" + s1);
        System.out.println("子类initPrint1 静态变量s2:" + s2);
        return 11;
    }
 
    private static int initPrint2() {
        System.out.println("子类initPrint2 静态变量s2:" + s2);
        return 21;
    }
 
    public Child(String s) {
        super(1);
        System.out.println("子类构造器");
    }
 
    public void callName() {
        System.out.println(s1);
    }
 
    public static void sMethodChild() {
        System.out.println("子类静态方法sMethodChild 静态变量s2:"+s2);
    }
}

方法和字段的重写

另一个基础的问题是子类对父类的override。

方法的重写有运行时绑定的效果，子类实例如果重写了基类的方法，即使向上转型为基类，调用的仍是子类的方法。而且在方法中的字段也会优先认为是子类的字段。

但是字段并没有运行时绑定一说，向上转型后调用的就是基类的字段。

同时静态方法与类关联，并不是与单个对象关联，它也没有运行时绑定。

class Base {
    public String s1 = "基类实例变量s1";
    private static String s2 = "基类静态变量s2";
 
    public void f() {
        System.out.println("基类方法");
    }
 
}
 
class Child extends Base {
    public String s1 = "子类实例变量s1";
    private static String s2 = "子类静态变量s2";
 
    public void f() {
        System.out.println("子类方法");
    }
}

对于上面的两个类，当如下使用时：

        Child child = new Child();
        System.out.println(((Base)child).s1);
        ((Base)child).f();

输出的结果为：

基类实例变量s1
子类方法

需要补充说明的是，private的方法虽然可以重写，但已经不是传统意义上的override，因为父类的private方法对子类不可见，所以子类重写的函数被认为是新函数，在父类函数中将子类向上转型时，调用的仍是父类的private方法，这是在类加载的解析阶段就确定的。

class Base {
    public String s1 = "基类实例变量s1";
 
    private void f() {
        System.out.println("基类方法");
    }
 
    public static void main(String[] args) {
        Child child = new Child();
        System.out.println(((Base)child).s1);
        ((Base)child).f();
 
    }
 
}
 
class Child extends Base {
    public String s1 = "子类实例变量s1";
 
    public void f() {
        System.out.println("子类方法");
    }
}

Base的main函数运行结果为：

基类实例变量s1
基类方法

解析阶段中确定唯一调用版本的方法有static方法、private方法、实例构造器和父类方法4类，满足“编译器可知，运行期不变”的要求。

综合题

最后我们来看一道牛客网上的题目：

public class Base
{
    private String baseName = "base";
    public Base()
    {
        callName();
    }
 
    public void callName()
    {
        System. out. println(baseName);
    }
 
    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }
    public static void main(String[] args)
    {
        Base b = new Sub();
    }
}

程序的输出结果是什么呢？

5
4
3
2
1

null (子类重写了父类的public方法，public实例方法属于运行时绑定的方法，实际调用时，传入的this引用的是一个子类对象，所以定位到了子类的函数，而父类构造时，子类还未构造，子类实例变量还没有初始化，为零值)。如果将Base里面的public callName()修改为private callName()结果会是什么呢？

5
4
3
2
1

base(子类并没有真正重写父类的callName()方法，它们是两个不同的方法，private方法在类加载阶段解析，满足“编译器可知，运行期不变”的要求，和调用者的实际类型无关，根据上下文信息，父类构造器中的方法被指定为父类中的私有方法)。