这是视频中的一个练习题，看了很多遍无法彻底看懂，毕老师也没有详细注解，希望得到大家的详解，并说明，谢谢！

写出程序结果:   
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)
        {
                //super();
                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);
        }
}

Super d=new Demo("A");// 该代码会执行 Demo类中的构造函数，先执行里面的隐式语句super();
而该隐式语句super();执行的是其父类中的无参构造函数，打印B   然后再回到子类Demo中的构造函数
System.out.println("C"); 打印C，再执行 i= 5;语句 此时 Super d=new Demo("A");// 代码执行完毕
回到主函数执行System.out.println(d.i);代码 打印出i的值5
所以打印出来的结果是：
B
C
5

这是java面向对象中的多态，老师举了个很生动的例子，就是儿子扮演父亲，儿子去替父亲上课。从这个例子出发去理解吧

父类中的常量会被覆写么？

在java多态中，编译看左边，运行看右边。
只要你读懂了

1. Super d=new Demo("A");

复制代码

你的问题就解决了。
运行

1. public Demo(String a)
   
2.         {
   
3.                 //super();
   
4.                 System.out.println("C");
   
5.                 i=5;                              
   
6.         }

复制代码

时，会先Super。因为没有传参数进去。所以运行的是无参数的构造函数。

1. public Super()
   
2.         {
   
3.                 System.out.println("B");
   
4.                 i+=2;
   
5.         }

复制代码

得到结果为B。and i被赋值为0+=2；(如果你把后面的i=5改为i+=5.最后输出的会是2+5=7；)
然后，传入一个参数A，运行

1. public Demo(String a)
   
2.         {
   
3.                 //super();
   
4.                 System.out.println("C");
   
5.                 i=5;                              
   
6.         }

复制代码

子类覆盖父类。
所以会得到输出C、and i被赋值为5.
最后输出i。
如果就是：B、C、5;

ixiangfeng 发表于 2013-10-31 14:25
Super d=new Demo("A");// 该代码会执行 Demo类中的构造函数，先执行里面的隐式语句super();
而该隐式语句 ...

父类中的常量会被覆写么？

Gump 发表于 2013-10-31 14:31
父类中的常量会被覆写么？

在多态中成员函数（非静态）的特点：在编译时期，参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有，编译失败; 在运行时期： 参阅对象所属的类中是否有调用的方法------
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边（指多态定义时的左边和右边，左边是父类，右边是子类）

在多态中，成员变量的特点：无论编译和运行，都参考左边（引用型变量所属的类）这点和非静态成员函数有所区别和静态成员函数相同 ，要注意！！！！

在多态中，静态成员函数的特点：无论编译和运行，都参考左边（）


这是我的笔记 如果看了还不理解的话建议把毕老师第8天的视频看一下

1. class fu
   
2. {
   
3.         int i=0;
   
4.         public fu(String a)
   
5.         {
   
6.                 System.out.println("A");
   
7.                 //i=1;        
   
8.         }
   
9.         public fu()//3 执行里面的代码块
   
10.         {
    
11.                 System.out.println("B");//最先打印了一个B.
    
12.                 //i+=2;// i=i+2 i=2 执行完跳转到4
    
13.                // System.out.println(i);
    
14.         }
    
15. }
    
16. class Demo extends fu
    
17. {
    
18.         public Demo(String a) //2
    
19.         {
    
20.                 //super(); //因为是继承，子类的每个构造函数都有一句隐式的super() 主要是为了查看父类是如果对参数进行初始化的。程序跳转到3
    
21.                 System.out.println("C");//4 接着打印了一个C
    
22.                 i=5; //在本类中并没有定义变量i,所以会寻找父类的i 这里改变的是父类的i .如果父类没有i 编译报错。
    
23.                 //System.out.println(super.i);
    
24.         }
    
25.         public static void main(String[] args)
    
26.         {
    
27.                 int i=4;
    
28.                 fu d=new Demo("A");//多态，使用父类引用指向本类子类对象。
    
29.                                                          //new Demo("A") 新建Demo对象，使用demo的有参构造函数。程序跳转到2
    
30.                 System.out.println(d.i);//最后执行d.i i 为父类中的变量。
    
31.         }
    
32. }

复制代码

如果问题已经解决，请及时修改主题为“提问结束”
修改主题的方法链接
http://bbs.itheima.com/thread-89313-1-1.html