Variablen in Java: Deklaration, Zuweisung und Gültigkeitsbereich erklärt

Was eine Variable ist

Eine Variable ist eine benannte Box, die einen Wert enthält. In Java hat jede Variable einen festen Typ - festgelegt beim Deklarieren - und dieser Typ ändert sich nie. Genau das macht Java statisch typisiert: Der Compiler kennt den Typ jeder Variablen, bevor das Programm läuft, und er weigert sich, Code zu kompilieren, der einen Wert der falschen Art in eine Box legt.

Eine Deklaration besteht aus drei Teilen: dem Typ, dem Namen und (meist) einem Anfangswert.

public class Main {
    public static void main(String[] args) {
        int age = 30;
        String name = "Ada";
        boolean isActive = true;

        System.out.println(name + " is " + age + ", active: " + isActive);
    }
}

Lies int age = 30; als „erstelle einen int namens age und lege 30 hinein". Das Semikolon beendet die Anweisung, genau wie die Seite über Kommentare gezeigt hat, dass es jede Anweisung tut.

Jetzt deklarieren, später zuweisen

Du kannst eine Deklaration von ihrer ersten Zuweisung trennen. Der Typ kommt nur einmal, bei der Deklaration; danach weist du nur mit dem Namen und = zu:

public class Main {
    public static void main(String[] args) {
        int score;        // deklariert, noch kein Wert
        score = 95;       // jetzt zugewiesen
        score = 100;      // neu zugewiesen - völlig in Ordnung

        System.out.println(score);
    }
}

Eine Regel, über die Anfänger stolpern: Du musst einer lokalen Variablen einen Wert zuweisen, bevor du sie liest. Der Compiler verfolgt das und lehnt Code ab, der eine nicht initialisierte lokale Variable liest:

int score;
System.out.println(score);   // compile error: variable score might not have been initialized

Das ist ein Feature, kein Ärgernis - es fängt eine ganze Klasse von Fehlern ab, bevor das Programm überhaupt läuft.

Benennungsregeln und Konventionen

Java erzwingt einige harte Regeln und legt dann Konventionen darüber. Die Regeln: Ein Name darf Buchstaben, Ziffern, _ und $ enthalten, aber nicht mit einer Ziffer beginnen, kein reserviertes Schlüsselwort sein (wie int oder class) und ist Groß-/Kleinschreibung-sensitiv (age und Age sind zwei verschiedene Variablen).

Die Konventionen, die jeder befolgt:

• Variablen und Methoden verwenden camelCase: firstName, totalScore.
• Konstanten verwenden UPPER_SNAKE_CASE: MAX_USERS.
• Namen sollten den Wert beschreiben: count, nicht c; userEmail, nicht x.

public class Main {
    public static void main(String[] args) {
        int itemCount = 3;
        double pricePerItem = 4.50;
        double totalPrice = itemCount * pricePerItem;

        System.out.println("Total: " + totalPrice);
    }
}

Klare Namen sind keine Dekoration - sie sind die Art, wie dein zukünftiges Ich den Code liest. totalPrice = itemCount * pricePerItem ist auf eine Weise selbsterklärend, wie es t = c * p nie sein wird.

Typsicherheit: Die Box behält ihren Typ

Da der Typ bei der Deklaration festgeschrieben wird, kannst du keinen Wert des falschen Typs in eine Variable legen. Das fängt Fehler zur Kompilierzeit ab:

int age = 30;
age = "thirty";   // compile error: incompatible types - String cannot become int

Das Zuweisen zwischen Zahlentypen folgt den Erweiterungsregeln (Widening) - ein kleinerer Typ fließt automatisch in einen größeren, aber nicht umgekehrt. Wir behandeln das ausführlich auf den Seiten zu Datentypen und Typumwandlung; für den Moment musst du nur wissen, dass der Compiler aufpasst.

Das Schlüsselwort var

Seit Java 10 kannst du var statt des Typs schreiben und den Compiler ihn aus dem Wert auf der rechten Seite herleiten lassen:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        var name = "Ada";              // hergeleitet als String
        var count = 5;                 // hergeleitet als int
        var prices = new ArrayList<Double>();

        prices.add(9.99);
        System.out.println(name + " " + count + " " + prices);
    }
}

var ist keine dynamische Typisierung - name ist genauso ein String, als hättest du String name geschrieben, und du kannst ihm später trotzdem keinen int zuweisen. Es spart nur Tipparbeit. Der Haken: var braucht einen Initialisierer, aus dem es herleiten kann, also ist var x; unzulässig, und es funktioniert nur für lokale Variablen - niemals für Felder, Methodenparameter oder Rückgabetypen. Verwende es dort, wo der Typ aus der rechten Seite offensichtlich ist; schreibe den Typ aus, wenn es für mehr Klarheit sorgt.

Konstanten mit final

Wenn sich ein Wert nach dem Setzen nie ändern soll, markiere ihn als final. Jeder Versuch, ihn neu zuzuweisen, wird zu einem Kompilierfehler:

public class Main {
    public static void main(String[] args) {
        final double TAX_RATE = 0.20;
        double price = 50.0;

        System.out.println("Tax: " + price * TAX_RATE);

        // TAX_RATE = 0.25;   // würde nicht kompilieren - eine final-Variable kann nicht neu zugewiesen werden
    }
}

final drückt eine Absicht aus („das ist ein fester Wert") und lässt den Compiler ihn für dich schützen. Greife darauf zurück, wann immer ein Wert konzeptionell eine Konstante ist - Sätze, Grenzen, Konfigurationsschlüssel -, damit eine versehentliche Neuzuweisung abgefangen wird, statt stillschweigend als Bug ausgeliefert zu werden.

Gültigkeitsbereich von Variablen

Eine Variable existiert nur innerhalb des Blocks - der { ... } -, in dem sie deklariert wird, und stirbt an der schließenden Klammer. Das ist ihr Gültigkeitsbereich. Eine innerhalb einer Schleife oder eines if-Blocks deklarierte Variable ist außerhalb davon unsichtbar:

public class Main {
    public static void main(String[] args) {
        int total = 0;

        for (int i = 1; i <= 3; i++) {
            int square = i * i;     // 'square' lebt nur innerhalb dieses Schleifenrumpfs
            total += square;
        }

        System.out.println("Total: " + total);
        // System.out.println(square);   // Fehler - 'square' ist hier außerhalb des Gültigkeitsbereichs
    }
}

Sowohl i als auch square gehören zur Schleife und verschwinden, wenn sie endet; total wird im äußeren Block deklariert und überlebt daher. Die praktische Erkenntnis: Deklariere jede Variable im kleinstmöglichen Block, der sie braucht. Ein enger Gültigkeitsbereich bedeutet weniger Namen, die um deine Aufmerksamkeit konkurrieren, und weniger Gelegenheiten, einen Wert weit entfernt von seiner Festlegung falsch zu verwenden.

Als Nächstes: Datentypen

Jede Variable auf dieser Seite begann mit einem Typ - int, double, String, boolean. Die nächste Seite schlüsselt Javas Datentypen im Detail auf: die acht primitiven Typen, wie groß jeder ist, der Unterschied zwischen Primitiven und Objekten und welchen Typ man wann wählt.