In Java, variables and constants serve as foundational building blocks for data storage and manipulation. Understanding their distinctions—especially regarding type safety, scope, initialization behavior, and naming conventions—is essential for writing robust and maintainable code.

Variables

A variable is a named memory location whose value may change during program execution. As a statically typed language, Java requires every variable to declare a explicit type before use.

Each variable has three core attributes: type, identifier, and scope. While multiple variables of the same type can be declared in a single statement (e.g., int a, b, c;), doing so reduces clarity and is discouraged in professional practice.

Based on scope, Java variables fall into three categories:

• Class (static) variables: Declared with the static keyword; shared across all instances and accessible without object instantiation.
• Instance variables: Belong to individual objects; initialized automatically with default values upon object creation.
• Local variables: Defined inside methods or blocks; must be explicitly initialized before first use and are inaccessible outside their declaring scope.

Here's a revised implementation demonstrating these concepts with improved structure and naming:

public class DataContainer {
    // Class variable (shared across all instances)
    static int globalCounter = 100;

    // Instance variables (default-initialized per object)
    String label;
    int count;
    double measurement;
    boolean isActive;

    public void performAction() {
        // Local variable — must be initialized before use
        int step = 5;
        System.out.println("Step size: " + step);
    }

    public static void main(String[] args) {
        DataContainer instance = new DataContainer();

        // Accessing instance variables (defaults applied)
        System.out.println("Label: " + instance.label);         // null
        System.out.println("Count: " + instance.count);         // 0
        System.out.println("Measurement: " + instance.measurement); // 0.0
        System.out.println("Active: " + instance.isActive);     // false

        // Accessing class variable
        System.out.println("Global counter: " + globalCounter); // 100

        // Demonstrates local variable scope limitation
        // System.out.println(step); // ❌ Compilation error: undefined symbol
    }
}

Constants

A constant represents an immutable value whose assignment occurs once—at declaration—and remains fixed throughout runtime. In Java, immutability is enforced using the final modifier. When combined with static, it becomes a compile-time constant accessible at the class level.

By convention, constant identifiers use UPPER_SNAKE_CASE to enhance readability and distinguish them from regular variables.

Example:

public class Configuration {
    public static final double GRAVITY_ACCELERATION = 9.81;
    public static final int MAX_RETRY_ATTEMPTS = 3;
    public static final String APP_VERSION = "2.4.1";

    public static void main(String[] args) {
        System.out.println("Gravity: " + GRAVITY_ACCELERATION + " m/s²");
        System.out.println("Max retries: " + MAX_RETRY_ATTEMPTS);
        System.out.println("Version: " + APP_VERSION);
    }
}

Naming Conventions

Consistent naming improves code comprehension and aligns with Java community standards:

• Variables & methods: Use camelCase (e.g., currentTemperature, calculateTotal()).
• Classes & interfaces: Use PascalCase (e.g., DataProcessor, NetworkClient).
• Constants: Use UPPER_SNAKE_CASE (e.g., TCP_PORT_NUMBER, DEFAULT_TIMEOUT_MS).