A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© miedongdong 高级黑马   /  2013-11-5 19:55  /  1392 人查看  /  4 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 miedongdong 于 2013-11-8 01:08 编辑

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

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

  2. class zi extends fu                                                                  class zi extends fu{                                                                                       

  3.   {

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

  30. C                                                                                       C

  31. B                                                                                       B

  32. 1                                                                                       2
复制代码

4 个回复

倒序浏览
  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. }
复制代码
回复 使用道具 举报
  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. }

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

好的,谢谢了!!感觉还是有点绕,还是慢慢来吧。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马