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
Example: This example demonstrates that local variables are only accessible within the block in
which they are declared
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.
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.
Difference Between Local, Instance, and Static Variables
FEATURE LOCAL VARIABLE INSTANCE VARIABLE STATIC VARIABLE
DECLARED Inside method/block Inside class, outside Inside class with static
methods keyword
SCOPE Only within the Across class methods Shared across all
block/method (non-static) objects of class
LIFETIME Exists only during Exists as long as Exists throughout
method/block object exists program execution
NUMBER OF Each method call Each object has its Only one copy for the
COPIES creates new own copy class
DEFAULT VALUE No default; must Default based on type Default based on type
initialize (0, null) (0, null)
ACCESS Only within Through objects Through class name (or
method/block object)
INITIALIZATION Required before use Optional; can use Optional; can use static
constructors blocks
