Die `do` -Schleife

Einführung

Die do -Schleife ähnelt der while -Schleife, jedoch wird der Schleifeninhalt einer do -Schleife bei Ausführung der Schleife immer mindestens einmal ausgeführt. Erst dann folgt eine Prüfung, welche entscheidet, ob sich ein weiterer Durchlauf anschließt.

Beispiel: Gesucht wird eine random()-Zufallszahl unter 0,5 durch wiederholtes Probieren.

Probierschleife ohne do zeigt Redundanz

{ double r = java.lang.Math.random();
  while( r >= 0.5 )r = java.lang.Math.random();
  /* postcondition: r < 0.5 */ }

Probierschleife mit do ohne Redundanz

{ double r; do
  r = java.lang.Math.random();
  while( r >= 0.5 );
  /* postcondition: r < 0.5 */ }

Das Semikolon hinter »while( r >= 0.5 )« ist in diesem Fall richtig.

Wenn man das Programm erst ab »while( r >= 0.5 )« liest, ohne von dem »do« davor zu wissen, könnte man denken, daß man es mit einer while-Schleife zu tun habe.

Die while -Schleife sieht man auch als eine abweisende Schleife an, weil ihr Schleifeninhalt unter Umständen nie ausgeführt wird.

Die do -Schleife sieht man auch als eine nicht-abweisende Schleife an, weil ihr Schleifeninhalt immer mindestens einmal ausgeführt wird.

Probierschleife mit while [Programmablaufplan]

                     |
                     v
    .---------------------------------.
    | r := java.lang.Math.random()    |
    '---------------------------------'
                     |
                     |<------------------------------------------------------.
                     |                                                       |
                     v                                                       |
                   .-'-.                                                     |   
                .-'     '-.                                                  |
             .-'           '-.    Ja   .---------------------------------.   |
          .-'     r > 0.5     '-.----->| r := java.lang.Math.random()    |---'
          '-.        ?         .'      '---------------------------------'
             '-.           .-'
                '-.     .-'
                   '-.-'
                     | Nein
                     v

Probierschleife mit do [Programmablaufplan]

                     |
                     |<--------------------.
                     v                     |
    .---------------------------------.    |
    | r := java.lang.Math.random()    |    |
    '---------------------------------'    |
                     |                     |
                     v                     |
                   .-'-.                   |
                .-'     '-.                |
             .-'           '-.             |
          .-'     r > 0.5     '-.----------'
          '-.        ?         .'
             '-.           .-'
                '-.     .-'
                   '-.-'
                     |
                     v

Probierschleife mit while [Struktogramm]

    .-----------------------------------.
    | r := java.lang.Math.random()      |
    |-----------------------------------|
    |      r > 0.5 ?                    |
    |    .------------------------------|
    |    | r := java.lang.Math.random() |
    '-----------------------------------'

Probierschleife mit do [Struktogramm]

    .-----------------------------------.
    |    | r := java.lang.Math.random() |
    |    '------------------------------|
    |      r > 0.5 ?                    |
    '-----------------------------------'

Syntax

     .--.     .-----------.     .'''''.      .-.     .----------.     .-.      .-.
--->( do )--->| Anweisung |--->( while )--->( ( )--->| Ausdruck |--->( ) )--->( ; )--->
     '--'     '-----------'     '.....'      '-'     '----------'     '-'      '-'

Typanforderungen

Wie bei der while -Schleife muß der Ausdruck vom Typ »boolean« sein.

Semantik

Die Anweisung nach »do« wird ausgeführt. Falls der Ausdruck dann wahr ist, wird die gesamte do -Anweisung erneut ausgeführt.

Schlüsselwörter

»do« ist ein Schlüsselwort.

Die bisher behandelte Schlüsselwörter

»boolean«, »break«, »case«, »char«, »do«, »double«, »else«, »for«, »if«, »import«, »public«, »return«, »int«, »final«, »static«, »switch«, »void«, »while«

Übungsaufgaben

Übungsaufgaben, zu deren Lösung auch Schleifen geschrieben werden können, finden sich in einer separaten Lektion mit Übungsaufgaben am Ende des Grundkurses.

Die do -Schleife