1. 
   

复制代码

1. class Super
   
2. {
   
3.         int i = 20;
   
4.         public Super(String a)
   
5.         {                  
   
6.                 i=1;
   
7.         }
   
8.         public Super()
   
9.         {
   
10.                 System.out.println("b  "+i);//b  20
    
11.                 i += 2;
    
12.                 System.out.println("c  "+i);//c  22
    
13.         }
    
14. }
    
15. class Demo extends Super
    
16. {
    
17.         public Demo (String a)
    
18.         {
    
19.                 System.out.println("d  "+i);//d  22
    
20.                 i = 5;
    
21.                 System.out.println("e  "+i);//e  5
    
22.         }
    
23.         public static void main(String[] args)
    
24.         {
    
25.                 int i = 4;
    
26.                 System.out.println("a  "+i);//a  4
    
27.                 Super d=new Demo("A");
    
28.                 System.out.println("f  "+i);//f  4
    
29.                 System.out.println(d.i);//5
    
30.         }
    
31. }

复制代码

1. class Super
   
2. {
   
3.         int i = 20;
   
4.         public Super(String a)
   
5.         {                  
   
6.                 i=1;
   
7.         }
   
8.         public Super()
   
9.         {
   
10.                 System.out.println("a  "+i);//a  20
    
11.                 i += 2;
    
12.                 System.out.println("b  "+i);//b  22
    
13.         }
    
14. }
    
15. class Demo extends Super
    
16. {
    
17.         static int i = 4;
    
18.         public Demo (String a)
    
19.         {
    
20.                 System.out.println("c  "+i);//c  4
    
21.                 i = 5;
    
22.                 System.out.println("d  "+i);//d  5
    
23.         }
    
24.         public static void main(String[] args)
    
25.         {
    
26.                 Super d=new Demo("A");
    
27.                 System.out.println("e  "+i);//e  5
    
28.                 System.out.println(d.i);//22
    
29.         }
    
30. }

复制代码

一个结果是5
一个结果是22

求高人指点，这结果怎么来的
我很迷惑…………

Clare0621 发表于 2013-11-5 00:15
顺序反了，根据你重新编辑的代码，下面程序一指楼主第二个程序，程序二指第一个程序：

// 程序一：子类中 ...

看来看去
发现你说的  的刚刚看懂……
似乎明白了
子类构造函数在为i  赋值的时候，本类有就在本类找  
那么，即使super（）语句继承了父类的  i  ，他也在本类找？？？

魏-玉-彪 发表于 2013-11-4 23:44

13.class Demo extends Super

14.{

15.              static int i = 4;      //在这里,子类和父类具有同名变量,如果没

16.

17.//这里没有定义   static int i = 4;  下面这个语句将给父类变量赋值 <==这个我了解，继承父类并重新赋值

18.//由于在子类中定义了 这个变量,所以下面语句赋值给本类中的i 而最后 <==这里本类中的 i  你指哪个？静态的还是父类继承来的非静态？
                                                                                                                               _
                                                                                                                              /|\
19.//打印的是父类中的 i                                                                                           |   
                                                                                                                               |        
20.        public Demo (String a)                                                                              |            
                                                                                                                               |
21.        {                                                                                                                 |
                                                                                                                               |  
22.                i = 5;  <==你要明白这句赋值语句之前隐式的super()把父类的 i 已经继承过来了……
                               怎么会给本类的 i 赋值呢？
23.        }

24.        public static void main(String[] args)
25.        {

26.                Super d=new Demo("A"); //第一步  

27.                System.out.println(d.i);  //第三步,打印父类中变量

28.        }

29.}

The_Wizard 发表于 2013-11-7 01:13
System.out.println("c  "+i);//c  4//这 打印的是什么时候的   i   呢？为什么？  相当于 this.i 吗？这个 ...

System.out.println("c  "+i);//c  4//这 打印的是什么时候的   i   呢？为什么？  相当于 this.i 吗？这个应该是
Demo2.i，这个你不说，我还没有发现呢，在构造函数中居然可以使用静态成员。
System.out.println("e  "+i);//e  5，这个 i 是本类中的 i。//确切的说是本类对象中的  i 吧（this.i），  
                                                      //同样，这里也是Demo2.i。 这是静态成员的调用方式啊……
                                                      //你意思是这里调用的是子类的静态成员啦？？  那么父类继承来的非静态的  i  呢？？被覆盖？？
                                                      //子类的静态成员把从父类继承来的非静态  i  覆盖掉了吗？不能吧……
前面定义的d是一个Super类， 它的 i 不就是22么。        //那么静态呢？这里d是Super类型的，Super哪里有静态的成员变量i，它的i是那个非静态的。

帖子已经分类。还没明白的，认真整理答案，会有你想要的。
也可以再看看视频

System.out.println("c  "+i);//c  4//这 打印的是什么时候的   i   呢？为什么？  相当于 this.i 吗？这个应该是
Demo2.i，这个你不说，我还没有发现呢，在构造函数中居然可以使用静态成员。
System.out.println("e  "+i);//e  5，这个 i 是本类中的 i。//确切的说是本类对象中的  i 吧（this.i），同样，这里也是Demo2.i。
前面定义的d是一个Super类， 它的 i 不就是22么。        //那么静态呢？这里d是Super类型的，Super哪里有静态的成员变量i，它的i是那个非静态的。

The_Wizard 发表于 2013-11-6 15:57
package answer;

class Super

那么，那个静态的  i  去哪了了呢？
一直都为  4 没有变过  ，是吗？
那么静态的  i  在什么时候会变化呢？？


静态的  i   在dome2（）中被父类中非静态的   i   覆盖并重新赋值为 5 了吗？

非静态不能覆盖静态吧……

        public class Demo2 extends Super
        {
                static int i = 4;
                public Demo2 (String a)
                {
                        System.out.println("c  "+i);//c  4//这 打印的是什么时候的   i   呢？为什么？  相当于 this.i 吗？
                        i = 5;
                        System.out.println("d  "+i);//d  5
                }
         }
                 public static void main(String[] args)
                 {
                        Super d=new Demo2("A");
                                System.out.println("e  "+i);//e  5，这个 i 是本类中的 i。//确切的说是本类对象中的  i 吧（this.i）
                        System.out.println(d.i);//22， 这个 i 是Super 类中的 i。                     
                      /*加上后边两句，应该就比较明显了。其实就是多态只针对非静态、非私有的函数。
                         前面定义的d是一个Super类， 它的 i 不就是22么。        //那么静态呢？
                        * 将d转换成Demo2，i 就是5。                                    
                        */
                         Demo2 e = (Demo2)d;                 
                        System.out.println(e.i);//5
                  }
        }

package answer;

class Super

{

        int i = 20;

        public Super(String a)

        {                  

                i=1;

        }

        public Super()

        {

                System.out.println("a  "+i);//a  20

                i += 2;

                System.out.println("b  "+i);//b  22

        }

}

public class Demo2 extends Super

{

        static int i = 4;

        public Demo2 (String a)

        {

                System.out.println("c  "+i);//c  4

                i = 5;

                System.out.println("d  "+i);//d  5

        }

        public static void main(String[] args)

        {

                Super d=new Demo2("A");

                System.out.println("e  "+i);//e  5，这个 i 是本类中的 i。

                System.out.println(d.i);//22， 这个 i 是Super 类中的 i。
               
               
              /*加上后边两句，应该就比较明显了。其实就是多态只针对非静态、非私有的函数。前面定义的d是一个Super类，它的 i 不就是22么。
               * 将d转换成Demo2，i 就是5。
               */
                Demo2 e = (Demo2)d;
               
                System.out.println(e.i);//5

        }

}

那位大神还有不同见解的
也来说说呀
分享一下……

何超 发表于 2013-11-5 21:33
= = 确实都定义了我知道  但是 你下面那个定义的 i  是静态全局变量   而你上面那个 i  是局部变量  两个 ...

我这两天也是这问题  
视频也没看……
你尽快吧  
这问题留作以后吧  
记着它

经验多了
慢慢应该就知道了

李新辉 发表于 2013-11-5 21:14
都定义了 就是多态
这在比老师的视频中讲过的   
这个我清楚……

= = 确实都定义了我知道  但是 你下面那个定义的 i  是静态全局变量   而你上面那个 i  是局部变量  两个不一样···所以导致最后结果不同   确实很麻烦  尼玛  我想了好久 搞得我今天视频都没看完  不知道能不能赶上12.1的那期

何超 发表于 2013-11-5 20:38
你可以试下 你把上面那个代码 也在子类的最外面定义一次  i   那么你输出的结果也是22  所以就是 this 和 s ...

都定义了 就是多态
这在比老师的视频中讲过的   
这个我清楚……
就这样吧  
太饶人了……

你可以试下 你把上面那个代码 也在子类的最外面定义一次  i   那么你输出的结果也是22  所以就是 this 和 super的问题了

上面说错了 = = 我是想不通为什么是 5

想了半天 最后发现其实应该就是 this.i  和  super.i 的问题  你下面那个代码在子类中直接初始化了一次 i  并且在构造方法中默认写的 i=赋值  此时默认为  this.i=赋值   所以你改变的是子类的 i   但是最后的d.i 其实运行的是父类的i  所以是22

同理  对于你上面那个代码  最后运行的也是父类的 i  只是你在子类的最外面没有定义一个  i 并且你子类的构造方法还是写的  i=赋值 此时默认为  super.i=赋值  此时 父类中的  i  就被你改变了   所以最后输出的5  其实还是  父类的 i  只不过是被你改变了值罢了

这样理解应该问题了吧

李新辉 发表于 2013-11-5 20:11
你自己运行一下就知道了  
每一个打印语句   打印的变量  是哪里来的  你搞得清楚不？ ...

我也是结果为 5 的那一句搞不清······跟你一样····我的想法还是应该是输出 22:L

何超 发表于 2013-11-5 20:02
1     总结：因为当调用静态方法时，只要建立子类对象，父类与子类中的静态方法都会随之加载入内存，是不 ...

你自己运行一下就知道了  
每一个打印语句   打印的变量  是哪里来的  你搞得清楚不？

那位大神能详细的给  我讲解一下  代码中每一个打印语句中是  变量  i  的出处啊？
还是不太明白……

heke 发表于 2013-11-5 00:57
成员函数在多态调用时，编译看左边，运行看右边。Demo2中i是成员函数中的局部变量，所以调用的是子的i,先初 ...

第一个结果为5的程序  最后 d.i 不是应该看父类的  i 么  前面也是父类引用指向子类对象  成员变量应该看父类里面的啊  跟 主函数里定义了一次  i  有什么关系   求告知！！！

heke 发表于 2013-11-5 00:57
成员函数在多态调用时，编译看左边，运行看右边。Demo2中i是成员函数中的局部变量，所以调用的是子的i,先初 ...

1     总结：因为当调用静态方法时，只要建立子类对象，父类与子类中的静态方法都会随之加载入内存，是不需要调用就可直接用类名.方法名的，而不需要对象。        
2     只要引用还存在，就看引用变量的类型。

1和2有关系么  为什么我看半天看不出来关系···1我知道 但是在这个程序里好像没体现啊
2是什么意思  说的是 父类引用指向子类对象么      ！！！

李新辉 发表于 2013-11-5 16:54
不建立对象   类加载  静态变量已经存在   这时候直接打印   i   就是  静态变量 而已
静态给类 初始化的 ...

恩，对程序而如此