Understanding Variable Scope in Java

Types of Scope

In Java, there are four types of scope: local, instance, class, and method parameters. Each type of scope has its own rules and implications for how variables are declared and used.

1. Local scope: A variable declared inside a method, constructor, or block is called a local variable. It can only be accessed within the same method, constructor, or block. It is created when the method, constructor, or block is entered and destroyed when it is exited. 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.
2. Instance scope: A variable declared inside a class but outside any method, constructor, or block is called an instance variable. It belongs to an object of the class and can be accessed by any method or block in the same class. It is created when the object is instantiated and destroyed when the object is garbage collected. If an instance variable is not explicitly initialised, its default values are false for boolean types, null for object references, and 0 for numeric types.
3. Class scope: A variable declared inside a class but outside any method, constructor, or block with the static keyword is called a class variable or a static variable. It belongs to the class itself and can be accessed by any method or block in the same class or by using the class name. It is created when the class is loaded and destroyed when the class is unloaded. Like instance variables, they have default values, and they keep those values until the programme ends.
4. Method parameter scope: A variable that is passed as an argument to a method is called a method parameter. It can be accessed within the method and has the same value as the argument. It is created when the method is invoked and destroyed when the method is returned.

• Accessibility Outside the Block

A variable declared outside a block can be used inside the block, but a variable declared inside a block cannot be used outside the block. For example:

public class Main {
  public static void main(String[] args) {
    int x = 10; // declared outside the block
    { // this is a block
      int y = 20; // declared inside the block
      System.out.println(x); // prints 10
      System.out.println(y); // prints 20
    }
    System.out.println(x); // prints 10
    // System.out.println(y); // error: y cannot be resolved
  }
}        

• Redeclaration Inside the Block

A variable declared outside a block cannot be redeclared inside the block with the same name. For example:

public class Main {
  public static void main(String[] args) {
    int x = 10; // declared outside the block
    { // this is a block
      // int x = 20; // error: duplicate local variable x
      System.out.println(x); // prints 10
    }
    System.out.println(x); // prints 10
  }
}        

• Redeclaration Outside the Block

A variable declared inside a block can be redeclared outside the block with the same name, as long as they are in different scopes. For example:

public class Main {
  public static void main(String[] args) {
    { // this is a block
      int x = 10; // declared inside the block
      System.out.println(x); // prints 10
    }
    int x = 20; // declared outside the block
    System.out.println(x); // prints 20
  }
}