Bedingungsschleifen

<-- zurck zur Startseite | <- eine Seite vor | eine Seite weiter ->

  1. abweisende Bedingungsschleifen
  2. nicht-abweisende Bedingungsschleifen
  3. Übung
  4. Lösung

1. abweisende Bedingungsschleifen

Sehen wir uns nun die abweisende Bedingungsschleife an. Bedingungsschleife deshalb, weil sie keinen expliziten Zähler, der die Anzahl der Durchläufe steuert, bei der Schleifendeklaration erhält. Stattdessen hängen die Schleifendurchläufe allein von einem (logischen) Ausdruck ab, der einen booleschen Wert zurückliefert. Das Schlüsselwort zum Einleiten einer abweisenden Bedingungsschleife ist while:

while (ausdruck) {
   // Anweisungen
}

Solange der bei der Deklaration angegebene Ausdruck "true" ergibt, wird die Schleife durchlaufen und bei jedem Durchlauf die in diesem Block stehenden Anweisungen ausgeführt. Ergibt er "false", so wird an das Ende der Schleife gesprungen.
Diese Schleife wird deswegen abweisend genannt, weil sofort ans Ende der Schleife gesprungen wird, wenn bereits vor dem ersten Durchlauf der Ausdruck "false" ergibt. Die Schleife wird dann komplett übersprungen, ohne ein einziges Mal durchlaufen zu werden! Das Verhalten von nicht-abweisenden Bedingungsschleifen werden wir weiter unten kennen lernen.
Wie bei der for-Schleife muss auch bei der while-Schleife darauf geachtet werden, dass die Schleife terminiert, d.h. verlassen werden kann! Überhaupt sind die Unterschiede zwischen diesen beiden Schleifen nicht so groß, wie sie auf den ersten Moment aussehen. Normalerweise lässt sich jede for-Schleife in eine while-Schleife umschreiben und umgekehrt. Nehmen wir beispielsweise folgende for-Schleife:

for (int i=1; i<=10; i++) {
   System.out.println("Wert von i: " + i);
}

Der while-Schleife fehlt im Vergleich zur for-Schleife die Fähigkeit, bei ihrer Deklaration einen Startwert initiieren zu können und eine Schrittweite für jeden Durchlauf festzulegen. Aber selbstverständlich kann man diese Bestandteile auch mit "konventionellen" Methoden nachbilden: der Startwert wird bereits vor der Schleife deklariert (so wie es auch bei for-Schleifen möglich ist), die Schrittweite des Zählers wird hingegen als eigene Anweisung in die while-Schleife geschrieben, und zwar als letzte Anweisung, da bei einer for-Schleife der Zählwert auch erst am Ende eines Durchlaufs geändert wird. Es ergibt sich:

int i=1;
while (i <= 10) {
   System.out.println("Wert von i: " + i);
   i++;
}

nach oben

2. nicht-abweisende Bedingungsschleifen

Die nicht-abweisende Bedingungsschleife unterscheidet sich von den abweisenden Bedingungsschleifen darin, dass der Ausdruck nicht am Anfang des Schleifendurchlaufs geprüft wird, sondern erst, wenn das Ende erreicht ist. Dies sieht man auch an der Stellung der Bedingung bei der Deklaration der Schleife. Sie wird erst hinter der schließenden, geschweiften Klammer angeführt. Das Schlüsselwort ist do:

do {
   // Anweisungen
} while (ausdruck);

Wie man hier sehen kann, ist sie mit der while-Schleife eng verwandt, was auch die erneute Verwendung des Schlüsselworts while verrät, wenn auch an anderer Stelle. Wichtig ist hier, dass die Schleife in jedem Fall wenigstens einmal durchlaufen wird, auch wenn die Bedingung bereits vor dem ersten Durchlauf "false" ergibt. Das liegt daran, dass der Ausdruck erst am Ende des Durchlaufs geprüft wird. Ansonsten gleicht ihr Verhalten der while-Schleife. Die do-Schleife kommt allerdings seltener vor als die while-Schleife. Achtung: bei bedingten Anweisungen und for- sowie while-Schleifen wurde kein Strichpunkt zum Abschluß benötigt. Anders die do-Schleife: Diese muss, wie man hier sehen kann, mit einem Strichpunkt abgeschlossen werden!
Obige while-Schleife kann ganz schnell in eine do-Schleife überführt werden:

int i=1;
do {
   System.out.println("Wert von i: " + i++);
} while (i <= 10);

nach oben

3. Übung

Löse die Aufgaben von Kap. 14 mit Hilfe von while-Schleifen (wahlweise do-Schleifen)!

nach oben

4. Lösung

Aufgabe 1 von Kap. 13 mit while-Schleife

public class Fakultaet2 {

  public static void main(String[] args) {
    int ergebnis=1, i=2;
    while (i<=7) {
       ergebnis *= i;
       i++;
    }
    System.out.println("Fakultaet von 7: " + ergebnis);
  }

}

Aufgabe 1 von Kap. 13 mit do-Schleife

public class Fakultaet3 {

  public static void main(String[] args) {
    int ergebnis=1, i=2;
    do {
       ergebnis *= i;
       i++;
    } while (i<=7);
    System.out.println("Fakultaet von 7: " + ergebnis);
  }

}

Aufgabe 2 von Kap. 13 mit while-Schleifen

public class Multiplikationstabelle2 {

  public static void main(String[] args) {
    int i=1, j=1;
    while (i<=4) {
      while (j<=4) {
        System.out.print(i*j + "\t");
	j++;
      }
      i++;
      System.out.println(); 
    }
  }

}

Aufgabe 2 von Kap. 13 mit do-Schleife

public class Multiplikationstabelle3 {

  public static void main(String[] args) {
    int i=1, j=1;
    do {
      do {
        System.out.print(i*j + "\t");
	j++;
      } while (j<=4);
      System.out.println(); 
      i++;
      j=1;
    } while (i<=4);
  }

}

nach oben