Iteration in Java (Iteration in Java), Lektion, Seite 720766
https://www.purl.org/stefan_ram/pub/while_java (Permalink) ist die kanonische URI dieser Seite.
Stefan Ram
↑Java-Kurs

Iteration in Java 

Kurze Wiederholung der if-Anweisung

Die if-Anweisung ist eine Anweisung.

if-Anweisung
      
     .-----.      .-.     .-----------.     .-.     .-----------.
--->( if    )--->( ( )--->| Ausdruck  |--->( ) )--->| Anweisung |--->
     '-----'      '-'     '-----------'     '-'     '-----------'

Die Anweisung hinter der runden Klammer zu »)« wird ausgeführt, wenn der Ausdruck den Wert »true« (wahr ist) hat.

Syntax der while-Anweisung (vereinfacht)

“while ” (englisch) /ʍɑɪl/ „solange[ wie]“

while-Anweisung
      
     .-----.      .-.     .-----------.     .-.     .-----------.
--->( while )--->( ( )--->| Ausdruck  |--->( ) )--->| Anweisung |--->
     '-----'      '-'     '-----------'     '-'     '-----------'
Anweisungen
Anweisung
        .--------------------------------------.
---.--->| Ausgabeanweisung                     |----.--->
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| Aufrufanweisung                      |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| Zuweisungsanweisung                  |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| Block                                |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| Variablendeklarationsanweisung       |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| Rueckgabeanweisung                   |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| if-Anweisung                         |----'
   |    '--------------------------------------'    |
   |    .--------------------------------------.    |
   '--->| while-Anweisung                      |----'
        '--------------------------------------'

Nach ihrem einleitenden Schlüsselwort while  („während“) wird die Anweisung zur bedingten Ausführung auch while-Anweisung  genannt.

Die while-Anweisung ist eine Anweisung.

Die Anweisung hinter der runden Klammer zu »)« wird auch die innere Anweisung  oder der Rumpf  der while-Anweisung genannt.

Die while-Anweisung ohne den Rumpf nennen wir auch den Kopf  der while-Anweisung.

Der while-Kopf
Anweisung
     .-----.      .-.     .-----------.     .-.
--->( while )--->( ( )--->| Ausdruck  |--->( ) )--->
     '-----'      '-'     '-----------'     '-'

Semantik der while-Anweisung

Die innere Anweisung wird ausgeführt, wenn der Ausdruck wahr ist. Nach jeder Ausführung der Anweisung wird der Ausdruck erneut ausgewertet. Ergibt sich dann wieder der Wert wahr, wird die innere Anweisung erneut ausgeführt.

Die innere Anweisug der while-Anweisung ist die Anweisung hinter dem Kopf der while-Anweisung. Wir nennen sie auch den Inhalt  der Schleife.

Anweisung
      
     .-----.      .-.     .-----------.     .-.     .-----------.
--->( while )--->( ( )--->| Ausdruck  |--->( ) )--->| Anweisung |--->
     '-----'      '-'     '-----------'     '-'     '-----------'
                            Bedingung                 Inhalt

Aussprache

Java 
while( x )java.lang.System.out.println( "z" );
auf deutsch:
„solange »x« (gilt), schreibe »z«“

Anmerkungen

Eine Wiederholung eines Programmteils ohne entsprechende Wiederholung von Anweisungen im Quelltext wird auch ein Schleife  genannt. Daher nennt man die while -Anweisung aus while-Schleife.

Unter einer Iteration  verstehen wir hier die Implementation von Schleifen durch solche speziellen Schleifenanweisungen.

Schlüsselwörter

»while« ist ein Schlüsselwort.

Die bisher behandelte Schlüsselwörter
»boolean«, »double«, »final«, »if«, »int«, »long«, »public«, »return«, »static«, »void«, »while«

Beispiel Endlosschleife

Das folgende Programm führt eine Ausgabeanweisung einmal  aus.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { if( true )
    java.lang.System.out.println( java.lang.Math.random() ); }}
Protokoll
0.9852789278929752

Das folgende Programm mit einer Endlosschleife gibt viele Zahlen aus (bis es irgendwie unterbrochen wird).

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { while( true )
    java.lang.System.out.println( java.lang.Math.random() ); }}
java.lang.System.out
0.1467934074234326
0.566118218484735
0.2474786329776645
0.2447229046636278
0.41637269525573997
u. s. w.

Der Schleifenkopf »while( true )« bedeutet also „wiederhole folgendes immer wieder“.

Beispiel Zählschleife

Das folgende Programm zählt in Zweierschritten von 10 (einschließlich) bis 14 (einschließlich). Da die Variable »i« die einzige und entscheidende Variable für diese Schleife ist, kann man »i« auch als „Schleifenvariable “ bezeichnen.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { int i = 10;                                         /* Schleifenvorbereitung */
    while                                               
    (                                                   
      i < 16                                            /* Schleifenpruefung     */
      )
    {                                                   /* Schleifeninhalt       */ 
      java.lang.System.out.println( i ); /* Nutzlast */ /* Schleifeninhalt       */
      i = i + 2;                 /* Schleifenschritt */ /* Schleifeninhalt       */
      }                                                 /* Schleifeninhalt       */
    java.lang.System.out.println( "Fertig!" );          /* Hinter der Schleife   */ }}
transcript
10
12
14
Fertig!
Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { int i = 10; while( i < 16 )
    { java.lang.System.out.println( i );
      i = i + 2; }
    java.lang.System.out.println( "Fertig!" ); }}
transcript
10
12
14
Fertig!

In diesem Programm erkennen wir für Schleifen typische Bestandteile: Einen Teil zur Vorbereitung der Schleife (die Schleifenvorbereitung ); die Prüfung zur Entscheidung, ob die Schleife erneut ausgeführt werden soll (die Schleifenprüfung ); den zu wiederholenden Schleifeninhalt; die zu wiederholende Nutzlast  der Schleife; und den Schleifenschritt, welcher den Übergang zum nächsten Schleifendurchlauf realisiert.

Jede Ausführung des Schleifeninhalts nennt man auch einen Schleifendurchlauf,  das Ausführen des Schleifeninhalts nennt man entsprechend das Durchlaufen  der Schleife.

Schreibt man die Schleifeninhalte mit den jeweiligen Werten der Schleifenvariablen hintereinander, so kommt man zu einem Ersatzprogramm, welches dasselbe Verhalten wie das Originalprogramm zeigt, aber keine while-Anweisung mehr enthält.

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 10 );
    java.lang.System.out.println( 12 );
    java.lang.System.out.println( 14 );
    java.lang.System.out.println( "Fertig!" ); }}
transcript
10
12
14
Fertig!

Die Vieldeutigkeit der Variablennamen ⃗

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { int i = 10; while( i < 16 )
    { java.lang.System.out.println( i );
      i = i + 2; }
    java.lang.System.out.println( "Fertig!" ); }}

In einer Schleife, wie der voranstehenden, kann man nicht mehr sagen, für welchen Wert ein bestimmter, als Ausdruck verwendeter, Variablenname an einer bestimmten Stelle, wie beispielsweise das »i« in »println( i )«, steht. Diese Stelle wird mehrfach durchlaufen, und »i« kann jedes Mal einen anderen Wert haben.

Übungsfragen

Übungsfrage 0

Was gibt das folgende Programm aus?

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { boolean v = true;
    while( v )java.lang.System.out.println( v = false ); }}

Übungsfrage 1

Was gibt das folgende Programm aus?

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { boolean v = false;
    while( v == false )java.lang.System.out.println( v ); }}

Übungsfrage 2

Was gibt das folgende Programm aus?

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { boolean v = false;
    while( v = false )java.lang.System.out.println( v ); }}

Übungsfrage 3

Was gibt das folgende Programm aus?

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { boolean v = true;
    while( v = true )java.lang.System.out.println( v == false ); }}

Übungsfrage 4

Was gibt das folgende Programm aus?

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { int v = 0;
    while( v == 0 )java.lang.System.out.println( v = 2 ); }}

Übungsfrage 5

Was gibt das folgende Programm aus?

Main.java
public final class Main
{ public static void main( final java.lang.String[] args )
  { int v = 0;
    while( v != 2 )java.lang.System.out.println( v = v + 1 ); }}

Übungsaufgaben

/   Schreiben einer while-Anweisung (Syntax)

Schreiben Sie eine while-Anweisung mit der Bedingung »a« (einem Ausdruck) und dem Inhalt »java.lang.System.out.println( n );« (eine Anweisung). Diese while-Anweisung soll von Leerzeilen umgeben sein.

Anweisung
      
     .-----.      .-.     .-----------.     .-.     .--------.
--->( while )--->( ( )--->| Bedingung |--->( ) )--->| Inhalt |--->
     '-----'      '-'     '-----------'     '-'     '--------'

/   Wiederholte Ausgabe eines Textes ⃖

Schreiben Sie ein Programm, das sieben Mal die Zeile »Dieses ist ein langer Satz.« ausgibt.

In diesem Programm soll nur einmal  eine Ausgabeanweisungen vorkommen, welche die Zeile »Dieses ist ein langer Satz.« genau einmal ausgibt. Jene Ausgabeanweisung soll in einer while-Anweisung enthalten sein, von der sie insgesamt sieben Mal wiederholt wird.

Erwartete Ausgabe
Dieses ist ein langer Satz.
Dieses ist ein langer Satz.
Dieses ist ein langer Satz.
Dieses ist ein langer Satz.
Dieses ist ein langer Satz.
Dieses ist ein langer Satz.
Dieses ist ein langer Satz.

/   Zählen von 12 bis 27

Schreiben Sie ein Programm, das nur eine Ausgabeanweisung enthält und die Zahlen von 12 (einschließlich) bis 27 (einschließlich) ausgibt (eine Zahl pro Zeile, aufsteigend in Einerschritten). Diese Aufgabe soll mit Hilfe einer Schleife gelöst werden, und jeder Schleifendurchlauf soll eine Zahl ausgeben.

Erwartete Ausgabe
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Schleife ↻

Schreiben Sie ein Programm, das mit Hilfe einer Schleife die Zahlen von 2 (einschließlich) bis 20 (einschließlich) ausgibt.

Schleife 1 ↻

Schreiben Sie ein Programm, das mit Hilfe einer Schleife die Zahlen von 0 (einschließlich) bis 20 (ausschließlich) ausgibt. Neben jeder Zahl soll die Zahl »1000« stehen.

/   Zählen ⃖

Zählen Sie, wie oft bei einer Ausführung Ihres Programms »java.lang.Math.random()« aufgerufen werden muß, bis sich zum ersten Mal ein Wert ergibt, der mindestens ‹ 0,9999 › ist.

Zusatzanforderung Schreiben Sie eine parametrisierte Wertmethode, die ergibt, wie oft bei einer Ausführung jener Methode »java.lang.Math.random()« aufgerufen werden muß, bevor sich zum ersten Mal ein Wert ergibt, der mindestens der Argumentwert vom Typ »double« ist.

/   In Zweierschritten von 14 bis 2 abwärts zählen

Schreiben Sie ein Programm, das nur eine Ausgabeanweisung enthält und die Zahlen von 14 bis 2 (eine Zahl pro Zeile) absteigend in Zweierschritten ausgibt. Das Programm darf neben der genannten Anweisung keine anderen Ausgabeanweisungen enthalten. Diese Aufgabe soll mit Hilfe einer Schleife gelöst werden, und jeder Schleifendurchlauf soll eine Zahl ausgeben.

Erwartete Ausgabe
14
12
10
 8
 6
 4
 2

/   Tabellieren der Quadratzahlen von 0 bis 9 ⃖

Schreiben Sie ein Programm, das die Zahlen von 0 bis 9 samt ihrer Quadrate tabelliert. Eine Zahl und ihre Quadratzahl sollen jeweils in einer Zeile stehen und in geeigneter Weise voneinander getrennt werden. Diese Aufgabe soll mit Hilfe einer Schleife gelöst werden, und jeder Schleifendurchlauf soll zwei Zahlen ausgeben. Die Schleife soll nur Ausgabeanweisungen und eine Anweisung zum Erhöhen des Zählers enthalten.

Das Quadrat  einer gegebenen Zahl erhält man, indem man die Zahl ‹ 1 › zweimal  mit der gegebenen Zahl multipliziert.
Erwartete Ausgabe (andere Formatierung möglich)
0 0
1 1
2 4
3 9
4 16
5 25
6 36
7 49
8 64
9 81
Unter Formatierung  verstehen wir die Gestaltung einer Ausgabe durch Hinzufügung oder Entfernung von Leerzeichen oder Zeilenenden.

/   Saldieren ⃖

Schreiben Sie eine Schleife, die alle ganzen Zahlen von »57« (einschließlich) bis »612« (ausschließlich) summiert und geben Sie die Summe aus.

Zusatzanforderung Schreiben Sie eine Wertmethode mit zwei Parametern, die alle ganzen Zahlen von ihrem ersten Argumentwert (einschließlich) bis zu ihrem zweiten Argumentwert (ausschließlich) summiert.

Schleife 2

Schreiben Sie ein Programm, das mit Hilfe einer Schleife die Zahlen von 0 (einschließlich) bis 20 (ausschließlich) ausgibt. Neben jeder Zahl soll die Summe aller bisher am Zeilenanfang ausgegebenen Zahlen stehen.

/   Warten

Schreiben Sie eine Schleife die eine Sekunde lang läuft. (Es kann hierfür beispielsweise »java.lang.System.nanoTime()« verwendet werden.)

Zusatzanforderung Schreiben Sie eine parametrisierte Wirkmethode, die so lange (in Sekunden) läuft die ihr Argumentwert vom Typ »double« angibt.

Anmerkung Zum Warten sollten spezielle Methoden aus der Standardbibliothek (wie »java.lang.Thread.sleep(long)«) verwendet werden. Das Warten mit einer Schleife ist im allgemeinen nicht empfehlenswert und dient hier nur zu Übungszwecken.

Programmablaufplan zur Zählschleife *

        |
        V
   .---------.
   | i := 10 |
   '---------'
        |       .------------.
        |<------| i := i + 2 |<-------.
        |       '------------'        |
        v                             |
      .-'-.             .----------   |
   .-'     '-.   true  / Ausgabe  /   |
.-'  i < 16 ? '-.---->/ i        /----'
 '-.         .-'     /          /
    '-.   .-'        -----------
       '.'
        | false
        |
        V

Struktogramm zur Zählschleife *

.------------------------------------------------.
| i := 10                                        |
|------------------------------------------------|
|      Wiederhole solange wie i kleiner als 16   |
|    .-------------------------------------------|
|    | Ausgabe i                                 |
|    |-------------------------------------------|
|    | Erhoehe i um 2                            |
'------------------------------------------------'

Seiteninformationen und Impressum   |   Mitteilungsformular  |   "ram@zedat.fu-berlin.de" (ohne die Anführungszeichen) ist die Netzpostadresse von Stefan Ram.   |   Eine Verbindung zur Stefan-Ram-Startseite befindet sich oben auf dieser Seite hinter dem Text "Stefan Ram".)  |   Der Urheber dieses Textes ist Stefan Ram. Alle Rechte sind vorbehalten. Diese Seite ist eine Veröffentlichung von Stefan Ram. Schlüsselwörter zu dieser Seite/relevant keywords describing this page: Stefan Ram Berlin slrprd slrprd stefanramberlin spellched stefanram720766 stefan_ram:720766 Iteration in Java erklärung schleife in java; Java, Die Schleife in Java, Java Schleifen in Java, Die Iteration in Java, Java Iterationen in Java, Java-Schleife in Java, Java-Schleifen in Java, Die Javaschleife in Java, Javaschleifen in Java Die Java-While-Anweisung in Java, Die While-Anweisung in Java, Die While-Schleife in Java, Die While-Schleife-Programmierung in Java, Die Whileschleife-Programmierung in Java, Die While-Schleifeprogrammierung in Java, Die Whileschleifeprogrammierung in Java, Die Schleife in Java, Schleifen in Java, Schleifendefinition, Schleifendefinitionen, Java Schleifenprogrammierung in Java, Java-Schleifendefinition, Java-Schleifendefinitionen, Wie programmiere ich eine Schleife in Java?, Wie definiere ich Methoden in Java?, Wie programmiert man eine Schleife in Java?, Wie programmiert man Schleifen in Java?, Wie kann ich eine Schleife in Java programmieren?, Wie kann ich Schleifen in Java programmieren?, Stefan Ram, Berlin, and, or, near, uni, online, slrprd, slrprdqxx, slrprddoc, slrprd720766, slrprddef720766, PbclevtugFgrsnaEnz Erklärung, Beschreibung, Info, Information, Hinweis,

Der Urheber dieses Textes ist Stefan Ram. Alle Rechte sind vorbehalten. Diese Seite ist eine Veröffentlichung von Stefan Ram.
https://www.purl.org/stefan_ram/pub/while_java