1. public class Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.         B b = new B();
   
6.         b.fun1();
   
7.         A a = b;
   
8.         a.fun1();
   
9.         }
   
10. }
    
11. 
    
12. class A
    
13. {
    
14.     void fun1()
    
15.     {
    
16.         System.out.println(fun2());
    
17.     }
    
18.     int fun2()
    
19.     {
    
20.         return 123;
    
21.     }
    
22. }
    
23. 
    
24. class B extends A
    
25. {
    
26.     int fun2()
    
27.     {
    
28.         return 456;
    
29.     }
    
30. }

复制代码

结果为：456 456.执行顺序是怎样的？

首先理清各个类之间的关系：
A类中的两个方法，第一个fun1(),第二个fun2(),而fun1()的功能是打印fun2()返回的内容。
B类中的方法，fun2()返回一个值。
因为B类继承了A类，B类就拥有了A类中的全部方法。
执行流程：实例化B类，调用fun1()，而fun2的值已经被B类复写，所以输入为456。
接下来有把此实例赋给了父类对象，这时就牵扯到了一个多态性（向上转型），
而fun2()的值用的还是被子类复写的，
所以调用fun1()时输出值还是456。

这个问题反映了子类对象对父类对象方法的重写这是我给你写的注释：

1. public class ShunXu{
   
2.         public static void main(String[] args) {
   
3.                 B b = new B();
   
4.                 b.fun1();   //调用B类中的fun1方法（继承自A），但是B重写了父类（A）的fun2方法，所以输出的是 456
   
5.                 A a = b;    //这句是赋值语句将对象 b 赋值给对象 a
   
6.                 a.fun1();   //这句同样会打印出 456 ，因为这时的 对象a 里面的方法已经变成了 对象 b 的方法，故，打印结果也是456.
   
7.         }
   
8. }
   
9. 
   
10. class A {
    
11.     void fun1() {
    
12.         System.out.println(fun2());
    
13.     }
    
14.     int fun2() {
    
15.         return 123;
    
16.     }
    
17. }
    
18. 
    
19. class B extends A {
    
20.     int fun2() {
    
21.         return 456;
    
22.     }
    
23. }

复制代码

建立子类B的对象，调用方法fun1（）
子类B继承了父类A,   子类的fun2（）方法覆盖了父类的fun2（）方法
System.out.println(fun2());--------结果为456

A a = b;父类的引用指向了自己的子类对象，这是多态
调用方法fun1（）
System.out.println(fun2());--------结果为456

先看看类的注释，再看main方法，能明白不

1. class Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.         B b = new B();
   
6.                 //B对象没有复写fun1方法，调用继承自父类A的fun1方法
   
7.                 //fun1调用了fun2，自然调用B自己复写过的fun2
   
8.         b.fun1();
   
9.                
   
10.                 //这里是多态，a变量内存里装的的还是B对象实例b的引用               
    
11.                 A a = b;
    
12.         a.fun1();
    
13.                 //你可以试试这个,看看是不是true
    
14.                 System.out.println((a==b));
    
15.         }
    
16. }
    
17. 
    
18. class A
    
19. {
    
20.     void fun1()
    
21.     {
    
22.         System.out.println(fun2());
    
23.     }
    
24.     int fun2()
    
25.     {
    
26.         return 123;
    
27.     }
    
28. }
    
29. 
    
30. class B extends A
    
31. {
    
32.         //B是A的子类，B中复写了父类A的fun2方法
    
33.         //所以建立B的对象时，调用的是自己的fun2方法
    
34.     int fun2()
    
35.     {
    
36.         return 456;
    
37.     }
    
38.         //B没有复写A的fun1,相当于B类中隐藏有下面的方法。
    
39.         void fun1()
    
40.         {
    
41.                 super.fun1();
    
42.         }
    
43. }

复制代码

B继承A类，拥有了A类的fun1()方法，并重新了fun2()方法，
B b = new B()；  b.fun1();调用继承父类的fun1()方法，而fun1()又调用fun2（）,此时对象指向B，所以调用B的fun2（）,返回456

而A a = b;  把a 指向 b，a.fun1（），实际调用的还是B类的fun1（），因为B类的fun1（）是继承A类的，所以还是456