In Java, variables are used to store data that can be manipulated throughout the program. Java provides several types of variables, each with its own scope, lifetime, and purpose.
Understanding variable types is fundamental to writing efficient and maintainable code.
This tutorial will cover different variable types in Java, including examples for each type.
Table of Contents
1. Local Variables
Local variables are declared within a method, constructor, or block and are only accessible within that scope. They are created when the method is invoked and destroyed when the method exits.
Key Points:
Must be initialized before use.
Not accessible outside the method or block in which they are declared.
public class LocalVariableExample {
public static void main(String[] args) {
// Local variable declared inside a method
int localVar = 10; // Must be initialized
// Using the local variable
System.out.println("Local Variable: " + localVar);
}
}
Explanation:
localVar is a local variable that is accessible only within the main() method.
Output:
Local Variable: 10.
2. Instance Variables
Instance variables (also called non-static fields) are declared within a class but outside any method. They are specific to an instance of a class, meaning each object of the class has its own copy of the instance variables.
Key Points:
No need to initialize (automatically initialized to default values).
Accessible by all methods of the class.
Their lifetime lasts as long as the object they are part of.
public class InstanceVariableExample {
// Instance variable
String name;
public void setName(String name) {
this.name = name; // 'this' refers to the instance variable
}
public void printName() {
System.out.println("Name: " + name); // Accessing instance variable
}
public static void main(String[] args) {
InstanceVariableExample obj = new InstanceVariableExample();
obj.setName("Alice");
obj.printName();
}
}
Explanation:
name is an instance variable. Each object of InstanceVariableExample will have its own name.
setName() method assigns a value to the instance variable.
Output:
Name: Alice.
3. Static Variables
Static variables (also called class variables) are declared using the static keyword. Unlike instance variables, static variables are shared among all instances of a class. They are associated with the class itself rather than any specific object.
Key Points:
Can be accessed without creating an instance of the class.
Only one copy of the static variable is shared among all instances.
Lifetime persists for the entire duration of the program.
public class StaticVariableExample {
// Static variable
static int count = 0;
public StaticVariableExample() {
count++; // Increment static variable
}
public static void printCount() {
System.out.println("Count: " + count); // Accessing static variable
}
public static void main(String[] args) {
// Creating objects
StaticVariableExample obj1 = new StaticVariableExample();
StaticVariableExample obj2 = new StaticVariableExample();
// Displaying the static variable
StaticVariableExample.printCount(); // No need to create an instance to access
}
}
Explanation:
count is a static variable. It is shared among all instances of StaticVariableExample.
Each time an object is created, count is incremented.
Output:
Count: 2 (because two objects are created).
4. Final Variables
Final variables are variables whose values cannot be changed once initialized. They are constants and are typically declared using the final keyword.
Key Points:
Must be initialized when declared or in a constructor.
Cannot be modified after initialization.
Used for constants.
public class FinalVariableExample {
// Final variable
final int MAX_AGE = 100;
public void display() {
System.out.println("Max Age: " + MAX_AGE); // Accessing final variable
}
public static void main(String[] args) {
FinalVariableExample obj = new FinalVariableExample();
obj.display();
}
}
Explanation:
MAX_AGE is a final variable and cannot be modified after initialization.
Output:
Max Age: 100.
5. Parameter Variables
Parameter variables are those that are passed to methods, constructors, or functions. They act as inputs to the method and are local to the method scope.
Key Points:
Defined as part of the method signature.
Only accessible within the method in which they are declared.
public class ParameterVariableExample {
// Method with parameter variable
public void greet(String name) {
System.out.println("Hello, " + name);
}
public static void main(String[] args) {
ParameterVariableExample obj = new ParameterVariableExample();
obj.greet("Alice"); // Passing "Alice" as a parameter
}
}
Explanation:
name is a parameter variable passed to the greet() method.
The value “Alice” is passed and used within the method.
Output:
Hello, Alice.
6. Block Variables
Block variables are declared within blocks of code, such as loops, if statements, or any other blocks enclosed in curly braces {}. They are only accessible within the block they are defined in.
Key Points:
Scope is limited to the block in which they are declared.
They exist only during the execution of the block.
public class BlockVariableExample {
public static void main(String[] args) {
int x = 10; // Local variable
// Block starts
{
int y = 20; // Block variable
System.out.println("Inside block: x = " + x + ", y = " + y);
}
// Block ends
// 'y' is not accessible here (outside the block)
// System.out.println("Outside block: y = " + y); // Error: y cannot be resolved
}
}
Explanation:
y is a block variable, and its scope is limited to the block in which it is defined.
Outside the block, trying to access y will cause a compilation error.
Output:
Inside block: x = 10, y = 20.
7. Shadowing Variables
Variable shadowing occurs when a local variable has the same name as an instance variable. The local variable “shadows” the instance variable within its scope.
Key Points:
The local variable hides the instance variable within the method.
To access the shadowed instance variable, use the this keyword.
public class ShadowingExample {
// Instance variable
String name = "Instance Variable";
public void setName(String name) {
// 'name' here is a local variable that shadows the instance variable
System.out.println("Local Variable: " + name);
System.out.println("Instance Variable: " + this.name);
}
public static void main(String[] args) {
ShadowingExample obj = new ShadowingExample();
obj.setName("Local Variable");
}
}
Explanation:
The local variable name shadows the instance variable with the same name.
this.name is used to refer to the instance variable.
Output:
Local Variable: Local Variable Instance Variable: Instance Variable
8. Default Values of Variables
Instance variables and static variables in Java are initialized to default values if not explicitly initialized. Local variables must be initialized before use.
Default Values:
int → 0
float → 0.0f
double → 0.0d
boolean → false
char → ‘\u0000' (null character)
Object references → null
public class DefaultValueExample {
// Instance variables
int num;
boolean flag;
String text;
public void display() {
System.out.println("Default int: " + num);
System.out.println("Default boolean: " + flag);
System.out.println("Default String: " + text);
}
public static void main(String[] args) {
DefaultValueExample obj = new DefaultValueExample();
obj.display();
}
}
Explanation:
Instance variables num, flag, and text are automatically initialized to their default values.
Output:
Default int: 0 Default boolean: false Default String: null
Conclusion
Java provides a variety of variable types, each with different behavior regarding scope, lifetime, and usage. Understanding these variable types is critical for writing effective Java programs:
Local Variables: Temporary storage within methods or blocks.
Instance Variables: Attributes of a class, specific to each object.
Static Variables: Shared among all instances of a class.
Final Variables: Constants that cannot be changed.
Parameter Variables: Passed as inputs to methods.
Block Variables: Exist within specific blocks of code.
By practicing with the examples provided, you will develop a strong understanding of how variables work in Java.