从静态方法调用超级方法

Question

是否可以从子静态方法调用超级静态方法？

我的意思是，以通用的方式，到目前为止，我有以下内容：

public class BaseController extends Controller {
    static void init() {
        //init stuff
    }
}

public class ChildController extends BaseController {
    static void init() {
        BaseController.loadState();
        // more init stuff
    }

}

并且它有效，但我想以通用的方式执行此操作，例如调用 super.loadState() ，这似乎不起作用。 ..

Answer 1

在Java中，静态方法不能被重写。 此处清楚地解释了原因

因此，它不依赖于它所引用的对象。但相反，它取决于引用的类型。因此，静态方法被称为隐藏另一个静态方法而不是覆盖它。

例如（Cat 是 Animal 的子类）：

public class Animal {
    public static void hide() {
        System.out.format("The hide method in Animal.%n");
    }
    public void override() {
        System.out.format("The override method in Animal.%n");
    }
}

public class Cat extends Animal {
    public static void hide() {
        System.out.format("The hide method in Cat.%n");
    }
    public void override() {
        System.out.format("The override method in Cat.%n");
    }
}

主类：

public static void main(String[] args) {
    Cat myCat = new Cat();
    System.out.println("Create a Cat instance ...");
    myCat.hide(); 
    Cat.hide();
    myCat.override();  

    Animal myAnimal = myCat;
    System.out.println("\nCast the Cat instance to Animal...");
    Animal.hide();     
    myAnimal.override();

    Animal myAnimal1 = new Animal();
    System.out.println("\nCreate an Animal instance....");
    Animal.hide();     
    myAnimal.override();
}

现在，输出如下所示

Create a Cat instance ...
The hide method in Cat.
The hide method in Cat.
The override method in Cat.  

Cast the Cat instance to Animal...
The hide method in Animal.
The override method in Cat.

Create an Animal instance....
The hide method in Animal.
The override method in Animal.

---

对于类方法，运行时系统调用引用的编译时类型中定义的方法调用该方法的对象。

换句话说，对静态方法的调用是在编译时映射的，并且取决于引用的声明类型（在本例中为 Parent），而不是运行时引用所指向的实例。在示例中，myAnimal 的编译时类型为 Animal。因此，运行时系统调用Animal中定义的hide方法。

Answer 2

Java 中有静态继承。改编 Nikita 的示例：

class A {
    static void test() {
        System.out.print("A");
    }
}
class B extends A {
}

class C extends B {
    static void test() {
        System.out.print("C");
        B.test();
    }

    public static void main(String[] ignored) {
       C.test();
    }
}

现在可以编译，当然，调用 C 会打印“CA”。现在我们将类 B 更改为：

class B extends A {
    static void test() {
        System.out.print("B");
    }
}

并仅重新编译 B（而不是 C）。现在再次调用 C，它将打印“CB”。

不过，静态方法没有 super 之类的关键字 - 一个（坏的）理由可能是“超类的名称写在此类的声明中，因此您必须重新编译您的类”尽管如此，为了改变它，所以你也可以在这里改变静态调用。”

Answer 3

整个继承概念不适用于 Java 中的静态元素。例如，静态方法不能覆盖另一个静态方法。
所以，不，您必须按名称调用它或使它们成为某个对象的实例方法。 （您可能特别想查看其中一种工厂模式）。

实际示例

class A {
    static void test() {
        System.out.println("A");
    }
}
class B extends A {
    static void test() {
        System.out.println("B");
    }
}

    A a = new B();
    B b = new B();
    a.test();
    b.test();

这将打印 A，然后打印 B。即，调用的方法取决于变量的声明方式，而不是其他。

Answer 4

如果您知道方法名称及其参数，您实际上可以以通用方式调用超类的静态方法。

public class StaticTest {

    public static void main(String[] args) {
        NewClass.helloWorld();
    }    
}

public class NewClass extends BaseClass {
    public static void helloWorld() {
        try {
            NewClass.class.getSuperclass().getMethod("helloWorld", new Class[] {}).invoke( NewClass.class ,new Object[]{} );
        } catch (Exception e) {
            e.printStackTrace();
        } 

        System.out.println("myVar = " + myVar);
    }
}

public class BaseClass extends BaseBaseClass {
    protected static String myVar;
    public static void helloWorld() {
        System.out.println("Hello from Base");
        myVar = "Good";
    }
}

这应该可行，并且在子类中，您可以使用基类中设置的所有内容。

输出应该是：

Hello from Base

myVar = Good

Answer 5

您的实现的正式名称称为方法隐藏。我建议引入静态 init(Controllercontroller) 方法，并调用实例方法来利用重写。

public class Controller {
   static void init(Controller controller) {
      controller.init();
   }

   void init() {
      //init stuff
   }
}

public class BaseController extends Controller {

   @override
   void init() {
      super.init();
      //base controller init stuff
   }

}

public class ChildController extends BaseController {
   @override
   void init() {
      super.init();
      //child controller init stuff
   }
}

然后您可以调用Controller.init(controllerInstance)。

Answer 6

对于静态方法，不需要类的实例，因此没有 super。