1、class Super
{

                int i=0;
        public Super(String a)
        {
                System.out.println("A");
                i=1;        
        }
        public Super()
        {
                System.out.println("B");
               i=4;
        }
}
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);


                }
}


2.

class Super
{

                int i=0;
        public Super(String a)
        {
                System.out.println("A");
                i=1;        
        }
        public Super()
        {
                System.out.println("B");
               i=4;
        }
}
class Demo extends Super
{
        int i=2;
        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);


                }
}

3
class Super
{

                int i=0;
        public Super(String a)
        {
                System.out.println("A");
                i=1;        
        }
        public Super()
        {
                System.out.println("B");
               i=4;
        }
}
class Demo extends Super
{
     int i=7;
        public Demo(String a)
        {       super(a);
                           
                System.out.println("C");
                i=5;                                
        }
        public static void main(String[] args)
        {
                Super d=new Demo("A");
                System.out.println(d.i);


                }

第一题：过程是这样的先调用了super d = new Demo("A");在堆内存中创建了new Demo对象，找子类中是否有带参数的构造函数，找到后子类构造函数中有隐式的super()语句，找父类空参构造函数，执行了B，在找子类输出C，然后调用了d.i，因父类初始化完毕调用的子类的5，结果是B C 5。
第二题：过程是这样的先调用了super d = new Demo("A");在堆内存中创建了new Demo对象，找子类中是否有带参数的构造函数，找到后子类构造函数中有隐式的super()语句，找父类空参构造函数，执行了B，在找子类输出C，然后调用了d.i，但是这个跟第一题不同，因为子父类中都有成员变量，根据多态成员变量的编译和运行都参考等号左边，走的是父类成员变量，最终的执行结果是B C 4。
第三题：过程是这样的先调用了super d = new Demo("A");在堆内存中创建了new Demo对象，找子类中是否有带参数的构造函数，找到后子类构造函数中执行了的super(a)语句，找父类带参的构造函数，执行了A，在找子类输出C，然后调用了d.i，因为子父类中都有成员变量，根据多态成员变量的编译和运行都参考等号左边，走的是父类成员变量，最终的执行结果是A C 1。

凊係柈泩 发表于 2012-12-18 13:01
第一题：过程是这样的先调用了super d = new Demo("A");在堆内存中创建了new Demo对象，找子类中是否有带参 ...

楼上的解释很好，如果你没有看视频或者老师的笔记，我建议你看一下老师的day08关于继承的相关知识，里面说的比较详细。
构造函数中：子类的所有够着方法都会访问父类中空参数的构造方法，每一个构造函数的第一行都会有一句隐式的super语句，这样子类会获取到父类中的数据，必须要先明确父类对数据的初始化过程。

最后补充一下，最后一个输出的结果是AC1，请版主修改一下。

三个的结果分别是BC5、BC4、AC1
主要说明的一个是子类构造函数隐藏的super（）语句，其次，多态中成员变量的特点，子父类出现重名变量时，参照引用型变量所属类 父类。
则第二个区别于第一个在于 i 都为成员变量，所以 i  参照父类i=4。
而第三个调用的是super（a）且 i 参照父类i=1。

标记一下

   在原理上应该掌握以下知识点：
          在多态中成员函数的特点：
                编译时期：参阅引用类型所属的类中是否有调用的方法，如果有编译通过，没有则编译失败 。
                运行时期：参阅对象所属的类中是否有调用的方法 ，即子类是否有该方法 ，如果有则执行子类的方法，没有则执行从父类继承来的 ，再没有编译失败 。
                 总结为：多态中成员函数的特点是编译看左边 ，执行看右边 。
           
          在多态中成员变量的特点：
                 楼主所说的情况只有在面试中发生，即在多态中子父类出现重名变量时 ，多态情况下看左边 。
                 总结为： 无论编译和运行 ，都参考左边（引用型变量所属的类）。


      (1)方法和变量在继承时的隐藏与覆盖
     隐藏：若B隐藏了A的变量或方法，那么B不能访问A被隐藏的变量或方法，但将B转换成A后可以访问A被隐藏的变量或者方法。
     覆盖：若B覆盖了A的变量或者方法，那么不仅B不能访问A被覆盖的变量或者方法，将B转换成A后同样不能访问A被覆盖的变量或者方法。
    (2)Java中变量与方法在继承中的隐藏与覆盖规则：
          一、父类的实例变量和类变量能被子类的同名变量隐藏。
          二、父类的静态方法被子类的同名静态方法隐藏，父类的实例方法被子类的同名实例方法覆盖。
          三、不能用子类的静态方法隐藏父类的实例方法，也不能用子类的实例方法覆盖父类的静态方法，否则编译器会异常。
          四、用final关键字修饰的最终方法不能被覆盖。
          五、变量只能被隐藏不会被覆盖，子类的实例变量可以隐藏父类的类变量，子类的类变量也可以隐藏父类的实例变量

已解决！