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

类是在任何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);

 }

<div class="line number14 inde    

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