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