黑马程序员技术交流社区

标题: 关于父类和子类的同名成员变量问题 [打印本页]
作者: miedongdong    时间: 2013-11-5 19:55
标题: 关于父类和子类的同名成员变量问题
本帖最后由 miedongdong 于 2013-11-8 01:08 编辑

   关于成员变量的特点：在多态中，无论编译和运行，都参考左边（引用变量所属的类）
  那么以下这道题是怎么回事呢？为什么子类的  i  作为成员变量和局部变量不同的
当zi 是继承父类的成员变量 i 的时候，第二个程序中的 f.i  调用的是zi类的成员变量还是父类的成员变量？

  2. i  作为成员变量的情况                                                         // i 作为局部变量的情况

  4. class zi extends fu                                                                  class zi extends fu{                                                                                       

  6.   {

  8.       int i = 2;                                                                                    
  9.       public static void main(String[] args)                                        public static void main(String[] args)
  10.       {                                                                                         {   
  11.                                                                                                         int i = 2;
  12.            fu f = new zi("A");                                                                   fu f = new zi("A");                                 
  13.            System.out.println(f.i);                                                              System.out.println(f.i);                                 
  14.       }                                                                                          }     
  15.       zi(String s )                                                                            zi(String s )            
  16.        {                                                                                         {   
  17.            System.out.println("B");                                                        System.out.println("B");                                                                                                                           
  18.              i++;                                                                                        i++;                                                                                            
  19.       }                                                                                         } </p><p>}                                                                                         }
  20. class fu                                                                                class fu                                                                                                  
  21. {                                                                                          {
  22.       int i = 0;                                                                             int i = 0;               
  23.       fu()                                                                                    fu()                                                                                               
  24.      {                                                                                         {   
  25.            System.out.println("C");                                                     System.out.println("C");                                                                                                                             
  26.             i++;                                                                                  i++;                                                                                                
  27.      }                                                                                        }   
  28. fu(String s)                                                                           fu(String s)                    
  29.       {                                                                                         {  
  30.           System.out.println("D");                                                       System.out.println("D");                                                                                                                           
  31.          i++;                                                                                     i++;                                                                                               
  32.      }                                                                                          }   
  33. }                                                                                         }   

  35. C                                                                                       C

  37. B                                                                                       B

  39. 1                                                                                       2
复制代码
作者: 李慧声    时间: 2013-11-5 22:16
  1. public class Zi extends Fu{
  2.         public static void main(String[] args) {
  3.                 int i = 2;
  4.                 Fu f = new Zi("A");
  5.                 System.out.println(f.i);//这个i是成员变量，不是局部变量，跟局部的i = 2没有任何关系
  6.         }
  7.         Zi(String s) {
  8.                 //super();//里面没有传任何参数，所以去找空参的了,所以打印结果为C而不是D
  9.                 System.out.println("B");
  10.                 super.i++;//i++[b];//因为Zi自身没有成员i，所以只能去找他爹的i了，i++前面省略了super. i加了两次，自然就是2了；第一次i++前面省略了this.，是Zi的i跟Fu的没关系，其实说白了就是玩this和super两个关键字[/b]
  11.         }
  12. }
复制代码
作者: ysunday    时间: 2013-11-8 01:00
  1. //所谓看左边的意思是声明的时候是什么类型的
  2. //就去看这个类型的对应的变量
  3. //比如，Fu f = new Zi();
  4. //左边声明的是Fu类型的，那么调用变量的时候
  5. //就去看Fu类中的变量f.i是Fu中的变量
  6. class Zi extends Fu{
  7.         int i = 2;
  8.         public Zi(String s){
  9.                 System.out.println("B");
  10.                 i++;
  11.         }
  12.         public static void main(String[] args){
  13.                 int i = 2;//这个是局部变量,跟f.i没关系
  14.                 Fu f = new Zi("A");//注意看左边，声明什么就去找什么类中的变量
  15.                 System.out.println(f.i);//这里的f.i,i指的是父类中的
  16.                                                                
  17.         }
  18. }
  19. class Fu{
  20.         int i = 0;
  21.         public Fu(){
  22.                 System.out.println("C");
  23.                 i++;
  24.         }
  25.         public Fu(String s){
  26.                 System.out.println("D");
  27.                 i++;
  28.         }
  29. }

  31. //这个Fu f= new Zi();
  32. //这句话执行了子类有参构造函数8行那里。
  33. //在Zi的这个函数体中的第一行隐藏了一句super()
  34. //写出来是这样
  35. //                super();
  36. //                System.out.println("B");
  37. //                i++;
  38. //这句super();执行Fu类无参构造函数即21行
  39. //打印C，然后父类的i++，i成了1
  40. //然后执行完了super
  41. //回到8行,然后打印B,i++, Zi类的i成了3
复制代码
作者: ysunday    时间: 2013-11-8 01:04
然后，14行的Fu f = new Zi("A");才算执行完。
然后打印f.i
这个i是Fu类中的是1，没猜错的话
作者: miedongdong    时间: 2013-11-8 01:08
本帖最后由 miedongdong 于 2013-12-6 22:32 编辑
ysunday 发表于 2013-11-8 01:00

好的，谢谢了！！感觉还是有点绕，还是慢慢来吧。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2