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.                 public Demo(String a)
    
18.                 {
    
19.                         System.out.println("C");
    
20.                         i=5;
    
21.                 }
    
22.                 public static void main(String[] args)
    
23.                 {
    
24.                         int i = 4;
    
25.                         Super d = new Demo("A");
    
26.                         System.out.println(d.i);
    
27.                 }
    
28.         }//结过怎么不是2是5？【正解】B C 5
    

复制代码

        class Super
        {
                int i=0;
                public Super(String a)
                {
                        System.out.println("A");
                        i=1;
                }
                public Super()
                {
                        System.out.println("B");//4、打印B
                        i+=2;//5、对i进行赋值运算。 此时的i为父类中的i，即i=i+2=0+2=2；
                }
        }
        class Demo extends Super
        {
                public Demo(String a)
                {
                        //super()； 3、隐式调用父类无参构造函数。
                        System.out.println("C");//6、打印C
                        i=5;//7、对i赋值，i=5；
                }
                public static void main(String[] args)
                {
                        int i = 4;                //1、对i赋值。
                        Super d = new Demo("A");//2、调用构造函数。
                        System.out.println(d.i);//8、打印i，此时i为5.
                }
        }
如果去掉第七步 i=5  的话i的值为2.

这里, 第17行, 这里会有一句super(); 调用父类的构造方法, 如果你不写, 由虚拟机加载, 所以第一个结果是 B, 因为调用了父类的构造方法

第18行, 程序执行这一句, 所以第二个结果是C

第19行, 这里你把5赋值给 i ,不管以前 i 是多少, 你给 i 赋值为5, 那答案自然就是 5 的啊, 如果你把这句注释掉的话, 答案就是 2 的哦

第24行, 这句没有意义, 因为没有被操作

1. class Super {
   
2.         int i = 0;
   
3. 
   
4.         public Super(String a) {
   
5.                 System.out.println("A");
   
6.                 i = 1;
   
7.         }
   
8. 
   
9.         public Super() {
   
10.                 System.out.println("B");
    
11.                 i += 2;
    
12.         }
    
13. }
    
14. 
    
15. class Demo extends Super {
    
16.         public Demo(String a) {
    
17.                 // super(); 调用父类的构造方法, 如果你不写, 由虚拟机加载, 所以第一个结果是 B
    
18.                 System.out.println("C");// 程序执行这一句, 所以第二个结果是C
    
19.                 i = 5;// 这里你把5赋值给 i ,不管以前 i 是多少, 你给 i 赋值为5, 那答案自然就是 5 的啊, 如果你把这句注释掉的话,
    
20.                                 // 答案就是 2 的哦
    
21.         }
    
22. 
    
23.         public static void main(String[] args) {
    
24.                 int i = 4;// 这句没有意义, 因为没有被操作
    
25.                 // 创建Demo实例对象
    
26.                 Super d = new Demo("A");
    
27.                 System.out.println(d.i);
    
28.         }
    
29. }// 结过怎么不是2是5？【正解】B 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;
                System.out.println("第一次修改时对象所属的类:="+(this instanceof Demo));
                System.out.println("第一次修改结果:="+i);
        }
}

public class Demo extends Super {
        public Demo(String a) {
                System.out.println("C");
                i = 5;
                System.out.println("第二次修改时对象所属的类:="+(this instanceof Demo));
                System.out.println("第二次修改结果:="+i);
        }

        public static void main(String[] args) {
                //下面这个局部变量没有使用到
                int i = 4;
                /*
                 * 创建Demo类的对象，调用Demo(String a)构造函数
                 * 1、由于有继承关系，所以先调用了父类Super的无参构造函数Super()，此为第一步打印，所以先输出"B"
                 *   输出"B"后，将父类的成员变量i的值由0修改为2。
                 *   但成员变量i所属的对象引用是刚刚对类Demo进行对象实例化缠身的d
                 * 2、父类构造函数执行完之后开始执行子类构造函数Demo(String a)，此为第二步打印，所以其次输出"C"
                 *   由于Demo类继承了Super类，而Demo类自己又没有成员变量，所以Demo类使用的成员变量都是父类的。
                 *   输出"B"后，将父类的成员变量i的值由2修改为"5"。
                 *   但原理同上边是一致的，这个i仍然是对象d的i
                 */
                Super d = new Demo("A");
                //基于上边的第2点，此处数据的结果为"5"
                System.out.println(d.i);
        }
}

class Super
        {
                int i=0;
                public Super(String a)
                {
                        System.out.println("A");
                        i=1;
                }
                public Super()
                {
                        System.out.println("B");
                        i+=2;//3.对i进行赋值运算。 此时的i为父类中的i，即i=i+2=0+2=2；
                }
        }
        class Demo extends Super
        {      //  super();2.先调用了父类Super的无参构造函数Super(),输出B，
                public Demo(String a)//执行子类构造函数Demo(String a)，输出C
                {
                        System.out.println("C");
                        i=5;//对i赋值，i=5；
                }
                public static void main(String[] args)
                {
                        int i = 4;
                        Super d = new Demo("A");//1.创建Demo类的对象，调用Demo(String a)构造函数
                        System.out.println(d.i);
                }
        }//首先弄懂创建对象时构造函数初始化的先后顺序。

爱翚 发表于 2014-5-3 12:03
class Super {
        int i = 0;
        public Super(String a) {

也就是说，只建立了一个对象，i 只有一个存储空间，不是父类一个，子类一个？
这样理解对吗？
子类继承父类时，i 的存储空间位置不变，是吧？:dizzy:

主函数一运行，变量i的初始化值是4，然后通过Demo类的构造函数创建了一个父类引用指向子类对象，将字符串A做为参数传给Demo类的构造函数。

子类的构造函数的第一行默认都有一个隐式的super();语句去访问父类中的空参数的构造函数，所以第一个打印的是B。

当执行完Demo类构造函数的隐式super()语句之后，再继续执行本构造函数的内容，所以第二个打印的是C。

最后是将变量i的值改成了5，所以最后执行 System.out.println(d.i);的打印结果就是5。

所以最终的输出结果是：B  C   5