vor()

Folge 6
JAVA
WHILE-Schleife
6.1 Schleifen
Schleifen dienen dazu, bestimmte Anweisungen immer wieder abzuarbeiten.
Zu einer Schleife gehören die Schleifenbedingung und der Rumpf. Die
Schleifenbedingung entscheidet darüber, unter welcher Bedingung die Wiederholung
ausgeführt wird. Sie muss ein logischer (Boolescher) Ausdruck sein. In Abhängigkeit
von der Schleifenbedingung kann der Rumpf mehrmals ausgeführt werden. Dazu wird
bei jedem Schleifendurchgang die Schleifenbedingung geprüft. Das Ergebnis
entscheidet, ob der Rumpf ein weiteres Mal durchlaufen (true) oder die Schleife
beendet wird (false).
6.2 Die WHILE-Schleife
Die WHILE-Schleife ist eine abweisende Schleife, da sie vor jedem Schleifeneintritt die
Schleifenbedingung prüft:
←
while(vornFrei())
{
vor();
}
Schleifenbedingung
Rumpf
Vor jedem Schleifendurchgang wird der Ausdruck neu ausgewertet und ist das
Ergebnis true, so wird der Rumpf ausgeführt. Die Schleife ist beendet, wenn das
Ergebnis false ist. Ist die Bedingung schon vor dem ersten Eintritt in den Rumpf nicht
wahr, so wird der Rumpf erst gar nicht durchlaufen. Der Typ der Bedingung muss
boolean sein.
6.3 Syntax der WHILE-Schleife
Die WHILE-Schleife, ist eine zusammengesetzte Anweisung!
Nach dem Schlüsselwort while steht in runden Klammern ein boolescher Ausdruck,
die so genannte Schleifenbedingung. Anschließend folgt der Rumpf mit den
Anweisungen die evtl. wiederholt ausgeführt werden müssen.
while
(
boolescher
Ausdruck
)
Anweisung/en
Syntaxdiagramm: while-Schleife
JAVA Folge 6, WHILE-Schleife_V1.doc
1/5
6.4 Beispiele
Beispiel 1
Der Hamster soll so lange geradeaus laufen, bis er an eine Wand stößt.
Zunächst wird der Testbefehl vornFrei() 01
ausgewertet. Er liefert den Wert true. Also 02
03
ist die Schleifenbedingung erfüllt.
04
05
D.h. als nächstes wird die Anweisung
06
vor() im Rumpf ausgeführt. Der Hamster 07
hüpft eine Kachel nach vorne. Danach
wird die Schleifen-bedingung erneut
überprüft. Der Testbefehl vornFrei()
liefert wieder den Wert true, so dass der
vor()-Befehl ein zweites Mal ausgeführt
wird.
void main()
{
while (vornFrei())
{
vor();
}
}
Dies geschieht so lang, bis der Hamster vor
der Mauer steht (rechtes Territorium). Da
der Hamster jetzt vor der Mauer steht
liefert der Testbefehl den Wert false. Damit
ist die WHILE-Schleife und – weil es die
einzige
Anweisung
des
Hamsterprogramms war – auch das
gesamte Hamsterprogramm beendet.
JAVA Folge 6, WHILE-Schleife_V1.doc
2/5
Beispiel 2
Der Hamster soll in die gegenüberliegende Ecke laufen und dann anhalten. Dabei soll
er alle Körner einsammeln. Auf den einzelnen Kacheln kann eine beliebige Anzahl
Körner liegen. Das Programm soll für beliebig große,
rechteckige Territorien
funktionieren.
Das Hauptprogramm ist simpel. Einziger
kleiner Trick ist der Beginn mit der Prozedur
sammle() . Er ist notwendig, damit die
Körner auf der ersten Kachel auch aufgenommen werden.
Die Prozedur: sammle() sorgt dafür, dass
der Hamster alle Körner von einer Kachel
aufnimmt.
Die
Prozedur:
laufeUndSammle()
bewegt den Hamster solange vorwärts bis
er auf eine Mauer trifft. Nebenbei sammelt
er noch die Körner ein.
Bei der Prozedur laufeUndSammle()
handelt es sich eigentlich um eine
geschachtelte Schleife! (Schleife in der Schleife)
Denn sammle() ist auch eine Schleife.
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void main()
{
sammle();
laufeUndSammle();
linksUm();
laufeUndSammle();
}
void sammle()
{
while (kornDa())
{
nimm();
}
}
void laufeUndSammle()
{
while (vornFrei())
{
vor();
sammle();
}
}
----------------------------Als geschachtelte Schleife sieht das dann
so aus:
JAVA Folge 6, WHILE-Schleife_V1.doc
void laufeUndSammle()
{
while (vornFrei())
{
vor();
while (kornDa())
{
nimm();
}
}
}
3/5
Beispiel 3 Kehrwoche
Der Hamster hat Kehrwoche. Er muss auf einem rechteckigen Schulhof beliebiger
Größe alle Körner auffegen. Er fängt immer in der unteren linken Ecke an und blickt
dabei nach Osten.
Tippen Sie das Programm ein und 01
versuchen Sie die Lösung nachzu- 02
03
vollziehen.
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
JAVA Folge 6, WHILE-Schleife_V1.doc
void main()
{
vorZurueck();
rechtsUm();
while (vornFrei())
{
vor();
rechtsUm();
vorZurueck();
rechtsUm();
}
}
void vorZurueck()
{
reihe();
kehrt();
zurueck();
}
void reihe()
{
sammle();
while (vornFrei())
{
vor();
sammle();
}
}
void zurueck()
{
while (vornFrei())
{
vor();
}
}
void sammle()
{
while (kornDa())
{
nimm();
}
}
void rechtsUm() { kehrt();
linksUm(); }
void kehrt() { linksUm();
linksUm(); }
4/5
6.5 (Vorsicht Falle) Endlosschleife
Schauen Sie sich folgendes Programm an:
01
02
Die Ausführung des Programms wird 03
niemals enden. Die Schleifenbedingung 04
05
liefert immer den Wert: true.
06
07
Das Programm wird endlos fortgesetzt.
08
Derartige Endlosprogramme sind im
allgemeinen fehlerhaft, es sei denn, in der
Aufgabenstellung wird dies explizit erlaubt.
void main()
{
while (vornFrei())
{
vor();
linksUm();
}
}
Programmieren Sie diese Schleife und
testen Sie sie.
6.6 Die DO / WHILE-Schleife
Dieser Schleifentyp ist eine annehmende Schleife, da die Schleifenbedingung erst
nach jedem Schleifendurchgang geprüft wird. Bevor es zum ersten Test kommt, ist der
Rumpf also schon einmal durchlaufen.
6.7 Die Syntax der DO / WHILE-Schleife
Dem Schlüsselwort do folgt der Rumpf mit den Anweisungen. Danach folgt das
Schlüsselwort while . Anschließend folgt in runden Klammern ein boolescher
Ausdruck (Schleifenbedingung). Abgeschlossen wird die DO / WHILE-Schleife mit
einem Semikolon!
do
Anweisung/en
while
(
boolescher
Ausdruck
)
;
Syntaxdiagramm: do/while-Schleife
Als erstes wird die Anweisung nimm() im
Rumpf ausgeführt. Erst danach wird der
Testbefehl kornDa() ausgewertet und
entschieden ob die Schleifenbedingung
erfüllt ist und wie oft die Anweisung im
Rumpf ausgeführt wird.
JAVA Folge 6, WHILE-Schleife_V1.doc
void main()
{
do
{
nimm();
}
while(kornDa());
}
5/5