1. class Sup{
   
2.         public int field = 0;
   
3.         public static String f1(){
   
4.                 return "Sup static f1";
   
5.         }
   
6.         public String f2(){
   
7.                 return "Sup f2";
   
8.         }
   
9. }
   
10. public class Main extends Sup{
    
11.         public int field = 1;
    
12.         public static String f1(){
    
13.                 return "Main static f1";
    
14.         }
    
15.         public String f2(){
    
16.                 return "Main f2";
    
17.         }
    
18.         public int getSupField(){
    
19.                 return super.field;
    
20.         }
    
21.         public static void main(String[] args) {
    
22.                 Sup sup = new Main();
    
23.                 System.out.println(sup.field);//输出0
    
24.                 System.out.println(sup.f1());//输出Sup static f1
    
25.                 System.out.println(sup.f2());//输出Main f2
    
26.                 Main m = new Main();
    
27.                 System.out.println(m.field);//输出0
    
28.                 System.out.println(m.f1());//输出Sup static f1
    
29.                 System.out.println(m.f2());//输出Main f2
    
30.                 System.out.println(m.getSupField());//输出0
    
31.         }
    
32. }
    
33. //当Main对象转型为Super引用时，任何域访问操作都将由编译器解析，因此不是多态的，这样实际上Main包含两个field域，它自己的和从父类继承的
    
34. //在引用Main的field时所产生的默认域不是Sup的field域，要想得到Sup.field,必须显式的指明super.field。
    
35. //静态方法也不是多态的。

复制代码

兄弟，你的输出结果好像有点不对吧。你在运行一遍看看，结果应该是：
0
Sup static f1
Main f2
1
Main static f1
Main f2
0
其实还是要记住多态的3个必要条件：要有继承，父类引用指向子类对象，重写，
还有一点就是有一个就近原则
，你再仔细看看吧，你会明白的
个人之见，仅供参考

牢记老师讲的笔记，再多做相应的习题就能很好的理解这类题了。笔记：
1，多态的体现

       父类的引用指向了自己的子类对象。

       父类的引用也可以接收自己的子类对象。

2，多态的前提

       必须是类与类之间有关系。要么继承，要么实现。

       通常还有一个前提：存在覆盖。

3，多态的好处

       多态的出现大大的提高程序的扩展性。

4，多态的弊端：

       虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

6，多态的出现代码中的特点(多态使用的注意事项)（需要注意，可以举例来）

在多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。

如果有，编译通过，如果没有编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：

无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：

无论编译和运行，都参考做左边。

其实多态记住3句话 就差不多能搞定了 引用楼上的：
　1、非静态成员函数　　编译看左边，运行看右边（动态绑定对象）

　2、成员变量　　      编译运行都看左边

　3、静态成员函数　　  编译运行都看左边（静态绑定类）

一生一世 发表于 2012-6-11 08:48
兄弟，你的输出结果好像有点不对吧。你在运行一遍看看，结果应该是：
0
Sup static f1

嗯，敲错了，那个0是1.