Java for Schleife

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.

direkt ins Video springen

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.

direkt ins Video springen

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.

direkt ins Video springen

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.

direkt ins Video springen

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.