今天群里看到小丰童鞋发了一段代码讨论对象实例化的过程，代码如下，我加了两条输出语句。 （由于比较卡）关于这段代码得出的总结在二楼……

1. class Super {
   
2.         int i = 10;
   
3.         Super() {
   
4.                         System.out.println("Super构造函数 is running");
   
5.                 print();
   
6.                 i = 20;
   
7.         }
   
8.         void print() {
   
9.                 System.out.println(i);
   
10.         }
    
11. }
    
12. 
    
13. class Sub extends Super {        
    
14.                 int j = 30;
    
15.         Sub() {
    
16.                         System.out.println("Sub构造函数 is running");
    
17.                 print();
    
18.                 j = 40;
    
19.         }
    
20.         void print() {
    
21.                 System.out.println(j);
    
22.         }               
    
23. }
    
24. class Test2
    
25. {
    
26.         public static void main(String[] args) {
    
27.                System.out.println(new Sub().j);
    
28.         }
    
29. }

复制代码

执行结果为：

关于楼上的代码的总结：
1.设置成员的值为默认的初始值（0，false，null）。
2.调用对象的构造方法（但是还没有执行构造方法体）。
3.调用父类的构造方法。
4.使用初始化程序和初始块初始化成员。
5.执行构造方法体。

初始化的过程中第一步是设置成员的值为默认值，所以在父类调用子类方法打印j的值为0的原因，就在这里。

然后再讨论下 有静态代码块和非静态代码块的执行顺序。代码如下：

1. class Super
   
2. {
   
3.         static int a = 0;
   
4.         {
   
5.                 System.out.println("Super非静态代码块 is running");
   
6.                 a = 10 ;
   
7.         }
   
8.         static
   
9.         {
   
10.                 System.out.println("Super静态代码块  is running");
    
11.                 a = 20;
    
12.         }
    
13.         Super()
    
14.         {
    
15.                 a = 30;
    
16.                 System.out.println("Super构造函数 is running");
    
17.         }
    
18. }
    
19. 
    
20. class Sub extends Super
    
21. {
    
22.         static int c = 0;
    
23.         static
    
24.         {
    
25.                 c = 10;
    
26.                 System.out.println("Sub静态代码块  is runnning and now c is " + c);
    
27. 
    
28.         }
    
29.         
    
30.         {
    
31.                 c = 20;
    
32.                 System.out.println("Sub非静态代码块  is runnning and now c is " + c);
    
33.         }
    
34. 
    
35.         Sub()
    
36.         {
    
37.                 c = 30;
    
38.                 System.out.println("Sub构造函数 is running and now c is " + c);
    
39.         }
    
40. }
    
41. class Test
    
42. {
    
43.         public static void main(String args[])
    
44.         {               
    
45.                 //System.out.println(Sub.c);
    
46.                 Sub s = new Sub();               
    
47.                 System.out.println(s.c);
    
48.                 //System.out.println(Sub.c);
    
49.         }
    
50. }
    

复制代码

执行结果为：

关于有静态代码块以及非静态代码块的初始化对象的初始化过程
对象被JVM装载，执行父类的相关代码，如果有静态初始化，先执行静态初始化，且只执行一次，以后即使有该类实例化，也不会再执行；如果有静态代码块（以与静态初始化一样的方式执行），楼上所示代码中如果把注释地方取消则结果为：

这里可以看出静态代码块只执行了一次，后面子类实例化的过程中没有执行。

如果有new语句带来的实例化（静态代码块执行了一次，没有没有执行参照上面写的）：
1.先为成员变量分配空间，设置成员的值为默认的初始值（0，false，null）
2.调用对象的构造方法（但是还没有执行构造方法体）
3.隐式或显式调用父类的构造方法（但是还没有执行构造方法体）
4.执行父类的非静态代码块
5.执行父类的构造方法。
6.使用初始化程序和初始块初始化成员。
7.执行子类的非静态代码块
8.执行子类的构造函数
9.然后其他代码。

这个是子类继承了父类然后关于初始化的问题：
我是这样理解的：
1，子类一定要访问父类中的构造函数。因为父类中的数据子类可以直接获取，所以子类子类对象在建立时，需要
先查看父类中如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定
2，子类默认都会访问父类中的空参数函数。因为子类每一个构造函数内第一行都有一句隐式的super();
3，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，但子类要保证至少有一个构造函数会访问父类中的构造函数

好贴，呵呵顶一个{:soso__10659464829293696901_2:}