Local Variable Type Inference (var)

var lets you declare a local variable without writing its type — the compiler infers one fixed static type from the value on the right, keeping your code concise while staying fully type-safe.

Learn Local Variable Type Inference (var) in our free Java course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a…

Part of the free Java course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

You should be comfortable with data types and variables and have seen generic collections like List<String> . var needs Java 10 or newer (Java 11+ for lambda parameters).

💡 Analogy: Imagine moving house. When a box is clearly a kettle , scrawling "KETTLE" on the side is just noise — anyone can see what it holds. var is letting the box speak for itself: var kettle = new Kettle(); still is a kettle box (the type is fixed), you just didn't bother writing the label twice. But for a plain cardboard box of mystery cables, you do want a label — that's when you keep the explicit type.

The key point: the type still exists and is permanent. var never makes a variable "any type". It simply spares you from repeating a type the compiler can already see.

When you write var x = expression; , the compiler looks at the type of expression and gives x exactly that type — permanently. var name = "Ada"; is compiled identically to String name = "Ada"; . There is no runtime difference at all.

Loops are where var earns its keep. In a classic loop, for (var i = 0; ...) infers int . In an enhanced loop, for (var item : list) infers the collection's element type. Iterating a map's entrySet() normally means typing Map.Entry<String, Integer> — with var it collapses to three letters.

Use var when the right-hand side already states the type — var list = new ArrayList<String>(); is clean. Avoid it when the type is hidden behind a method call — var x = service.process(); forces the reader to go hunting. A good explicit type is documentation; don't throw it away.

There is also a subtle trap with the diamond operator <> . Because var infers from the right-hand side, var list = new ArrayList<>(); infers ArrayList<Object> — almost never what you want. Put the type argument on the right.

var is strictly a local variable feature. Each line below is a compile error:

Predict the result before opening each answer.

Answer: double . Mixing an int with a double promotes the result to double , so x is 7.0 , a double .

Answer: No. msg was inferred as String and that's permanent, so assigning the int 42 is error: incompatible types .

Answer: It compiles, but items is ArrayList<Object> because the bare diamond infers Object . You lose type safety on the elements. Fix it: new ArrayList<String>() .

🎯 Your Turn — Sum word lengths with var

Use var for both the accumulator and the loop variable to total every word's length.

🧩 Mini-Challenge — Find the hottest reading

Track a running maximum across a list of temperatures using var throughout.

You can now use var to drop redundant local-variable types, you know it stays statically typed, and you know exactly where it's forbidden (fields, parameters, returns, and uninitialized or null declarations). You also know to keep the type argument on the right of a generic.

Next up: Text Blocks — multi-line string literals that make JSON, SQL, and HTML readable.

Practice quiz

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary