10. Block Scope & Variable Lifecycles

[!NOTE] In Java, variables do not live forever. A variable is born when it is declared, and it dies when its surrounding "Block" finishes executing. This is called Scope.

What is a Block?

A block of code refers to all of the code enclosed between curly braces { and }.

Variables are only accessible inside the block they are created in. Furthermore, they are only accessible after the exact line they are declared on.

public class Main {
  public static void main(String[] args) {
    
    // Code here CANNOT use x
    
    { // A block artificially begins here!

      int x = 100;

      // Code here CAN use x
      System.out.println(x);
      
    } // The block ends here. The variable 'x' is immediately destroyed in memory!

    // Code here CANNOT use x
  }
}

Practical Scope: For Loops

A very common practical example of Scope involves for loops.

When you declare your iterator variable int i = 0 inside the parenthesis of a for loop, that variable i is strictly scoped to the loop itself. You cannot access i once the loop finishes computing.

for (int i = 0; i < 5; i++) {
    System.out.println(i); // This is perfectly fine.
}

System.out.println(i); // COMPILATION ERROR! 'i' no longer exists!

If you need to know the value of i after the loop finishes (for example, to know exactly what index caused a failure), you must declare i in the block above the loop!

int i = 0; // Raised scope

for (i = 0; i < 5; i++) {
    if (i == 3) { break; }
}

System.out.println("The loop broke at index: " + i); // This works beautifully!

Scope Helps You Prevent Accidental Bugs

Scope is not only a rule to memorize for exams. It is a design tool. The smaller a variable's scope, the fewer places can accidentally change it. That makes code safer and easier to reason about.

Keep Variables Close to Where They Are Used

// Good: message exists only inside the branch that needs it
if (score >= 60) {
    String message = "Passed";
    System.out.println(message);
}

// message is not visible here, which is a good thing

Shadowing

Shadowing happens when an inner variable has the same name as an outer variable. It compiles in some cases, but it can confuse readers.

class Player {
    String name = "Guest";

    void updateName(String name) {
        this.name = name; // this.name means the field, name means the parameter
    }
}

The this keyword is useful when a parameter name intentionally matches a field name. You will see this pattern often in constructors and setters.

Scope and Memory

When a local variable goes out of scope, you can no longer access it. If it referenced an object, the object may later become eligible for garbage collection if nothing else references it. This is one reason Java can clean up many objects automatically.

Common Mistakes

Declaring variables too high in a method before they are needed.
Trying to use a loop counter after a loop when it was declared inside the loop.
Reusing the same variable name for different meanings in one method.
Confusing a local variable with a class field that has the same name.

Mini Practice

Write a method with an if block, a for loop, and a local variable inside each. Try to print those variables outside their blocks and observe the compiler errors. Then move only the variables that truly need wider scope.

Practice Lab: Scope Detective

Experiment with where variables can and cannot be used.

Declare a variable inside an if block and try to print it outside.
Declare a loop counter inside a for loop and try to print it after the loop.
Move only the variables that truly need wider access outside their blocks.
Create one example that uses this to distinguish a field from a parameter.

Goal: Understand why smaller scope makes programs safer and easier to debug.

Revision Checkpoint

Block: Code inside curly braces has its own scope.
Local variable: Exists only after declaration and inside its block.
Loop counter: A counter declared in a for loop is not available after the loop.
Small scope: Safer because fewer lines can accidentally change the variable.
this: Refers to the current object, often used to distinguish fields from parameters.

Before the quiz: Predict which variables are visible at three different lines inside a nested block example.