Java Local Variable

Local Variable Rules in Java

1. Local variables are declared in a blocks, methods or constructors
2. Access modifiers cannot be used for declaring local variables.
3. Stack memory is used for storing local variables and function calls and has a fixed size
4. Local variables do not have default values. You must initialize them before using.
5. Local variables declared in loops or blocks are destroyed after the block or loop completes

Rules for Local Variables in Java:

1. Declaration and Initialization:

   • A local variable must be declared before it can be used.
   • Local variables must be initialized explicitly before use, as Java does not provide default values for them.

   java
   public void exampleMethod() {
       int num; // Declared but not initialized
       // System.out.println(num); // ERROR: Variable 'num' might not have been initialized
       num = 10; // Initialized
       System.out.println(num); // Works fine
   }
   

2. Scope:

   • The scope of a local variable is limited to the block (method, constructor, or loop) in which it is declared.
   • The variable is destroyed when the block exits.

   java
   public void showScope() {
       if (true) {
           int x = 5; // Local variable
           System.out.println(x); // Accessible here
       }
       // System.out.println(x); // ERROR: x is out of scope
   }
   

3. Access Modifiers:

   • Local variables cannot have access modifiers (e.g., public, private, protected).
   • They can only have final as a modifier to make them immutable.

   java
   public void test() {
       final int x = 10; // A final local variable
       // x = 20; // ERROR: Cannot assign a value to a final variable
   }
   

4. No Default Value:

   • Unlike instance variables, local variables do not have default values. You must initialize them before using.

5. Shadowing:

   • A local variable can shadow (hide) a class or instance variable with the same name. Use this to refer to the instance variable explicitly.

   java
   public class Example {
       int value = 20;
   
       public void method() {
           int value = 10; // Shadows the instance variable
           System.out.println(value); // Prints 10
           System.out.println(this.value); // Prints 20
       }
   }
   

6. Loops and Blocks:

   • Local variables declared in loops or blocks are destroyed after the block or loop completes.

   java
   public void loopExample() {
       for (int i = 0; i < 5; i++) {
           System.out.println(i); // Accessible inside the loop
       }
       // System.out.println(i); // ERROR: i is out of scope
   }
   

7. Lambda Expressions:

   • Local variables referenced in lambda expressions must be effectively final, meaning they cannot be reassigned after their initial assignment.

   java
   public void lambdaExample() {
       int num = 10;
       Runnable r = () -> System.out.println(num); // num is effectively final
       // num = 20; // ERROR: Variable used in lambda should be final or effectively final
       r.run();
   }