What did Java 10 var add, and what are its limitations?

• var – A reserved type name introduced in Java 10 that enables local variable type inference by inferring the static type from the initializer expression.
• Compile-time sugar – The inferred type is baked into the bytecode and the variable is just as strongly typed as if the type were written by hand; there is no runtime cost or dynamic typing.
• Locals only – Allowed for local variables, for-loop indexes, and try-with-resources variables, but not for fields, method parameters, or return types.
• Initializer required – var x; does not compile because there is nothing to infer from, and var x = null; fails because null has no definite type.
• Not a keyword – var is a reserved type name, so existing code using var as a variable or method name still compiles.

What is var and how does it work?

var reduces the boilerplate of repeating a type that the right-hand side already states. The compiler infers the exact static type and bakes it into the bytecode. The variable is permanently that type.

package com.bank.service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class VarBasicsDemo {

    public void demonstrateVar() {
        // Infers ArrayList<Account>
        var accounts = new ArrayList<Account>();

        // Infers BigDecimal
        var balance = new BigDecimal("50000.00");

        // Infers HashMap<String, List<Transaction>>
        var byAccount = new HashMap<String, List<Transaction>>();

        // balance = "hello"; // COMPILE ERROR: balance is BigDecimal
    }
}

How is var different from JavaScript's var or Python's dynamic variables?

var in Java is NOT dynamic typing. The type is fixed at compile time and can never change. The bytecode is byte-for-byte identical to writing the type explicitly.

package com.bank.service;

import java.math.BigDecimal;

public class VarIsNotDynamic {

    public void staticTyping() {
        var fee = new BigDecimal("250.00");
        // fee is permanently BigDecimal
        // fee = "hello"; // COMPILE ERROR
        // fee = 42;      // COMPILE ERROR

        // Identical to:
        BigDecimal fee2 = new BigDecimal("250.00");
        // Same bytecode, same type
    }
}

Where can you use var? (Allowed positions)

var works for local variables, for-loop indexes, and try-with-resources variables.

package com.bank.service;

import java.io.FileReader;
import java.io.BufferedReader;
import java.util.List;

public class VarAllowedPositions {

    public void allowedUses() {
        // Local variable
        var accountId = "SAV2001";

        // For-loop index
        var accounts = List.of("SAV2001", "CUR3001");
        for (var id : accounts) {
            System.out.println(id);
        }

        // Traditional for-loop
        for (var i = 0; i < 10; i++) {
            System.out.println(i);
        }

        // Try-with-resources
        try (var reader = new BufferedReader(
                new FileReader("accounts.csv"))) {
            var line = reader.readLine();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

What are the limitations of var?

var cannot be used for fields, method parameters, return types, or constructor parameters. It needs an initializer, cannot be initialized with null alone, cannot type a lambda or method reference without a target type, and does not work with the curly-brace array initializer.

package com.bank.service;

public class VarLimitations {

    // COMPILE ERROR: var not allowed for fields
    // private var balance = BigDecimal.ZERO;

    // COMPILE ERROR: var not allowed for parameters
    // public void transfer(var amount) { }

    // COMPILE ERROR: var not allowed for return types
    // public var getBalance() { return BigDecimal.ZERO; }

    public void limitations() {
        // COMPILE ERROR: no initializer
        // var x;

        // COMPILE ERROR: null has no type
        // var x = null;

        // COMPILE ERROR: lambda needs target type
        // var f = x -> x + 1;

        // COMPILE ERROR: array initializer shorthand
        // var arr = {1, 2, 3};

        // OK: explicit array creation
        var arr = new int[]{1, 2, 3};
    }
}

What is the diamond operator trap with var?

var list = new ArrayList<>(); infers ArrayList