Java Variables

A variable is a named storage location with a fixed type. Once declared, the type can't change, but the value inside it usually can. This chapter covers how to declare variables, how to initialize them, the four kinds Java distinguishes, and the rules around scope and var.

Declaring a variable

The basic form is:

<type> <name>;

The simplest declarations:

int score;
String name;
boolean ready;

These reserve storage; they don't put a value in it yet.

Initializing

To assign a value, use =:

int score = 0;
String name = "Ada";
boolean ready = true;

You can also declare and assign separately:

int score;
score = 0;

Or declare several variables of the same type at once:

int x = 1, y = 2, z = 3;

(One-per-line is usually clearer.)

Local variables must be assigned before use

A local variable — declared inside a method — has no default value. The compiler refuses to let you read it until you've assigned something:

public static void main(String[] args) {
    int x;
    // System.out.println(x); // compile error: variable x might not have been initialized
    x = 5;
    System.out.println(x);    // OK
}

This is one of Java's most useful safety features — it catches a category of bugs other languages let slip through.

The four kinds of variables

Java distinguishes four variable categories by where they're declared:

1. Local variables — declared inside a method or block. Live only while the method runs. No default value. Must be initialised before use.
2. Instance variables (fields) — declared inside a class but outside any method. One copy per object. Default to 0 / 0.0 / false / null.
3. Static variables (class variables) — declared with the static keyword. One copy shared by every instance of the class. Default to 0 / false / null.
4. Parameters — declared in a method signature; receive the value passed by the caller.

public class Counter {
    static int totalCounters;   // static (class) variable
    int count;                  // instance variable

    public void add(int delta) { // delta is a parameter
        int doubled = delta * 2; // doubled is a local variable
        count += doubled;
    }
}

You'll meet instance and static variables again in the OOP chapters; for now most of the variables you write will be local.

final — assign once

Prefixing a declaration with final makes the variable a one-shot binding. After the first assignment, it cannot change:

final int MAX_RETRIES = 3;
// MAX_RETRIES = 4; // compile error: cannot assign a value to final variable

Using final for things that aren't supposed to change makes intent explicit and lets the compiler catch accidental reassignment.

var — let the compiler pick the type

Since Java 10, you can write var instead of a type for local variables when the right-hand side makes the type obvious:

var name = "Ada";          // inferred as String
var score = 0;             // inferred as int
var values = new int[10];  // inferred as int[]

var is not dynamic typing — the variable still has a fixed type, the compiler just figures it out for you. Restrictions:

• Only for local variables.
• The right-hand side must be present (var x; is illegal).
• Not allowed for parameters, instance variables, or static variables.

var is most helpful when the type name is long or obvious from context:

var orders = new HashMap<String, List<Order>>();

Use ordinary type declarations when the inferred type isn't obvious to a reader.

Scope

A variable is in scope — visible — from its declaration to the end of the enclosing block:

public static void main(String[] args) {
    int outer = 1;

    if (outer > 0) {
        int inner = 2;
        System.out.println(outer + inner);   // both visible
    }

    // System.out.println(inner);   // compile error: inner is out of scope
}

You cannot declare two variables with the same name in overlapping scopes.

A working example

What's next

Java Naming Conventions covers the standard rules every Java codebase follows for class, method, variable, and constant names.

Practice