java对象的创建过程

以一道例题开始：

public class Test {
	
	public static int k = 0;
	public static Test t1 = new Test("t1");
	public static Test t2 = new Test("t2");
	public static int i = print("i");
	public static int n = 99;
	public int j = print("j");

	{
		print("构造快");
	}

	static {
		print("静态块");
	}

	public Test(String str) {
		System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
		++n;
		++i;
	}

	public static int print(String str) {
		System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
		++i;
		return ++n;
	}

	public static void main(String[] args) {
		Test t = new Test("init");
	}

}

 

执行结果是：

1:j i=0 n=0
2:构造快 i=1 n=1
3:t1 i=2 n=2
4:j i=3 n=3
5:构造快 i=4 n=4
6:t2 i=5 n=5
7:i i=6 n=6
8:静态块 i=7 n=99
9:j i=8 n=100
10:构造快 i=9 n=101
11:init i=10 n=102

对上题执行结果的分析：

加载类信息：
	1、静态变量默认初始化
	2、对静态变量赋值 （赋值顺序按书写顺序）
	3、静态代码块中内容
创建对象：
	1、实例变量初始化
	2、实例变量赋值（依然按顺序）
	3、构造代码块中内容
	4、构造函数中内容

public static int k = 0; //对静态变量k初始化

public static Test t1 = new Test("t1");  //t1默认值null,下面就是赋值
public Test(String str)	//创建t1对象，但现在并不是执行构造函数内的代码
public int j = print("j");	//对实例变量赋值，当然赋值前会进行默认初始化，即为0
public static int print(String str) //j变量的输出 执行print代码段  输出
	1:j i=0 n=0	//此时i和j还没有加载，值仍是默认的值
print("构造快"); //实例变量初始化后，执行构造代码块中内容，对于构造代码块中的内容，每创建一次对象，都会执行一次
public static int print(String str) //构造代码块的输出 执行print
	2:构造块 i=1 n=1
public Test(String str)	//执行构造函数中代码段，输出
	3:t1 i=2 n=2

public static Test t2 = new Test("t2"); //其执行顺序和t1的初始化一样 下面只写输出内容
	4:j i=3 n=3
	5:构造块 i=4 n=4
	6:t2 i=5 n=5

public static int i = print("i"); //继续按顺序对静态变量赋值
public static int print(String str) //输出
	7:i i=6 n=6

public static int n = 99;

print("静态块"); //对静态变量赋值完后  执行静态代码块
	8:静态块 i=7 n=99 //此时已经对n进行了赋值，所以其值为99

new Test("init") //静态信息加载完毕后 就是对象的创建
public int j = print("j"); //每个对象创建后都会对实例变量  默认初始化 赋值 然后执行构造代码块 构造函数
	9:j i=8 n=100 
print("构造快");
	10：构造块 i=9 n=101
public Test(String str)//构造函数
	11：init i=10 n=102

以上只是针对该题的分析，下面总结一下

对象创建时对象的加载过程：

1、类信息加载
 加载父类信息(静态属性默认初始化 -> 静态属性赋值 ->静态代码块) -> 加载子类信息(顺序同父)
 注：类的信息只加载一次，之后创建对象时，类信息不在重复加载
2、对象创建
 父类对象信息(父类实例属性默认初始化 -> 赋值 ->构造代码块->构造函数) -> 子类对象创建(顺序同父类)
 注：在子类的构造函数第一行代码，当没有 super 或 this 的明确调用时，默认 super()
 即调用父类无参构造函数
  当父类中有构造函数，但是没有无参构造时(当然此时没有默认的无参构造)，子类必须有构造函数，
 且要明确调用的构造函数，即 super(参数) 或 this (参数) 明确指定。这也就是说此时子类的参数个数
 也有一定的限制，即参数个数不能多于 super 或 this中的参数个数。所以创建类时，为了更好的扩展
 一般都要写上无参构造函数。

对上面的描述，几个例子简单分析一下

public class Test extends Father{	
	public static int k = 10;
	private int inta = 20;
	{
		System.out.println("子类构造代码块" + inta + " " + k);
	}
	static {
		System.out.println("子类静态代码块"+ k);
	}

	public Test(String str) {
		//super(str) //默认调用父类的无参构造
		System.out.println("子类构造函数" + inta + " " + k);
	}

	public static void main(String[] args) {
		Test t = new Test("init");
	}
}

class Father{
	public static int inta = 30;
	private String name;
	{
		System.out.println("父类构造代码块" + inta + name);
	}
	static {
		System.out.println("父类静态代码块" + inta);
	}
	Father(){
		System.out.println("父类无参构造" + inta + name);
	}
	Father(String name){
		this.name = name;
		System.out.println("父类无参构造" + inta + name);
	}
}

执行结果：

父类静态代码块30 //父类静态属性 -> 父类静态代码块
子类静态代码块10 //子类静态信息 -> 子类静态代码块
父类构造代码块30null //父类实例变量(默认初值为null) 父类构造代码块
父类无参构造30null //子烈默认调用父类的无参构造
子类构造代码块20 10 //子类
子类构造函数20 10