在多态中，成员变量和静态成员函数的特点是什么？

给你一个地址我们俩学习学习吧。讲的挺好。加油。

http://blog.csdn.net/iu_81/article/details/1557323

那感情好啊。多谢啊

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

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

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

在多态中，成员变量的特点：
无论编译和运行，都参考左边（引用型变量所属的类）。

在多态中，静态成员函数的特点：
无论编译和运行，都参考左边。

例子

1. class Fu  
   
2. {  
   
3.      int num= 1;  
   
4.      void method1()  
   
5.      {  
   
6.         System.out.println("fu method-1");  
   
7.      }  
   
8.      void method2()  
   
9.      {  
   
10.         System.out.println("fu method-2");  
    
11.      }  
    
12.      static void method4()  
    
13.      {  
    
14.         System.out.println("fu method-4");  
    
15.      }  
    
16. }  
    
17.   
    
18. class Zi extends Fu  
    
19. {  
    
20.      int num = 2;  
    
21.      void method1()  
    
22.      {  
    
23.         System.out.println("Zi method-1");  
    
24.      }  
    
25.      void method3()  
    
26.      {  
    
27.         System.out.println("Zi method-3");  
    
28.      }  
    
29.      static void method4()  
    
30.      {  
    
31.         System.out.println("Zi  method-4");  
    
32.      }  
    
33.   
    
34. }  
    
35.   
    
36. class Test  
    
37. {  
    
38.     public static void main(String[] args)   
    
39.     {  
    
40.         Fu f= new Zi();   
    
41.         f.method1();    //结果是Zi的method1，覆盖  
    
42.         f.method2();    //结果是Fu的method2.  
    
43.          
    
44.         //num全局变量  
    
45.         System.out.println(f.num);  //结果是Fu的num  
    
46.         Zi z= new Zi();  
    
47.         System.out.println(z.num);  //结果是Zi的num  
    
48.          
    
49.         //method4() 是静态函数  
    
50.         f.method4();    //结果是Fu的method4  
    
51.         z.method4();    //结果是Zi的method4  

复制代码

简单总结就是：
在多态中，成员函数的特点
编译看左边，运行看右边。

在多态中，成员变量的特点：
无论编译和运行，都参考左边（引用型变量所属的类）。

在多态中，静态成员函数的特点：
无论编译和运行，都参考左边。

1. class Test  
   
2. {  
   
3.     public static void main(String[] args)   
   
4.     {  
   
5.         //Zi extends Fu
   
6. 
   
7.                 //method1()是成员函数
   
8.                 Fu f= new Zi();   
   
9.         f.method1();    //结果是Zi的method1，覆盖  
   
10.         f.method2();    //结果是Fu的method2.  
    
11.          
    
12.         //num全局变量  
    
13.         System.out.println(f.num);  //结果是Fu的num  
    
14.         Zi z= new Zi();  
    
15.         System.out.println(z.num);  //结果是Zi的num  
    
16.          
    
17.         //method4() 是静态函数  
    
18.         f.method4();    //结果是Fu的method4  
    
19.         z.method4();    //结果是Zi的method4  
    
20.         }

复制代码

我也不太明白这个

都只看引用类型那个类，它不会走子类

楼上有结果了