Scope of Variables in Java

In programming, scope of variable defines how a specific variable is accessible within the program or across classes. In this section, we will discuss the scope of variables in Java.

Scope of a Variable

In programming, a variable can be declared and defined inside a class, method, or block. It defines the scope of the variable i.e. the visibility or accessibility of a variable. Variable declared inside a block or method are not visible to outside. If we try to do so, we will get a compilation error. Note that the scope of a variable can be nested.

We can declare variables anywhere in the program but it has limited scope.
A variable can be a parameter of a method or constructor.
A variable can be defined and declared inside the body of a method and constructor.
It can also be defined inside blocks and loops.
Variable declared inside main() function cannot be accessed outside the main() function

Demo.java

  public class Demo  {  //instance variable    String name = “Andrew”;   //class and static variable   static double height= 5.9;   public static void main(String args[])   {  //local variable    int marks = 72;   }  }  

In Java, there are three types of variables based on their scope:

Member Variables (Class Level Scope)
Local Variables (Method Level Scope)

Member Variables (Class Level Scope)

These are the variables that are declared inside the class but outside any function have class-level scope. We can access these variables anywhere inside the class. Note that the access specifier of a member variable does not affect the scope within the class. Java allows us to access member variables outside the class with the following rules:

Access Modifier	Package	Subclass	Word
public	Yes	Yes	Yes
protected	Yes	Yes	No
private	No	No	No
default	Yes	No	No

Syntax:

  public class DemoClass  {  //variables declared inside the class have class level scope  int age;  private String name;  void displayName()   {  //statements  }  int dispalyAge()   {  //statements   }  char c;  }  

Let’s see an example.

VariableScopeExample1.java

  public class VariableScopeExample1  {  public static void main(String args[])   {  int x=10;  {  //y has limited scope to this block only      int y=20;  System.out.println(“Sum of x+y = ” + (x+y));  }  //here y is unknown   y=100;  //x is still known  x=50;  }  }  

Output:

Scope of Variables in Java

We see that y=100 is unknown. If you want to compile and run the above program remove or comment the statement y=100. After removing the statement, the above program runs successfully and shows the following output.

Sum of x+y = 30

There is another variable named an instance variable. These are declared inside a class but outside any method, constructor, or block. When an instance variable is declared using the keyword static is known as a static variable. Their scope is class level but visible to the method, constructor, or block that is defined inside the class.

Let’s see an example.

Product.java

  public class Product  {  //variable visible to any child class  public String pName;  //variable visible to product class only  private double pPrice;  //creating a constructor and parsed product name as a parameter  public Product (String pname)   {  pName = pname;  }  //function sets the product price  public void setPrice(double pprice)   {  pPrice= pprice;  }  //method prints all product info  public void getInfo()   {  System.out.println(“Product Name: ” +pName );  System.out.println(“Product Price: ” +pPrice);  }  public static void main(String args[])   {  Product pro = new Product(“Mac Book”);  pro.setPrice(65000);  pro.getInfo();  }  }  

Output:

Product Name: Mac Book  Product Price: 65000.0

Let’s see another example.

StaticVariableScope.java

  public class StaticVariableScope  {  //declaring a private static variable  private static double pivalue;  //declaring a constant variable  public static final String piconstant = “PI”;  public static void main(String args[])   {  pivalue = 3.14159265359;  System.out.println(“The value of ” + piconstant + ” is: ” + pivalue);  }  }  

Output:

The value of PI is: 3.14159265359

Local Variables (Method Level Scope)

These are the variables that are declared inside a method, constructor, or block have a method-level or block-level scope and cannot be accessed outside in which it is defined. Variables declared inside a pair of curly braces {} have block-level scope.

Declaring a Variable Inside a Method

  public class DemoClass1  {  void show()   {  //variable declared inside a method has method level scope  int x=10;  System.out.println(“The value of x is: “+x);  }  public static void main(String args[])   {  DemoClass1 dc = new DemoClass1();  dc.show();  }  }  

Output:

The value of x is: 10

Let’s see another example of method-level scope.

DemoClass2.java

  public class DemoClass2  {  private int a;      public void setNumber(int a)  {  this.a = a;  System.out.println(“The value of a is: “+a);  }  public static void main(String args[])   {  DemoClass2 dc = new DemoClass2();  dc.setNumber(3);  }  }  

Output:

The value of a is: 3

In the above example, we have passed a variable as a parameter. We have used this keyword that differentiates the class variable and local variable.

Declaring a Variable Inside a Constructor

VariableInsideConstructor.java

  public class VariableInsideConstructor  {    //creating a default constructor    VariableInsideConstructor()  {  int age=24;      System.out.println(“Age is: “+age);  }    //main() method    public static void main(String args[])  {    //calling a default constructor    VariableInsideConstructor vc=new VariableInsideConstructor();    }    }    

Output:

Age is: 24

Declaring a Variable Inside a Block

VariableInsideBlock.java

  public class VariableInsideBlock  {  public static void main(String args[])   {  int x=4;  {  //y has limited scope to this block only      int y=100;  System.out.println(“Sum of x+y = ” + (x+y));  y=10;  //gives error, already defined  int y=200;  }  //creates a new variable  int y;  }  }  

Output:

Scope of Variables in Java

Sum of x+y = 30

Let’s see another example.

BlockScopeExample1.java

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

Output:

Scope of Variables in Java

When we run the above program, it shows an error at line 9, cannot find symbol because we have tried to print the variable x that is declared inside the loop. To resolve this error, we need to declare the variable x just before the for loop.

BlockScopeExample2.java

  public class BlockScopeExample2  {  public static void main(String args[])  {  int x;  for (x = 0; x < 10; x++)  {  //prints 0 to 9      System.out.print(x+”t”);  }  //prints 10      System.out.println(x);  }  }  

Output:

012345678910

Next TopicGroovy vs Java

Scope of Variables in Java

Scope of Variables in Java

Scope of a Variable

Member Variables (Class Level Scope)

Local Variables (Method Level Scope)

Declaring a Variable Inside a Method

Declaring a Variable Inside a Constructor

Declaring a Variable Inside a Block

POJO in Java

Sphenic Number in Java

You may also like