Java Variables

Variables in Java are containers for storing data values. Understanding variables is fundamental to Java programming.

Types of Variables

Primitive Variables

Java provides eight primitive data types for basic values:

• byte: 8-bit signed integer (-128 to 127)
• short: 16-bit signed integer (-32,768 to 32,767)
• int: 32-bit signed integer (-2³¹ to 2³¹-1)
• long: 64-bit signed integer (-2⁶³ to 2⁶³-1)
• float: 32-bit floating point
• double: 64-bit floating point
• boolean: true or false
• char: 16-bit Unicode character

Reference Variables

Reference variables store addresses that point to objects in memory:

• Objects: Instances of classes
• Arrays: Collections of similar type elements
• Strings: Special objects for text manipulation

Variable Declaration and Initialization

// Declaration
int age;
String name;

// Initialization
age = 25;
name = "Java Developer";

// Declaration and initialization
double salary = 75000.50;
boolean isActive = true;
char grade = 'A';

Variable Scope

Variables have different scopes based on where they're declared:

Instance Variables

public class Employee {
    private String name;  // Instance variable
    private int age;
    
    public Employee(String name, int age) {
        this.name = name;  // 'this' distinguishes from parameter
        this.age = age;
    }
}

Static Variables

public class Counter {
    private static int count = 0;  // Shared among all instances
    
    public Counter() {
        count++;
    }
    
    public static int getCount() {
        return count;
    }
}

Local Variables

public void calculate() {
    int result = 0;  // Local to this method
    for (int i = 0; i < 10; i++) {  // Loop variable
        result += i;
    }
    // 'i' is not accessible here
}

Memory Allocation

Stack Memory

• Stores primitive variables
• Stores references to objects
• Fast access
• Limited size
• Automatically managed

Heap Memory

• Stores objects
• Dynamic allocation
• Larger size
• Managed by garbage collector

public class MemoryExample {
    public static void main(String[] args) {
        int x = 10;           // Stack
        String name = "Java"; // Reference on stack, object on heap
        int[] numbers = new int[100]; // Reference on stack, array on heap
    }
}

Best Practices

1. Use descriptive names: customerAge instead of ca
2. Initialize variables: Avoid uninitialized variables
3. Use appropriate types: Choose the smallest type that fits your needs
4. Follow naming conventions: camelCase for variables
5. Limit scope: Declare variables in the smallest possible scope

Common Pitfalls

• Uninitialized local variables: Compiler error
• Variable shadowing: Hiding outer variables
• Type mismatch: Incompatible assignments
• Scope issues: Accessing variables outside their scope

Understanding variables and memory management is crucial for writing efficient and bug-free Java code.