理解多态--边看例子边画内存

本文参考总结了某马培训机构和其他博客上面的一些例子。

多态的前提：

       a.要有继承关系

       b.要有方法重写

       c.父类引用指向子类对象

多态中的成员访问特点：

       （1）成员变量：编译看左边，运行看左边

       （2）成员方法：编译看左边，运行看右边 （动态绑定）

       （3）静态方法：编译看左边，运行看左边

下面我们通过内存示意图来分别解析多态的三条总结。

一. 成员变量：编译看左边，运行看左边

代码示例：

[java]  view plain  copy

1. /** 
2.  * 成员变量 
3.  *  
4.  * @author buder_cp 
5.  * 
6.  */  
7. class Father {  
8.     int num = 10;  
9. }  
10.   
11. class Son extends Father {  
12.     int num = 20;  
13. }  
14.   
15. public class Polymorphic {  
16.     public static void main(String[] args) {  
17.         Father f = new Son();  
18.         System.out.println(f.num);  
19.   
20.         Son s = new Son();  
21.         System.out.println(s.num);  
22.     }  
23. }  

内存情况如图：

       

       具体解析：首先类加载机制加载Demo2_Polymorphic.class，主方法进栈。执行Father f创建变量时，开始加载Father.class和Son.class两个类。创建Son实例分配内存时，内存区域有一块super，也就是子类可以访问父类的内存区域，num初始化值为10（super指针指向）；它自己内存区域有num初始化值为20（this指针指向），此时的f是指向Son实例内存的super内存块，因此f.num的取值肯定就是10了。

二. 成员方法：编译看左边，运行看右边

代码示例：

[java]  view plain  copy

1. /** 
2.  * 成员方法 
3.  *  
4.  * @author buder_cp 
5.  * 
6.  */  
7. class Father {  
8.     int num = 10;  
9.   
10.     public void print() {  
11.         System.out.println("father");  
12.     }  
13. }  
14.   
15. class Son extends Father {  
16.     int num = 20;  
17.   
18.     public void print() {  
19.         System.out.println("son");  
20.     }  
21. }  
22.   
23. public class Demo2_Polymorphic {  
24.     public static void main(String[] args) {  
25.         Father f = new Son();  
26.         f.print();  
27.     }  
28. }  

内存使用情况如图：

       具体解析：在调用f.print()方法时，编译器编译首先检查父类Father中有木有print()方法（蓝线），如果没有就会编译报错；如果有就通过编译开始运行print()方法，运行看右边也就是运行的子类Son的print方法（红线），此时子类的print方法进栈运行，结束后弹栈。

三. 静态方法：编译看左边，运行看左边

代码示例：

[java]  view plain  copy

1. package java多态;  
2.   
3. /** 
4.  * 成员方法 
5.  *  
6.  * @author buder_cp 
7.  * 
8.  */  
9. class Father {  
10.     int num = 10;  
11.   
12.     public static void print() {  
13.         System.out.println("static father");  
14.     }  
15. }  
16.   
17. class Son extends Father {  
18.     int num = 20;  
19.   
20.     public static void print() {  
21.         System.out.println("static son");  
22.     }  
23. }  
24.   
25. public class Demo2_Polymorphic {  
26.     public static void main(String[] args) {  
27.         Father f = new Son();  
28.         f.print();  
29.     }  
30. }  

       具体解析：静态方法就很好理解了，因为是static修饰，随着类的加载里面的变量和方法就是类的属性和方法，f.print()，其实也就是Father.print()，很显然调用的就是父类的方法。