今天学习过程中把老师的计算程序运行时间时方法都加了static,发现没有像想象中那样的结果，代码如下：
class GetTime//父类
{
        public static void  getTime()
        {
                long start=System.currentTimeMillis();
                runCode();
                long end=System.currentTimeMillis();
                System.out.println("\n毫秒数："+(end-start));
        }
        public  static void runCode()
        {
                for(int i=0; i<1000; i++)
                {
                        System.out.print(i);
                }
        }
}

class MyTime extends GetTime
{
        public static void runCode()
        {
                for(int i=0; i<4000; i++)
                {
                        System.out.print(i);
                }
        }
}
class  Demo
{
        public static void main(String[] args)
        {
                //GetTime.getTime();
               
                GetTime M=new MyTime();
                M.getTime();
                //MyTime.getTime();
        }
}

子类中的runCode方法应该能覆盖父类中的方法呀，加了static,执行的是父类中的runCode,而不加static执行的是子类中的runCode,static方法应该可以被继承的，为何会出现这种结果？

楼主 您的这个问题毕老师有讲到过而且很全面
包括非静态成员函数，成员变量 ，静态成员函数在多态中的特点。

下面以一个例子来说明：

1. 
   
2.   class Fu   //定义了一个父类
   
3.   {
   
4.         int num = 5;
   
5.         void method1()
   
6.         {
   
7.                 System.out.println("父类的非静态方法");
   
8.         }
   
9.         static void method2()
   
10.         {
    
11.                 System.out.println("父类的静态方法");
    
12.         }
    
13.        
    
14.   
    
15.   class Zi extends Fu  //定义了一个子类 继承父类
    
16.   {
    
17.         int num = 8;
    
18.         void method1()
    
19.         {
    
20.                 System.out.println("子类的非静态方法");
    
21.         }
    
22.         static void method2()
    
23.         {
    
24.                 System.out.println("子类的静态方法");
    
25.         }
    
26.   }
    
27.   public class  DuoTai        
    
28.   {
    
29.         public static void main(String[] args)
    
30.         {
    
31.                 Fu f = new Zi();      //父类的引用f指向了子类的对象
    
32.                 System.out.println(f.num);
    
33.                 f.method1();
    
34.                 f.method2();
    
35.                
    
36. 
    
37.                 Zi z = new Zi();  //子类的引用z指向了子类对象
    
38.                 System.out.println(z.num);
    
39.                 z.method1();
    
40.                 z.method2();
    
41.         }
    
42.   }
    
43. 
    
44. 打印结果：
    
45. 
    
46. 5
    
47. 子类的非静态方法
    
48. 父类的静态方法
    
49. 8
    
50. 子类的非静态方法
    
51. 子类的静态方法

复制代码

根据打印结果总结如下：
  (1)多态中成员函数的特点：成员函数在多态调用时，编译看左边，运行看右边。
  (2)多态中成员变量的特点：无论编译和运行，都参考左边(引用型变量所属的类).
  (3)多态中静态成员函数的特点 ：无论编译和运行，也都参考左边。

不用static修饰的时候就不用解释了，直接继承重写，，但是用static的时候要考虑下static修饰符的作用
在方法中加不加static是完全不同的，可以这样认为，在内存的方法区中有两块放方法的区域，一块是静态方法区，还有一块儿非静态方法区
不用static修饰的方法放在非静态方法区中，每创建一个对象就会有一个这个方法。此方法是每个对象私有的。
而用static修饰的方法在静态方法去中，他只加载一次，是所有方法公用的。
而你说的继承中static其实跟这原因一样，不用static的时候这个方法可以出现多次，父类和子类各是各的，所以你执行的时候是子类的
而用static的时候加载了父类的这个方法后就被以后的这个方法共享，就是不会再加载
所有就造成了你这个问题

我也是学员，反正我是这么认为的，你可以参考一下

静态的话，没有重写这一说，直接用类名调用。 M.getName(),当然运行父类的静态方法

第一：你这叫多态：GetTime M=new MyTime();其中的M是父类的引用 ，后面又是子类的对象。很明显是父类的引用指向子类的对象。
对于多态来说：静态方法和成员变量都是按照父类中进行运行的。
第二：即使你写成MyTime M＝　new MyTime(),再通过M来调用getTime()方法时，运行的还是父类的，因为你在子类中没有重写父类的这个方法，
那么这个方法调用的别的方法都是父类中的。如果你想运行子类中的runCode()方法，只能在子类中重写父类的getTime()方法。
第三：静态的方法可以被覆盖，但是只能用静态去覆盖静态。
下面的这个代码运行的就是子类中的runCode()方法

1. 
   
2. 
   
3. class GetTime//父类
   
4. {
   
5.         public static void  getTime()
   
6.         {
   
7.                 long start=System.currentTimeMillis();
   
8.                 runCode();
   
9.                 long end=System.currentTimeMillis();
   
10.                 System.out.println("\n毫秒数："+(end-start));
    
11.         }
    
12.         public  static void runCode()
    
13.         {
    
14.                 for(int i=0; i<1000; i++)
    
15.                 {
    
16.                         System.out.print(i);
    
17.                 }
    
18.                 System.out.println("父类中的");//加上这句是为了看的方法些
    
19.         }
    
20. }
    
21. 
    
22. class MyTime extends GetTime
    
23. {
    
24.         public static void runCode()
    
25.         {
    
26.                 for(int i=0; i<4000; i++)
    
27.                 {
    
28.                         System.out.print();
    
29.                 }
    
30.                 System.out.println("子类中的");
    
31.         }
    
32.         public static void  getTime()//覆盖父类的方法，不然运行的时候调用的还是父类中的runCode。
    
33.         {
    
34.                 long start=System.currentTimeMillis();
    
35.                 runCode();
    
36.                 long end=System.currentTimeMillis();
    
37.                 System.out.println("\n毫秒数："+(end-start));
    
38.         }
    
39. }
    
40. class  Demo
    
41. {
    
42.         public static void main(String[] args)
    
43.         {
    
44.                 //GetTime.getTime();
    
45.                
    
46.                 MyTime M=new MyTime();//用子类来创建对象，不是用父类的引用来指向子类的对象
    
47.                 M.getTime();
    
48.                 //MyTime.getTime();
    
49.         }
    
50. }

复制代码

多谢各位的指点，明白了，多态还没有看到，不过明白了。

哎，真心的感觉到了，这里真是个好地方，任何问题都能再最快的时间得到解决。