下面这段程序执行的结果为什么是" B  C   7"，而不是"C  5 " ，求解释，谢谢。
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)
        {
                int i=4;
                Super d=new Demo("A")
                System.out.println(d.i);
        }
}

第一步：new Demo("A")运行 Demo的构造函数，又因为构造函数中有隐含的super();而先加载父类，并且运行空参数的构造函数，即：
                System.out.println("B");   //先打印B
                i+=2;    //此时父类成员i=2;
然后运行System.out.println("C");      //打印 C
            i+=5;       //子类中没有局部和成员变量 i,所以使用的是父类中的成员变量i, 此时 i=7;
最后运行：System.out.println(d.i);
即：最后的结果为父类的成员i的值。7
就得到了 B C 7

首先要明确主函数中的int i = 4;这个i 是局部变量  只在主函数的范围内起作用  主函数中最后的输出的是成员变量的i 这两个i是不同的 当new Demo("A")调用子类Demo的构造函数public Demo(String a),而该构造函数的第一句之前就是打印c这个语句之前 有一个隐式的无参Super构造函数 所以要先调用父类中的public Super（）构造函数  所以最后结果就是b c 7

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. class Demo extends Super
    
16. {
    
17. 
    
18.         public Demo(String a)
    
19.         {
    
20.                  //super()
    
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. }

复制代码

程序运行先以主函数作为入口，执行顺序如上图，当执行到②时，容易看出这是

多态，先去匹配Demo自身的构造函数，因为Demo继承Super所以构造函数第一行有

一条隐式的super()语句，即要先初始化父类Super，即跳转③，输出B,此时i的值

为2，接着再来初始化子类自己的，跳转到⑥，输出 C，执行⑦（子类自身没有i

，子类继承父类所以直接拿来用），i的值变为7，然后执行⑧，输出7，所以结果

是B C 7

下面这段程序执行的结果为什么是" B  C   7"，而不是"C  5 " ，求解释，谢谢。
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)
         {
                 int i=4;
                 Super d=new Demo("A")
                 System.out.println(d.i);
         }
}
在执行new Demo("A")创建一个子类对象时，调用了Demo的带参数的构造方法，由于Demo继承了Super(也就继承了super中的i),所以，在 System.out.println("C");之前其实是隐藏了一句super（）；它会自动调用父类的不带参数的构造函数，所以会先输出B，并且i+2，然后再输出C。既然Demo继承了Super中的i,那么，Demo中i+=5,此时自然就变成7了。Super d=new Demo("A")，这句是父类的引用指向子类的对象，但在执行d.i时，会调用子类中的i，然后再输出，就是7.
其实在这个程序里还有一点很重要：Super d=new Demo();Super s=new Super();Demo d=new Demo();这些都可以。但不可以创建子类的引用指向父类的对象。