package com;

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

class Base {
    public int i = 2;

    public Base() {
        this.dispaly();
    }

    public void dispaly() {
        System.out.println("Base");
        System.out.println(i);
    }
}

class Child extends Base {
    public int i = 22;

    public Child() {
        i = 222;
    }

    public void dispaly() {
        System.out.println("Child");
        System.out.println(i);
    }
}
输出结Child 0
i 0

1.你new了一个子类对象，先走到public Child(){,注意它并没有走下去，而且走到了父类public Base() {｝;
2.当走到父类public Base() {｝;则执行了空构造方法中的this.dispaly();；
3.此时的this,代表着引用对象Child,所以运行子类中的    public void dispaly() ；
4.只要创建子类对象，当子类方法跟父类一样时则进行覆盖；
5.所以运行       System.out.println("Child");        System.out.println(i);输 出Child和0
6.为什么会是0，因为你创建子类对象时没有进行初始化；
7.public int i = 22;这句话并没有被执行到，所以i默认值为0.
8.这也是为什么有时我们需要创建带参的构造函数，目的就是为了初始化数据。
9.需要注意的是运行子类是先走父类再走子类，子类会覆盖父类中的同名一样的方法。

赞同楼上观点！Java语言奉行单继承机制，Child类的直接父类是Base，Base类的直接父类是Object类。
创建实例对象进行初始化时，由子类沿继承关系，向上到达所有类的超类Object类中，若有静态代码块，先则先执行，执行顺序为从Object类到创建实例的子类，之后从Object类往下，依次执行类中的普通代码块、构造函数等等。
由于非静态成员属性随实例加载，在实例未加载前，成员属性值尚未初始化，故i为0。

1. class Child extends Base {
   
2. public int i = 22;
   
3. 
   
4. public Child() {
   
5. super(); //隐含了super()语句
   
6. i = 222;
   
7. }

复制代码

这里有一经典实例演示静态代码块、普通代码块、构造函数之间的先后执行顺序，也可从中查看单继承机制下，实例创建的初始化过程。

1. 
   
2. <P>//静态代码块、普通代码块、构造函数
   
3. 
   
4. class ConstructorDemo{
   
5. 
   
6.       public static void main( String[] args ) throws Exception
   
7.       {
   
8.              Leaf lf = new Leaf( "haha" );
   
9.              System.out.println();
   
10.              Leaf lf2 = new Leaf();
    
11.       }</P>
    
12. <P>
    
13. class Root
    
14. {
    
15.       static
    
16.       {
    
17.             System.out.println( "我是Root的静态构造代码块！" );
    
18.       }
    
19. </P>
    
20. <P> </P>
    
21. <P>     {
    
22.             System.out.println( "我是Root的构造代码块！" );
    
23.       }
    
24. 
    
25.       Root()
    
26.       {
    
27.       System.out.println( "我是无参数的Root构造函数！" );
    
28.       }
    
29. }
    
30. 
    
31. class Mid extends Root
    
32. {
    
33.       static
    
34.       {
    
35.             System.out.println( "我是Mid的静态构造代码块！" );
    
36.       }
    
37. 
    
38.       {
    
39.             System.out.println( "我是Mid的构造代码块！" );
    
40.       }
    
41. 
    
42.       Mid()
    
43.       {
    
44.             System.out.println( "我是无参数的Mid构造函数！" );
    
45.       }
    
46. 
    
47.       Mid( String s )
    
48.       {
    
49.             this();
    
50.             System.out.println( "我是有参数的Mid构造函数！" );
    
51.       }
    
52. }
    
53. 
    
54. class Leaf extends Mid
    
55. {
    
56.       static
    
57.       {
    
58.             System.out.println( "我是Leaf的静态构造代码块！" );
    
59.       }
    
60. 
    
61.       {
    
62.             System.out.println( "我是Leaf的构造代码块！" );
    
63.       }
    
64. 
    
65.       Leaf()
    
66.       {
    
67.             System.out.println( "我是无参数的Leaf构造函数！" );
    
68.       }
    
69. 
    
70.       Leaf( String s )
    
71.       {
    
72.             this();
    
73.             System.out.println( "我是有参数的Leaf构造函数！" );
    
74.       }
    
75. }</P>

复制代码

上面程序执行结果为：
我是Root的静态构造代码块！
我是Mid的静态构造代码块！
我是Leaf的静态构造代码块！
我是Root的构造代码块！
我是无参数的Root构造函数！
我是Mid的构造代码块！
我是无参数的Mid构造函数！
我是Leaf的构造代码块！
我是无参数的Leaf构造函数！
我是有参数的Leaf构造函数！
我是Root的构造代码块！
我是无参数的Root构造函数！
我是Mid的构造代码块！
我是无参数的Mid构造函数！
我是Leaf的构造代码块！
我是无参数的Leaf构造函数！