Question

class XYZ{
    public static void show(){
        System.out.println("inside XYZ");
    }
}

public class StaticTest extends XYZ {
    public static void  show() {
        System.out.println("inside statictest");

    }

    public static void main(String args[]){
        StaticTest st =new StaticTest();
        StaticTest.show();

    }

}

虽然我们知道静态方法不能被覆盖。然后究竟发生了什么？

Answer 1

静态方法属于该类。他们无法覆盖。但是，如果在子类中定义了与父类静态方法具有相同签名的方法，则隐藏父类方法。 StaticTest.show()隐藏了XYZ.show()方法，因此StaticTest.show()是在代码中的main方法中执行的方法。

Answer 2

它不是overriding它们是具有相同签名的两个不同类中的两种不同方法。但XYZ中的方法在子类中不能通过继承获得。

它将从StaticTest

调用方法

Answer 3

它没有被正确覆盖说...静态方法与类“绑定”所以

StaticTest.show();

和

XYZ.show();

是完全不同的两件事。请注意，您无法调用super.show（）

Answer 4

要了解差异，您必须使用更强大的示例：

class Super {
    public static void hidden(Super superObject) {
        System.out.println("Super-hidden");
        superObject.overriden();
    }

    public void overriden() {
        System.out.println("Super-overriden");
    }
}

class Sub extends Super {
    public static void hidden(Super superObject) {
        System.out.println("Sub-hidden");
        superObject.overriden();
    }

    public void overriden() {
        System.out.println("Sub-overriden");
    }
}

public class Test {
    public static void main(String[] args) {
        Super superObject = new Sub();
        superObject.hidden(superObject);
    }
}

由于Samit G.已经在基类和派生类中编写了具有相同签名的静态方法，因此隐藏了实现，这是无意义的。您可以通过将静态方法中的一个或另一个更改为非静态方法或将它们更改为非静态来查看示例，以查看java编译器出现的编译错误。

Answer 5

这不是覆盖，而是隐藏XYZ中方法的单独方法。

Answer 6

据我所知，任何静态成员（方法或状态）都是类的属性，不会与类的任何实例相关联。因此，在您的示例中，XYZ是一个类，StaticTest也是如此（如您所知）。因此，通过调用构造函数，首先会发生两件事。创建类型为Class的Object。它上面有一个成员调用shows（）。类，XYZ.class，从Object扩展，因此它上面有所有那些Object方法加上show（）。与StaticClass相同，类对象也有show（）。它们都扩展了java.lang.Object。 StaticClass的一个实例也是XYZ的一个实例。但是现在更有趣的问题是当你在st？

上调用show（）时会发生什么

StaticClass st = new StaticClass();
st.show();
XYZ xyz = st;
xyz.show();

那里发生了什么？我的猜测是第一次是StaticClass.show（）而第二次是XYZ.show（）。

Answer 7

静态方法与类绑定，而不是与实例（对象）绑定。

因此，调用始终是ClassName.staticMethod（）;

当出现子类中相同静态方法的这种情况时，它被称为精炼（重新定义）静态方法而不是覆盖。

Answer 8

// Java允许从实例/对象引用中调用静态方法 //在C＃Dot net等其他纯OOP语言中并非如此。 //导致这种混乱。 //从技术上讲，静态方法总是绑定到Class而不是实例。 //换句话说，绑定是在编译时为静态函数。 - 早期绑定 // //例如。

class BaseClass 
{
 public static void f1()
 {
  System.out.println("BaseClass::f1()...");
 } // End of f1().
}

public class SubClass extends BaseClass 
{
  public static void f1() 
  {
    System.out.println("SubClass::f1()...");
    // super.f1(); // non-static variable super cannot be referenced from a static context

  } // End of f1().

  public static void main(String[] args)
  {
f1();
SubClass obj1 = new SubClass();
obj1.f1();
BaseClass b1 = obj1;
b1.f1();

  } // End of main().

} // End of class.

// Output:
// SubClass::f1()...
// SubClass::f1()...
// BaseClass::f1()...

// // //所以即使在这种情况下，使用实际引用的实例b1调用 //一个SuperClass类型的对象，它调用BaseClass：f1方法。 //

静态方法覆盖

8 个答案: