Zählschleife: Unterschied zwischen den Versionen
Hauer (Diskussion | Beiträge) (→Der Schleifenkopf) |
Hauer (Diskussion | Beiträge) (→Aufbau einer for-Schleife) |
||
| Zeile 6: | Zeile 6: | ||
= Aufbau einer for-Schleife = | = Aufbau einer for-Schleife = | ||
| + | |||
| + | Eine for-Schleife besteht, schon wie [[while]]- und [[do-while]]-Schleifen aus einem Kopf und einem Rumpf. Zwischen Schleifenkopf und Rumpf steht '''kein''' Semikolon! | ||
==Der Schleifenkopf== | ==Der Schleifenkopf== | ||
| − | Das Schlüsselwort für eine for-Schleife ist das namensgebende '''for'''. Darauf folgt der Schleifenkopf mit folgendem Aussehen: '''(''' ''1.'' ''';''' ''2.'' ''';''' ''3.'' ''') | + | Das Schlüsselwort für eine for-Schleife ist das namensgebende '''for'''. Darauf folgt der Schleifenkopf mit folgendem Aussehen: '''(''' ''1.'' ''';''' ''2.'' ''';''' ''3.'' ''')'''. |
Unter ''1.'' kann eine Zählvariable initialisiert werden, z.B. ''int i = 0;''. | Unter ''1.'' kann eine Zählvariable initialisiert werden, z.B. ''int i = 0;''. | ||
| Zeile 27: | Zeile 29: | ||
==Der Schleifenrumpf== | ==Der Schleifenrumpf== | ||
| − | Als Schleifenrumpf wird der Programmcode bezeichnet, der in der Schleife wiederholt werden soll. Wenn keine {}-Klammern gesetzt werden, wird nur der erste Befehl nach dem Schleifenkopf wiederholt. Wenn mehrere Befehle wiederholt werden sollen, dann muss auf dem Schleifenkopf { folgen. Nach dem letztem Befehl des | + | Als Schleifenrumpf wird der Programmcode bezeichnet, der in der Schleife wiederholt werden soll. Wenn keine {}-Klammern gesetzt werden, wird nur der erste Befehl nach dem Schleifenkopf wiederholt. Wenn mehrere Befehle wiederholt werden sollen, dann muss auf dem Schleifenkopf ein Block mit '''{''' folgen. Nach dem letztem Befehl des Schleifenrumpfes muss der Block mit '''}''' geschlossen werden. Ein leerer Rumpf kann mit einem einzelnem Semikolon nach dem Schleifenkopf signalisiert werden. |
| − | <source lang="java"> | + | <source lang="java" title="Schleifenrumpf"> |
for (...) | for (...) | ||
{ | { | ||
| Zeile 37: | Zeile 39: | ||
Mit jedem Schleifendurchlauf wird die Variable ''erg'' um 5 erhöht. Danach wird diese im jedem Durchlauf ausgegeben. | Mit jedem Schleifendurchlauf wird die Variable ''erg'' um 5 erhöht. Danach wird diese im jedem Durchlauf ausgegeben. | ||
| − | <source lang="java"> | + | <source lang="java" title="Schleifenrumpf ohne Block"> |
for (...) | for (...) | ||
erg = erg + 5; | erg = erg + 5; | ||
| Zeile 43: | Zeile 45: | ||
</source> | </source> | ||
| − | Auch hier wird bei jedem Schleifendurchlauf die Variable ''erg'' um 5 erhöht. Jedoch wird nur diese Variable nur nach der Schleife einmal ausgegeben. | + | Auch hier wird bei jedem Schleifendurchlauf die Variable ''erg'' um 5 erhöht. Jedoch wird nur diese Variable nur nach der Schleife einmal ausgegeben, da die Ausgabe nicht innerhalb der Schleife liegt. Die Einrückung der <code>System.out.println(erg)</code> - Zeile ist demnach auch falsch! |
| − | + | <source lang="java" title="Schleifenrumpf ohne Block mit korrekter Einrückung"> | |
| + | for (...) | ||
| + | erg = erg + 5; | ||
| + | System.out.println(erg); | ||
| + | </source> | ||
| + | |||
| + | <source lang="java" title="Leerer Rumpf"> | ||
| + | for (...); | ||
| + | erg = erg + 5; | ||
| + | System.out.println(erg); | ||
| + | </source> | ||
| + | Hier wird nun auch die Variable ''erg'' nur ein mal um 5 erhöht, da die Schleife selbst einen leeren Rumpf durch das einzelne Semikolon nach dem Schleifenkopf hat. | ||
==die (komplette) for-Schleife== | ==die (komplette) for-Schleife== | ||
| Zeile 64: | Zeile 77: | ||
Analog werden die Fälle für i = 2, i = 3 und i = 4 ausgeführt. | Analog werden die Fälle für i = 2, i = 3 und i = 4 ausgeführt. | ||
| − | Die Bedingung i < 5 ist bei i = 5 nicht mehr erfüllt. Daher wird der Schleifenrumpf nicht mehr ausgeführt. Die Zählvariable ''i'' wird nun verworfen. | + | Die Bedingung i < 5 ist bei i = 5 nicht mehr erfüllt. Daher wird der Schleifenrumpf nicht mehr ausgeführt. Die Zählvariable ''i'' wird nun verworfen. Durch die Initialisierung von i mit 0 und dem Test i '''<''' 5 wird die Schleife genau 5 mal durchlaufen. Natürlich könnten Sie die Schleife auch mit '''int i = 1''' initialisieren und den Test i '''<=''' 5 durchführen, jedoch ist dies aus mehreren Gründen unüblich. |
Version vom 5. Oktober 2015, 12:17 Uhr
Die for-Schleife ist eine Schleifenart in Java. In solch einer Schleife werden Befehle solange wiederholt, bis eine Abbruchbedingung erfüllt wurde. Ansonsten ist ein laufendes Programm in einer Endlosschleife gefangen.
Inhaltsverzeichnis
[Verbergen]Namensherkunft und Zweck
For Schleifen haben ihren Namen aus Aussagen, wie "Für jedes x in M ..." (engl. for each x in M) und "Für x gleich 3 sei ..." (engl. for x equals 3 let). Sie versuchen die Initialisierung, Überprüfung und Fortsetzung einer while-Schleife durch syntaktischen Zucker zu vereinfachen, indem sie leichter niederzuschreiben sind, dem Programmierer leichter Fehler erkennen lassen und sich im geistigen Lesefluss besser visualisieren lassen. Nehmen Sie z.B. folgenden Satz: "Sei i gleich 0, so wiederhole solange i kleiner ist als 5 folgende Zeilen, von denen eine die Variable i um 1 erhöht ..." und "Für i gleich 1 bis 5 in Schrittgröße 1 führe folgende Zeilen aus: ...". Letzterer wird den meisten Lesern angenehmer sein, da hier alle relevanten Informationen über die Durchführung der Schleife in ihrer Deklaration vorhanden sind. Aus dem selben Grund gibt es for-Schleifen. Prinzipiell lassen sich natürlich alle for-Schleifen auch durch while-Schleifen und umgekehrt umsetzen.
Aufbau einer for-Schleife
Eine for-Schleife besteht, schon wie while- und do-while-Schleifen aus einem Kopf und einem Rumpf. Zwischen Schleifenkopf und Rumpf steht kein Semikolon!
Der Schleifenkopf
Das Schlüsselwort für eine for-Schleife ist das namensgebende for. Darauf folgt der Schleifenkopf mit folgendem Aussehen: ( 1. ; 2. ; 3. ).
Unter 1. kann eine Zählvariable initialisiert werden, z.B. int i = 0;.
Unter 2. kann und sollte eine Bedingung für das Ausführen der Schleife stehen, z.B. i < 5. Solange dies erfüllt ist, wird die Schleife ausgeführt.
Unter 3. kann eine Fortsetzung stehen, die als letztes im Schleifenrumpf ausgeführt wird, z.B. ++i.
Zusammenfassend sieht der Schleifenkopf einer for-Schleife so aus:
for(Initialisierung ; Bedinung ; Fortsetzung)
1 | for( int i = 0 ; i < 5 ; ++i) |
Der Schleifenrumpf
Als Schleifenrumpf wird der Programmcode bezeichnet, der in der Schleife wiederholt werden soll. Wenn keine {}-Klammern gesetzt werden, wird nur der erste Befehl nach dem Schleifenkopf wiederholt. Wenn mehrere Befehle wiederholt werden sollen, dann muss auf dem Schleifenkopf ein Block mit { folgen. Nach dem letztem Befehl des Schleifenrumpfes muss der Block mit } geschlossen werden. Ein leerer Rumpf kann mit einem einzelnem Semikolon nach dem Schleifenkopf signalisiert werden.
1 2 3 4 5 | for (...){ erg = erg + 5; System.out.println(erg);} |
Mit jedem Schleifendurchlauf wird die Variable erg um 5 erhöht. Danach wird diese im jedem Durchlauf ausgegeben.
1 2 3 | for (...) erg = erg + 5; System.out.println(erg); |
Auch hier wird bei jedem Schleifendurchlauf die Variable erg um 5 erhöht. Jedoch wird nur diese Variable nur nach der Schleife einmal ausgegeben, da die Ausgabe nicht innerhalb der Schleife liegt. Die Einrückung der System.out.println(erg) - Zeile ist demnach auch falsch!
1 2 3 | for (...) erg = erg + 5;System.out.println(erg); |
1 2 3 | for (...);erg = erg + 5;System.out.println(erg); |
Hier wird nun auch die Variable erg nur ein mal um 5 erhöht, da die Schleife selbst einen leeren Rumpf durch das einzelne Semikolon nach dem Schleifenkopf hat.
die (komplette) for-Schleife
1 2 3 4 5 | for( int i = 0 ; i < 5 ; ++i){ erg = erg + 5; System.out.println(erg)} |
Zunächst wird die Zählvariable i mit 0 initialisiert. Danach wird geprüft, ob i < 5 ist. Da dies korrekt ist, wird nun der Schleifenrumpf ausgeführt. Auf die Variable erg wird 5 aufaddiert und danach wird die Variable ausgegeben. Nun wird i auf 1 erhöht.
Der Schleifenkopf wird nun mit i = 1 ausgeführt. Die Initialisierung wird nun nicht mehr ausgeführt, da diese nur zu Beginn der Schleife ausgeführt wird. Es wird also direkt überprüft, ob i < 5 ist. 1 < 5 ist korrekt, der Schleifenrumpf wird also wieder ausgeführt. Der Variable erg wird nun wieder 5 aufaddeirt und danach wieder ausgegeben. Anschließend wird i auf 2 erhöht.
Analog werden die Fälle für i = 2, i = 3 und i = 4 ausgeführt.
Die Bedingung i < 5 ist bei i = 5 nicht mehr erfüllt. Daher wird der Schleifenrumpf nicht mehr ausgeführt. Die Zählvariable i wird nun verworfen. Durch die Initialisierung von i mit 0 und dem Test i < 5 wird die Schleife genau 5 mal durchlaufen. Natürlich könnten Sie die Schleife auch mit int i = 1 initialisieren und den Test i <= 5 durchführen, jedoch ist dies aus mehreren Gründen unüblich.
