Strukturen

Blöcke

Mehrere Anweisungen werden durch geschweifte Klammern in Blöcke zusammengefasst. Der gesamte Block kann dann als einzelne Anweisung betrachtet werden und überall dort auftauchen, wo sonst eine Anweisungen stehen würde. Blöcke können auch beliebig verschachtelt werden.

bedingte Anweisungen

Eine bedingte Anweisung ist eine Verzweigung des Programmes in zwei Varianten, abhängig von einer Bedingung.


    if (<Bedingung>) {
      <Anweisungen>
    } else {
      <Anweisungen>
    }

Die Bedingung muss ein Boolscher Ausdruck sein, die Klammern um die Bedingung darf man nicht weglassen. Wenn dieser wahr ist, werden die Anweisungen im ersten Block ausgeführt, sonst die im zweiten Block. Der else-Part ist optional.


    int x = <irgend ein Wert>;

    if (x % 2 == 0) {
      System.out.println("die Zahl " + x + " ist durch 2 teilbar");
    }

    if (x < 0) {
      System.out.println("x ist kleiner als Null");
    } else if (x > 0) {
      System.out.println("x ist grösser als Null");
    } else {
      System.out.println("x ist gleich Null");
    }

Für den Fall, dass man eine Variable mit verschiedenen Konstanten vergleichen muss, gibt es eine spezielle Struktur. Die folgenden beiden Ausschnitte sind gleichwertig.

switchif else Folge

switch (<Variable>) {
  case <Wert1>:
    <Anweisungen1>
    break;

  case <Wert2>:
    <Anweisungen2>
    break;
  ...

  default:
    <AnweisungenN>
}

if (<Variable> == <Wert1>) {
  <Anweisungen1>

} else if (<Variable> == <Wert2>) {
  <Anweisungen2>

} ... else {
  <AnweisungenN>

}

Wie der else Part ist auch das default optional.

Mit der switch Variante lassen sich Berechnungen ausdrücken, die mit einer Folge von if then nicht so leicht beschrieben werden können. Denn die break Anweisung, die zum Verlassen des switch Blockes auffordert kann ebenfalls weggelassen werden. Dies führt dazu, dass alle nachfolgenden Anweisung ebenfalls aufgeführt werden (ohne weitere Tests durchzuführen), bis zum Erreichen des nächsten break.

switchif else Folge

switch (x) {
  1: System.out.println("x ist 1");
     /* falls through */
  2: System.out.println("x ist 1 oder 2");
     break;
  3:
  4: System.out.println("x ist 3 oder 4");
     /* falls through */
  default:
     System.out.println("x ist nicht 1 oder 2");
}

if (x == 1) {
  System.out.println("x ist 1");
  System.out.println("x ist 1 oder 2");
} else if (x == 2) {
  System.out.println("x ist 1 oder 2");
} else if ((x == 3) || (x == 4)) {
  System.out.println("x ist 3 oder 4");
  System.out.println("x ist nicht 1 oder 2");
} else {
  System.out.println("x ist nicht 1 oder 2");
}

Wenn x gleich 1 ist, wird "x ist 1" ausgegeben. Da danach kein break folgt, wird auch noch "x ist 1 oder 2" ausgegeben. Um im Quelltext hervorzuheben, dass das break nicht vergessen wurde, sollte man dies mit einem Kommentar deutlich machen.

for-Schleife

Schleifen werden benutzt um eine Anweisung oder einen Block von Anweisungen mehrfach auszuführen. Die klassische Variante ist die for-Schleife. Sie wird üblicherweise verwendet, wenn die Anzahl der iterationen bekannt ist.


    for (<Initialisierung>;  <Bedingung>;  <Inkrementanweisung>) {
      <Anweisungen>
    }

Als erstes wird eine Laufvariable initialisiert. Diese kann auch direkt dort deklariert werden. Dadurch vermeidet man Nebeneffekte mit globalen Variablen. Als zweites folgt die Abbruchbedingung, dies sollte ein Boolscher Ausdruck sein. Zum Schluss steht eine (oder mehrere durch Komma getrente) Anweisung(en), die jeweils nach einem Schleifendurchlauf ausgeführt werden.


    for (int i = 0;  i < 10;  i++) {
      System.out.println(i);
    }

    for (int i = 0, j = 1;  i < 10;  i++, j *= 2) {
      System.out.println("2^" + i + " = " + j);
    }

Das erste Beispiel gibt alle ganzen Zahlen von 0 bis 9 aus, das zweite alle Zweierpotenzen bis 1024.

Alle drei Argumente im Kopf der Schleife sind optional. Es ist auch möglich Endlosschleifen zu basteln.


    for (;;) {
      System.out.println("ich bin eine Endlosschleife");
    }

Diese Schleife kann aber noch mehr, als nur ganze Zahlen zählen, denn die Initialisierung bzw. die Anweisungen können völlig beliebig sein.


    Object obj;
    for (Iterator iter = foo();  iter.hasNext();  obj = iter.next()) {
      bar(obj);
    }

Ein Iterator kann dazu benutzt werden, Listen zu durchlaufen. Er besitzt genau die beiden oben verwendeten Methoden. Die Methode next() liefert jeweils das nächste Element und mit hasNext() wird geprüft, ob es weitere Elemente gibt.

do-Schleife


  do {
    <Anweisungen>
  } while (<Bedingung>);

Die do-Schleife ist etwas einfacher aufgebaut. Sie besteht nur aus dem Anweisungsblock und einer Boolschen Bedingung. Die Anweisungen werden solange wiederholt, wie die Bedingung noch erfüllt ist. Das besondere dieser Schleife ist, dass die Anweisungen mindestens einmal ausgeführt werden.


  int a, b;  // mit positiven Werten initialisiert
  int r;
  do {
    r = a % b;
    a = b;
    b = r;
  } while (r != 0);
  System.out.println(a);

Dies ist der Eukliedische Algorithmus, der den grössten gemeinsamen Teiler von a und b berechnet, sofern keine der beiden Zahlen Null ist.

while-Schleife


  while (<Bedingung>) {
    <Anweisungen>
  }

Die while-Schleife wird auch als abweisende Schleife bezeichnet. Wenn Die Bedingung von Anfang an nicht erfüllt ist, dann wird die Anweisung gar nicht ausgeführt. Das Wort do taucht bei dieser Struktur (im Gegensatz zu anderen Programmiersprachen) nicht auf. An sonsten gibt es keinen Unterschied zur do-Schleife.


Erstellt von Markus Durzinsky, aktualisiert 2004-03-17
Für Fragen, Probleme oder Anregungen stehe ich gerne zur Verfügung