Java Variable Scope

Variable Scopes

• The scope of variables refers to the part of the program where the variable is accessible.
• Java identifiers have lexical (or static) scoping.
• Scope of a variable can be determined at compile time and is independent of the function call stack.

Types of Variable Scopes in Java

• Instance variables have class-level scope.
• These variables are declared inside a class, outside of any funciton.
• Instance variables can be directly accessed anywhere in class.
• The general scope of an instance variable extends throughout the class, except static methods.
• The lifespan of an instance variable lasts until the object stays in memory.

public class Puppy {
    private int puppyAge;

    public void setAge(int age) {
        // Access the instance variable and modify it
        puppyAge = age;
    }

    public int getAge() {
        // Access the instance variable
        return puppyAge;
    }

    public static void main(String[] args) {
        Puppy myPuppy = new Puppy();
        myPuppy.setAge(2);
        System.out.println("Puppy Age: " + myPuppy.getAge());
    }
}

• Local variables are declared inside a method, constructor, or code block.
• Only the precise block in which they are defined is accessible.
• A local variable exits the block's scope after it has been used, and its memory is freed.
• Temporary data is stored in local variables, which are frequently initialised in the block where they are declared.
• The Java compiler throws an error if a local variable is not initialised before being used.
• The range of local variables is the smallest of all the different variable types.

public SumExample {
    public void calculateSum() {
        int a = 5; // Local variable
        int b = 10; // Local variable
        int sum = a + b;
        System.out.println("The sum is: " + sum);
    } // a, b, and sum go out of scope here
}

• Static variables are a type of class variable shared across instances.
• Once declared, static variables can be used anywhere, even outside the class, without initialising the class.
• Unlike local variables, static variables' scopes are not limited to the class or block.

// Using Static variables
import java.io.*;

class Test {
    // Static variable in Test class
    static int var = 10;
}

class Geeks {
    public static void main(String[] args) {
        // Accessing the static variable
        System.out.println("Static Variable: " + Test.var);
    }
}

• Method and parameter-local variables are variables supplied to a method when it is invoked and are known as method parameters.
• They serve as inputs for method execution and are used to receive values from the caller.
• The scope of method parameters is restricted to the method in which they are defined, making them local to that method.
• Arguments given are allocated to the respective parameters when a method is called.

public class Geeks {
  // Class Scope variable
  static int x = 11;

  // Instance Variable
  private int y = 33;

  // Parameter Scope (x)
  public void testFunc(int x) {
    // Method Scope (t)
    Geeks t = new Geeks();
    this.x = 22;
    y = 44;

    // Printing variables with different scopes
    System.out.println("Geeks.x: " + Geeks.x);
    System.out.println("t.x: " + t.x);
    System.out.println("t.y: " + t.y);
    System.out.println("y: " + y);
  }

  // Main Method
  public static void main(String args[]) {
    Geeks t = new Geeks();
    t.testFunc(5);
  }
}

• A block-level scope is a variable declared inside a pair of brackets “{}” in a method.
• Block-level variables have scope within the brackets only.

// Using Block Scope
public class Test {
  public static void main(String args[]) {
    { // Block Level Scope
      {
        // The variable x has scope within the brackets
        int x = 10;
        System.out.println(x);
      }
      // Uncommenting below line would produce an error since variable x is
      // out of scope.
      // System.out.println(x);
    }
  }
}

Variable Storage Class and Java Memory Management

• Java Memory Management is a concept that involves the automatic allocation and deallocation of objects, managed by the Java Virtual Machine (JVM).
• Java Virtual Machine (JVM) uses a garbage collector to automatically remove unused objects, freeing up memory in the background.
• The VM defines various run time data areas used during execution of a program.
• Some of the areas are created by the JVM, whereas some are created by the threads used in a program.
• The memory area created by JVM is destroyed only when the JVM exits.
• The data areas of a thread are created during instantiation and destroyed when the thread exits.
• These areas include: Heap Area, Method Area, JVM Stacks, Native Method Stacks, and Program Counter (PC) Registers.
• Heap is a shared runtime data area where objects and arrays are stored.
• It is created when the JVM starts.
• The memory in the heap is allocated for all the class instances and arrays.
• Heap can be of fixed or dynamic size depending on the system's configuration.
• The JVM allows the user to adjust the heap size.
• When the "new" keyword is used, the object is allocated in the heap, and its reference is stored in the stack.
• There exists one and only one heap for a running JVM process.

Scanner sc = new Scanner(System.in)

• The Scanner object is stored in the heap, and the reference sc is stored in the stack.
• Garbage collection in the heap area is mandatory.
• Method area is a logical part of the heap and is created when the JVM starts.
• It is used to store class-level information such as class structures, Method bytecode, Static variables, Constant pool, and Interfaces.
• The method area can be of fixed or dynamic size, depending on the system's configuration.
• Though the method area is logically a part of heap, it may or may not be garbage collected even if garbage collection is compulsory in the heap area.
• A stack is created when a thread is created.
• It is used to store method execution data, including local variables, method arguments, and return addresses.
• Each Thread has its own stack to ensure thread safety.
• Stacks size can be either fixed or dynamic and can be set when the stack is created.
• The memory for a stack doesn't have to be contiguous.
• When a method completes execution, its associated stack frame is removed automatically.
• Memory is allocated for each thread when it is created and can have either a fixed or dynamic size.
• Native method stacks handle the execution of native methods that interact with the Java code.
• The native method stack is also known as C stacks.
• They are not written in Java language.
• Memory is allocated for each thread when it is created and can have either a fixed or dynamic size.

Call By Reference and Recursion

• Recursion is a process in which a method calls itself continuously.
• A method that calls itself is called a recursive method.
• Recursion is used in algorithms and problem-solving.
• Formal parameters are those that are defined during function definition.
• Actual parameters are those which are passed during the function call in other functions.
• C/C++ supports the call by reference because in the call by reference they pass the address of actual parameters in the place of formal parameters using Pointers.
• Java does not support pointers, so it does not support Call by Reference.
• For objects, the "value" being passed is a reference to the object, and this can cause confusion about whether Java is call-by-reference or call-by-value.
• When using recursion with objects in Java, references are passed by value.
• Changes to the object's state within the recursive method will be visible outside the method.
• Reassigning the parameter to a new object within the method won't affect the original reference.
• Here is the syntax:

returntype methodname() {
  // code to be executed
  methodname(); // calling same method
}

public class RecursionExample {
  public static void main(String[] args) {
    StringBuilder result = new StringBuilder();
    appendNumbers(result, 1, 5);
    System.out.println(result.toString()); // Prints "12345"
  }

  private static void appendNumbers(StringBuilder sb, int start, int end) {
    if (start > end) {
      return;
    }
    sb.append(start); // Modifies the object state - visible outside
    appendNumbers(sb, start + 1, end); // Recursive call
  }
}

• To mimic call by reference behavior in Java for recursion, you need to work with wrapper classes or containers.
• Java is inherently pass-by-value.
• The key approach is to use a container class (like an array or a custom wrapper class) to hold the values you want to modify.
• Since the container itself is passed by value but the reference points to the same object, changes to the object's contents will be visible outside the method.
• One way to mimic call by reference is by using a wrapper class.

public class RecursionCallByReferenceExample {
  // Wrapper class to mimic call by reference
  static class Wrapper<T> {
    T value;

    Wrapper(T value) {
      this.value = value;
    }
  }

  public static void main(String[] args) {
    // Using our wrapper to mimic call by reference
    Wrapper<Integer> number = new Wrapper<>(1);

    System.out.println("Before recursion: " + number.value);
    countUpTo(number, 5);
    System.out.println("After recursion: " + number.value);
  }

  private static void countUpTo(Wrapper<Integer> num, int limit) {
    System.out.println("Current value: " + num.value);

    if (num.value >= limit) {
      return; // Base case
    }

    // Modify the value inside the wrapper (mimics pass by reference)
    num.value = num.value + 1;

    // Recursive call with the same wrapper object
    countUpTo(num, limit);
  }
}

• Another method to mimic call by reference is by using single element arrays

public class ArrayReferenceRecursion {
  public static void main(String[] args) {
    int[] counter = {0}; // Single-element array to hold our value

    System.out.println("Initial value: " + counter[0]);
    recursiveIncrement(counter, 5);
    System.out.println("Final value: " + counter[0]);
  }

  private static void recursiveIncrement(int[] value, int times) {
    if (times <= 0) {
      return;
    }

    // Increment value inside the array
    value[0]++;
    System.out.println("Current value: " + value[0]);

    // Recursive call
    recursiveIncrement(value, times - 1);
  }
}