What is the difference between method overriding and method hiding in Java?

## The core idea Java lets a subclass declare a member (method or field) with the same name as one in its superclass. Depending on *what kind* of member it is, Java does one of two very different things — **overriding** or **hiding** — and they resolve the call at different times. ### Terms defined - **Class / subclass (child) / superclass (parent):** a class can `extends` another, inheriting its members. `Child extends Parent`. - **Instance method:** a normal method that operates on an object (`void run()`), invoked on an instance. - **Static method:** a method declared `static`; it belongs to the *class itself*, not to any instance (`static void run()`). - **Field:** a data member (a variable) declared in the class body. - **Signature:** the method name plus its parameter types. Two methods *match* when their signatures are the same. - **Compile-time type (static type / declared type):** the type written in the variable's declaration, e.g. in `Parent p = new Child();` the compile-time type of `p` is `Parent`. - **Runtime type (dynamic type / actual type):** the class of the object actually created — here `Child`. - **Static binding (early binding):** the compiler decides at compile time *which* member a name refers to, using the compile-time type. - **Dynamic binding (late binding / dynamic dispatch):** the JVM decides at *run* time which method body to execute, using the runtime type of the object. This is what makes polymorphism work. ### Overriding (instance methods) When a subclass declares an instance method with the same signature as a superclass instance method, it **overrides** it. Java uses **dynamic dispatch**: the method body that runs is chosen by the object's **runtime type**, no matter what reference type you call through. ```java Parent p = new Child(); p.instanceMethod(); // runs Child's version — runtime type wins ``` This is the engine of polymorphism: you write code against `Parent` and get `Child`'s behavior. ### Hiding (static methods) Static methods are **not** polymorphic. If a subclass declares a static method with the same signature, it **hides** the parent's. Resolution is **static binding** by the **compile-time type** of the reference (and static methods should really be called on the class name, not a reference, anyway). ```java Parent p = new Child(); p.staticMethod(); // runs Parent's version — compile-time type wins ``` The object is a `Child`, but because the reference is declared `Parent` and the method is static, `Parent`'s version runs. This surprises people who expect override-like behavior. ### Field hiding Fields behave like static methods for resolution: they are **never** overridden, only **hidden**. Field access is resolved by the **compile-time type** of the expression. If both `Parent` and `Child` declare a field `name`, then `((Parent) child).name` reads `Parent.name` and `child.name` (typed `Child`) reads `Child.name` — *the same object holds both fields simultaneously.* ### The summary rule > **Methods resolve by the runtime type (dynamic). Fields and static methods resolve by the compile-time/declared type (static).** ### Why it matters Hiding looks like overriding in source code but behaves oppositely, which produces bugs that are hard to spot. The `@Override` annotation is your guard: it compiles only on a genuine override and errors on an accidental hide or signature typo. Best practice: don't redeclare static methods across a hierarchy, and keep field names unique down a hierarchy (or keep fields private and expose them through overridable getters, which *do* dispatch dynamically).