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

复制代码

继承抽象函数的话 不需要重定义fun1吗？

A a=b只是产生了一个指向B b 的指针   输出应该是456 456

B b = new B()  b.fun1() 会打印之类自己的方法  所以是456

A a = new B()   a.fun1() 属于父类引用指向之类对象，会打印父类的方法   所以是123

同意楼上

B b = new B( );
b.fun1( );
B继承A方法fun1( ), 输出B的fun2( )，结果456；

A a = b;
a.fun1( );
是多态，B重写A方法fun2( )，结果456，

1. class A {
   
2.     void fun1() {
   
3.               System.out.println(fun2());
   
4.         }
   
5.         int fun2() {
   
6.                 return 123;
   
7.         }
   
8. }
   
9. 
   
10. public class B extends A {
    
11.         int fun2() {
    
12.                  return 456;
    
13.          }
    
14.       public static void main(String args[]) {
    
15.                 B b = new B();
    
16.                 /**
    
17.                  * B继承了A，B也就继承了A中所有的方法
    
18.                  * B调用方法时，会先找B中是否有这个方法，然后再去A中找
    
19.                  * 因此此时b.fun1();调用的是B对象中的方法，结果456
    
20.                  */
    
21.                 b.fun1();
    
22.                 /**
    
23.                  * 父类A引用指向子类对象B
    
24.                  * 子类B重写了A中的fun1()，
    
25.                  * 典型的多态，所以结果依然是456
    
26.                  */
    
27.                 A a = b;
    
28.                 a.fun1();
    
29.         }
    
30. }
    

复制代码

学习了。我真么搞这么清楚

提前看看，涨涨知识

前来学习。