类是在任何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方法在类加载阶段解析，满足“编译器可知，运行期不变”的要求，和调用者的实际类型无关，根据上下文信息，父类构造器中的方法被指定为父类中的私有方法)。
