在Java(和许多面向对象语言，但我不能说所有;所有的方法都有一个固定的签名——参数和类型。在虚方法中，第一个参数是隐含的:对对象本身的引用，当从对象内部调用时，编译器会自动添加这个参数。

静态方法没有区别——它们仍然有固定的签名。然而，通过将方法声明为静态，您已经显式地声明了编译器不能在该签名的开头包含隐含的对象形参。因此，任何其他调用此方法的代码都不能试图将对象引用放到堆栈上。如果它确实这样做了，那么方法执行将无法工作，因为参数将在堆栈上的错误位置—移位1。

由于两者之间的差异;虚方法总是有一个上下文对象的引用(即this)，这样就可以引用堆中属于该对象实例的任何东西。但是对于静态方法，由于没有传递引用，该方法不能访问任何对象变量和方法，因为上下文是未知的。

如果您希望Java更改定义，以便为每个方法(静态方法或虚拟方法)传递对象上下文，那么实际上您将只有虚拟方法。

就像有人在评论中问的那样——你想要这个功能的原因和目的是什么?

I do not know Ruby much, as this was mentioned by the OP, I did some research. I see that in Ruby classes are really a special kind of object and one can create (even dynamically) new methods. Classes are full class objects in Ruby, they are not in Java. This is just something you will have to accept when working with Java (or C#). These are not dynamic languages, though C# is adding some forms of dynamic. In reality, Ruby does not have "static" methods as far as I could find - in that case these are methods on the singleton class object. You can then override this singleton with a new class and the methods in the previous class object will call those defined in the new class (correct?). So if you called a method in the context of the original class it still would only execute the original statics, but calling a method in the derived class, would call methods either from the parent or sub-class. Interesting and I can see some value in that. It takes a different thought pattern.

由于您正在使用Java工作，您将需要适应这种做事方式。他们为什么这么做?好吧，可能是为了提高当时的性能基于现有的技术和理解。计算机语言在不断发展。回顾过去，并没有OOP这种东西。在未来，还会有其他新的想法。

EDIT: One other comment. Now that I see the differences and as I Java/C# developer myself, I can understand why the answers you get from Java developers may be confusing if you are coming from a language like Ruby. Java static methods are not the same as Ruby class methods. Java developers will have a hard time understanding this, as will conversely those who work mostly with a language like Ruby/Smalltalk. I can see how this would also be greatly confusing by the fact that Java also uses "class method" as another way to talk about static methods but this same term is used differently by Ruby. Java does not have Ruby style class methods (sorry); Ruby does not have Java style static methods which are really just old procedural style functions, as found in C.

顺便说一下，谢谢你的问题!今天我学到了一些关于类方法的新知识(Ruby风格)。

重写依赖于类的实例。多态性的意义在于，您可以子类化一个类，而实现这些子类的对象对于父类中定义的相同方法将具有不同的行为(并且在子类中被重写)。静态方法不与类的任何实例相关联，因此这个概念不适用。

There were two considerations driving Java's design that impacted this. One was a concern with performance: there had been a lot of criticism of Smalltalk about it being too slow (garbage collection and polymorphic calls being part of that) and Java's creators were determined to avoid that. Another was the decision that the target audience for Java was C++ developers. Making static methods work the way they do had the benefit of familiarity for C++ programmers and was also very fast, because there's no need to wait until runtime to figure out which method to call.

现在看到上面的答案，每个人都知道我们不能重写静态方法，但不应该误解从子类访问静态方法的概念。

我们可以通过子类引用访问超类的静态方法，如果这个静态方法没有被子类中定义的新静态方法所隐藏。

例如，请参见下面的代码:-

public class StaticMethodsHiding {
    public static void main(String[] args) {
        SubClass.hello();
    }
}


class SuperClass {
    static void hello(){
        System.out.println("SuperClass saying Hello");
    }
}


class SubClass extends SuperClass {
    // static void hello() {
    // System.out.println("SubClass Hello");
    // }
}

输出:

SuperClass saying Hello

关于在子类中隐藏静态方法的细节，请参阅Java oracle文档并搜索你可以在子类中做什么。

谢谢

Here is a simple explanation. A static method is associated with a class while an instance method is associated with a particular object. Overrides allow calling the different implementation of the overridden methods associated with the particular object. So it is counter-intuitive to override static method which is not even associated with objects but the class itself in the first place. So static methods cannot be overridden based on what object is calling it, it will always be associated with the class where it was created.

简短的回答是:这是完全可能的，但Java没有做到。

下面是一些代码，说明了Java中的当前状态:

文件Base.java:

package sp.trial;
public class Base {
  static void printValue() {
    System.out.println("  Called static Base method.");
  }
  void nonStatPrintValue() {
    System.out.println("  Called non-static Base method.");
  }
  void nonLocalIndirectStatMethod() {
    System.out.println("  Non-static calls overridden(?) static:");
    System.out.print("  ");
    this.printValue();
  }
}

文件Child.java:

package sp.trial;
public class Child extends Base {
  static void printValue() {
    System.out.println("  Called static Child method.");
  }
  void nonStatPrintValue() {
    System.out.println("  Called non-static Child method.");
  }
  void localIndirectStatMethod() {
    System.out.println("  Non-static calls own static:");
    System.out.print("  ");
    printValue();
  }
  public static void main(String[] args) {
    System.out.println("Object: static type Base; runtime type Child:");
    Base base = new Child();
    base.printValue();
    base.nonStatPrintValue();
    System.out.println("Object: static type Child; runtime type Child:");
    Child child = new Child();
    child.printValue();
    child.nonStatPrintValue();
    System.out.println("Class: Child static call:");
    Child.printValue();
    System.out.println("Class: Base static call:");
    Base.printValue();
    System.out.println("Object: static/runtime type Child -- call static from non-static method of Child:");
    child.localIndirectStatMethod();
    System.out.println("Object: static/runtime type Child -- call static from non-static method of Base:");
    child.nonLocalIndirectStatMethod();
  }
}

如果你运行这个(我在Mac上做的，从Eclipse，使用Java 1.6)，你会得到:

Object: static type Base; runtime type Child.
  Called static Base method.
  Called non-static Child method.
Object: static type Child; runtime type Child.
  Called static Child method.
  Called non-static Child method.
Class: Child static call.
  Called static Child method.
Class: Base static call.
  Called static Base method.
Object: static/runtime type Child -- call static from non-static method of Child.
  Non-static calls own static.
    Called static Child method.
Object: static/runtime type Child -- call static from non-static method of Base.
  Non-static calls overridden(?) static.
    Called static Base method.

在这里，唯一可能令人惊讶的情况(也是这个问题所涉及的)似乎是第一种情况:

运行时类型并不用于确定调用哪些静态方法，即使是在使用对象实例(obj.staticMethod())调用时也是如此。

最后一种情况:

当从类的对象方法中调用静态方法时，选择的静态方法是类本身可访问的方法，而不是定义对象运行时类型的类可访问的方法。

使用对象实例调用

静态调用在编译时解析，而非静态方法调用在运行时解析。注意，尽管静态方法是继承的(从父方法)，但它们不会被(子方法)覆盖。如果你另有期待，这可能会是一个惊喜。

从对象方法中调用

对象方法调用使用运行时类型解析，但静态(类)方法调用使用编译时(已声明)类型解析。

改变规则

要更改这些规则，以便示例中的最后一个调用Child.printValue()，静态调用必须在运行时提供类型，而不是编译器在编译时使用对象(或上下文)声明的类解析调用。然后，静态调用可以使用(动态)类型层次结构来解析调用，就像现在的对象方法调用一样。

这是很容易做到的(如果我们改变Java:-O)，并不是完全不合理的，然而，它有一些有趣的考虑。

主要需要考虑的是，我们需要决定哪个静态方法调用应该执行此操作。

目前，Java语言中有这种“怪癖”，即obj.staticMethod()调用被ObjectClass.staticMethod()调用取代(通常带有警告)。[注意:ObjectClass是obj的编译时类型。]这些将是很好的候选人，以这种方式重写，采用obj的运行时类型。

如果我们这样做了，就会使方法体更难阅读:父类中的静态调用可能会被动态地“重新路由”。为了避免这种情况，我们必须使用类名调用静态方法——这使得调用更明显地用编译时类型层次结构来解析(就像现在一样)。

调用静态方法的其他方法更加棘手:this. staticmethod()的意思应该与obj.staticMethod()相同，接受this的运行时类型。然而，这可能会给现有程序带来一些麻烦，这些程序调用(显然是本地的)没有修饰的静态方法(可以说相当于this.method())。

那么无修饰调用staticMethod()会怎样呢?我建议他们像今天一样，使用本地类上下文来决定要做什么。否则就会产生巨大的混乱。当然，如果method是非静态方法，则method()意味着this.method()，如果method是静态方法，则意味着ThisClass.method()。这是另一个困惑的来源。

其他的考虑

如果我们改变了这种行为(并使静态调用具有潜在的动态非本地性)，我们可能会希望重新审视final、private和protected作为类静态方法的限定符的意义。然后，我们都必须习惯这样一个事实:私有静态方法和公共final方法不会被覆盖，因此可以在编译时安全地解析，并且可以“安全”地作为本地引用读取。

Well... the answer is NO if you think from the perspective of how an overriden method should behave in Java. But, you don't get any compiler error if you try to override a static method. That means, if you try to override, Java doesn't stop you doing that; but you certainly don't get the same effect as you get for non-static methods. Overriding in Java simply means that the particular method would be called based on the run time type of the object and not on the compile time type of it (which is the case with overriden static methods). Okay... any guesses for the reason why do they behave strangely? Because they are class methods and hence access to them is always resolved during compile time only using the compile time type information. Accessing them using object references is just an extra liberty given by the designers of Java and we should certainly not think of stopping that practice only when they restrict it :-)

示例:让我们试着看看如果我们尝试重写一个静态方法会发生什么:-

class SuperClass {
// ......
public static void staticMethod() {
    System.out.println("SuperClass: inside staticMethod");
}
// ......
}

public class SubClass extends SuperClass {
// ......
// overriding the static method
public static void staticMethod() {
    System.out.println("SubClass: inside staticMethod");
}

// ......
public static void main(String[] args) {
    // ......
    SuperClass superClassWithSuperCons = new SuperClass();
    SuperClass superClassWithSubCons = new SubClass();
    SubClass subClassWithSubCons = new SubClass();

    superClassWithSuperCons.staticMethod();
    superClassWithSubCons.staticMethod();
    subClassWithSubCons.staticMethod();
    // ...
}
}

输出: SuperClass:在staticMethod内部 SuperClass:在staticMethod内部 子类:staticMethod内部

注意输出的第二行。如果staticMethod被重写，这一行应该与第三行相同，因为我们在运行时类型的对象上调用'staticMethod()'作为'子类'而不是'超类'。这证实了静态方法总是只使用它们的编译时类型信息进行解析。