重写静态方法问题

Question

对以下代码的运行结果有点疑问，请求帮忙
class Parent{     
 public void nonStaticMethod() {        
      System.out.println("Parent's Non-Static Method is Called");     
  }       
 public static void staticMethod() {      
      System.out.println("parent's static method is called");      
  }     
}     
   
class Child extends Parent{     
  public void nonStaticMethod() {      
          System.out.println("child's non-static method is called");      
  }      
  public static void staticMethod() {     
          System.out.println("child's static method is called");      
     }       
}  public class Test{     
      public static void main(String args[])          {       
           Parent p1 = new Parent();       
            Parent p2 = new Child();       
           Child c = new Child();     
          System.out.print("Parent.static: ");     
                Parent.staticMethod();      
          System.out.print("p1.static: ");     
        p1.staticMethod();      
            System.out.print("p2.static: ");     
         p2.staticMethod();     
            System.out.print("p1.nonStatic: ");    
        p1.nonStaticMethod();     
        System.out.print("p2.nonStatic: ");     
        p2.nonStaticMethod();     
        System.out.print("Child.static: ");     
      Child.staticMethod();     
  
      System.out.print("c.static: ");     
   
                 c.staticMethod();      
  
         System.out.print("c.nonStatic: ");     
   
        c.nonStaticMethod();      
   
      }     
   
}     
   
程序的运行结果为： 
Parent.static: parent's static method is called 
p1.static: parent's static method is called 
p2.static: parent's static method is called 
p1.nonStatic: Parent's Non-Static Method is Calle 
p2.nonStatic: child's non-static method is called 
Child.static: child's static method is called 
c.static: child's static method is called 
c.nonStatic: child's non-static method is called 请问：p2实际上是一个Child的类型的引用，然而在调用静态方法的时候，它执行的却是父类的静态方法，而不是Child的静态方法，而调用 p2的非静态方法的时候执行的是Child 的非静态方法，为什么呢？

Answer 1

静态方法不存在重写覆盖的问题。看你申明变量时是什么类型的，就调用这个类型的方法，
例如：
Super s=
Sub sb=...
如果你s.静态方法名，调用的是Super的静态方法，哪怕是你申明为：s=new Sub()，任然调用Super的静态方法
sb.静态方法名，调用的了Sub的静态方法。

Answer 2

static 告诉编译器 这个方法不被覆写
就像private  子类里 看似覆写 实则是新加

Answer 3

static的方法不存在重写的问题，我喜欢把static的方法当作属性来看，以谁来定义引用方法就用那个类的static方法。

Answer 4

直接把STATIC看成一种特殊类，不存在覆盖的问题

Answer 5

p2实际上是一个Parent的类型的引用,关于是什么类型是看等号左边不是右边！！这是个关于静态方法和非静态方法能不能被重写的多态的例子！！！
基类中的静态方法不能被子类重写，非静态方法可以被子类重写！！！
当你 Parent p2 = new Child(); 的时候创建了一个Persent类型的对象引用P2，并不是Child对象
 当用P2调用非静态方法nonStaticMethod() 的时候首先它会检查是否子类对该方法重写了，如果没有重写就返回基类的，如果重写了就返回子类的！！！
当调用静态方法的时候，由于静态方法不能被重写，所以是哪个类型的对象调用的就返回该类型的方法！！！
LZ可以试下这样：
class Parent{     
public void nonStaticMethods() { {//我在基类的这个方法后面加了一个s，这样子类的非静态方法就没有重写了，因为两个不是两个相同的方法，你运行下，看结果是不是变了，当你在用P2调用这个方法的时候就是输出这个方法的输出语句，当基类和子类的方法名相同返回类型相同访问权限也相同的时候，子类就重写了基类的非静态方法，就返回子类的输出语句
      System.out.println("Parent's Non-Static Method is Called");     
 }       
public static void staticMethod() {      
      System.out.println("parent's static method is called");      
 }     
}     
   
class Child extends Parent{     
  public void nonStaticMethod() {      
          System.out.println("child's non-static method is called");      
  }      
 public static void staticMethod() 
          System.out.println("child's static method is called");      
     }       
}  public class Test{     
      public static void main(String args[])          {       
           Parent p1 = new Parent();       
            Parent p2 = new Child();       
           Child c = new Child();     
         System.out.print("Parent.static: ");     
                Parent.staticMethod();      
         System.out.print("p1.static: ");     
        p1.staticMethod();      
           System.out.print("p2.static: ");     
        p2.staticMethod();     
            System.out.print("p1.nonStatic: ");     
        p1.nonStaticMethod();     
        System.out.print("p2.nonStatic: ");     
        p2.nonStaticMethod();     
        System.out.print("Child.static: ");     
      Child.staticMethod();     
  
      System.out.print("c.static: ");     
   
                 c.staticMethod();      
  
         System.out.print("c.nonStatic: ");     
   
        c.nonStaticMethod();      
   
      }     
   
}     

Answer 6

static 属于类, 在类级别中是没有继承的. 对象才能继承

Answer 7

答:按Gosling的说法,static方法 1)只有"隐藏",没有"重写".2)它是按"编译时期的类型"进行调用的,而不是按"运行时期的类型"进行调用的.  3)而非static方法,才是按"运行时期的类型"进行调用的.针对你的例子,Parent p2 = new Child(); 中,变量p2编译时期的类型是:Parent,运行时期的类型是Child(因为:运行时,p2真正指向的是对象new Child()),因此,调用static方法:p2.staticMethod(); 时,是按编译时期类型Parent. staticMethod(); 调用的,而调用p2.nonStaticMethod(); 时,非static方法,才是按"运行时期的类型"进行调用的.
由于p2运行时期的类型是Child,故真正调用的Child中定义的nonStaticMethod();.
Gosling的书是我认为讲的最权威和最清楚的书,建议可能的话,多仔细看看.以上仅供你参考   

Answer 8

严重批判！
静态方法在多态实现时，只能被隐藏，而不是被覆盖。即取决于你在定义变量时的定义方式。比如：class Parent{
public static void print(){
System.out.println("Parent!");
}
}class Child extends Parent{
public static void print(){
System.out.println("Child!");
}
}如果你定义的时候，使用 SuperClass cls = ...，那么调用静态方式时调用的就是SuperClass中的静态方法，其他则是子类中重写的方法；
如果 ChildClass cls = ...，那么调用的就是子类中的方法。如果你定义了ChildClass cls = ...，还想调用SuperClass中的静态方法，就((SuperClass)cls)转换