Java-Grundlagen: Variablen in Java – Deklaration, Sichtbarkeit und Lebensdauer

In der Programmiersprache Java gibt es drei Variablen-Typen: Lokale-, Klassen– und Instanz-Variablen.

Im Allgemeinen werden Variablen in Java und den anderen Programmiersprachen dazu benutzt, um Daten im Hauptspeicher der Anwendung abzuspeichern.

Auf diese Anwendungsdaten kann zur Programmlaufzeit lesend und schreibend zugegriffen werden.

Die folgenden 3 Variablen-Typen gibt es in Java:

• Lokale Variablen – diese existieren nur lokal, etwa innerhalb einer Methode oder einer Block-Anweisung.

• Klassen-Variablen – existieren auch wenn kein Objekt vorher instanziert wurde, sie werden durch die Klassendefinition festgelegt.

• Instanz-Variablen – existieren nur in Verbindung mit einem vorher instanzierten Objekt, sie werden durch die Klassendefninition festgelegt.

Sonderfälle von Variablen sind Exception-Handler, Parameter von Methoden sowie Array-Komponenten.

---

Alle Variablen können entweder durch eine Zuweisung (a = b + 17;) oder einen Inkrement-/Dekrement-Operator (a++;) verändert werden.

Hinweis: Java ist eine typsichere Sprache. Alle Typ-Überprüfungen werden zur Compile-Zeit durchgeführt. Ein Variable in Java ist entweder von der primitiven Datentypenart oder der Referenz-Datentypenart. Die Ausnahme dazu stellen Array-Variablen dar.

Deklaration von Variablen in Java

Die Deklaration von Variablen geschieht immer auf ein und dieselbe Art. Zuerst wird der Variablentyp angegeben und anschließend der Variablenname festgelegt. Die Deklaration kann an jeder beliebigen Stelle im Quellcode vorgenommen werden.

Beispiele für Variablendeklarationen sind:

• int zahl;
• boolean isBooked = false;
• float reelleZahl = 3.01f;
• JButton startButton = new JButton(„Start“);

Variablen können bei ihrer Deklaration auch sogleich initialisiert werden, also einen konkreten Wert direkt zugewiesen bekommen.

In der folgenden Beispielanwendung werden verschiedene Variablen deklariert und anschließend die in den Variablen gespeicherten Werte auf der Kommandozeile ausgegeben:

Beispielanwendung Deklaration von Variablen in Java.

/*
 * Beispielanwendung Deklaration von Variablen in Java.
 */

public class VariablenDeklaration{
    public static void main(String[] args) {
        System.out.println("\n1: Deklarieren der Variablen");

        boolean isBooked;
        isBooked            = true;
        char zeichenQ       = '\u0051';
        long kleineZahl     = -9_223_372_036_854_775_808L;
        float relleZahl     = 3.01f;
        String zeichkette   = "Hallo Programmieren Lernen HQ";

        System.out.println("\n2: Ausgabe der Werte\n");
        System.out.println("isBooked:   " + isBooked);
        System.out.println("zeichenQ:   " + zeichenQ);
        System.out.println("kleineZahl: " + kleineZahl);
        System.out.println("relleZahl:  " + relleZahl);
        System.out.println("zeichkette: " + zeichkette);

        System.out.println("\n3: In Blockanweisung\n");
        for (int i = 1; i < 5; i++) {
            float relleZahlBlock = 9.03f + i;            
            System.out.println("relleZahlBlock:   " + relleZahlBlock);
        }
    }
}

In dem oberen Quelltext haben wir in Zeile 9 die Variable isBooked deklariert und anschließend in Zeile 10 der Variable isBooked den Wert true zugewiesen.

Diese beiden Schritte können zu einem Schritt zusammengefasst werden, wie es bei den restlichen Variablen Zeile 11 bis 14 der Fall ist.

In den Zeilen 17 bis 21 werden die Werte der Variablen auf der Kommandozeile ausgegeben.

Innerhalb der For-Schleife wird die Variable reelleZahlBlock in Zeile 25 deklariert. Die Variable muss einen anderen Namen tragen als die Variable reelleZahl von Zeile 19, da lokale Variablen in einer Block-Anweisung keine anderen lokalen Variablen außerhalb des Blocks übderdecken dürfen. Dies gilt nicht für Klassen- und Instanzvariablen.

Die nachfolgende Abbildung stellt die Ausgabe der Java-Anwendung “VariablenDeklaration” dar. Im ersten Schritt werden die Variablen deklariert und initialisiert. Anschließend wird der Inhalt der jeweiligen Variable auf der Kommandozeile ausgegeben.

Lebensdauer und Sichtbarkeit von Variablen in Java

Der Begriff Lebensdauer einer Variable bezeichnet die Zeitspanne von der Geburt der Variable bis zu ihrem Tod. Dabei ist die Geburt der Variable der Deklarationsschritt. Der Tod der Variable ist abhängig von dem Variablen-Typ. Hierbei besitzen lokale Variablen die geringste Lebensdauer und Klassenvariablen die längste Lebensdauer.

Wurde eine Variable erstellt, dann ist sie für andere Programmteile sichtbar. Die Sichtbarkeit von Variablen ist der Lebensdauer einer Variable sehr ähnlich. Solange eine Variable existiert ist diese auch sichtbar.

Die Lebensdauer einer lokalen Variable beginnt mit der Variablendeklaration. Wurde die Variable innerhalb einer Block-Anweisung deklariert, endet ihre Lebenszeit mit Verlassen des Blocks. Wurde die Variable in einer Methode deklariert, dann wird ihre Existenz mit Ende des Methodenaufrufs ausgelöscht.

Hinweis: Lokale Variablen dürfen gleichnamige andere lokale Variablen nicht überecken. So darf eine lokale Variable in einer Block-Anweisung nicht den gleichen Variablennamen besitzen wie die lokale Variable außerhalb des Block. Klassen- und Instanzvariablen können jedoch verdeckt werden. Der this-Zeiger löst die Mehrdeutigkeit auf.

Mit dem Erzeugen einer Instanz eines Klassenobjekts beginnt die Lebenszeit von Instanzvariablen. Ihre Lebenszeit endet erst mit dem Zerstören des zugehörigen Objekts. Während dieser Zeit sind Instanzvariablen innerhalb der ganzen Klasse sichtbar.

Sie können von lokalen Variablen mit den gleichen Namen überdeckt werden. Über den this-Zeiger ist sichergestellt, dass auf die Instanzvariable zugegriffen wird. Mit this.variableA wird auf die Instanzvariable zugegriffen, mit variableA auf die gleichnamige lokale Variable.

Wie bereits weiter oben erwähnt, besitzen Klassenvariablen die längste Lebensspanne. Sie existieren während der kompletten Laufzeit der Anwendung und sind in dieser Zeit auch sichtbar. Für Klassenvariablen gelten die gleichen Überdeckungsregeln wie für Instanzvariablen.

---