How do the modifiers in a method header (static, final, abstract, synchronized, access) shape what the method is and how it is dispatched, and what tensions arise when combining them?

## The two families of modifiers - **Access modifiers** — `public`, `protected`, default/package-private (no keyword), `private`. They control *who can call* the method and, indirectly, who can *override* it. - **Non-access modifiers** — `static`, `final`, `abstract`, `synchronized`, `native`, `strictfp`, plus `default` (interface methods). They change the method's *nature*, *dispatch*, or *lifecycle*. ## How modifiers govern dispatch (the core senior/principal insight) Java uses **dynamic (virtual) dispatch** for instance methods: the actual method run is chosen by the object's runtime type. But three modifiers opt a method *out* of virtual dispatch, binding it statically at compile time: - **`static`** — belongs to the class; resolved by the *compile-time* type of the reference. Static methods are **hidden**, not overridden; `@Override` is illegal on them. - **`private`** — not visible to subclasses, so it cannot be overridden; bound statically. - **`final`** — explicitly forbids overriding, so the compiler/JIT may bind/inline it directly. Everything else (a normal `public`/`protected` instance method) is virtually dispatched. Understanding this is what lets you reason about whether a subclass can change behaviour. ## abstract: the 'no body' modifier and its incompatibilities `abstract` declares a method with **no body**; the class must itself be `abstract`, and a concrete subclass must implement it. Because its entire purpose is *to be overridden*, it conflicts with anything that prevents or bypasses overriding: - `abstract` + `final` → contradiction (must override vs cannot override) — **illegal**. - `abstract` + `static` → static methods aren't overridden (they're hidden) and have no instance to dispatch on — **illegal**. - `abstract` + `private` → private isn't visible to subclasses to override — **illegal**. - `abstract` + `synchronized` → there's no body to synchronize — **illegal**. - `abstract` + `native` → both assert 'no Java body here' in different ways — **illegal** together. These are not arbitrary: each is the compiler rejecting a semantic contradiction. ## final: design intent and optimisation `final` on a method means **no subclass may override it**. Uses: - *Design*: freeze an algorithm (e.g. a template-method step you don't want altered), enforce invariants, prevent a subclass from breaking security-sensitive logic. - *Performance*: non-virtual binding enables inlining (though the modern JIT does much of this via class-hierarchy analysis anyway). - *Security*: a `final` method can't be overridden by a malicious subclass to subvert checks. ## synchronized: an implementation detail, not a contract `synchronized` on an instance method acquires that **instance's monitor** (`this`); on a `static` method it acquires the **Class object's monitor**. Important design points: - It is *not* part of the method signature or the interface — a subtype/override is free to drop it, so callers can't rely on it. *Effective Java*: prefer private lock objects / synchronized blocks over `synchronized` on a public method, because publishing the lock (the instance) lets outside code interfere. - Two `synchronized` instance methods on the same object are mutually exclusive; instance and static synchronized methods use *different* locks and don't exclude each other. ## access modifiers and overriding Access interacts with extensibility: - A `private` method is invisible to subclasses (no override; redeclaring it in a subclass is a new, unrelated method). - An override may only **widen** access (e.g. `protected` → `public`), never narrow it — narrowing would break substitutability. ## Putting it together: modifiers as contract The header's modifiers encode three orthogonal intents: 1. **Visibility** (access) — the API surface. 2. **Extensibility/dispatch** (`final`, `static`, `private`, `abstract`) — can this be specialised, and how is the actual implementation chosen? 3. **Concurrency/runtime** (`synchronized`, `native`, `strictfp`) — implementation concerns that ideally stay out of the published contract. The principal-level skill is reading a header and immediately knowing the override/dispatch story and which combinations are even legal, then using those modifiers deliberately to constrain how others may extend your type.