黑马程序员技术交流社区

标题: 父类中的static方法能被子类重写吗 [打印本页]
作者: zcbyzcb    时间: 2013-5-15 22:05
标题: 父类中的static方法能被子类重写吗
本帖最后由 zcbyzcb 于 2013-5-17 09:47 编辑

今天学习过程中把老师的计算程序运行时间时方法都加了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方法应该可以被继承的，为何会出现这种结果？
作者: 刘学明　　　    时间: 2013-5-15 22:50
楼主 您的这个问题毕老师有讲到过而且很全面
包括非静态成员函数，成员变量 ，静态成员函数在多态中的特点。

下面以一个例子来说明：

  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.                

  37.                 Zi z = new Zi();  //子类的引用z指向了子类对象
  38.                 System.out.println(z.num);
  39.                 z.method1();
  40.                 z.method2();
  41.         }
  42.   }

  44. 打印结果：

  46. 5
  47. 子类的非静态方法
  48. 父类的静态方法
  49. 8
  50. 子类的非静态方法
  51. 子类的静态方法
复制代码
根据打印结果总结如下：
  (1)多态中成员函数的特点：成员函数在多态调用时，编译看左边，运行看右边。
  (2)多态中成员变量的特点：无论编译和运行，都参考左边(引用型变量所属的类).
  (3)多态中静态成员函数的特点 ：无论编译和运行，也都参考左边。
作者: 第一枭雄    时间: 2013-5-15 22:52
不用static修饰的时候就不用解释了，直接继承重写，，但是用static的时候要考虑下static修饰符的作用
在方法中加不加static是完全不同的，可以这样认为，在内存的方法区中有两块放方法的区域，一块是静态方法区，还有一块儿非静态方法区
不用static修饰的方法放在非静态方法区中，每创建一个对象就会有一个这个方法。此方法是每个对象私有的。
而用static修饰的方法在静态方法去中，他只加载一次，是所有方法公用的。
而你说的继承中static其实跟这原因一样，不用static的时候这个方法可以出现多次，父类和子类各是各的，所以你执行的时候是子类的
而用static的时候加载了父类的这个方法后就被以后的这个方法共享，就是不会再加载
所有就造成了你这个问题

我也是学员，反正我是这么认为的，你可以参考一下
作者: 张迁    时间: 2013-5-15 23:09
静态的话，没有重写这一说，直接用类名调用。 M.getName(),当然运行父类的静态方法
作者: 飞鸟青崖    时间: 2013-5-16 07:21
第一：你这叫多态：GetTime M=new MyTime();其中的M是父类的引用 ，后面又是子类的对象。很明显是父类的引用指向子类的对象。
对于多态来说：静态方法和成员变量都是按照父类中进行运行的。
第二：即使你写成MyTime M＝　new MyTime(),再通过M来调用getTime()方法时，运行的还是父类的，因为你在子类中没有重写父类的这个方法，
那么这个方法调用的别的方法都是父类中的。如果你想运行子类中的runCode()方法，只能在子类中重写父类的getTime()方法。
第三：静态的方法可以被覆盖，但是只能用静态去覆盖静态。
下面的这个代码运行的就是子类中的runCode()方法


  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. }

  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. }
复制代码
作者: zcbyzcb    时间: 2013-5-16 15:54
多谢各位的指点，明白了，多态还没有看到，不过明白了。
作者: zcbyzcb    时间: 2013-5-16 16:10
哎，真心的感觉到了，这里真是个好地方，任何问题都能再最快的时间得到解决。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2