在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风格)。

通过重写，我们可以根据对象类型创建一个多态性质。静态方法与对象无关。因此java不支持静态方法重写。

重写静态方法有什么好处呢?不能通过实例调用静态方法。

MyClass.static1()
MySubClass.static1()   // If you overrode, you have to call it through MySubClass anyway.

编辑:似乎由于语言设计中的一个不幸疏忽，您可以通过实例调用静态方法。一般没人会这么做。我的坏。

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

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

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

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文档并搜索你可以在子类中做什么。

谢谢

我个人认为这是Java设计中的一个缺陷。是的，是的，我理解非静态方法附加到实例，而静态方法附加到类，等等。不过，考虑下面的代码:

public class RegularEmployee {
    private BigDecimal salary;

    public void setSalary(BigDecimal salary) {
        this.salary = salary;
    }

    public static BigDecimal getBonusMultiplier() {
        return new BigDecimal(".02");
    }

    public BigDecimal calculateBonus() {
        return salary.multiply(getBonusMultiplier());
    }

    /* ... presumably lots of other code ... */
}

public class SpecialEmployee extends RegularEmployee {
    public static BigDecimal getBonusMultiplier() {
        return new BigDecimal(".03");
    }
}

这段代码不能像您期望的那样工作。也就是说，特殊员工和普通员工一样有2%的奖金。但如果你去掉了“静态”，那么SpecialEmployee就能得到3%的奖金。

(不可否认，这个例子的编码风格很差，因为在现实生活中，你可能希望奖励乘数在数据库的某个地方，而不是硬编码。但这只是因为我不想用大量与主题无关的代码使示例陷入困境。)

在我看来，您可能想要使getBonusMultiplier成为静态的，这似乎很合理。也许您希望能够显示所有员工类别的奖金乘数，而不需要在每个类别中有一个员工实例。搜索这样的例子有什么意义呢?如果我们正在创建一个新的员工类别，并且还没有任何员工分配给它，该怎么办?这在逻辑上是一个静态函数。

但这并不奏效。

是的，是的，我可以想出很多方法来重写上面的代码，让它工作。我的观点不是它产生了一个无法解决的问题，而是它为粗心的程序员制造了一个陷阱，因为这种语言的行为不像我认为一个理性的人所期望的那样。

也许如果我试着为OOP语言编写一个编译器，我很快就会明白为什么实现它以覆盖静态函数是困难的或不可能的。

或许有一些很好的理由来解释为什么Java会这样做。有人能指出这种行为的好处吗，这种行为能让一些问题变得更简单吗?我的意思是，不要只是把我指给Java语言规范，然后说“看，这是它如何行为的文档”。我知道。但是，它为什么会有这样的表现，有一个很好的理由吗?(除了明显的“让它正常工作太难了”……)

更新

@VicKirk: If you mean that this is "bad design" because it doesn't fit how Java handles statics, my reply is, "Well, duh, of course." As I said in my original post, it doesn't work. But if you mean that it is bad design in the sense that there would be something fundamentally wrong with a language where this worked, i.e. where statics could be overridden just like virtual functions, that this would somehow introduce an ambiguity or it would be impossible to implement efficiently or some such, I reply, "Why? What's wrong with the concept?"

I think the example I give is a very natural thing to want to do. I have a class that has a function that does not depend on any instance data, and which I might very reasonably want to call independent of an instance, as well as wanting to call from within an instance method. Why should this not work? I've run into this situation a fair number of times over the years. In practice I get around it by making the function virtual, and then creating a static method whose only purpose in life is to be a static method that passes the call on to the virtual method with a dummy instance. That seems like a very roundabout way to get there.

其实我们错了。 尽管Java默认情况下不允许重写静态方法，但如果你彻底查看Java中Class和Method类的文档，你仍然可以通过以下工作方法来模拟静态方法重写:

import java.lang.reflect.InvocationTargetException;
import java.math.BigDecimal;

class RegularEmployee {

    private BigDecimal salary = BigDecimal.ONE;

    public void setSalary(BigDecimal salary) {
        this.salary = salary;
    }
    public static BigDecimal getBonusMultiplier() {
        return new BigDecimal(".02");
    }
    public BigDecimal calculateBonus() {
        return salary.multiply(this.getBonusMultiplier());
    }
    public BigDecimal calculateOverridenBonus() {
        try {
            // System.out.println(this.getClass().getDeclaredMethod(
            // "getBonusMultiplier").toString());
            try {
                return salary.multiply((BigDecimal) this.getClass()
                    .getDeclaredMethod("getBonusMultiplier").invoke(this));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        return null;
    }
    // ... presumably lots of other code ...
}

final class SpecialEmployee extends RegularEmployee {

    public static BigDecimal getBonusMultiplier() {
        return new BigDecimal(".03");
    }
}

public class StaticTestCoolMain {

    static public void main(String[] args) {
        RegularEmployee Alan = new RegularEmployee();
        System.out.println(Alan.calculateBonus());
        System.out.println(Alan.calculateOverridenBonus());
        SpecialEmployee Bob = new SpecialEmployee();
        System.out.println(Bob.calculateBonus());
        System.out.println(Bob.calculateOverridenBonus());
    }
}

输出结果:

0.02
0.02
0.02
0.03

我们想要达到的目标:)

即使我们将第三个变量Carl声明为regulareemployee并给它分配了SpecialEmployee实例，我们仍然会在第一种情况下调用regulareemployee方法，在第二种情况下调用SpecialEmployee方法

RegularEmployee Carl = new SpecialEmployee();

System.out.println(Carl.calculateBonus());
System.out.println(Carl.calculateOverridenBonus());

看看输出控制台:

0.02
0.03

;)