Types of Java Variables

In Java, variables are containers that store data values, such as numbers, text, or Boolean values. Java variables are categorized into different types based on their scope, lifetime, and usage, helping programmers manage data efficiently and write organized, maintainable code

Let us discuss the traits of every type of variable listed here in detail.

Local Variables 

A variable defined within a block, method, or constructor is referred to as a local variable. 

Key Features

• The Local variable is created at the time of declaration and destroyed when the function completes its execution.
• The scope of local variables exists only within the block in which they are declared.
• We first need to initialize a local variable before using it within its scope.

Example: Java Program to show the use of local variables

import java.io.*;

class Geeks {
    public static void main(String[] args)
    {
        // Declared a Local Variable
        int var = 10;

        System.out.println("Local Variable: " + var);
    }
}

Local Variable: 10

Example: This example demonstrates that local variables are only accessible within the block in which they are declared

// Java Program to show the use of Local Variables
import java.io.*;

public class Geeks {
    
    public static void main(String[] args)
    {
        // x is a local variable
        int x = 10;

        // message is also a local
        // variable
        String message = "Hello, world!";

        System.out.println("x = " + x);
        System.out.println("message = " + message);

        if (x > 5) {
            // result is a
            // local variable
            String result = "x is greater than 5";
            System.out.println(result);
        }
        // Uncommenting the line below will result in a
        // compile-time error System.out.println(result);
        for (int i = 0; i < 3; i++) {
            String loopMessage
                = "Iteration "
                  + i; // loopMessage is a local variable
            System.out.println(loopMessage);
        }
        // Uncommenting the line below will result in a
        // compile-time error
        // System.out.println(loopMessage);
    }
}

x = 10
message = Hello, world!
x is greater than 5
Iteration 0
Iteration 1
Iteration 2

Instance Variables

Instance variables are known as non-static variables and are declared in a class outside of any method, constructor, or block. 

Key Features

• Instance variables are created when an object is instantiated and destroyed when the object is destroyed.
• Can have access specifiers; default access is used if none is specified.
• Instance Variables are not mandatory to initialize; take default values based on data type (0 for int, null for String, etc.).
• Scope is throughout the class, except in static contexts.
• Accessed only through objects of the class.
• Instance Variables can be initialized using constructors or instance blocks.

Example: This example demonstrates the use of instance variables, which are declared within a class and initialized via a constructor, with default values for uninitialized primitive types.

import java.io.*;

class Geeks {

    // Declared Instance Variable
    public String geek;
    public int i;
    public Integer I;
    public Geeks()
    {
        // Default Constructor
        // initializing Instance Variable
        this.geek = "Sweta Dash";
    }

    // Main Method
    public static void main(String[] args)
    {
        // Object Creation
        Geeks name = new Geeks();

        // Displaying O/P
        System.out.println("Geek name is: " + name.geek);
        System.out.println("Default value for int is "+ name.i);
      
        // toString() called internally
        System.out.println("Default value for Integer is: "+ name.I);
    }
}

Geek name is: Sweta Dash
Default value for int is 0
Default value for Integer is: null

Static Variables

Key Features

Static variables in Java are variables declared with the static keyword inside a class but outside any method. They are shared among all objects of the class and exist for the entire lifetime of the program. 

• There is only one copy of a static variable for the entire class, and all objects share it
• Static variable are created at program start and destroyed when the program ends.
• Not mandatory to initialize; default values depend on the data type (0 for int, null for String, etc.).
• Can be accessed via the class name; accessing through objects shows a compiler warning.
• Cannot be declared locally inside instance methods.
• Can be initialized using static blocks.

Example: This example demonstrates the use of static variables, which belong to the class and can be accessed without creating an object of the class.

import java.io.*;

class Geeks {
    
    // Static variable
    static String geek = "Sweta Dash";
  
    public static void main(String[] args)
    {
        // Access static variable without creating an object
        System.out.println("Geek Name is: " + Geeks.geek);

        // static int c = 0; 
        // Error: static variables cannot be declared inside a method
    }
}

Geek Name is: Sweta Dash

Difference Between Local, Instance, and Static Variables