代码如下，运行结果是3，希望知道的同学帮忙分析下中间的详细过程。程序都走了哪几步？

1. class Super
   
2. {
   
3.         int i=0;
   
4.         public Super(int a)
   
5.         {
   
6.         
   
7.         i=1;
   
8.         }
   
9.         public Super()
   
10.         {
    
11.         i+=2;
    
12.         }
    
13. }
    
14. class Demo extends Super
    
15. {
    
16.         public Demo(int a)
    
17.         {
    
18.         i++;
    
19.         }
    
20.         public static void main(String[] args)
    
21.         {
    
22.         int i=4;
    
23.         Super d=new Demo(5);
    
24.         System.out.println(d.i);
    
25.         
    
26.         }
    
27. }

复制代码

1. package com.itheima;
   
2. 
   
3. 
   
4. class Super
   
5. {
   
6.         int i=0;
   
7.         public Super(int a)
   
8.         {        
   
9.         i=1;
   
10.         }
    
11.         public Super()
    
12.         {
    
13.         i+=2;
    
14.         }
    
15. }
    
16. class Demo extends Super
    
17. {
    
18.         public Demo(int a)
    
19.         {
    
20.         i++;
    
21.         }
    
22.         public static void main(String[] args)
    
23.         {
    
24.         int i=4;//这里的i=4是局部变量，不用管
    
25.         Super d=new Demo(5);
    
26.         //1.这一句中Super父类创建对象，没有指定构造函数，默认为空参数，执行Super(),则Super.i=2;
    
27.         //2.父类函数执行完毕，开始执行子类函数Demo(5),开始i++，i为父类的变量，则super.i=3
    
28.         //3.父类的对象d调用i，i为父类的变量，即d.i=3,输出完毕
    
29.         System.out.println(d.i);
    
30.         
    
31.         }
    
32. }

复制代码

执行顺序：new Demo(),在调用Demo(5)的构造前 ，先掉用Super()构造。然后看System.out.println(d.i);
i=0; 接着无参构造，i+=2; 这时i=2，然后掉子类Demo(2),i++;最后输出i=3。

第一步：int i=4;这里的i是重新定义的i，是个局部变量，跟成员变量没有关系。
第二步: new Demo(5);
第三步：i+=2;此时super.i=2。因为子类使用构造方法创建对象，需要使用父类的构造方法，如果没有指定，那么就默认为空参数的构造方法，而且父类的构造方法需要放在子类构造方法的第一行。此时super.i=2
第四步：i++;此时super.i=3。执行完父类的空参数构造函数，开始执行子类的构造函数，i++。由于子类当中没有自己定义的i，所以使用的是父类对象的i，即对super.i再加1.
第五步：把new Demo(5)这个对象的地址赋给d;
第六步：打印d.i；如上所述，子类使用的是父类的i，打印的是父类对象的i，即3.

本题涉及到多态问题，首先把多态的知识搞懂，我下面总结了一下，可以理解一下。
1、使用父类类型的引用指向子类的对象
2、该引用只能调用父类中定义的方法和变量
3、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法（动态连接）
4、变量不能被重写（覆盖），“重写”的概念只针对方法，如果子子类中”重写“了父类中的变量，那么在编译时会报错。
该题是调用变量，故该引用d只能调用父类中的方法和变量，你就不用你用管子类中的变量和方法了，这样就不会晕了。父类的变量方法开始运行，super方法中变量i变为1，到了下一个方法i的值就变为3，之后就输出。就这样。

i=4;   这个一直都存在，并且没有被改变过。

Super d=new Demo(5); 这句话先调用class Super{int i=0;public Super(){i+=2;}}   这会d.i==2;
然后调用Demo 类中的构造函数Demo(int a){i++;}  这里的i是对象调用的，所以i++  d.i==3;
你最后打印d.i就是3；
如果你打印i结果就是4；

执行顺序：
super(); i+=2 ==0+2==2;
Demo(5); i++ ==2+1==3