Chapter 6 — Java Variable Types

Where Do Variables Live?

In Java, a variable's "type" can also refer to where it is declared. This determines its scope (where it can be accessed) and lifetime (how long it exists in memory).

There are three main types of variables based on their declaration location:

• Local Variables: Declared inside a method.
• Instance Variables: Declared inside a class but outside a method.
• Class/Static Variables: Declared inside a class with the static keyword.

Understanding these differences is crucial for writing clean, bug-free, and efficient code.

Temporary Variables for a Method

A local variable is declared inside a method, constructor, or a block of code (like a loop or an `if` statement).

Key Characteristics:

• Scope: It is only accessible within the method or block where it is declared.
• Lifetime: It is created when the method/block is entered and destroyed as soon as the method/block is exited.
• No Default Value: Local variables do not have a default value. You must initialize them with a value before you can use them.

Think of them as temporary notes used to perform a specific task within a single method.

public class Calculator {
    
    public void addNumbers() {
        // 'a', 'b', and 'sum' are local variables to this method
        int a = 10;
        int b = 20;
        
        int sum = a + b; // Must be initialized before use
        
        System.out.println("The sum is: " + sum);
    }

    public void anotherMethod() {
        // System.out.println(sum); // ERROR! 'sum' does not exist here.
    }
}

Variables Belonging to an Object

An instance variable is declared inside a class but outside any method. Each object (instance) of the class gets its own separate copy of these variables.

Key Characteristics:

• Scope: Accessible to any method within the class. Its visibility to other classes can be controlled with access modifiers (public, private, etc.).
• Lifetime: It is created when an object of the class is created using new, and it is destroyed when the object is destroyed.
• Default Value: If not initialized, they get a default value (e.g., 0 for numbers, false for booleans, null for objects).

These variables define the state or properties of an object.

public class Dog {
    // 'name' and 'age' are instance variables.
    // Each Dog object will have its own name and age.
    String name;
    int age;

    public Dog(String dogName, int dogAge) {
        name = dogName;
        age = dogAge;
    }

    public void printDetails() {
        System.out.println("Dog's Name: " + this.name);
        System.out.println("Dog's Age: " + this.age);
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog("Rex", 5);
        Dog dog2 = new Dog("Buddy", 3);

        dog1.printDetails(); // Prints: Name: Rex, Age: 5
        dog2.printDetails(); // Prints: Name: Buddy, Age: 3
    }
}

Variables Shared by All Objects

A static variable (or class variable) is declared inside a class with the static keyword. There is only one copy of a static variable, and it is shared among all objects of that class.

Key Characteristics:

• Scope: Can be accessed by any object of the class, or more commonly, directly using the class name (ClassName.variableName).
• Lifetime: It is created when the program starts and is destroyed when the program ends. It is independent of any object creation.
• Default Value: Like instance variables, they get a default value if not initialized.

Static variables are often used for constants or for tracking data that should be common to all objects, like a counter.

public class Employee {
    private String name;
    
    // 'employeeCount' is a static variable.
    // It is shared by all Employee objects.
    private static int employeeCount = 0;

    public Employee(String employeeName) {
        this.name = employeeName;
        employeeCount++; // Increment the shared counter for each new employee
    }

    public static int getEmployeeCount() {
        return employeeCount;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Initial employees: " + Employee.getEmployeeCount()); // 0

        Employee emp1 = new Employee("Alice");
        Employee emp2 = new Employee("Bob");

        // Accessing static variable via class name (best practice)
        System.out.println("Total employees: " + Employee.getEmployeeCount()); // 2
    }
}

Notice how employeeCount is incremented each time a new Employee object is created, and the final count is the same regardless of which object you check (or if you check it via the class itself).