Scope of Variables in Java

Last Updated : 05 May, 2025

The scope of variables is the part of the program where the variable is accessible. Like C/C++, in Java, all identifiers are lexically (or statically) scoped, i.e., scope of a variable can be determined at compile time and independent of the function call stack. In this article, we will learn about Java Scope Variables.

Java Scope of Variables

Java Scope Rules can be covered under the following categories.

Instance Variables
Static Variables
Local Variables
Parameter Scope
Block Scope

Now we will discuss all these Scopes and variables according to them.

1. Instance Variables - Class Level Scope

These variables must be declared inside a class (outside any function). They can be directly accessed anywhere in class. Let's take a look at an example:

public class Test {
// All variables defined directly inside a class
// are member variables
int a;
private String b;

void method1() {....}
int method2() {....}

char c;
}

We can declare class variables anywhere in the class, but outside methods.
Access specified of member variables doesn't affect scope of them within a class.
Member variables can be accessed outside a class.

Access Modifiers and Member Variable Scope

Modifier	Package	Subclass	World
public	Yes	Yes	Yes
protected	Yes	Yes	No
Default (no modifier)	Yes	No	No
private	No	No	No

2. Static Variables - Class Level Scope

Static Variable is a type of class variable shared across instances. Static Variables are the variables which once declared can be used anywhere even outside the class without initializing the class. Unlike Local variables it scope is not limited to the class or the block.

Example:

Java

// 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);
    }
}

Output

Static Variable : 10

3. Method Level Scope - Local Variable

Variables declared inside a method have method level scope and can't be accessed outside the method.

public class Test {
void method1()
{
// Local variable (Method level scope)
int x;
}
}

Note: Local variables don't exist after method's execution is over.

4. Parameter Scope - Local Variable

Here's another example of method scope, except this time the variable got passed in as a parameter to the method:

class Test {
private int x;

public void setX(int x) {
this.x = x;
}
}

The above code uses this keyword to differentiate between the local and class variables.

Example of Method and Parameter Scope:

Java

// Using Method Scope and Parameter Scope
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); 
    }
}

Output

Geeks.x: 22
t.x: 22
t.y: 33
y: 44

5. Block Level Scope

A variable declared inside pair of brackets "{" and "}" in a method has scope within the brackets only.

Example:

Java

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

        // System.out.println(x); 
    }
}

Output

Incorrect Usage of Local Variables

1. For Block Level Cases which are wrong

Let's look at tricky example of loop scope. Predict the output of following program. You may be surprised if you are regular C/C++ programmer.

Programs:

Case 1

class Test
{
    public static void main(String args[])
    {
      	// local variable declared
        int a = 5;
      
      	// for loop variable declared 
        for (int a = 0; a < 5; a++)
        {
            System.out.println(a);
        }
    }
}


/*
Output: 

6: error: variable a is already defined in method go(int)
       for (int a = 0; a < 5; a++)       
                ^
1 error
*/

Case 2

// Java Program Implementing
// Block Level Variables
class Test
{
    public static void main(String args[])
    {
      	// Block Created
        {
          	// variable inside block
            int x = 5;
          
          	// Nested Block
            {
              	// Variable inside nested block
                int x = 10;
                System.out.println(x);
            }
        }
    }
}


/*
Output: 

./Test.java:8: error: variable x is already defined in method main(String[])
                int x = 10;
                    ^
1 error
/*

Note: In C++, Program 1 will run. But in Java it is an error because in Java, the name of the variable of inner and outer loop must be different. A similar program in C++ works. See this.

2. Incorrect Way to use Local Variable - Block Scope

Incorrect

class Test
{
    public static void main(String args[])
    {
        for (int x = 0; x < 4; x++)
        {
            System.out.println(x);
        }

        // Will produce error
        System.out.println(x);
    }
}


/* 
Output:	
11: error: cannot find symbol
System.out.println(x);      

*/

Correct

// Correcting the error
class Test
{
    public static void main(String args[])
    {
        int x;
        for (x = 0; x < 4; x++) {
            System.out.print(x + " ");
        }

       System.out.println(x);
    }
}

Output:

0 1 2 3 4

Java Program Demonstrating All Variable Scopes

Example:

Java

public class Geeks {

    // Instance Variable (belongs to each object)
    private int instanceVar = 10;

    // Static Variable (shared among all instances)
    static int staticVar = 100;

    // Constructor demonstrating parameter scope
    public Geeks(int instanceVar) {
        
        // Parameter Scope 
        // using 'this' to refer to instance variable
        this.instanceVar = instanceVar;
    }

    // Method to demonstrate local, parameter, and block scope
    public void showScopes(int paramVar) {
        
        // Local Variable 
        // only accessible in this method
        int localVar = 20;

        System.out.println("Instance Variable: " + instanceVar);
        System.out.println("Static Variable: " + staticVar);
        System.out.println("Method Parameter: " + paramVar);
        System.out.println("Local Variable: " + localVar);

        // Block Scope (variable only accessible inside this block)
        if (localVar > 10) {
            int blockVar = 5;
            System.out.println("Block Variable: " + blockVar);
        }

        // Uncommenting below line would cause an error: blockVar out of scope
        // System.out.println(blockVar);
    }

    public static void main(String[] args) {
        Geeks obj = new Geeks(50);
        obj.showScopes(30);
    }
}

Output

Instance Variable: 50
Static Variable: 100
Method Parameter: 30
Local Variable: 20
Block Variable: 5

Important Points about Variable Scope in Java

In general, a set of curly brackets { } defines a scope.
In Java we can usually access a variable as long as it was defined within the same set of brackets as the code we are writing or within any curly brackets inside of the curly brackets where the variable was defined.
Any variable defined in a class outside of any method can be used by all member methods.
When a method has the same local variable as a member, "this" keyword can be used to reference the current class variable.
For a variable to be read after the termination of a loop, It must be declared before the body of the loop.

Java

// Java Program to demonstrate
// local variables - block level

class Test 
{
    public static void main(String args[])
    {
        for (int i = 1; i <= 10; i++) {
            System.out.print(i + " ");
        }
      
        int i = 20;
        System.out.print(i + " ");
    }
}

Output

1 2 3 4 5 6 7 8 9 10 20

Reason: Yes, it will run. See the program carefully, inner loop will terminate before the outer loop variable is declared. So the inner loop variable is destroyed first and then the new variable of same name has been created.

Java Data Types

kartik

Improve

Article Tags :

Practice Tags :

Java

Scope of Variables in Java

Java Scope of Variables

1. Instance Variables - Class Level Scope

Access Modifiers and Member Variable Scope

2. Static Variables - Class Level Scope

3. Method Level Scope - Local Variable

4. Parameter Scope - Local Variable

5. Block Level Scope

Incorrect Usage of Local Variables

1. For Block Level Cases which are wrong

2. Incorrect Way to use Local Variable - Block Scope

Java Program Demonstrating All Variable Scopes

Important Points about Variable Scope in Java

Similar Reads

Basics of Java

Variables & DataTypes in Java

Operators in Java

Packages in Java

Flow Control in Java

Loops in Java

Jump Statements in Java

Arrays in Java

Strings in Java

OOPS in Java

Thank You!

What kind of Experience do you want to share?