Was sind Variablen?

Variablen sind Verweise auf Speicherplätze, die, mit einem lesbaren Namen versehen, sowohl Werte primitiver Typen, als auch Objekte enthalten können.

Jedes Computerprogramm verarbeitet Daten. Diese Daten können unterschiedlichen Typs sein und als solche wiederum verschiedene Werte besitzen. So kann ein int den Wert 5, -34, 23456, etc. annehmen, ein String "Hallo Welt!" oder "Heinz Meyer-Lüdenscheid" lauten.
Die Daten stellen das 'Material' dar, das ein Programm verarbeitet. Im Rahmen dieser Verarbeitung müssen die Werte natürlich (zwischen-)gespeichert werden, um bei Bedarf auf sie zugreifen zu können. Variablen sind dabei eine Art 'Lesezeichen', das auf den Speicherort verweist und angibt, wie dieser angesprochen werden kann. Darüber hinaus enthält sie Informationen über den gespeicherten Datentyp.

Deklaration und Initialisierung

Die Erzeugung einer Variablen, bezeichnet man als deren Deklaration. Sie besteht formal darin, dass ein durch Menschen leicht lesbarer Name, der Bezeichner, gemeinsam mit dem vorangestellten Datentyp notiert wird. Durch die Nennung des Datentyps gemeinsam mit dem Bezeichner wird der für den Typ benötigte Speicherplatz automatisch reserviert.
Der Bezeichner muss sich bezüglich seiner Form innerhalb der erlaubten Norm bewegen, er muss innerhalb des Gültigkeitsbereiches der Variablen einmalig sein und sollte darüber hinaus möglichst sprechend sein. Darunter ist zu verstehen, dass er eine Aussage über seine Funktion machen sollte.
Der gesamte Ausdruck der Deklaration wird immer mit einem Semikolon abgeschlossen.

Deklaration einer int-Variablen ohne Initialisierung.

Die erstmalige Zuweisung eines Wertes an eine Variable wird als Initialisierung bezeichnet. Sie kann zusammen mit der Deklaration oder getrennt davon erfolgen. Finden Deklaration und Initialisierung gemeinsam statt, können mehrere Variablen des selben Typs gleichzeitig in einem Ausdruck deklariert werden.

Initialisierung einer int Variablen nach deren Deklaration. Der Datentyp darf im zweiten Ausdruck nicht wiederholt werden, da hierdurch eine verbotene Doppeldeklaration stattfinden würde.

Deklaration einer int-Variablen mit Initialisierung.

Deklaration mehrerer int-Variablen innerhalb eines Ausdrucks. Die Variablen müssen durch Kommata voneinander getrennt werden.

Die Erzeugung einer Variablen besteht somit aus bis zu vier Teilschritten.

Festlegung des Datentyps Der Typ bestimmt, welche Art von Daten in der Variablen gespeichert werden können.
Vergabe eines Bezeichners Im Rahmen der Code-Konventionen leicht lesbarer Name der Variablen.
Reservierung des Speicherplatzes Erfolgt im Rahmen der Deklaration automatisch.
Initialisierung mit einem Wert Vergabe eines initialen Wertes. Optional bei der Deklaration. Sie kann auch zu einem späteren Zeitpunkt erfolgen.

Die Initialisierung einer Variablen kann durch jeden Ausdruck erfolgen, der einen passenden Wert liefert.

int zahl = gibZahl(); // Methode gibZahl() gibt int-Wert zurück
int nochEineZahl;     // Deklaration
nochEineZahl = 24;    // nachträgliche Initialisierung

Variablenarten

Java kennt drei Arten von Variablen, die sich hinsichtlich ihrer Gültigkeit und ihres Anwendungsbereiches unterscheiden.

Lokale Variablen

Sie werden wie oben erläutert deklariert. Ihre Gültigkeit bezieht sich auf den Block, in dem sie deklariert wurden und alle Blöcke, die in diesen eingeschlossen sind. Eine Neudeklaration mit dem selben Bezeichner ist, unabhängig vom Datentyp, in diesem Umfeld nicht zulässig.
Lokale Variablen werden meist zum Zwischenspeichern von Werten verwendet, etwa als Zählvariablen in Kontrollstrukturen, Variablen innerhalb von Methodenkörpern, etc. Ein Zugriff von außerhalb der Klasse, in der sie deklariert wurden, ist nicht möglich.

{ // Beginn des Blockes einer Methode, Schleife, Verzweigung, o.ä.
    int zahl = 24;
    { // Beginn eingeschlossener Block
        String zahl = "67";   // Fehler
    }
}
Type Inference

v.10Mit der Version 10 wurden in Java Type Inference und das Schlüsselwort var eingeführt. Hierbei wird der Datentyp aus dem gesamten Kontext des Quelltextes geschlussfolgert. Statt des Datentyps wird hierbei das Schlüsselwort var dem Bezeichner vorangestellt.

var zahl = 5;  // vermuteter int-Wert
var s = "Hallo Welt";  // vermuteter String-Wert

Derartig deklarierte Variablen müssen zwingend bei der Deklaration auch initialisiert werden, da ansonsten der Typ nicht geschlussfolgert werden kann. Darüber hinaus ist diese Form der Deklaration ausschließlich für lokale Variablen zulässig.
Wird nach der Deklaration versucht den Typ zu wechseln, so erfolgt eine Fehlermeldung. Erlaubtes Casting ist jedoch weiterhin möglich.

var zahl = 5;
zahl = 3.14       // Fehler
zahl = (int)3.14  // 3

Instanzvariablen

Sie werden direkt innerhalb eines Klassenblockes deklariert und sind somit auch in allen Methoden, gültig. Ihre Deklaration findet oft unter Voranstellung eines Zugriffsmodifizierers statt, nach dem sich die Möglichkeit des Zugriffs von außerhalb der Klasse richtet. Der Zugriff selbst erfolgt üblicherweise mittels Accessor-Methoden.
Die gleichen Instanzvariablen verschiedener Objekte können bei der Objektbildung unterschiedliche Werte annehmen. Die Werte der Gesamtheit aller Instanzvariablen eines Objektes beschreiben dessen Zustand.

class Test {
    private int zahl = 24;
    void schreibe() {
        System.out.println(zahl);  // 24
    }
}

Klassenvariablen

Klassenvariablen sind innerhalb eines Klassenblockes static deklarierte Variablen, die zur Klasse selbst und nicht primär zu den daraus gebildeten Objekten gehören. Sie werden nicht über Accessor-Methoden, sondern über den mit dem Punktoperator verbundenen vorangestellten Klassennamen aufgerufen.
Klassenvariablen dienen auch als Konstanten. Sie werden dann final deklariert, müssen bei der Deklaration auch initialisiert werden und sollten nach den Konventionen durchgängig mit Bezeichnern in Großbuchstaben versehen werden.

class Test {
    static int zahl = 24;
    static final String NAME = "Javabeginners";
    //...
}
    
class Testerei {
    void machWas() {
        System.out.println(Test.zahl);  // 24
    }
}

Instanz- versus Klassenvariablen

Unabhängig von den syntaktischen Unterschieden sei hier zur funktionalen Abgrenzung von Instanz- und Klassenvariablen ein hoffentlich einigermaßen anschauliches Beispiel angeführt:

Denkbar sei eine Klasse Auto mit einer Instanzvariablen farbe. Die verschiedenen Objekte der Klasse, die 'gebauten' Autos, können verschiedene Farben aufweisen oder sogar auch unlackiert sein. Selbst Umlackierungen im Laufe des Lebens eines Autos sind möglich. Die Instanzvariablen der Farbe des jeweiligen Autos werden dann ganz unterschiedlich belegt, obwohl alle Autos von ein und dem selben Typ sind. Die Farbe ist eine dem einzelnen Auto, dem Objekt, zugewiesene Eigenschaft.
So kann eine Farbe auch vielen ganz anderen Dingen eigen sein kann. Sie ist nicht wesenhaft an ein Auto gekoppelt.

Im Gegensatz dazu besitzt die Java-Klasse Font z.B. eine statische int-Variable ITALIC, die den Schriftstil 'kursiv' definiert. Diese Eigenschaft ist eine, die zwingend an 'Schrift' gekoppelt ist, die also als allgemein mögliche Eigenschaft des Phänomens Schrift zum spezifischen Typ der Klasse Font gehört.
Werden von der Klasse Font Objekte gebildet, so ist es weder sinnvoll noch möglich, die Eigenschaft 'kursiv' zu variieren. Eine Schrift selbst - nicht ein Objekt mit Schrift - ist entweder kursiv oder auch nicht.