Anweisungen

Java bietet drei Formen von Anweisungen

• Ausdrucksanweisungen
  • Wertzuweisungen
  • Inkrement/Dekrement mit ++ und -
  • Methodenaufruf (egal ob die Methode einen Wert liefert)
  • Objekterzeugung mit new

• Deklarationsanweisungen
  • deklarieren lokale Variablen
  • irgendwo im Block, nicht nur am Anfang
• Steuerungsanweisungen
  • Beeinflussen den Ablauf der Ausführung ( control flow).

Mit geschweiften Klammern { und } werden Anweisungen zu Blöcken gruppiert. Diese können überall anstelle von einzelnen Anweisungen verwendet werden.

Dieses Kapitel beschäftigt sich mit den Steuerungsanweisungen.

Verzweigung

Die Formen

   if (boolean_expression)
      statement

und

   if (boolean_expression)
      statement_1
   else
      statement_2

Bei geschachtelten if-Anweisungen wird ein else dem jeweils letzten else-losen if zugeordnet.

Fallunterscheidung

Die switch-Anweisung wertet einen ganzzahligen Ausdruck aus und verzweigt abhängig von dessen Wert zu einer markierten Anweisung.

Beispiel:

   switch (Verbosity)
   { case NORMAL:
        System.out.println(summaryState);
        // Weiter in der Anweisungsfolge
     case VERBOSE:
        System.out.println(basicState);
        break;
        // Raus aus dem Switch
     default:
        throw new UnexpectedVerbException
                (Verbosity);
   }

Wichtig:

• Ohne break, return oder throw geht es weiter mit der nächsten Anweisung im Block ( Fallthrough).
• Wenn kein case zutrifft und kein default existiert, endet die Fallunterscheidung normal.

while- und do-Schleifen

Die Formen

   while (boolean_expression)
      statement

und

   do statement
   while (boolean_expression)

Wichtig:

• Die while-Schleife prüft die Bedingung vor Ausführung des Rumpfes.
• Die do-Schleife prüft die Bedingung nachdem der Rumpf ausgeführt wurde.

for-Schleife

Form:

   for (init_expr; boolean_expr; incr_expr)
      statement

entspricht in der Wirkung der while-Schleife:

   init_expr;
   while (boolean_expr)
   {  statement
      incr_expr;
   }

mit dem Unterschied, daß incr_expr immer ausgeführt wird, wenn während der Ausführung von statement eine continue-Anweisung (siehe Seite ) ausgeführt wird.

Abbruch-Anweisungen: break, continue, return

Die Abbruch-Anweisungen break und continue können Label als Argumente benutzen, die die Aufsetzpunkte angeben.

Zur Spezifikation solcher Aufsetzpunkte gibt es markierte Anweisungen

   label: statement

Die break-Anweisung

Zwei Formen:

   break

und

   break identifier

Das break ohne Label verläßt die umgebende while-, do-, for- oder switch-Anweisung. Existiert die nicht, gibt es einen Übersetzerfehler.

Das break mit Label verläßt die mit dem Label markierte umgebende Anweisung (z.B. auch einen Block). Existiert die nicht, gibt es einen Übersetzerfehler.

Beispiel:

class Breaktry
{ private float [][] Matrix;
  boolean find(float val)
  { boolean found = false;
    int x, y;
    search:
    for (y = 0; y < Matrix.length; y++)
      for (x = 0; 
           x < Matrix[y].length; 
           x++)
        if (Matrix[y][x] == val)
          { found = true;
            break search;
          }
    if (!found)
      return false;
    // mach irgendwas mit Matrix[x][y]
    return true;
  }
}

Die continue-Anweisung

Darf nur in Schleifen auftreten. Beendet die aktuelle Iteration und fährt mit der Auswertung der Schleifenbedingung fort.

continue mit Label beendet die aktuelle Iteration der markierten Schleife.

continue ohne Label beendet die aktuelle Iteration der direkt umgebenden Schleife.

Beispiel:

   while (! stream.eof())
   { token = stream.next();
     if (token.equals("skip"))
        continue;
     // Verarbeite token
   }

Die return-Anweisung

Beendet die Ausführung einer Methode und kehrt zum Aufrufer zurück.

Liefert die Methode kein Ergebnis, ist die Form

    return;

Liefert die Methode ein Ergebnis, ist die Form

    return expression;

wobei expression einen Typ haben muß, der an den Typ des Methodenergebnisses zugewiesen werden kann.

Besonderheit:

return kann auch zum Verlassen von Konstruktoren und Initialisierungsblöcken verwendet werden.