Howdy -- let me see if I can add a little more... (especially since I'm the one that probably made it confusing in the book

)
Normally, when we say "override" we mean the following;
* Redefine a non-static method in a subclass
(which of course means we have certain rules to follow like we can't change the args or return type, and we can't have more restrictive access or throw new or broader checked exceptions)
And when we do that, it means that the version of the method that runs (parent's version vs. child version) depends on the actual object type, not the reference type.
Normal overridden method;
public class Foo {
void go() { }
}
public class Bar extends Foo [
void go() { } // overrides the parent class method
}
// somewhere else...
Foo f = new Bar();
f.go(); // the Bar version runs, because Bar is the *object* type, even though Foo is the *reference* type - that's polymorphism in action.
But with a static method, the polymorphism does not apply.
public class Foo {
static void go() { }
}
public class Bar extends Foo [
static void go() { } // redeclares it, but this is not considered an override (even though it looks like it)
}
Foo f = new Bar();
f.go(); // this time the Foo version runs, even though Bar is the object type. Static methods are bound at compile time based on the *reference* type, which is Foo. So this tells us that the static go() method was not *really* overridden.
When you think "override", think "polymorphism", think "object type, not reference type"
cheers,
Kathy