Java for Schleife
In diesem Beitrag erklären wir dir, wie die for Schleife in Java funktioniert.
Du möchtest schnell for Schleifen verstehen und in der Programmiersprache Java umsetzen? Dann schau dir unser Video dazu an!
Inhaltsübersicht
Java for Schleife einfach erklärt
In Java gibt es verschiedene Arten von Schleifen, wie zum Beispiel die for Schleife, die while- und die do-while-Schleife. Wir beschäftigen uns hier mit der Java for Schleife. Jetzt fragst du dich vielleicht, was eigentlich der Unterschied zwischen einer while- und einer for Schleife ist. Im Prinzip machen beide genau das Gleiche. Sie wiederholen den Code innerhalb der geschweiften Klammern bis die Bedingung nicht mehr erfüllt ist.
Es gibt nur EINEN großen Unterschied. Die while Schleife hat nur EINE Bedingung innerhalb der runden Klammern. Die for Schleife besitzt zwar ebenfalls eine Bedingung, hat aber zusätzlich eine sogenannte Laufvariable. Außerdem gibst du in den runden Klammern der for Schleife auch noch an, wie sich die Laufvariable verändern soll. Zusammengefasst besteht eine for Schleife also aus der Initialisierung einer Laufvariablen, gefolgt von einer Abbruchbedingung und als letztes einer Angabe der Veränderung der Laufvariablen
for(Initialisierung; Abbruchbedingung; Veränderung Laufvariable){
//Anweisungen
}
for Schleife Java Beispiel
Damit du die Funktionsweise der for Schleife gut nachvollziehen kannst, schauen wir uns den Aufbau an einem konkreten Beispiel gemeinsam an. Zuerst teilen wir unserem Programm mit, dass es sich um eine for Schleife handeln soll. Dafür bedienen wir uns dem Grundgerüst der for Schleife in Java
for(...){
//Anweisungen
}
In den runden Klammern weisen wir nun zuerst einer Laufvariablen, welche vom Typ Integer ist, einen Wert zu. In unserem Fall nennen wir die Laufvariable counter
und weisen ihr den Wert 1
zu
for(int counter = 1;...){
//Anweisungen
}
Diese sogenannte Initialisierungsklausel wird einmalig zu Beginn der Schleife ausgeführt! Um die Variable jetzt von der Bedingung zu trennen, setzt du dahinter einfach ein Semikolon. Als nächtes geben wir die Bedingung an, zu welchem Zeitpunkt die for Schleife abbrechen soll. Angenommen du möchtest, dass counter
nicht größer als 10 wird, dann kannst du nun diese Bedingung mit dem logischen Operator <=
wie folgt ausdrücken
for(int counter = 1; counter <= 10;...){
//Anweisungen
}
Die Bedingung ist lediglich dazu da, dass counter
nicht größer als 10 werden darf. Ansonsten bricht die for Schleife ab. Mit einem weiteren Semikolon trennst du die Bedingung von der Veränderung der Laufvariablen. Dort sagen wir dem Programm, dass unsere Variable counter
nach jedem Durchgang zum Beispiel um 1 erhöht werden soll. Dies erreichst du mit dem Befehl counter++
. Insgesamt hat unsere for Schleife also nun folgende Gestalt
for(int counter = 1; counter <= 10; counter++){
//Anweisungen
}
Der Befehl counter++
wird dabei erst am Ende der for Schleife ausgeführt! Damit haben wir die runden Klammern abgearbeitet. Vergiss aber niemals die einzelnen Teile mit einem Semikolon zu trennen, denn nur dann weiß das Programm, dass es sich um unterschiedliche Angaben handelt.
Im nächsten Schritt schreibst du nun in die geschweiften Klammern deinen Code, also was die for Schleife machen soll. Betrachten wir als einfaches Beispiel, dass du nur die Variable counter
auf der Konsole ausgeben möchtest. Dann erreichst du das durch den Befehl System.out.println
for(int counter = 1; counter <= 10; counter++){
System.out.println("Zaehler ist bei: " + counter);
}
Wenn die Bedingung counter <= 10
nicht mehr erfüllt ist und die for Schleife abbricht, wird die Laufvariable counter
gelöscht. Dadurch kannst du später im Code nochmal eine Variable counter
deklarieren, ohne dass es zu einem Fehler kommt. Damit ist unsere for Schleife auch schon fertig.
Wie du siehst, haben wir hier die Laufvariable counter
genannt, um unser Beispiel nachvollziehbarer zu machen. Du wirst aber im Laufe deiner Programmierkarriere feststellen, dass man meistens den Variablennamen i
verwendet. Am Ende ist es aber dir überlassen, wie du deine Variablen benennst.
Vergleich while und for Schleife in Java
Damit du nun einen Unterschied zwischen den Schleifen sehen kannst, vergleichen wir unsere for Schleife mit der while Schleife. Es ist leicht zu sehen, dass du bei der while Schleife viel mehr Zeilen benötigst als bei der for Schleife. Außerdem muss deine Laufvariable counter
außerhalb der while Schleife deklariert werden. Dies kann eventuell zu Problemen innerhalb eines größeren Codes führen, da es schnell unübersichtlich werden kann. Das ist einer der großen Vorteile der for Schleife. Sie ist überschaubarer und du kannst deine Variable nicht außerhalb der Schleife versehentlich verändern.
Verschachtelte Java for Schleifen
Da es natürlich möglich ist, beliebig viele for Schleifen in Java zu verschachteln, wollen wir dir das an einem konkreten Beispiel mit zwei for Schleifen genauer erklären. Gehen wir einmal davon aus, du hast die Aufgabe folgende Ausgabe mit for Schleifen zu erzeugen
XXXXXXXXXX
XXXXXXXXXX
XXXXXXXXXX
XXXXXXXXXX
XXXXXXXXXX
Zusätzlich musst du jedoch noch die Bedingung berücksichtigen, dass du bei jedem Durchlauf der for Schleife maximal ein X ausgeben darfst. Es sollen also fünf Reihen mit jeweils 10 X´en auf der Konsole angezeigt werden. Das klingt jetzt erstmal kompliziert und du fragst dich sicher, wie das funktionieren soll. Keine Sorge, wir gehen es jetzt Schritt für Schritt mit dir durch.
Zuerst einmal benötigst du eine for Schleife, welche 10 X’en nacheinander auf der Konsole ausgibt
for(int x = 0; x <= 10; x++){
System.out.print("X");
}
Diese for Schleife erzeugt die Ausgabe XXXXXXXXXX
. Da ja nun 5 Reihen mit jeweils 10 X’en ausgegeben werden sollen, musst du diese for Schleife wieder in eine for Schleife mit einer neuen Laufvariablen y
verpacken. Die Laufvariable y
soll ja dann gerade bis 5 laufen. Sobald 10 X’e ausgegeben sind, musst du einen Zeilenumbruch mit System.out.println();
veranlassen, um die gegebene Aufgabe zu erfüllen. Der komplette Java Code sieht dann wie folgt aus:
for(int y = 0; y <= 5; y++){
for(int x = 0; x <= 10; x++){
System.out.print("X");
}
System.out.println();
}
Wenn du nun dein Programm noch flexibler gestalten möchtest, dann kannst du die maximalen Werte für x
und y
auch in einer Variablen x_max
beziehungsweise y_max
speichern. Durch die Variablen hast du die Möglichkeit die Zahlen einfacher auszutauschen. Für komplexere Strukturen und Aufgaben bietet sich eine solche Vorgehensweise an.
Somit ist unser Java Code komplett. Jetzt werden erst die X´e innerhalb einer Reihe ausgegeben, bis die Laufvariable x
den Wert x_max
erreicht. Danach wird in der äußeren Schleife ein Zeilenumbruch durchgeführt. Dieser Prozess wiederholt sich dann so lange, bis die Laufvariable der äußeren for Schleife den Wert y_max
erreicht.
Wie du sicher schon vermutet hast, kann man mit verschachtelten Schleifen beispielsweise mathematische Dinge, wie Funktionen oder Vektoren anschaulich darstellen. Man kann damit aber auch andere graphische Dinge erzeugen und auf der Benutzeroberfläche verschieben. Natürlich ist es auch möglich Rechnungen ausführen zu lassen, die variierende Werte wie unser x
und y
benötigen.