java 语言 程序分析题_JAVA语言中类的实例化过程变量的初始化顺序讲解，附常见笔试程序阅读题分析...

本文主要向大家介绍了JAVA语言中类的实例化过程变量的初始化顺序讲解，附常见笔试程序阅读题分析，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。

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

类加载：

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

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

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

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

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

这一句的执行结果为：

基类initPrint2 静态变量s4:null

基类静态方法sMethodBase 静态变量s4：基类静态变量s4

创建对象：

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

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

进入构造器时，如果有基类，会进入基类的无参构造器(或者用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);

}

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注编程语言JAVA频道！