1. class Fu
   
2. {
   
3.         static int num = 5;
   
4.         void method1()
   
5.         {
   
6.           System.out.println("fu method1");
   
7.         }
   
8.         void method2()
   
9.         {
   
10.          System.out.println("fu method2");
    
11.         }
    
12.         static void method4()
    
13.         {
    
14.          System.out.println("fu method4");
    
15.         }
    
16. }
    
17. class Zi extends Fu
    
18. {
    
19.          static int num = 8;
    
20.          void method1()
    
21.          {
    
22.            System.out.println("zi method1");
    
23.          }
    
24.            void method3()
    
25.          {
    
26.            System.out.println("zi method3");         
    
27.          }
    
28.           static void method4()
    
29.          {
    
30.             System.out.println("zi method4");
    
31.          }
    
32. }
    
33. class DuoTaiDemo4
    
34. {
    
35.         public static void main(String[] args)
    
36.         {
    
37.                 Fu f = new Zi();
    
38.                 System.out.println(f.num);
    
39.                 f.method4();
    
40.                
    
41.                 Zi z = new Zi();
    
42.                 z.method4();
    
43.         }
    
44. }
    

复制代码

你想问啥？

楼主定义对象时是将子类对象new Zi()赋值给Fu类对象f，在多态中，静态成员或函数的特点：无论编译和运行，都是参考左边。（静态被加载入内存时，不用指向对象，所以不存在覆盖，只有非静态成员方法才能被覆盖。）所以System.out.println(f.num)打印出来的是Fu类的num为“5”;同理，method4()方法Fu类和Zi类都有，是静态方法，所以f.method4()调用的也是Fu类的method4( );最后Zi z=new Zi();z.method4()调用的自然是Zi类的method4()方法。另外补充，多态中非静态成员函数的特点：
在编译时期，参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，否则失败。如上：父中没有method3，而子中有，f.method3()会编译失败。因为找不着。
在运行时期，参阅对象所属的类中是否有调用的方法。f.method1()打印的是子的方法，因为父被子覆盖了。
简单总结：成员函数在多态调用时，编译看左边，运行看右边。

运行没问题

代码运行没有问题