Java Variables: Declaration, Assignment, and Scope Explained

What a Variable Is

A variable is a named box that holds a value. In Java every variable has a fixed type - decided when you declare it - and that type never changes. This is what makes Java statically typed: the compiler knows the type of every variable before the program runs, and it will refuse to compile code that puts the wrong kind of value in a box.

A declaration has three parts: the type, the name, and (usually) an initial value.

public class Main {
    public static void main(String[] args) {
        int age = 30;
        String name = "Ada";
        boolean isActive = true;

        System.out.println(name + " is " + age + ", active: " + isActive);
    }
}

Read int age = 30; as "make an int called age and put 30 in it". The semicolon ends the statement, just like the comments page showed every statement does.

Declaring Now, Assigning Later

You can split a declaration from its first assignment. The type comes once, at the declaration; after that you assign with just the name and =:

public class Main {
    public static void main(String[] args) {
        int score;        // declared, not yet given a value
        score = 95;       // assigned now
        score = 100;      // reassigned - perfectly fine

        System.out.println(score);
    }
}

One rule that trips up beginners: you must assign a value to a local variable before you read it. The compiler tracks this and rejects code that reads an uninitialized local:

int score;
System.out.println(score);   // compile error: variable score might not have been initialized

This is a feature, not an annoyance - it catches a whole class of bugs before the program ever runs.

Naming Rules and Conventions

Java enforces a few hard rules, then layers conventions on top. The rules: a name may contain letters, digits, _, and $, but cannot start with a digit, cannot be a reserved keyword (like int or class), and is case-sensitive (age and Age are two different variables).

The conventions everyone follows:

• Variables and methods use camelCase: firstName, totalScore.
• Constants use UPPER_SNAKE_CASE: MAX_USERS.
• Names should describe the value: count, not c; userEmail, not x.

public class Main {
    public static void main(String[] args) {
        int itemCount = 3;
        double pricePerItem = 4.50;
        double totalPrice = itemCount * pricePerItem;

        System.out.println("Total: " + totalPrice);
    }
}

Clear names are not decoration - they are how your future self reads the code. totalPrice = itemCount * pricePerItem is self-explanatory in a way t = c * p never will be.

Type Safety: The Box Keeps Its Type

Because the type is locked in at declaration, you cannot drop a value of the wrong type into a variable. This catches mistakes at compile time:

int age = 30;
age = "thirty";   // compile error: incompatible types - String cannot become int

Assigning across number types follows widening rules - a smaller type flows into a larger one automatically, but not the reverse. We will cover that fully on the data types and type casting pages; for now, just know the compiler is watching.

The var Keyword

Since Java 10 you can write var instead of the type and let the compiler infer it from the value on the right:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        var name = "Ada";              // inferred as String
        var count = 5;                 // inferred as int
        var prices = new ArrayList<Double>();

        prices.add(9.99);
        System.out.println(name + " " + count + " " + prices);
    }
}

var is not dynamic typing - name is just as much a String as if you had written String name, and you still cannot later assign an int to it. It only saves typing. The catch: var needs an initializer to infer from, so var x; is illegal, and it works only for local variables - never for fields, method parameters, or return types. Use it where the type is obvious from the right-hand side; spell the type out when it adds clarity.

Constants with final

When a value should never change after it is set, mark it final. Any attempt to reassign it becomes a compile error:

public class Main {
    public static void main(String[] args) {
        final double TAX_RATE = 0.20;
        double price = 50.0;

        System.out.println("Tax: " + price * TAX_RATE);

        // TAX_RATE = 0.25;   // would not compile - cannot reassign a final
    }
}

final communicates intent ("this is a fixed value") and lets the compiler guard it for you. Reach for it whenever a value is conceptually a constant - rates, limits, configuration keys - so an accidental reassignment is caught instead of silently shipping a bug.

Variable Scope

A variable exists only inside the block - the { ... } - where it is declared, and it dies at the closing brace. This is its scope. A variable declared inside a for loop or if block is invisible outside it:

public class Main {
    public static void main(String[] args) {
        int total = 0;

        for (int i = 1; i <= 3; i++) {
            int square = i * i;     // 'square' lives only inside this loop body
            total += square;
        }

        System.out.println("Total: " + total);
        // System.out.println(square);   // error - 'square' is out of scope here
    }
}

Both i and square belong to the loop and vanish when it ends; total is declared in the outer block, so it survives. The practical takeaway: declare each variable in the smallest block that needs it. Narrow scope means fewer names competing for your attention and fewer chances to misuse a value far from where it was set.

Next: Data Types

Every variable on this page started with a type - int, double, String, boolean. The next page breaks down Java's data types in detail: the eight primitives, how big each one is, the difference between primitives and objects, and which type to reach for when.