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();
                }
        }
分析下运行结果

⊙﹏⊙b汗，这是基础测试题吧，下面是我提交的：

1. package com.itheima;
   
2. 
   
3.   class A {   
   
4.          void fun1() {
   
5.                System.out.println(fun2());
   
6.          }
   
7. 
   
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.           }
    
18. 
    
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. }
    
29. 
    
30. 
    
31. /**
    
32. * 运行结果为： 456
    
33. *              456
    
34. * 在子类中重写了fun2，使调用fun1的时候打印456
    
35. * main方法中的b.fun1打印456
    
36. * a虽然是A类，但是指向b的地址，a.func1依旧是打印456。
    
37. *
    
38. */

复制代码

我是这样回答得

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

复制代码

都是456
第一个因为B类的fun2()覆盖了A类的方法，所以调用的是B的fun2()
第二个因为父类的引用指向子类，实际上调用的还是父类的fun2()

运行结果：456 456

分析：B new 一个对象b，然而B继承了A类，当使用B的对象调用方法的时候，首先会查找B类中有没有此方法，如果没有，则到父类去查找此方法，如果有，则调用子身的成员方法。故b.fun1();的执行顺序:b.fun1()-->A.fun1()-->B.fun2();          接下来是将类B的引用传递给了类A，进行了类型提升，在调用a.fun1()
时，也会回到类B调用类B的fun2()方法     所以两次执行的结果都是一样的

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();

结果为：456    456