黑马程序员技术交流社区

标题: 求大神分析 [打印本页]
作者: 　　米奇    时间: 2014-3-23 10:41
标题: 求大神分析
本帖最后由 　　米奇 于 2014-3-23 16:38 编辑

  class A {
            void fun1() {
                      System.out.println(fun2());
                }
                int fun2() {
                        return 123;
                }
        }
         public class B extends A {
                int fun2() {
                         return 456;
                 }
              public static void main(String args[]) {
                        B b = new B();
                        b.fun1();
                        A a = b;
                        a.fun1();
                }
        }
分析下运行结果
作者: 蓝枫    时间: 2014-3-23 10:50
结果为：456    456
作者: 坏米饭    时间: 2014-3-23 11:00
B b = new B();
b.fun1();//456 子类继承父类方法，void fun1() {
                      System.out.println(fun2());//此处省略了 this.fun2()
                } 所以子类调用的时候，是b.fun2()
A a = b; //多态，父类引用指向子类对象，将b提升为A类。
a.fun1();//父类的引用指向的是b对象，即，b.fun1();
作者: 龙健    时间: 2014-3-23 14:39
运行结果：456 456

分析：B new 一个对象b，然而B继承了A类，当使用B的对象调用方法的时候，首先会查找B类中有没有此方法，如果没有，则到父类去查找此方法，如果有，则调用子身的成员方法。故b.fun1();的执行顺序:b.fun1()-->A.fun1()-->B.fun2();          接下来是将类B的引用传递给了类A，进行了类型提升，在调用a.fun1()
时，也会回到类B调用类B的fun2()方法     所以两次执行的结果都是一样的
作者: H-Deka    时间: 2014-3-23 16:35
都是456
第一个因为B类的fun2()覆盖了A类的方法，所以调用的是B的fun2()
第二个因为父类的引用指向子类，实际上调用的还是父类的fun2()
作者: 赵彦丰    时间: 2014-3-23 18:25
我是这样回答得
  1. class A
  2. {
  3.      void fun1() //调用fun2
  4.      {
  5.              System.out.println(fun2());
  6.      }
  7.      int fun2()
  8.      {
  9.              return 123;
  10.      }
  11. }
  12. public class B extends A {//B继承A
  13.         //默认继承fun1  而且fun1 调用fun2都是本方法中的
  14.      int fun2()
  15.      {
  16.              return 456;//这里覆盖A中fun2方法
  17.      }
  18.      public static void main(String args[])
  19.      {
  20.              B b = new B();
  21.          b.fun1();//这里就输出456
  22.          A a = b;//多态，父类引用指向子类对象，将B提升为A类。
  23.          a.fun1();//这里就输出456
  24.      }
  25. }
复制代码
作者: hyace    时间: 2014-3-23 21:31
⊙﹏⊙b汗，这是基础测试题吧，下面是我提交的：
  1. package com.itheima;

  3.   class A {   
  4.          void fun1() {
  5.                System.out.println(fun2());
  6.          }

  8.          int fun2() {
  9.                  return 123;
  10.          }
  11. }
  12.   
  13. //Test7继承于A
  14.   public class Test7 extends A {
  15.          int fun2() {
  16.                   return 456;
  17.           }

  19.          public static void main(String args[]) {
  20.                   //实例化Test7
  21.                  Test7 b = new Test7();
  22.                  //调用fun1()           
  23.                  b.fun1();
  24.                  //将b赋给父类实例a                 
  25.                  A a = b;
  26.                  a.fun1();
  27.          }
  28. }


  31. /**
  32. * 运行结果为： 456
  33. *              456
  34. * 在子类中重写了fun2，使调用fun1的时候打印456
  35. * main方法中的b.fun1打印456
  36. * a虽然是A类，但是指向b的地址，a.func1依旧是打印456。
  37. *
  38. */
复制代码




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