Variablen

---

Laut Java ist eine Variable nichts anderes als ein Speicherplatz. Eine Variable erhält einen Namen, über den man auf den Speicherplatz (im Hauptspeicher) zugreifen kann. Dieser Platz wird reserviert, sobald eine Variable angelegt bzw. definiert wird, und mit einem Wert initialisiert. Dort ist dann zum Beispiel ein Wahrheitswert oder eine Zahl abgelegt. Mit Variablen kann man sich also Informationen merken, die man später verwenden oder ändern möchte.

Im folgenden Beispiel werden boolesche Variablen und ganzzahlige Variablen (Integerwerte „int“) definiert und initialisiert. Die Initialisierung erfolgt mit dem Gleichheitszeichen. (Weitere Datentypen wie char (Zeichen) oder double (Gleitkommazahl) werden hier nicht besprochen.)

 

boolean meinWahrerWahrheitswert = true;

boolean keinKornDa = !kornDa();

boolean einKombinierterWert = maulLeer() || vornFrei();

boolean vornFrei = vornFrei();             // formal richtig (aber nicht empfohlen): der Compiler erkennt Funktionen an „()“

 boolean meinBool;                                   // ohne Zuweisung wird mit false initialisiert.

 boolean a, b = true;                                  // a ist „false“, b ist „true“

 int sieben = 7;

 int summe = (5 + sieben) * 2;

 int negativeZahl = -9;

 int rest = 14 % 3;                                        // =2, Modulo-Operator (Rest der ganzzahligen Division)

 int zahl = 7 / 0                                             // Fehler! Division durch 0 nicht möglich

 int x;                                                               // Automatische Initialisierung mit 0

 

Boolesche Variablen können überall da verwendet werden, wo bisher boolesche Ausdrücke einen Wahrheitswert geliefert haben: zum Beispiel in if-Anweisungen, in Schleifenbedingungen oder bei return-Anweisungen.

Zahlenwerte können mit Hilfe von Vergleichsoperatoren sogenannte Vergleichsausdrücke bilden, die ebenfalls einen Wahrheitswert liefern.

int a = 5; int b = 4;

   (a == 5) liefert true  (Gleichheitsoperator ==)

   (a != b) liefert true   (Ungleichheitsoperator !=)

   (a < 5) liefert false   (Kleineroperator)

   (a <= 5) liefert true  (Kleinergleichoperator)

   > und >= analog

 

Variablen-Zuweisungen

Variablen können nach der Definition und Initialisierung ihren Wert ändern. Dazu verwenden wir den Zuweisungsoperator „=“. Im Beispiel wird der Variablen mit dem Namen „weiter“ der Wert „false“  zugewiesen, falls der Hamster vor einer Mauer steht. Der alte Wert „true“ wird in diesem Fall überschrieben.

void main() {
    boolean weiter = true;
    …
    if (!vornFrei()) {
       weiter = false;
    }
…
}

 

Zum Ändern eines Integerwertes i gibt es abkürzende Schreibweisen:

   i++;                     // entspricht i = i + 1  (Inkrement-Operator ++)

   i–;                       // entspricht i = i – 1 (Dekrement-Operator –)

   i += 5                  // entspircht i = i + 5 (-=, *=, /= und %= analog)

 

Hier ein Beispiel zum Zählen von Schritten:

int schritte = 0;
while (vornFrei()) {
   vor();
   schritte++;
}

 

Gültigkeitsbereich und Lebensdauer von Variablen

Eine lokale Variable wird innerhalb eines Blocks definiert, also innerhalb geschweifter Klammern. Der Rumpf einer Prozedur oder einer Funktion ist zum Beispiel ein Block. Wir finden Blöcke auch in if- oder else-Zweigen oder in Schleifen. Eine lokale Variable ist innerhalb des Blocks, in der sie definiert wurde, gültig und kann hier (und in Unterblöcken) verwendet werden. Wird innerhalb des Blocks eine andere Prozedur aufgerufen, kann dort nicht auf die Variable zugegriffen werden, sie ist nicht gültig. Ihr Speicher bleibt aber reserviert und der Zugriff ist nach Beenden der anderen Prozedur wieder möglich. Nach Beenden des Blocks, in der die Variable definiert wurde, wird der Speicherplatz wieder freigegeben und ihre Lebensdauer endet. Eine Zuweisung nach Blockende führt dann zu einem Fehler.

void main() {
    boolean weiter = true;
    if (!vornFrei()) {
       boolean friss = kornDa();
       weiter = false;
    }
    if (friss) { // Fehler: „friss“ lebt nicht mehr
        nimm();
    }
}

 

Die Variablennamen müssen innerhalb des Gültigkeitsbereichs eindeutig sein. Es dürfen also keine gleichen Namen innerhalb des Blockes (auch nicht in Unterblöcken) vergeben werden. Da Prozeduren und Funktionen eigene Blöcke bilden, sind gleiche Variablennamen in verschiedenen Funktionen möglich.

Globale Variablen werden außerhalb von Prozeduren oder Funktionen definiert. Sie sind während der gesamten Programmausführung verfügbar und müssen eindeutige Namen haben. Die Reihenfolge der Initialisierung richtet sich nach der Reihenfolge der Definition. Es ist möglich, lokale Variablen mit dem gleichen Namen zu definieren. Diese überdecken dann die globalen Variablen, auf diese kann man dann im Block nicht mehr zugreifen. Die Verwendung von globalen Variablen kann leicht zu Fehlern führen.

boolean weiter = true;

void main() {
    if (!vornFrei()) {
        weiter = false;
    }
    bewegDich();
}

void bewegDich() {
    if (weiter) {
        vor();

    }

}

---