Lokale Variablen mit var? Das ist doch JavaScript, oder?

Java • 8. Dezember 2025 • Lesezeit: 6 Minuten

Wenn du in den letzten Jahren mit Java gearbeitet hast, ist dir vielleicht schon das Schlüsselwort var begegnet. Ja, du hast richtig gelesen: in Java! Denn schon seit Java 10 kannst du damit lokale Variablen deklarieren, ohne ihren Typ explizit anzugeben. Das ist eine praktische Erweiterung - aber wie so oft in der Programmierung steckt der Teufel im Detail. Heute schauen wir uns an, was var genau macht, wann es hilfreich ist und wann du lieber darauf verzichten solltest.

Was bedeutet „lokale Variable mit var“ überhaupt?

Normalerweise schreibst du in Java bei einer Variablen den Typ dazu, zum Beispiel:

String name = "Marcy";
int alter = 32; // vielleicht geflunkert
List<String> namen = new ArrayList<>();

Mit var überlässt du Java die Entscheidung, welchen Typ die Variable haben soll:

var name = "Marcy";
var alter = 32;
var namen = new ArrayList();

Die Idee ist einfach: Der Compiler erkennt den Typ automatisch anhand des Ausdrucks auf der rechten Seite. Bei "Marcy" ist klar, dass es ein String ist, bei 32 ein int und bei new ArrayList<String>() eine ArrayList<String>.

Wichtig: var ist kein „dynamischer Typ“ oder „Schummeltrick“ - Java bleibt weiterhin streng typisiert. Der Typ steht nach der Kompilierung genauso fest wie vorher.

Was darf ich mit var machen?

Das Schlüsselwort var funktioniert nur bei lokalen Variablen, also innerhalb von Methoden, Schleifen oder Blöcken. Du kannst es nicht für Attribute einer Klasse, Methodenparameter oder Rückgabetypen verwenden.

Ein Beispiel:

public void beispiel() {
    var zahl = 10;          // erlaubt
    var text = "Hallo";     // erlaubt
    var liste = new ArrayList(); // erlaubt
}

Aber das hier funktioniert nicht:

public class Beispiel {
    var feld = "Test"; // Fehler! var ist hier nicht erlaubt
}

Wie erkennt der Compiler den Typ?

Der Typ wird aus dem rechten Ausdruck abgeleitet. Das nennt man „Typinferenz“. Der Compiler schaut sich den Wert rechts vom Gleichheitszeichen an und bestimmt daraus den konkreten Typ.

Beispiel:

var wert = 3.14;
System.out.println(wert.getClass().getName());

Ausgabe:

java.lang.Double

Du siehst: Obwohl wir nur 3.14 geschrieben haben, erkennt der Compiler korrekt, dass es sich um ein double (genauer gesagt java.lang.Double) handelt.

Wann hilft var beim Schreiben von Code?

Wenn du in Java schon mal eine längere Generics-Deklaration geschrieben hast, kennst du sicher Situationen wie diese:

Map<String, List> daten = new HashMap<String, List>();

Mit var sieht das plötzlich viel aufgeräumter aus:

var daten = new HashMap<String, List>();

Der Code wird kürzer und übersichtlicher. Besonders bei langen Typen oder Streams ist das angenehm:

var namen = List.of("Anna", "Ben", "Chris");
var gefiltert = namen.stream()
                     .filter(n -> n.startsWith("C"))
                     .map(String::toUpperCase)
                     .toList();

System.out.println(gefiltert);

Ausgabe:

[CHRIS]

Hier wäre es unnötig, explizit List<String> zu schreiben - der Compiler weiß ohnehin, dass es sich um eine Liste von Strings handelt.

Wo kann var verwirrend sein?

So praktisch var auch ist - manchmal macht es den Code weniger lesbar. Besonders, wenn der Typ nicht sofort klar ist:

var ergebnis = berechneWert();

Wenn du nicht weißt, was berechneWert() zurückgibt, hast du ein Problem. Mit einem klaren Typ wie int oder BigDecimal wäre sofort ersichtlich, womit du arbeitest. Das heißt: Verwende var nur dort, wo der Typ eindeutig ist oder keine Rolle spielt.

Ein gutes Beispiel für den Unterschied:

var text = "123";
var zahl = Integer.parseInt(text);
System.out.println(zahl + 10);

Ausgabe:

133

Hier ist der Typ klar erkennbar: text ist ein String, zahl ist ein int. Kein Problem. Aber wenn du in einer komplexen Methode mit mehreren Typen arbeitest, kann var schnell zur Verwirrung führen - vor allem für Neueinsteiger.

Typische Fehler mit var

Es gibt ein paar Stolperfallen, die du kennen solltest:

1. var braucht immer eine Initialisierung:

var x; // Fehler! Kein Typ ableitbar

Der Compiler muss den Typ sofort erkennen können - du kannst var nicht deklarieren und später befüllen.

2. Null ist kein Typ:

var text = null; // Fehler! Der Compiler weiss nicht, welcher Typ gemeint ist

3. Verwechslungsgefahr bei Literalen:

var zahl = 1;     // int
var kommazahl = 1.0; // double

Java entscheidet anhand der Schreibweise des Literals. Wenn du z. B. eine long-Variable brauchst, musst du sie auch als solche schreiben:

var langeZahl = 1L; // long

var im echten Alltag

Nutze var vor allem dort, wo der Typ ohnehin klar ist oder wo du lange Generics vermeiden möchtest. Zum Beispiel bei Streams, Maps oder temporären Variablen in Schleifen.

for (var eintrag : daten.entrySet()) {
    System.out.println(eintrag.getKey() + ": " + eintrag.getValue());
}

Auch in Unit-Tests ist var praktisch, wenn du den Typ leicht aus dem Zusammenhang erkennst. Aber in produktivem Code gilt: Lesbarkeit geht vor Kürze.

Fazit

var ist eine sinnvolle Ergänzung der Java-Syntax. Es kann Code lesbarer und kompakter machen - besonders bei langen Typdefinitionen. Aber wie bei allen Vereinfachungen gilt: Du solltest wissen, was du tust. Wenn der Typ auf den ersten Blick klar ist, ist var wunderbar. Wenn du oder dein Team den Typ erst erraten müsst, dann lieber klassisch bleiben.

Ein letzter kleiner Tipp: Viele IDEs (z. B. IntelliJ) zeigen dir beim Überfahren der Variable mit der Maus den abgeleiteten Typ an. Das ist eine gute Hilfe, um dich mit var vertraut zu machen, ohne die Kontrolle zu verlieren.

Und denk daran: var ist kein Ersatz für das Denken über Typen - es ist nur eine Abkürzung, wenn du den Typ schon kennst.