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

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

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

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

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

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

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

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

这样理解应该问题了吧

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

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

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

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

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

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

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

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

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

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

        }

}

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
                  }
        }

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-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是那个非静态的。

魏-玉-彪 发表于 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.}

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

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

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