写出程序结果:  //不解为什么d.i 的值是5，d不是父类的引用吗？那么d.i 的值应该是父类的i的值: i=0+2=2 。  成员变量无论编译和运行不都是参考左边吗？
class Super
{
        int i=0;
        public Super(String a)
        {
                System.out.println("A");
                i=1;       
        }
        public Super()
        {
                System.out.println("B");
                i+=2;
        }
}
class Demo extends Super
{
        public Demo(String a)
        {
                System.out.println("C");
                i=5;                               
        }
        public static void main(String[] args)
        {
                Super d=new Demo("A");
                System.out.println(d.i);
        }
}

你这是向上转型，可是子类已经改变了父类中i的值，所以上转型之后，父类调用的也是改变之后的

拿父类new 子类对象只能调用父类和子类都有的方法，不能调用子类特有的方法，d.i 其实是调用的子类的构造函数，因为他是new的子类，也就是所谓的 多态

因为子类继承了父类、父类的变量i ，并在构造方法中将其值改成5、所以i 最终的值为5

   public Demo(String a)
        {
                //supper();
                System.out.println("C");
                i=5;                                
        }
        public static void main(String[] args)
        {
                Super d=new Demo("A");
                System.out.println(d.i);
        }
}
代码中隐去了supper();,对象d一被建立，父类引用就指向了子类对象Demo，因为Demo继承了Supper，所以会先执行supper()；
继承父类空参数的构造函数public Super()
        {
                System.out.println("B");
                i+=2;
        }
，打印B，i=2（i的初值是0），然后子类的构造函数部分执行打印C，然后成员变量i被赋值为5
结构就是B C 5
成员变量无论编译和运行不都是参考左边吗？这句话很好理解，如果子类构造函数没有对i重新赋值，d.i就是父类初始化的值，但是子类构造函数重新赋值了，d.i就变成5了嘛！楼主钻牛角尖了

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.                                 System.out.println(i);//i=0
    
13.                 i+=2;
    
14.                                 System.out.println(i);//i=2
    
15.         }
    
16.                
    
17. }
    
18. class Demo extends Super
    
19. {
    
20.        
    
21.         public Demo(String a)
    
22.         {
    
23.                 System.out.println("C");
    
24.                 i=5;
    
25.                                 System.out.println(i);//i=5
    
26.         }
    
27.         public static void main(String[] args)
    
28.         {
    
29.                 Super d=new Demo("A");
    
30.                 System.out.println(d.i);
    
31.         }
    
32. }

复制代码

因为你new的是子类的实力对象,所以会调用子类的构造函数,而且子类的构造函数里面改变了i的值,因为子类继承了父类,所以也就继承了父类的i变量,你在子类中修改子类的值,当然会得到i=5如果你把这段代码去掉,就可以看到结果了。i=2；