Declaring Variables with Explicit Types in Java

Java 11 introduced the var keyword, which lets you declare a local variable without writing its type name. Many learners who meet var for the first time assume it changes Java into a language where one variable can hold a number at one moment and a piece of text at another. That assumption is natural, because languages such as Python let a variable hold whatever value is assigned to it. This article tests that assumption directly, and then explains what the compiler actually does.

A var declaration gives the variable a type, and that type comes from the value on the right side of the equals sign. The compiler looks at the initial value, determines what type that value has, and assigns that type to the variable. Nothing about the variable is left open for a later decision. The diagram below traces this flow for a single declaration.

The important word is fixed. The type is not a loose label that can drift over time. It is determined when the declaration is compiled. The value stored in the variable can change later, as long as the new value is compatible with the type. The type itself does not change.

Because the type is fixed at compile time, every later assignment to the variable is checked against that type. An assignment that fits the type compiles. An assignment that does not fit is rejected before the program runs. The code below uses the rate variable from the prediction to show both outcomes.

The rule to apply when predicting a reassignment is simple. Ask whether the new value can be stored in the type the compiler already fixed. If it can, the line compiles. If it cannot, the line fails, even though the variable is declared with var and not with an explicit type name.

A var declaration has the same parts as any other local variable declaration, except that the type name is replaced by the keyword var. It has the keyword, a name, an equals sign, and an initial value. The annotated strip below labels each part.

The var form has two firm restrictions. It can only be used for local variables, meaning variables declared inside subroutines, and a variable declared with var must be given an initial value. The table compares the positions discussed in the source material.

The loop control variable of a for loop is a local variable, so var can be used there. The declaration part of the loop takes the same form as any other var declaration: the keyword, a name, and an initial value, with the type inferred from that value. The rest of the loop header works as before. The two loops below behave the same way, and the second one only removes the explicit type name.

The source notes that for simple values such as a loop counter, the explicit type is short and clear, so var adds little. Its value increases for parameterized types, which appear later in the course. There the type names can be long and complicated, and var keeps the declaration readable while the compiler still checks the type.

The compiler can only fix a type when the initial value has one it can read. Some initializers do not give it that information. A bare null, a bare array literal in braces, and a lambda expression all leave the compiler without a type it can take from the value, so a var declaration using one of them is rejected. The explicit type name is the way to declare these variables. This follows from the rule that the type comes from the initial value: when that value does not establish a type, there is nothing for var to use.