#Java Variable Types and Naming

In Java, variables are containers used to store data values. Based on where variables are declared, Java variables can be divided into three main types: Instance Variables, Class/Static Variables, and Local Variables.

#1. Instance Variables

Instance variables are declared within a class, but outside of any method, constructor, or code block. They are attributes of an object.

• Lifecycle: When an object is created, instance variables are created; when the object is destroyed, they are destroyed.
• Scope: Visible throughout the class, but can only be accessed through object instances.
• Storage Location: Heap memory, because they are part of the object.
• Default Value: If not explicitly initialized, instance variables automatically get default values (0 for numeric, false for boolean, null for reference types).

Example:

public class Dog {
    // The following are all instance variables
    String name; // Default value is null
    int age;     // Default value is 0

    public Dog(String dogName) {
        // 'this.name' refers to the instance variable of the current object
        this.name = dogName;
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");
        Dog anotherDog = new Dog("Max");

        // Each object has its own copy of instance variables
        System.out.println("First dog's name: " + myDog.name); // Output: Buddy
        System.out.println("Second dog's name: " + anotherDog.name); // Output: Max
    }
}

#2. Class Variables (Static Variables)

Class variables are declared using the static keyword. They are also declared within a class, but outside of any method, constructor, or code block.

• Key Characteristic: A class has only one copy of a class variable, no matter how many objects of that class are created. This variable is shared by all objects.
• Lifecycle: Created when the program starts and the class is loaded into memory, destroyed when the program ends.
• Scope: Can be accessed directly through the class name, or through object instances (though not recommended).
• Storage Location: Method area in memory (or metaspace, depending on JVM version).
• Default Value: Same as instance variables, has default values.

Example: Suppose we want to count how many dogs have been created in total.

public class Dog {
    String name; // Instance variable
    
    // 'dogCount' is a class variable used to track the number of all Dog objects
    static int dogCount = 0;

    public Dog(String name) {
        this.name = name;
        dogCount++; // Counter increases by 1 each time a Dog object is created
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Initial dog count: " + Dog.dogCount); // Access directly through class name

        Dog dog1 = new Dog("Buddy");
        Dog dog2 = new Dog("Max");

        System.out.println("Dog count after creating two dogs: " + Dog.dogCount); // Output: 2
        // Can also access through instance, but not recommended as it causes confusion
        System.out.println("Access count through dog1: " + dog1.dogCount); // Output: 2
    }
}

#3. Local Variables

Local variables are declared inside methods, constructors, or code blocks.

• Lifecycle: Created when entering the method/code block, destroyed when exiting.
• Scope: Only visible within the method, constructor, or code block where it is declared.
• Storage Location: Stack memory.
• Default Value: No default value! Local variables must be explicitly initialized before use, otherwise the compiler will report an error.

Example:

public class Calculator {
    public void calculateSum() {
        // 'sum' is a local variable, must be initialized
        int sum = 0; 
        
        for (int i = 0; i < 10; i++) { // 'i' is also a local variable, scope is only within the for loop
            sum += i;
        }

        // System.out.println(i); // This will cause an error because 'i' is out of scope

        System.out.println("The sum is: " + sum);
    }
}

#Variable Types Summary

#Java Naming Conventions Review

To maintain code readability and consistency, always follow Java's naming conventions:

• Variable names (all types): Use lowerCamelCase. Examples: myAge, userName, dogCount.
• Constants (modified with final static): All letters uppercase, words separated by underscores. Example: static final int MAX_SPEED = 120;.

Choosing meaningful and clearly descriptive variable names is a key step in writing high-quality code.