> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Java 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. ```java theme={"dark"} // Explicitly typed variable Map> explicitMap = new HashMap<>(); // Implicitly typed variable var implicitMap = new HashMap>(); ``` ## 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). ```java theme={"dark"} // Enhanced for-loop for (var element : collection) { ... } // Try-with-resources try (var reader = new BufferedReader(new FileReader("file.txt"))) { ... } // Lambda parameters (Java 11+) BiFunction 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. ```java theme={"dark"} 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. ```java theme={"dark"} 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. ```java theme={"dark"} 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`. ```java theme={"dark"} var strings = new ArrayList(); // Valid: infers ArrayList var objects = new ArrayList<>(); // Pitfall: infers ArrayList