Implicitly Typed Variable

An implicitly typed variable in Java utilizes the var identifier to instruct the compiler to infer the static type of a local variable at compile-time based on its initializer. Introduced in Java 10 via Local-Variable Type Inference (JEP 286), var does not make Java dynamically typed; the inferred type is fixed and strongly bound to the variable throughout its lifecycle. The resulting bytecode is identical to that of an explicitly typed variable.

// Explicitly typed variable
Map<String, List<Integer>> explicitMap = new HashMap<>();

// Implicitly typed variable
var implicitMap = new HashMap<String, List<Integer>>(); 

Technical Mechanics

Under the hood, var is a reserved type name, not a reserved keyword. This distinction ensures backward compatibility; existing variables, methods, or packages named var remain valid, but developers can no longer create classes, interfaces, or enums named var.

When the Java compiler encounters var, it analyzes the right-hand side (RHS) expression. It resolves the Abstract Syntax Tree (AST) node for the initializer, determines its exact static type, and assigns that type to the left-hand side (LHS) variable declaration.

Scope and Applicability

The var identifier is strictly limited to local execution contexts.

Permitted Contexts:

• Local variables with immediate initializers.
• Enhanced for-loop iterables.
• Traditional for-loop index variables.
• try-with-resources variable declarations.
• Implicitly typed lambda expressions (introduced in Java 11).

// Enhanced for-loop
for (var element : collection) { ... }

// Try-with-resources
try (var reader = new BufferedReader(new FileReader("file.txt"))) { ... }

// Lambda parameters (Java 11+)
BiFunction<Integer, Integer, Integer> add = (var a, var b) -> a + b;

Forbidden Contexts:

• Class or instance fields.
• Method parameters.
• Method return types.
• catch block exception parameters.

Compiler Rules and Constraints

Because type inference relies entirely on the RHS expression, the compiler enforces strict rules to guarantee type safety.

1. Mandatory Initialization A var declaration must be initialized on the same line. The compiler cannot infer a type from deferred assignment.

var count; // COMPILATION ERROR: cannot use 'var' on variable without initializer
count = 10;

2. Compound Variable Declarations Restriction The var identifier cannot be used in multiple (compound) variable declarations. Declaring more than one variable in a single var statement is strictly forbidden by the Java Language Specification.

var x = 1, y = 2; // COMPILATION ERROR: 'var' is not allowed in a compound declaration
var a = 1; var b = 2; // Valid

3. Null Assignment Restriction The null literal lacks a specific type, making it impossible for the compiler to infer the intended reference type without an explicit cast.

var user = null; // COMPILATION ERROR: variable initializer is 'null'
var user = (String) null; // Valid: infers java.lang.String

4. Generics and the Diamond Operator (<>) When instantiating generic types, type inference relies entirely on the RHS. If var is used alongside an empty diamond operator (<>), the compiler lacks the LHS type information normally used to infer the generic type parameter, causing it to default to Object.

var strings = new ArrayList<String>(); // Valid: infers ArrayList<String>
var objects = new ArrayList<>();       // Pitfall: infers ArrayList<Object>

5. Poly Expressions and Target Typing var cannot be used with poly expressions (like lambdas or method references) unless an explicit target type is provided via a cast. Poly expressions rely on the LHS for target typing, creating a circular dependency if the LHS is var.

var runnable = () -> {}; // COMPILATION ERROR: lambda expression needs an explicit target-type
var runnable = (Runnable) () -> {}; // Valid: infers java.lang.Runnable

6. Array Initialization Shorthand Implicit typing does not support the shorthand array initializer syntax, as the RHS does not contain enough type information on its own.

var numbers = {1, 2, 3}; // COMPILATION ERROR: array initializer needs an explicit target-type
var numbers = new int[]{1, 2, 3}; // Valid: infers int[]

7. Non-Denotable Types var can capture non-denotable types, such as anonymous class types or intersection types, which cannot be explicitly written in Java syntax.

var obj = new Object() {
    String name = "Anonymous";
};
System.out.println(obj.name); // Valid: The compiler retains the anonymous type structure

Master Java with Deep Grasping Methodology!

Learn More