Java变量初始化顺序-优快云博客

Java初始化变量顺序

作者：RednaxelaFX
链接：https://www.zhihu.com/question/36643366/answer/68519999
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

从Java SE 6开始是这样的：

public class MyClass {
  private int a = 1; // field declaration with initializer
    
  {
    // instance initializer 1
    a = 2;
  }
    
  public MyClass() {
    // constructor
    a = 4;
  }
    
  {
    // instance initializer 2
    a = 3;
  }

}

这个MyClass的构造器从Java语言层面看就是 public MyClass() { ... } 的部分。不过对JVM来说所有实例初始化动作都要收集到“特殊的实例初始化方法”（名为“<init>”，内容对应所有实例初始化器+构造器）里，所以上面的代码从JVM的角度看会是这样：

public class MyClass {
  private int a;

  public void <init>() {
    // implicit superclass constructor call
    super();
    // field initializer
    a = 1;
      
    // instance initializer 1
    a = 2;
      
    // instance initializer 2
    a = 3;
      
    // explicit constructor
    a = 4;

  }
}

这个合成的 <init>()V 里，先是构造器里隐式或显式的 super() 调用，然后是按代码顺序把实例初始化动作（包括实例字段初始化与匿名的实例初始化器）收集起来，然后是构造器自身的内容。

final 属性的初始化

附:

如果属性被 final 修饰, 在以上四个地方都可以初始化, 否则默认为 null .

final :

基本类型值恒定不变, static final 的属性占据不可变的储存空间
引用类型引用恒定不变, 但是对象本身可以被修改

Java语言规范里对构造器中 super() 调用的位置的限制其实颇为鸡肋。一来可以通过上述方式通过写字段初始化或实例初始化器来在 super() 前执行代码，二来就算不用它们而只用普通的构造器也还是可以在 super() 前执行代码，只要 super() 可以接受至少一个参数——做法如下：

public class Derived extends Base {
  public Derived() {
    super(foo()); // assuming there's a Base(int) constructor
    System.out.println("Derived ctor");
  }

  private int foo() {
    System.out.println("foo!"); // arbitrary side effect
    return 42;
  }
}

只要基类有接受至少一个参数的构造器，子类的构造器在调用super()时就可以调用任意方法去提供那个参数的值，于是就可以在真的调用super()前产生任意的副作用了。

示例:

public class c1 {
	public String s = "AAAA";
	 //父类构造函数
	public c1() {
		call();
	}
	public void call() {
		System.out.println(s);
	}
    public static void main(String[]args){
		c1 c=new c2();
	}
 
}
class c2 extends c1{
	public String s="BBBB";
	//子类构造函数
	public c2(){
		System.out.println(s);
	}
	//重写父类中的call函数
	public void call(){
		System.out.println(s);
	}
}

输出:

null
BBBB

执行顺序:

执行 c1 c=new c2(); 语句时:

初始化 c2 类 → 声明 c2中的 s (未赋值)→ 调用 super() → 初始化父类 c1 → 声明 c1 中的 s (未赋值) → 给 c1 中的 s 赋值为 AAA → 执行 c1 的构造器 → 因为 call() 被重写, 调用 c2 中的 call() → c2 中的 s 未赋值, 所以输出 null → c2 初始化完成 → c1 中的 s 赋值为 BBB → 执行 c2 构造器 → 输出 BBB