Think about how overriding works. The compiler only looks at the type of the
reference to determine which signature we're calling and to see if the reference type has a method with that signature. Then at runtime, the JVM looks at the
object itself to see what class it is and what that class's version of the method is.
So for #1 and #4, the compiler determines that Parent has m1(), so it's legal. Then at runtime, for #1, the JVM see's that the object is of class Parent, and invokes Parent's m1(), and at #4 it sees that the object is of class Child and so it invokes Child's m1().
But for static methods, there is no associated object. Even when we use a reference like at #2 and #5--instead of the preferred form of using the class name as in #3 and #6--the JVM never looks at any objects, because no object is needed to call a static method. In fact, we could set the references to null, as in #7, and call the static methods, and there will be no NPE.
Of course, it could be asked, "But why didn't they design the language so that if there is a reference instead of the class name, it follows it to the object and calls the overridden method, just like with the non-static case?" Sure, they could have done that, and there are languages (Smalltalk I think, and maybe C++, probably others) where static methods can be overridden.
But the designers chose not to do so in
Java. Unless we ask them or get hold of their meeting notes and white papers, we can only speculate as to why they made that decision. A reasonable guess, however, is that they felt it would add too much complexity to the language for too little value. Simplicity has always been one of the core goals of Java.