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

复制代码

这个打印的结果是
B C 5
我 翻开笔记发现毕老师写过这么一句话：在多态中成员变量的特点：无论编译和运行都参考左边。
那么应该打印的是
B C 2
为什么呢？

class Demo extends Super
{
        int i=3;//加上这个就是打印2了，没有的话说明子类没有i只有父类有，相当于你继承过来的。
                 //也就是说其实只有一个i，所以打印肯定是I的最后结果。
        public Demo(String a)
        {
                System.out.println("C");
                i=5;
        }
        public static void main(String[] args)
        {
                int i=4;
                Super d=new Demo("A");
                System.out.println(d.i);
        }
}

class Super
{
        int i=0;
        public Super(String a)
        {
                System.out.println("A");
                i=1;
        }
        
        public Super()   // 1
        {
                System.out.println("B");
                i+=2;  //i=2  在这里父类执行完毕，开始执行子类的
        }
}


class Demo extends Super
{
        public Demo(String a)  //2
        {
                super();//调用父类空的构造函数 1
                System.out.println("C");
                i=5;  //最后i=5  结果就是  B C 5
        }
        public static void main(String[] args)
        {
                int i=4;
                Super d=new Demo("A");
                System.out.println(d.i);
        }
}

System.out.println(d.i);
为什么方法调用的是变量i是父类对象的。其实是多态的问题。多态是针对子类重写父类的方法的，但对变量则没有多态。
比如Super d=new Demo("A");是创建了一个子类对象并把它当成父类对象Super用也就是父类引用指向子类对象 此时,引用变量d有2个类型,编译时的类型为Super,运行时的类型为Demo.在代码编译过程中,Super 只能调用属于Super的方法. 不能调用Demo类里面的方法.注意,由于继承关系,如果Demo重写了Super的某个方法,
假如说Super有一个方法a(),而在代码编译过程中,Super.a()调用的是Super的a(),但在程序运行时,却运行的是Demo的a().
这就是多态

在编译的时候编译器不管右边是什么类，只要左边的Super类能编译通过就行，不过运行的时候按照右边Demo类的实际情况来运行！！

你在子类Demo方法中并没有定义i
public Demo(String a)
        {
                System.out.println("C");
                i=5;//这里的i是将继承父类的i值改为5
        }
所以你的打印结果5其实是子类改变父类i后的值
如果此处改为int i = 5；
运行结果就是B C 2 了

构造函数执行的顺序：
Super d=new Demo("A");
这句调用了
public Demo(String a)
{
    super();    //这句是编译器自动给你补上的，这时打印B，i=2
    System.out.println("C");
    i=5;    //这时 i=5
}
那打印的当然是5。
实例变量能重新赋值，也就是说Super类有个 i ，他的所有子类的对象也一定都会有个 i ，能重新给这个 i  赋值。
你这个 i 本来就是Super的 i 被继承了又赋值了。