看到毕老师的视频里，有说到，成员函数在多态调用时，编译看左边，运行看右边，小弟不理解，请给详细说明一下，谢谢啦

编译看左边：例
Person person=new Student();这样编译时没有错的 多态可以简单理解为父类对象可以指向子类对象
如果你左边是跟Student 一样继承Person的类编译就会出错
不好意思，上面是我的一点回忆
编译看左边就是如果父类没有子类的方法就会报错
运行的时候运行的是右边子类的方法  所以运行看右边

这是我当时的练习你看下，希望对你有帮助、

1. /*
   
2. 多态中成员函数的特点：编译看左边运行看右边 如例一;
   
3. 成员变量的特点：无论编译还是运行都看左边 如例二;
   
4. 静态成员函数的特点：编译或运行都看左边 如例三;
   
5. */
   
6. class Fu
   
7. {
   
8.         int num = 5;
   
9.          void show1()
   
10.         {
    
11.                 System.out.println("Fu show_1");
    
12.         }
    
13.         void show2()
    
14.         {
    
15.                 System.out.println("Fu show_2");
    
16.         }
    
17.         static void show4()
    
18.         {
    
19.                 System.out.println("Fu show_4");
    
20.         }
    
21. }
    
22. class Zi extends Fu
    
23. {
    
24.         int num = 8;
    
25.         int x=3;
    
26.          void show1()
    
27.         {
    
28.                 System.out.println("Zi show_1");
    
29.         }
    
30.         void show3()
    
31.         {
    
32.                 System.out.println("Zi show_3");
    
33.         }
    
34.         static void show4()
    
35.         {
    
36.                 System.out.println("Zi show_4");
    
37.         }
    
38.         static void show5()
    
39.         {
    
40.                 System.out.println("Zi show_5");
    
41.         }
    
42. }
    
43. class  DuoTaiTeDian
    
44. {
    
45.         
    
46.         public static void main(String[] args)
    
47.         {
    
48.                 Fu f = new Zi();
    
49.         //如果是f.Show3();则编译不通过因为父类中没有f.Show3();下面运行结果则是累类中的"Zi show_1";
    
50.                 f.show1();//例一：
    
51.     //如果是f.x则编译不通过，因为看左边父类中无X成员变量；下面运行结果也是5，因为运行也看左边父类中有num=5；
    
52.             System.out.println(f.num);//例二
    
53.         //因为左边父类中无show5()，所以编译不通过。如果为f.show4()，则打印结果为"Fu show_4";
    
54.          f.show5();//例三
    
55. 
    
56. 
    
57.                 //Zi z = new Zi();
    
58.                 //System.out.println(z.x);
    
59.         }
    
60. }
    

复制代码

父类引用指向子类对象在开发中最常见的多态

父类 引用=new 子类();

调用实例方法

前提:查看父类中是否存在该方法

调用:调用的是子类中的重写的方法。

调用实例属性:

前提:父类中是否存在属性

调用:父类中的属性。

类属性:

前提：查看父类中是否存在该属性

调用: 调用的是父类中的类属性

类方法:

前提：查看父类中是否存在该属性

调用: 调用的是父类中的类方法

所以，调用成员方法时，编译的时候看左边父类是否存在该方法，运行的时候实际调用的是子类的，重写的方法。也就是右边

Animal c = new Cat();   左边是 Animal 类(或接口)  右边是 Cat()类； 在编译的时候编译器不管你右边是什么类，只要左边的Animal类(或接口)能编译通过就不会报错。但是运行的时候就要按照右边的Cat()类实际情况来运行。
从这里来看.编译的时候就是验证Animal是否有这个接口,(左边)
运行的时候 a实际上是Cat.(Cat 是 Animald的实现类)
实际是要运行Cat的实现方法.(右边)

Animal c = new Cat();   左边是 Animal 类(或接口)  右边是 Cat()类； 在编译的时候编译器不管你右边是什么类，只要左边的Animal类(或接口)能编译通过就不会报错。但是运行的时候就要按照右边的Cat()类实际情况来运行。
从这里来看.编译的时候就是验证Animal是否有这个接口,(左边)
运行的时候 a实际上是Cat.(Cat 是 Animald的实现类)
实际是要运行Cat的实现方法.(右边)

在多态中非静态成员函数的特点：
         在编译时期：参阅引用型变量中是否有调用的方法，有则编译通过，没有则编译失败。
         在运行时期：参阅对象所属的类中是否有调用的方法。
         简单总结就是：非静态成员函数在多态调用时，编译看左边，运行看右边。
编译时只是检查语法。
如class fu(){方法一}   class zi(){zi方法一；方法二}父子之间是继承关系，
此时你 new fu f=new zi();编译时 会发现 fu里有方法一和zi里一致，可以调用，运行时，看zi类中的调用方法有一，有二，此时你调用方法一是没问题的，调用方法二，因为fu中没有相应的方法，所以调用二时会报错，所以运行时要看右边