Integration

In Java all calls to static method are statically bound (and only those calls).

All calls to non-static methods are dynamically bound in Java.

The code of your example only presents dynamic binding.

Try to think of "binding" as when_ Java makes the connection between the name of your method and the code it executes.
With static binding (early), that association happens when you compile your program.
With dynamic binding (late), that association doesn't happen until the program is actually running.

Is there any reason static binding couldn't be used when a final method is invoked?

final methods cannot be overriden so they must be statically binded. are they ?

javap says "invokevirtual"

But they can be overloaded+.

I'm oversexed. Does that count?

I'm not sure how that helps the OP.
Am I missing something?

+" . . . and there's no runtime polymorphism on them."+

Even in the case of method overloading?

Static/dynamic binding refers to WHEN it's decided which method is to be called, at compile time (static binding) or at runtime (dynamic binding).

In principle any method that can be overriden is bound dynamically. This means any non-static, non-final or non-private method is bound dynamically. BUT due to clever optimization at runtime methods that are bound dynamically but aren't overridden are called as if they were statically bound.

Final methods can still be dynamically bound (if they override a non-final method and the non-final method is called)

But other than that, this is the reason why I always have a bad feeling about posting that kind of high-level overview: I feel like I always forget some cases and therefore write illegitimate generalizations.

Overloading is always resolved at compile time (i.e. the exact signature of the method to be called is decided at compile time). Only Overriding is done at runtime (i.e. the exact method to be called from among the methods with the given signature is decided at runtime).

Understood.
Thank you.