Home / Language / Type inference with var
Language beginner

Type inference with var

Use var for local variable type inference — less noise, same safety.

Code Comparison
✕ Java 8 
Map<String, List<Integer>> map =
    new HashMap<String, List<Integer>>();
for (Map.Entry<String, List<Integer>> e
    : map.entrySet()) {
    // verbose type noise
}
✓ Java 10+ 
var map = new HashMap<String, List<Integer>>();
for (var entry : map.entrySet()) {
    // clean and readable
}
Why the modern way wins
⚡

Less boilerplate

No need to repeat complex generic types on both sides of the assignment.

👁

Better readability

Focus on variable names and values, not type declarations.

🔒

Still type-safe

The compiler infers and enforces the exact type at compile time.

Old Approach
Explicit Types
Modern Approach
var keyword
Since JDK
10
Difficulty
beginner
JDK Support
Type inference with var
Available

Widely available since JDK 10 (March 2018)

How it works

Since Java 10, the compiler infers local variable types from the right-hand side. This reduces visual noise without sacrificing type safety. Use var when the type is obvious from context.

Related patterns

Language intermediate

Sealed classes for type hierarchies

Java 8
// Anyone can extend Shape
public abstract class Shape { }
public class Circle extends Shape { }
public class Rect extends Shape { }
// unknown subclasses possible
Java 17+
public sealed interface Shape
    permits Circle, Rect {}
public record Circle(double r)
    implements Shape {}
public record Rect(double w, double h)
    implements Shape {}
Hover to see modern ➜
JDK 17+ →
Language beginner

Pattern matching for instanceof

Java 8
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}
Java 16+
if (obj instanceof String s) {
    System.out.println(s.length());
}
Hover to see modern ➜
JDK 16+ →
Language intermediate

Exhaustive switch without default

Java 8
// Must add default even though
// all cases are covered
double area(Shape s) {
    if (s instanceof Circle c)
        return Math.PI * c.r() * c.r();
    else if (s instanceof Rect r)
        return r.w() * r.h();
    else throw new IAE();
}
Java 21+
// sealed Shape permits Circle, Rect
double area(Shape s) {
    return switch (s) {
        case Circle c ->
            Math.PI * c.r() * c.r();
        case Rect r ->
            r.w() * r.h();
    }; // no default needed!
}
Hover to see modern ➜
JDK 21+ →
Share 𝕏 🦋 in ⬡