下面这段代码的运行结果为什么是：456，456？为什么？


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继承了类A并覆盖了类A的fun2方法，哪么不管是建立类A的对象还是类B的对象，运行时，都是走的子类方法，
  B b = new B();
  b.fun1();//走的子类中的fun2方法，打印456
  A a = b;//这里用到的是多态，
  a.fun1();//因为子类覆盖了父类的方法，所以走的还是子类的fun2,结果当然还是456
总之一句话：当子类覆盖父类方法时，哪么运行时，走的都是子类方法

1. class A {
   
2.                 void fun1() {
   
3.                       System.out.println(fun2());
   
4.                 }
   
5. 
   
6.                 int fun2() {
   
7.                         return 123;
   
8.                 }
   
9.         }
   
10. 
    
11.          public class B extends A {//B继承后重写A中fun2方法
    
12.                 int fun2() {
    
13.                          return 456;
    
14.                  }
    
15. 
    
16.                 public static void main(String args[]) {
    
17.                         B b = new B();
    
18.                         b.fun1();
    
19.                         A a = b;//多态(父类变量引用子类对象)
    
20.                         a.fun1();
    
21.                                                 A a1=new A();
    
22.                                                 a1.fun1();
    
23.                 }
    
24.         }

复制代码

试试上面的代码

  你这个是多态的问题
第一个是    子类 对象名 = new  子类；你调用的方法，父类也有，所以就是一般的覆盖了。
定义多态  一般是 ：父类    对象名 = new  子类；
                           左边                         右边；    当你在调用子类的非静态方法的时候编译这个方法是的时候，要看这个方法父类有没有存在，在运行的时候，执行的是子类的方法。 总结就是编译时看左边，运行时看右边。
在附赠你 一些其他规则：  多态中，如果是调用静态方法，或者成员变量的时候，左边是什么类，就执行什么类的方法。就是编译，运行都看左边。
调用

b实例化后由于继承自A类调用fun1方法，再调用fun2方法，这时继承A类的fun2方法被B所重写所以显示456
a由子类所实例化，所以调用fun1方法后再调用fun2方法时用的为B类所重写后的方法，所以显示456

1. public class Test {
   
2. 
   
3.         public static void main(String args[]) {
   
4.                 B b = new B();
   
5.                 b.fun1();
   
6.             A a = b;  //此处父类对象由子类实例化，以下在调用fun1方法后再调用的fun2会指向子类重写后的方法
   
7.                                     //父类引用指向子类对象
   
8.             a.fun1();
   
9.         }
   
10. }
    
11. 
    
12. class A {
    
13.    
    
14.     void fun1() {   
    
15.           System.out.println(fun2());
    
16.     }
    
17.      // 以下是父类中的func2()方法，因为下面的子类中重写了该方法 ，
    
18.       //所以在父类类型的引用中调用时，这个方法将不再有效，
    
19.       //取而代之的是将调用子类中重写的func2()方法
    
20.     int fun2() {
    
21.             return 123;
    
22.     }
    
23. }
    
24. 
    
25. class B extends A {
    
26.           
    
27.     int fun2() {
    
28.          return 456;
    
29.      }
    
30. }

复制代码

多态的特点：
编译时期，参阅引用型变量所属的类中是否有调用的方发，如果有，编译通过，如果没有编译失败
在运行期间：参阅对象所属的类中是否有调用的方法。
成员函数在多态调用时，编译看左边的引用所属类，运行看右边的对象类。