1. package com.xiaoye.test;
   
2. 
   
3. class A {
   
4.         public int a = 10;
   
5. 
   
6.         public void say() {
   
7.                 System.out.println("in class a");
   
8.         }
   
9. 
   
10. }
    
11. 
    
12. class B extends A {
    
13.         public int a = 20;
    
14. 
    
15.         public void say() {
    
16.                 System.out.println("in class b");
    
17.         }
    
18. 
    
19. }
    
20. 
    
21. public class test {
    
22. 
    
23.         /**
    
24.          * @param args
    
25.          */
    
26.         public static void main(String[] args) {
    
27.                 A a = new B();
    
28.                 Printa(a);
    
29. 
    
30.         }
    
31. 
    
32.         public static void Printa(A he) {
    
33.                 System.out.println(he.a);
    
34.         }
    
35. 
    
36. }
    

复制代码

江南雨 发表于 2013-5-23 14:17
什么编译看左边，执行看右边，能解释清楚吗？

A a = new B();
也就是说：
在编译时期：参阅等号左边引用型变量所属的类(A)中是否有调用变量；如果有，编译通过，如果没有编译失败。
在运行时期：参阅等号左边引用型变量所属的类(A)中的变量的值

其他两个你可以类推一下

lpflpy 发表于 2013-5-23 13:36
多态应用时：
A:成员变量：
        编译看左边,执行看左边

什么编译看左边，执行看右边，能解释清楚吗？

这个是多态问题，只有成员方法是编译看左边而执行是看右边的，其他都以左边为准。

多态应用时：
A:成员变量：
        编译看左边,执行看左边
B:成员方法：
        编译看左边,执行看右边
C:静态修饰成员：
        编译看左边,执行看左边

多态应用时，

首先明确一点，方法存在重写，成员变量不存在重写，你的代码中用到多态， A a = new B();，利用父类对象调用调用同名成员变量a，输出的就是父类对象中初始化的变量a的值10，多态就是这样，父类对象引用可以调用子父类共有的方法，不可以调用子类特有方法（即父类中没有的方法，访问的局限性）；此外作为成员变量它不存在多态，即不会有变量的重新赋值，这一点一定要明确，此外还有用static修饰的静态成员同样没有多态，谁调用就取本身的成员，不会去掉实际指向的对象的成员。希望你能明白