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