如下的程序分析输出结果：

1. class A {
   
2.         void fun1() {
   
3.                 System.out.println(fun2());
   
4.         }
   
5. 
   
6.         int fun2() {
   
7.                 return 123;
   
8.         }
   
9. }
   
10. 
    
11. class B extends A {
    
12.         int fun2() {
    
13.                
    
14.                 return 456;
    
15.         }
    
16.        
    
17.         public static void main(String argv[]) {
    
18.                 /*
    
19.                  * 分析：
    
20.                  *         1、B 继承了 A,在多态中成员方法是可以继承的，子类可以覆盖父类中的共有方法，
    
21.                  *                 在本例中，子类B继承了父类的fun1(),覆盖了fun2();
    
22.                  *  2、b.fun1();子类b调用了父类的fun1(),fun1()方法中又调用了fun2(),由于子父类中
    
23.                  *          都有fun2(),非静态成员方法编译看左边，运行看又边，b.fun1()调用了子类自己的fun2()
    
24.                  *          输出结果是456。
    
25.                  *  3、a = b 等效于 A a = new B();多态，父类引用指向子类，
    
26.                  *          a.fun1(),运行时期：看得是所属的类中是否有调用的方法
    
27.                  *          如果父子类中出现同名方法，会运行子类中方法，因为方法有覆盖特性
    
28.                  *          输出结果还是456。
    
29.                  *
    
30.                  */
    
31.                 A a;
    
32.                 B b = new B();
    
33.                 b.fun1();//456
    
34.                 a = b; // 等效于 A a = new B();
    
35.                 a.fun1();//456
    
36.         }
    
37. }

复制代码

学习了。

              //改写了一下代码：
              A a = new A();
                System.out.println(a);
                B b = new B();
                System.out.println(b); //测试出的地址:test1.B@12940b3
                b.fun1();//456
                a = b; // 等效于 A a = new B();在这里其实是将b对象在内存中的地址赋给a,而址始终指向的是b对象，所以在运行时执行当然b对象的方法
                a.fun1();//456
                System.out.println(a); //测试出的地址:test1.B@12940b3