Explain variable scope in Java: what determines where a variable is visible, and what happens when names overlap (shadowing)?

## What 'scope' means **Scope** is the part of the program text where a given name is valid and refers to a specific declaration. When the compiler sees a name like `count`, it must decide *which* declaration you mean; scope rules answer that. ### Block scope for locals Java uses **block scope**. A *block* is any region delimited by `{ }` — a method body, a loop body, an `if` branch, or a bare `{ }`. A local variable is visible: - from the point of its declaration (not before — you cannot use it on a line above its declaration), - to the end of the enclosing block, - including any blocks nested inside. ```java void demo() { int a = 1; // visible for the rest of demo() if (a == 1) { int b = 2; // visible only inside this if-block System.out.println(a + b); // both visible } // b is NOT visible here } ``` A variable declared in a `for` header (`for (int i = 0; ...)`) is scoped to the loop only. ### Field scope **Instance** and **static** variables (fields) are declared in the class body and are in scope throughout the entire class — every method and constructor can see them, regardless of textual order (a method can use a field declared *below* it). Their visibility to *other* classes is a separate concern controlled by access modifiers (`private`, `public`, …), which is *accessibility*, not *scope*. ### Shadowing **Shadowing** happens when a name in an inner scope hides a same-named declaration in an outer scope. The most common case: a local variable or parameter has the same name as a field. ```java class Box { int size = 10; // field void setSize(int size) { // parameter shadows the field size = size; // BUG: assigns the parameter to itself this.size = size; // correct: field = parameter } } ``` Inside `setSize`, the unqualified `size` means the *parameter* (the nearest declaration). To reach the shadowed field you must qualify it: `this.size` for an instance field, `Box.size` for a static field. ### What is and isn't allowed - You **cannot** declare two locals with the same name in *overlapping* scopes (e.g. a local and then another local of the same name in a nested block) — that is a compile error. - You **can** reuse a name in *disjoint sibling* blocks (two separate `if` branches), because their scopes do not overlap. - A local **can** shadow a field (allowed), and a field is never a compile error against a local because they are different kinds of declaration. ### Why narrow scope is good practice Declaring variables as locally and as late as possible: - limits the chance of using a stale or wrong value, - makes the variable's purpose obvious, - helps the JVM and reader reason about lifetime, - avoids accidental shadowing confusion. The classic guidance (Effective Java): *minimize the scope of local variables* and prefer initializing them at the point of declaration.