I hear people say it all the time..."I've got this static method that is overridden in my child class..." The long and short of it is that you're wrong - you don't have an overridden static method because you CAN'T have an overridden static method.

Let me quote the JLS, in section 8.4.6.2 Hiding (by Class Methods), it states:

"If a class declares a static method, then the declaration of that method is said to hide any and all methods with the same signature in the superclasses and superinterfaces of the class that would otherwise be accessible to code in the class."

So, now let's look at what that means, shall we?

class Parent
{
    public static void myStaticMethod()
    {
        System.out.println("A");
    }

    public void myInstanceMethod()
    {
        System.out.println("B");
    }
}

public class Child extends Parent
{
    public static void myStaticMethod()
    {
        System.out.println("C");
    }

    public void myInstanceMethod()
    {
        System.out.println("D");
    }

    public static void main(String[] args)
    {
        Parent o1 = new Parent();
        Parent o2 = new Child();
        Child  o3 = new Child();

        Parent.myStaticMethod();  // A
        Child.myStaticMethod();   // C

        o1.myStaticMethod();      // A
        o1.myInstanceMethod();    // B

        o2.myStaticMethod();      // A
        o2.myInstanceMethod();    // D

        o3.myStaticMethod();      // C
        o3.myInstanceMethod();    // D

        myStaticMethod();         // C
        myInstanceMethd();        // Compiler Error
    }
}

I have included the output next to each line so that you can see exactly what gets invoked. Pay particular attention to the methods invoked on the variable o2.

Notice that o2.myStaticMethod invokes Parent.myStaticMethod(). If this method were truly overridden, we should have invoked Child.myStaticMethod, but we didn't. Rather, when you invoke a static method, even if you invoke it on an instance, as we did here, you really invoke the method associated with the "compile-time type" of the variable. In this case, the compile-time type of o2 is Parent. Therefore, we invoke Parent.mStaticMethod().

However, when we execute the line o2.myInstanceMethod(), we really invoke the method Child.myInstanceMethod(). That's because, unlike static methods, instance methods CAN be overridden. In such a case, we invoke the method associated with the run-time type of the object. Even though the compile-time type of o2 is Parent, the run-time type (the type of the object o2 references) is Child. Therefore, we invoke Child.myInstanceMethod rather than Parent.myInstanceMethod().

Be sure to check out the JLS and what it has to say about overriding vs. hiding.