Java类创建过程与初始化顺序

最近翻书，看到这个Java初始化与类创建过程挺有意思的，动手试了试，才知道初始化非静态方法还有直接{}这种语法

class Apple {
	public Apple(int i) {
		System.out.println("Apple(" + i + ")");
	}
}

class Apples {
	private Apple apple1 = new Apple(11);
	private static Apple apple_s1 = new Apple(1111);
	{
		apple1 = new Apple(1);
		apple2 = new Apple(2);
		System.out.println("apple1 and apple2 initialized!");
	}
	private Apple apple2 = new Apple(22);;
	static {
		apple_s1 = new Apple(111);
		apple_s2 = new Apple(222);
	}
	private static Apple apple_s2 = new Apple(2222);

	public Apples() {
		System.out.println("Apples()");
	}

	public static void print(int i) {
		System.out.println("Static fun(" + i + ")!");
	}
}

public class Initial {
	public static void main(String[] args) {
		System.out.println("inside");
		Apples.print(1000);
		System.out.println("Static fun completed");
		new Apples();
		System.out.println("new Apples() completed");

	}
}

Output:

inside
Apple(1111)
Apple(111)
Apple(222)
Apple(2222)
Static fun(1000)!
Static fun completed
Apple(11)
Apple(1)
Apple(2)
apple1 and apple2 initialized!
Apple(22)
Apples()
new Apples() completed

static 变量在首次用到类方法或首次初始化类的时候会进行初始化，按照变量在类中的顺序进行初始化。

非静态变量在初始化类的时候调用，初始化赋值顺序也是按照类中顺序进行。({}与static{}与变量顺序排序）

总结下对象的创建过程，例如Apple：

1）及时没有显示地使用static关键字，构造器实际上也是静态方法。因此，当首次创建类型为Apple时（构造器看成静态方法），或者Apple类的静态方法/静态域首次被访问时，Java解释器必须查找类路径，定位Apple.class文件。

2）然后载入Apple.class，有关静态初始化的所有动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。

3）当用new Apple（）创建对象的时候，首先将在堆上为Apple对象分配足够的存储空间。

4）这块存储空间会被清零，这就自动得将Apple对象中的所有基本类型数据都设置成了默认值（boolean为false），引用则被设置成null。

5）执行所有出现于字段定义处的初始化动作。

6）执行构造器。

更新：

碰到一个新问题：

public class Test {
	public static void main(String[] args) {
		new B();
	}
}
class A{
	int i=20;
	public A(){
		print();
	}
	public void print(){
		System.out.println("A:"+i);
	}
}
class B extends A{
	int i=30;
	public B(){
		print();
	}
	public void print(){
		System.out.println("B:"+i);
	}
}

输出什么呢

肯定知道第二行要输出 “B:30”；

那第一行呢，A的print()为java默认的virtual，那么要输出“B：”那A中的i=20起作用了么？

第一行是输出“B:0”，“B：20”还是“B：30”呢

答案是

B:0
B:30

理由呢，思考下

想了下，没想出原因，试着改改输出，改成这样

public class Test {
	public static void main(String[] args) {
		new B();
	}
}

class A {
	int i=a();
	public A(){
		System.out.println("A()");
		print();
	}
	public int a(){
		System.out.println("a");
		return 20;
	}
	public void print(){
		System.out.println("A:"+i);
	}
}
class B extends A{
	int i=b();
	public B(){
		System.out.println("B()");
		print();
	}
	public int b(){
		System.out.println("b");
		return 30;
	}
	public void print(){
		System.out.println("B:"+i);
	}
}

输出：

a
A()
B:0
b
B()
B:30

说明class A中的int i = a()；这句话调用了，而且是在A的构造函数之前，那么为什么A的构造函数中输出的i是0，难道是生成B对象时，A中print()函数调用B中的i，与A中i不是一个东西，不是简单的覆盖，而是更外生成，以前理解的一直错了。