• +91-9142290450

  • Hajipur, Bihar, 844101

☰
❮
❯

Java Scope

← Previous Next →

In Java, scope refers to the region in a program where a variable is accessible or visible. It defines where a variable can be used and where it cannot. Understanding variable scope is essential because it helps avoid errors, memory waste, and confusion in large programs.

In simple words, a variable’s scope is its lifetime and visibility inside the program. Once a variable goes out of scope, it can no longer be accessed.

What Is Variable Scope in Java?

Every variable in Java is declared within a block of code such as a class, method, or loop. The scope of that variable depends on where it is declared. For example, if you declare a variable inside a method, it can only be accessed within that method.

In Java, scope is managed using curly braces { }. Anything declared inside these braces is considered part of that block, and variables declared there cannot be accessed outside it.

Types of Variable Scope in Java

There are four main types of variable scope in Java:

  1. Local Scope

  2. Instance Scope

  3. Static Scope

  4. Block Scope

Let’s understand each one with examples.

1. Local Variables (Local Scope)

A local variable is declared inside a method, constructor, or block. It can only be accessed within that method or block. Once the method finishes execution, the variable is destroyed.

Example:

class Example {
    void showMessage() {
        int number = 10;  // local variable
        System.out.println("Number is: " + number);
    }

    public static void main(String[] args) {
        Example obj = new Example();
        obj.showMessage();
        // System.out.println(number); // Error: number not visible here
    }
}

Here, the variable number is local to the showMessage() method. It cannot be used outside that method.

2. Instance Variables (Instance Scope)

Instance variables are declared inside a class but outside any method or block. Each object of the class has its own copy of instance variables. They are used to store data that belongs to a specific object.

Example:

class Student {
    String name;  // instance variable

    void setName(String studentName) {
        name = studentName;
    }

    void display() {
        System.out.println("Student name: " + name);
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("Ananya");
        s1.display();

        Student s2 = new Student();
        s2.setName("Riya");
        s2.display();
    }
}

Each object (s1 and s2) has its own copy of the name variable. Changing one does not affect the other.

3. Static Variables (Class Scope)

A static variable is declared using the static keyword. It belongs to the class rather than any specific object. This means all objects share the same copy of the static variable.

Example:

class Counter {
    static int count = 0;  // static variable

    Counter() {
        count++;
        System.out.println("Object count: " + count);
    }

    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
    }
}

All three objects share the same count variable. The output shows how the static variable keeps its value across different object creations.

4. Block Scope

A block is any code enclosed within curly braces { }. Variables declared inside a block are only accessible within that block. This type of scope is often seen in loops or conditional statements.

Example:

class BlockExample {
    public static void main(String[] args) {
        if (true) {
            int x = 100;  // block variable
            System.out.println("Inside block: " + x);
        }
        // System.out.println(x); // Error: x is out of scope
    }
}

The variable x is accessible only inside the if block. Once the block ends, x goes out of scope.

Variable Shadowing in Java

Variable shadowing happens when a variable declared inside a method or block has the same name as an instance variable. In this case, the local variable “shadows” or hides the instance variable.

Example:

class ShadowExample {
    int number = 10;  // instance variable

    void display() {
        int number = 20;  // local variable shadows instance variable
        System.out.println("Local number: " + number);
        System.out.println("Instance number: " + this.number);
    }

    public static void main(String[] args) {
        ShadowExample obj = new ShadowExample();
        obj.display();
    }
}

Here, number declared inside display() hides the instance variable number. Using this.number refers to the instance variable.

Scope of Variables in Loops and Conditions

Variables declared inside loops and conditions are only valid within that block. Once the block finishes, the variable is destroyed.

Example:

class LoopExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Value of i: " + i);
        }
        // System.out.println(i); // Error: i is out of scope
    }
}

The loop variable i cannot be accessed outside the loop block.

Best Practices for Variable Scope

  1. Keep variables as local as possible. This makes your code more readable and prevents accidental changes to global data.

  2. Use instance variables only when necessary. They should hold data that belongs to individual objects.

  3. Be careful with static variables. Since they are shared among all objects, changes in one instance affect all others.

  4. Avoid reusing variable names. It can cause confusion or variable shadowing.

  5. Always initialize variables. Using uninitialized variables can cause compilation errors.

Summary of the Tutorial

Variable scope in Java defines where a variable can be accessed within a program. There are four types of scopes — local, instance, static, and block scope. Local variables exist only within methods or blocks, instance variables belong to objects, static variables belong to the class, and block variables are accessible only inside curly braces.

Understanding scope helps in writing clean, organized, and bug-free Java programs. It also improves memory management and reduces variable conflicts in large codebases.

Practice Questions

  1. Write a Java program to demonstrate the difference between local and global variables by declaring variables with the same name inside and outside a method.

  2. Create a program where a class variable keeps track of the total number of objects created and print the count after creating several objects.

  3. Write a Java program to show how a local variable can shadow an instance variable within a method.

  4. Create a program that uses a static variable to count how many times a specific method has been called.

  5. Write a program to illustrate that a variable declared inside a loop is not accessible outside the loop.

  6. Develop a Java program to demonstrate how variables declared inside a block (like an if statement) are limited to that block’s scope.

  7. Create a Java class with multiple methods that access the same instance variable and print its value from each method.

  8. Write a Java program to show how changing the value of a static variable from one object affects all objects of the same class.

  9. Create a Java program that defines nested blocks and shows how variable scope behaves when variables of the same name are declared in inner and outer blocks.

  10. Write a Java program to explain that method parameters act as local variables within that method and cannot be accessed outside of it.

← Previous Next →

Try a Short Quiz.

coding learning websites codepractice

No quizzes available.

Java

online coding class codepractice

Java Basics

Java Variables & Data Types

Java Control Flow

Java Arrays

Java Methods

Java Classes & Objects

OOP Principles

Java Utilities

Error Handling

Collections Framework

Java File Handling

Advanced Java

codepractice logo
Login
Go Back Top